Merge pull request #164 from orange-cpp/feaute/disk_optimization

avoid saving files on disk

.cmake-format

@@ -0,0 +1,25 @@
+format:
+  line_width: 100
+  tab_size: 4
+  use_tabchars: false
+  max_subgroups_hwrap: 3
+  max_pargs_hwrap: 5
+  separate_ctrl_name_with_space: false
+  separate_fn_name_with_space: false
+  dangle_parens: false
+  dangle_align: child
+  line_ending: unix
+  command_case: canonical
+  keyword_case: upper
+  enable_sort: true
+  autosort: true
+markup:
+  bullet_char: "*"
+  enum_char: .
+  enable_markup: false
+additional_commands:
+  target_link_libraries:
+    kwargs:
+      PUBLIC: "*"
+      SHARED: "*"
+      PRIVATE: "*"

.gitattributes

@@ -1,5 +1,98 @@
+# SCM syntax highlighting & preventing 3-way merges
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true -diff
+
+# Images
+*.png  filter=lfs diff=lfs merge=lfs -text
+*.jpg  filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.gif  filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.tif  filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.bmp  filter=lfs diff=lfs merge=lfs -text
+*.heic filter=lfs diff=lfs merge=lfs -text
+*.heif filter=lfs diff=lfs merge=lfs -text
+*.avif filter=lfs diff=lfs merge=lfs -text
+*.ico  filter=lfs diff=lfs merge=lfs -text
+*.psd  filter=lfs diff=lfs merge=lfs -text
+*.ai   filter=lfs diff=lfs merge=lfs -text
+*.xcf  filter=lfs diff=lfs merge=lfs -text
+*.kra  filter=lfs diff=lfs merge=lfs -text
+*.sketch filter=lfs diff=lfs merge=lfs -text
+# Video
+*.mp4  filter=lfs diff=lfs merge=lfs -text
+*.mov  filter=lfs diff=lfs merge=lfs -text
+*.m4v  filter=lfs diff=lfs merge=lfs -text
+*.mkv  filter=lfs diff=lfs merge=lfs -text
+*.avi  filter=lfs diff=lfs merge=lfs -text
+*.wmv  filter=lfs diff=lfs merge=lfs -text
+*.flv  filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+*.mpeg filter=lfs diff=lfs merge=lfs -text
+*.mpg  filter=lfs diff=lfs merge=lfs -text
+# Audio
+*.mp3  filter=lfs diff=lfs merge=lfs -text
+*.wav  filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.aac  filter=lfs diff=lfs merge=lfs -text
+*.ogg  filter=lfs diff=lfs merge=lfs -text
+*.m4a  filter=lfs diff=lfs merge=lfs -text
+# 3D / CAD / DCC
+*.blend filter=lfs diff=lfs merge=lfs -text
+*.fbx   filter=lfs diff=lfs merge=lfs -text
+*.obj   filter=lfs diff=lfs merge=lfs -text
+*.stl   filter=lfs diff=lfs merge=lfs -text
+*.glb   filter=lfs diff=lfs merge=lfs -text
+*.gltf  filter=lfs diff=lfs merge=lfs -text
+*.usd   filter=lfs diff=lfs merge=lfs -text
+*.usdz  filter=lfs diff=lfs merge=lfs -text
+*.max   filter=lfs diff=lfs merge=lfs -text
+*.c4d   filter=lfs diff=lfs merge=lfs -text
+*.dwg   filter=lfs diff=lfs merge=lfs -text
+*.dxf   filter=lfs diff=lfs merge=lfs -text
+*.step  filter=lfs diff=lfs merge=lfs -text
+*.stp   filter=lfs diff=lfs merge=lfs -text
+*.iges  filter=lfs diff=lfs merge=lfs -text
+*.igs   filter=lfs diff=lfs merge=lfs -text
+# Documents / publishing binaries
+*.pdf  filter=lfs diff=lfs merge=lfs -text
+*.indd filter=lfs diff=lfs merge=lfs -text
+*.idml filter=lfs diff=lfs merge=lfs -text
+*.ppt  filter=lfs diff=lfs merge=lfs -text
+*.pptx filter=lfs diff=lfs merge=lfs -text
+*.key  filter=lfs diff=lfs merge=lfs -text
+*.doc  filter=lfs diff=lfs merge=lfs -text
+*.docx filter=lfs diff=lfs merge=lfs -text
+# Archives / packaged artifacts
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.7z  filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.gz  filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.xz  filter=lfs diff=lfs merge=lfs -text
+# Fonts
+*.ttf  filter=lfs diff=lfs merge=lfs -text
+*.otf  filter=lfs diff=lfs merge=lfs -text
+*.woff filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
+# ML / data artifacts
+*.onnx      filter=lfs diff=lfs merge=lfs -text
+*.pt        filter=lfs diff=lfs merge=lfs -text
+*.pth       filter=lfs diff=lfs merge=lfs -text
+*.ckpt      filter=lfs diff=lfs merge=lfs -text
+*.pb        filter=lfs diff=lfs merge=lfs -text
+*.tflite    filter=lfs diff=lfs merge=lfs -text
+*.h5        filter=lfs diff=lfs merge=lfs -text
+*.hdf5      filter=lfs diff=lfs merge=lfs -text
+*.parquet   filter=lfs diff=lfs merge=lfs -text
+*.feather   filter=lfs diff=lfs merge=lfs -text
+*.arrow     filter=lfs diff=lfs merge=lfs -text
+*.npy       filter=lfs diff=lfs merge=lfs -text
+*.npz       filter=lfs diff=lfs merge=lfs -text
+*.pickle    filter=lfs diff=lfs merge=lfs -text
+*.pkl       filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
 *.psd filter=lfs diff=lfs merge=lfs -text

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+open_collective: libomathorg
+github: orange-cpp

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

@@ -1,4 +1,4 @@
-name: Omath CI (Arch Linux / Windows)
+name: Omath CI
 
 on:
   push:
@@ -10,24 +10,82 @@ concurrency:
   group: ci-${{ github.ref }}
   cancel-in-progress: true
 
-
 ##############################################################################
-# 1)  ARCH LINUX  –  Clang / Ninja
+# 1)  Linux  –  Clang / Ninja
 ##############################################################################
 jobs:
-  arch-build-and-test:
-    name: Arch Linux (Clang)
-    runs-on: ubuntu-latest
-    container: archlinux:latest
+  linux-build-and-test:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: Linux (Clang) (x64-linux)
+            triplet: x64-linux
+            runner: ubuntu-latest
+            preset: linux-release-vcpkg
+            coverage: true
+            install_cmd: |
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              sudo apt-get update
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev \
+                     llvm-21
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+          - name: Linux (Clang) (x86-linux)
+            triplet: x86-linux
+            runner: ubuntu-latest
+            preset: linux-release-vcpkg-x86
+            coverage: false
+            install_cmd: |
+              # Add LLVM 21 repository
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              # Add GCC Toolchain PPA
+              sudo add-apt-repository -y "deb http://archive.ubuntu.com/ubuntu plucky main universe"
+              # Enable i386 architecture
+              sudo dpkg --add-architecture i386
+              sudo apt-get update
+              # Install Clang 21
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev
+              sudo apt-get install -y -t plucky binutils
+              # Install GCC 15 with multilib support
+              sudo apt-get install -y gcc-15-multilib g++-15-multilib
+              # Set up alternatives for Clang
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+              # Set up alternatives for GCC
+              sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-15 100
+              sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-15 100
+          - name: Linux (Clang) (arm64-linux)
+            triplet: arm64-linux
+            runner: ubuntu-24.04-arm
+            preset: linux-release-vcpkg-arm64
+            coverage: false
+            install_cmd: |
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              sudo apt-get update
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+      fail-fast: false
     env:
       VCPKG_ROOT: ${{ github.workspace }}/vcpkg
     steps:
-      - name: Install basic tool-chain with pacman
+      - name: Install basic tool-chain
         shell: bash
-        run: |
-          pacman -Sy --noconfirm archlinux-keyring
-          pacman -Syu --noconfirm --needed \
-                 git base-devel clang cmake ninja zip unzip fmt
+        run: ${{ matrix.install_cmd }}
 
       - name: Checkout repository (with sub-modules)
         uses: actions/checkout@v4
@@ -38,29 +96,82 @@ jobs:
         shell: bash
         run: |
           git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
       - name: Configure (cmake --preset)
         shell: bash
-        run: cmake --preset linux-release-vcpkg -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
-        run: cmake --build cmake-build/build/linux-release-vcpkg --target unit_tests omath
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
 
       - name: Run unit_tests
         shell: bash
         run: ./out/Release/unit_tests
 
+      - name: Run Coverage
+        if: ${{ matrix.coverage == true }}
+        shell: bash
+        run: |
+          sudo apt-get install lcov
+          chmod +x scripts/coverage-llvm.sh
+          ./scripts/coverage-llvm.sh \
+            "${{ github.workspace }}" \
+            "cmake-build/build/${{ matrix.preset }}" \
+            "./out/Release/unit_tests" \
+            "cmake-build/build/${{ matrix.preset }}/coverage"
 
+      - name: Upload Coverage Report
+        if: ${{ matrix.coverage == true }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report-linux
+          path: cmake-build/build/${{ matrix.preset }}/coverage/
 
-  ##############################################################################
-  # 2)  Windows  –  MSVC / Ninja
-  ##############################################################################
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+##############################################################################
+# 2)  Windows  –  MSVC / Ninja
+##############################################################################
   windows-build-and-test:
-    name: Windows (MSVC)
-    runs-on: windows-latest
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: Windows (MSVC) (x64-windows)
+            runner: windows-latest
+            arch: amd64
+            preset: windows-release-vcpkg
+            triplet: x64-windows
+          - name: Windows (MSVC) (x86-windows)
+            runner: windows-latest
+            arch: amd64_x86
+            preset: windows-release-vcpkg-x86
+            triplet: x86-windows
+          - name: Windows (MSVC) (arm64-windows)
+            runner: windows-11-arm
+            arch: arm64
+            preset: windows-release-vcpkg-arm64
+            triplet: arm64-windows
+      fail-fast: false
     env:
-      OMATH_BUILD_VIA_VCPKG: ON
-
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
     steps:
       - name: Checkout repository (with sub-modules)
         uses: actions/checkout@v4
@@ -72,25 +183,171 @@ jobs:
 
       - name: Set up MSVC developer command-prompt
         uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.arch }}
 
       - name: Configure (cmake --preset)
         shell: bash
-        run: cmake --preset windows-release-vcpkg -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DOMATH_ENABLE_COVERAGE=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
-        run: cmake --build cmake-build/build/windows-release-vcpkg --target unit_tests omath
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
 
       - name: Run unit_tests.exe
         shell: bash
         run: ./out/Release/unit_tests.exe
 
+      ##########################################################################
+      # Coverage (x64-windows only)
+      ##########################################################################
+      - name: Install LLVM
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        run: |
+          choco install llvm -y
+
+      - name: Clean Build Directory for Coverage
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: pwsh
+        run: |
+          $buildDir = "cmake-build/build/${{ matrix.preset }}"
+          if (Test-Path $buildDir) {
+            Write-Host "Cleaning build directory to prevent compiler conflict: $buildDir"
+            Remove-Item -Path $buildDir -Recurse -Force
+          }
+
+      - name: Build Debug for Coverage
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DCMAKE_C_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" \
+            -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" \
+            -DCMAKE_LINKER="C:/Program Files/LLVM/bin/lld-link.exe" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DOMATH_ENABLE_COVERAGE=ON \
+            -DOMATH_THREAT_WARNING_AS_ERROR=OFF \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
+          cmake --build cmake-build/build/${{ matrix.preset }} --config Debug --target unit_tests omath
+
+      - name: Run Tests (Generates .profraw)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: pwsh
+        env:
+          LLVM_PROFILE_FILE: "cmake-build/build/${{ matrix.preset }}/unit_tests.profraw"
+        run: |
+          ./out/Debug/unit_tests.exe
+
+      - name: Process Coverage (llvm-profdata & llvm-cov)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: pwsh
+        run: |
+          $BUILD_DIR = "cmake-build/build/${{ matrix.preset }}"
+          $EXE_PATH = "./out/Debug/unit_tests.exe"
+          
+          # 1. Merge raw profile data (essential step)
+          & "C:/Program Files/LLVM/bin/llvm-profdata.exe" merge `
+            -sparse "$BUILD_DIR/unit_tests.profraw" `
+            -o "$BUILD_DIR/unit_tests.profdata"
+
+          # 2. Export to LCOV format
+          #    NOTE: We explicitly ignore vcpkg_installed and system headers
+          & "C:/Program Files/LLVM/bin/llvm-cov.exe" export "$EXE_PATH" `
+            -instr-profile="$BUILD_DIR/unit_tests.profdata" `
+            -format=lcov `
+            -ignore-filename-regex="vcpkg_installed|external|tests" `
+            > "$BUILD_DIR/lcov.info"
+
+          if (Test-Path "$BUILD_DIR/lcov.info") {
+            Write-Host "✅ LCOV info created at $BUILD_DIR/lcov.info"
+          } else {
+            Write-Error "Failed to create LCOV info"
+            exit 1
+          }
+
+      - name: Install LCOV (for genhtml)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        run: choco install lcov -y
+
+      - name: Generate HTML Report
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: bash
+        run: |
+          BUILD_DIR="cmake-build/build/${{ matrix.preset }}"
+          LCOV_INFO="${BUILD_DIR}/lcov.info"
+          HTML_DIR="${BUILD_DIR}/coverage-html"
+
+          # Fix paths for genhtml (Perl hates backslashes)
+          sed -i 's|\\|/|g' "${LCOV_INFO}"
+          
+          # Locate genhtml provided by 'choco install lcov'
+          # It is typically in ProgramData/chocolatey/lib/lcov/tools/bin
+          GENHTML=$(find /c/ProgramData/chocolatey -name genhtml -print -quit)
+          
+          if [ -z "$GENHTML" ]; then
+            echo "Error: genhtml executable not found"
+            exit 1
+          fi
+          
+          echo "Using genhtml: $GENHTML"
+          mkdir -p "$HTML_DIR"
+          
+          # Run genhtml
+          # Added --demangle-cpp if your version supports it, otherwise remove it
+          perl "$GENHTML" \
+            "${LCOV_INFO}" \
+            --output-directory "$HTML_DIR" \
+            --title "OMath Coverage Report" \
+            --legend \
+            --show-details \
+            --branch-coverage \
+            --ignore-errors source
+            
+          echo "✅ LCOV HTML report generated at $HTML_DIR"
+
+      - name: Upload Coverage (HTML Report)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html-windows
+          path: cmake-build/build/${{ matrix.preset }}/coverage-html/
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
   ##############################################################################
   # 3)  macOS  –  AppleClang / Ninja
   ##############################################################################
   macosx-build-and-test:
-    name: macOS (AppleClang)
-    runs-on: macOS-latest
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: macOS (AppleClang) (arm64-osx)
+            runner: macos-latest
+            preset: darwin-release-vcpkg
+            triplet: arm64-osx
+            coverage: true
+          - name: macOS (AppleClang) (x64-osx)
+            runner: macos-15-intel
+            preset: darwin-release-vcpkg-x64
+            triplet: x64-osx
+            coverage: false
+      fail-fast: false
     env:
       VCPKG_ROOT: ${{ github.workspace }}/vcpkg
     steps:
@@ -111,12 +368,446 @@ jobs:
           
       - name: Configure (cmake --preset)
         shell: bash
-        run: cmake --preset darwin-release-vcpkg -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
-        run: cmake --build cmake-build/build/darwin-release-vcpkg --target unit_tests omath
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
 
       - name: Run unit_tests
         shell: bash
         run: ./out/Release/unit_tests
+
+      - name: Run Coverage
+        if: ${{ matrix.coverage == true }}
+        shell: bash
+        run: |
+          brew install lcov
+          chmod +x scripts/coverage-llvm.sh
+          ./scripts/coverage-llvm.sh \
+            "${{ github.workspace }}" \
+            "cmake-build/build/${{ matrix.preset }}" \
+            "./out/Release/unit_tests" \
+            "cmake-build/build/${{ matrix.preset }}/coverage"
+
+      - name: Upload Coverage Report
+        if: ${{ matrix.coverage == true }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report-macos
+          path: cmake-build/build/${{ matrix.preset }}/coverage/
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: macos-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+  ##############################################################################
+  # 4)  iOS  –  AppleClang / Xcode / arm64-ios
+  ##############################################################################
+  ios-build:
+    name: iOS (AppleClang) (${{ matrix.triplet }})
+    runs-on: macOS-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: arm64-ios
+            preset: ios-release-vcpkg
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install CMake tooling
+        shell: bash
+        run: |
+          brew install cmake ninja
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --config Release --target unit_tests omath
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: ios-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+  ##############################################################################
+  # 5)  FreeBSD  –  Clang / Ninja
+  ##############################################################################
+  freebsd-build-and-test:
+    name: FreeBSD (Clang) (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: x64-freebsd
+            preset: freebsd-release-vcpkg
+            arch: x86-64
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/tmp/vcpkg
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build and Test
+        uses: cross-platform-actions/action@v0.31.0
+        with:
+          operating_system: freebsd
+          architecture: ${{ matrix.arch }}
+          version: '15.0'
+          memory: '12G'
+          cpu_count: 4
+          run: |
+            sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
+            git config --global --add safe.directory `pwd`
+            # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
+            export VCPKG_ROOT=/tmp/vcpkg
+            rm -rf "$VCPKG_ROOT"
+            git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+            cd "$VCPKG_ROOT"
+            ./bootstrap-vcpkg.sh
+            cd -
+            export VCPKG_FORCE_SYSTEM_BINARIES=0
+            cmake --preset ${{ matrix.preset }} \
+              -DOMATH_BUILD_TESTS=ON \
+              -DOMATH_BUILD_BENCHMARK=OFF \
+              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" \
+              -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
+            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+            ./out/Release/unit_tests
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: freebsd-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+  ##############################################################################
+  # 6)  Android NDK  –  Clang / Ninja
+  ##############################################################################
+  android-build:
+    name: Android NDK (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: arm-neon-android
+            preset: android-arm-neon-release-vcpkg
+          - triplet: arm64-android
+            preset: android-arm64-release-vcpkg
+          - triplet: x64-android
+            preset: android-x64-release-vcpkg
+          - triplet: x86-android
+            preset: android-x86-release-vcpkg
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+      ANDROID_NDK_HOME: ${{ github.workspace }}/android-ndk
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Android NDK
+        shell: bash
+        run: |
+          NDK_VERSION="r28b"
+          NDK_ZIP="android-ndk-${NDK_VERSION}-linux.zip"
+          wget -q "https://dl.google.com/android/repository/${NDK_ZIP}"
+          unzip -q "${NDK_ZIP}" -d "${{ github.workspace }}"
+          mv "${{ github.workspace }}/android-ndk-${NDK_VERSION}" "$ANDROID_NDK_HOME"
+          rm "${NDK_ZIP}"
+          echo "ANDROID_NDK_HOME=${ANDROID_NDK_HOME}" >> $GITHUB_ENV
+
+      - name: Install basic tool-chain
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build cmake
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: android-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+  ##############################################################################
+  # 7)  WebAssembly (Emscripten)  –  Clang / Ninja / wasm32-emscripten
+  ##############################################################################
+  wasm-build-and-test:
+    name: WebAssembly (Emscripten) (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: wasm32-emscripten
+            preset: wasm-release-vcpkg
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install basic tool-chain
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build
+
+      - name: Setup Emscripten
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 'latest'
+
+      - name: Verify Emscripten
+        shell: bash
+        run: |
+          echo "EMSDK=$EMSDK"
+          emcc --version
+          # Verify toolchain file exists
+          ls -la "$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: wasm-build-logs-${{ matrix.triplet }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Run WASM Unit Tests
+        run: node out/Release/unit_tests.js
+
+  ##############################################################################
+  # 8)  Windows MSYS2 MinGW  –  GCC / Ninja
+  ##############################################################################
+  mingw-build-and-test:
+    name: ${{ matrix.name }}
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        include:
+          - name: MINGW64 (MSYS2) (x64-mingw-dynamic)
+            msystem: MINGW64
+            pkg_prefix: mingw-w64-x86_64
+            preset: mingw-release-vcpkg
+          - name: UCRT64 (MSYS2) (x64-mingw-dynamic)
+            msystem: UCRT64
+            pkg_prefix: mingw-w64-ucrt-x86_64
+            preset: mingw-release-vcpkg
+          - name: MINGW32 (MSYS2) (x86-mingw-dynamic)
+            msystem: MINGW32
+            pkg_prefix: mingw-w64-i686
+            preset: mingw32-release-vcpkg
+      fail-fast: false
+    
+    defaults:
+      run:
+        shell: msys2 {0}
+    
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    
+    steps:
+      - name: Setup MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          update: true
+          install: >-
+            ${{ matrix.pkg_prefix }}-toolchain
+            ${{ matrix.pkg_prefix }}-cmake
+            ${{ matrix.pkg_prefix }}-ninja
+            ${{ matrix.pkg_prefix }}-pkg-config
+            git
+            base-devel
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
+
+      - name: Build
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+
+      - name: Run unit_tests.exe
+        run: |
+          ./out/Release/unit_tests.exe
+
+      - name: Upload logs on failure
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: mingw-build-logs-${{ matrix.msystem }}
+          path: |
+            cmake-build/build/${{ matrix.preset }}/**/*.log
+            ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+
+  ##############################################################################
+  # 9)  Valgrind Memory Check
+  ##############################################################################
+  valgrind-memory-check:
+    name: Valgrind Analysis (All Targets)
+    runs-on: ubuntu-latest
+    needs: [linux-build-and-test]
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install toolchain
+        shell: bash
+        run: |
+          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+          sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+          sudo apt-get update
+          sudo apt-get install -y git build-essential cmake ninja-build \
+            zip unzip curl pkg-config ca-certificates \
+            clang-21 lld-21 libc++-21-dev libc++abi-21-dev \
+            llvm-21 valgrind libxmu-dev libxi-dev libgl-dev libxinerama-dev libxcursor-dev xorg-dev libglu1-mesa-dev
+          sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+          sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+          sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset linux-release-vcpkg \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DOMATH_BUILD_EXAMPLES=OFF \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=ON \
+            -DOMATH_ENABLE_VALGRIND=ON \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;lua;tests;benchmark"
+
+      - name: Build All Targets
+        shell: bash
+        run: cmake --build cmake-build/build/linux-release-vcpkg
+
+      - name: Run Valgrind (All Registered Targets)
+        shell: bash
+        working-directory: cmake-build/build/linux-release-vcpkg
+        run: |
+          cmake --build . --target valgrind_all

.github/workflows/release.yml

@@ -0,0 +1,618 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+
+jobs:
+  ##############################################################################
+  # 1)  Linux  –  Clang / Ninja
+  ##############################################################################
+  linux-release:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: Linux (Clang) (x64-linux)
+            triplet: x64-linux
+            runner: ubuntu-latest
+            preset: linux-release-vcpkg
+            archive: omath-linux-x64
+            install_cmd: |
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              sudo apt-get update
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+          - name: Linux (Clang) (x86-linux)
+            triplet: x86-linux
+            runner: ubuntu-latest
+            preset: linux-release-vcpkg-x86
+            archive: omath-linux-x86
+            install_cmd: |
+              # Add LLVM 21 repository
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              # Add GCC Toolchain PPA
+              sudo add-apt-repository -y "deb http://archive.ubuntu.com/ubuntu plucky main universe"
+              # Enable i386 architecture
+              sudo dpkg --add-architecture i386
+              sudo apt-get update
+              # Install Clang 21
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev
+              sudo apt-get install -y -t plucky binutils
+              # Install GCC 15 with multilib support
+              sudo apt-get install -y gcc-15-multilib g++-15-multilib
+              # Set up alternatives for Clang
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+              # Set up alternatives for GCC
+              sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-15 100
+              sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-15 100
+          - name: Linux (Clang) (arm64-linux)
+            triplet: arm64-linux
+            runner: ubuntu-24.04-arm
+            preset: linux-release-vcpkg-arm64
+            archive: omath-linux-arm64
+            install_cmd: |
+              wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+              sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+              sudo apt-get update
+              sudo apt-get install -y git build-essential cmake ninja-build \
+                     zip unzip curl pkg-config ca-certificates \
+                     clang-21 lld-21 libc++-21-dev libc++abi-21-dev
+              sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+              sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+              sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install basic tool-chain
+        shell: bash
+        run: ${{ matrix.install_cmd }}
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2"
+
+      - name: Build
+        shell: bash
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: bash
+        run: tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 2)  Windows  –  MSVC / Ninja
+  ##############################################################################
+  windows-release:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: Windows (MSVC) (x64-windows)
+            runner: windows-latest
+            arch: amd64
+            preset: windows-release-vcpkg
+            triplet: x64-windows
+            archive: omath-windows-x64
+          - name: Windows (MSVC) (x86-windows)
+            runner: windows-latest
+            arch: amd64_x86
+            preset: windows-release-vcpkg-x86
+            triplet: x86-windows
+            archive: omath-windows-x86
+          - name: Windows (MSVC) (arm64-windows)
+            runner: windows-11-arm
+            arch: arm64
+            preset: windows-release-vcpkg-arm64
+            triplet: arm64-windows
+            archive: omath-windows-arm64
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    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
+        with:
+          arch: ${{ matrix.arch }}
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2"
+
+      - name: Build
+        shell: bash
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: pwsh
+        run: Compress-Archive -Path staging\* -DestinationPath "${{ matrix.archive }}.zip"
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.zip" --clobber
+
+  ##############################################################################
+  # 3)  macOS  –  AppleClang / Ninja
+  ##############################################################################
+  macos-release:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - name: macOS (AppleClang) (arm64-osx)
+            runner: macos-latest
+            preset: darwin-release-vcpkg
+            triplet: arm64-osx
+            archive: omath-macos-arm64
+          - name: macOS (AppleClang) (x64-osx)
+            runner: macos-15-intel
+            preset: darwin-release-vcpkg-x64
+            triplet: x64-osx
+            archive: omath-macos-x64
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install basic tool-chain with Homebrew
+        shell: bash
+        run: |
+          brew install cmake ninja
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2"
+
+      - name: Build
+        shell: bash
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: bash
+        run: tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 4)  iOS  –  AppleClang / Xcode / arm64-ios
+  ##############################################################################
+  ios-release:
+    name: iOS (AppleClang) (${{ matrix.triplet }})
+    runs-on: macOS-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: arm64-ios
+            preset: ios-release-vcpkg
+            archive: omath-ios-arm64
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install CMake tooling
+        shell: bash
+        run: |
+          brew install cmake ninja
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --config Release --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: bash
+        run: tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 5)  FreeBSD  –  Clang / Ninja
+  ##############################################################################
+  freebsd-release:
+    name: FreeBSD (Clang) (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: x64-freebsd
+            preset: freebsd-release-vcpkg
+            arch: x86-64
+            archive: omath-freebsd-x64
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/tmp/vcpkg
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build and Package
+        uses: cross-platform-actions/action@v0.31.0
+        with:
+          operating_system: freebsd
+          architecture: ${{ matrix.arch }}
+          version: '15.0'
+          memory: '12G'
+          cpu_count: 4
+          run: |
+            sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
+            git config --global --add safe.directory `pwd`
+            # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
+            export VCPKG_ROOT=/tmp/vcpkg
+            rm -rf "$VCPKG_ROOT"
+            git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+            cd "$VCPKG_ROOT"
+            ./bootstrap-vcpkg.sh
+            cd -
+            export VCPKG_FORCE_SYSTEM_BINARIES=0
+            cmake --preset ${{ matrix.preset }} \
+              -DOMATH_BUILD_TESTS=OFF \
+              -DOMATH_BUILD_BENCHMARK=OFF \
+              -DVCPKG_MANIFEST_FEATURES="imgui;avx2" \
+              -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
+            cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+            cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+            tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 6)  Android NDK  –  Clang / Ninja
+  ##############################################################################
+  android-release:
+    name: Android NDK (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: arm-neon-android
+            preset: android-arm-neon-release-vcpkg
+            archive: omath-android-arm-neon
+          - triplet: arm64-android
+            preset: android-arm64-release-vcpkg
+            archive: omath-android-arm64
+          - triplet: x64-android
+            preset: android-x64-release-vcpkg
+            archive: omath-android-x64
+          - triplet: x86-android
+            preset: android-x86-release-vcpkg
+            archive: omath-android-x86
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+      ANDROID_NDK_HOME: ${{ github.workspace }}/android-ndk
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Android NDK
+        shell: bash
+        run: |
+          NDK_VERSION="r28b"
+          NDK_ZIP="android-ndk-${NDK_VERSION}-linux.zip"
+          wget -q "https://dl.google.com/android/repository/${NDK_ZIP}"
+          unzip -q "${NDK_ZIP}" -d "${{ github.workspace }}"
+          mv "${{ github.workspace }}/android-ndk-${NDK_VERSION}" "$ANDROID_NDK_HOME"
+          rm "${NDK_ZIP}"
+          echo "ANDROID_NDK_HOME=${ANDROID_NDK_HOME}" >> $GITHUB_ENV
+
+      - name: Install basic tool-chain
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build cmake
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: bash
+        run: tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 7)  WebAssembly (Emscripten)  –  Clang / Ninja / wasm32-emscripten
+  ##############################################################################
+  wasm-release:
+    name: WebAssembly (Emscripten) (${{ matrix.triplet }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - triplet: wasm32-emscripten
+            preset: wasm-release-vcpkg
+            archive: omath-wasm32
+      fail-fast: false
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install basic tool-chain
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build
+
+      - name: Setup Emscripten
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 'latest'
+
+      - name: Verify Emscripten
+        shell: bash
+        run: |
+          echo "EMSDK=$EMSDK"
+          emcc --version
+          ls -la "$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        shell: bash
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: bash
+        run: tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.tar.gz" --clobber
+
+  ##############################################################################
+  # 8)  Windows MSYS2 MinGW  –  GCC / Ninja
+  ##############################################################################
+  mingw-release:
+    name: ${{ matrix.name }}
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        include:
+          - name: MINGW64 (MSYS2) (x64-mingw-dynamic)
+            msystem: MINGW64
+            pkg_prefix: mingw-w64-x86_64
+            preset: mingw-release-vcpkg
+            archive: omath-mingw64-x64
+          - name: UCRT64 (MSYS2) (x64-mingw-dynamic)
+            msystem: UCRT64
+            pkg_prefix: mingw-w64-ucrt-x86_64
+            preset: mingw-release-vcpkg
+            archive: omath-ucrt64-x64
+          - name: MINGW32 (MSYS2) (x86-mingw-dynamic)
+            msystem: MINGW32
+            pkg_prefix: mingw-w64-i686
+            preset: mingw32-release-vcpkg
+            archive: omath-mingw32-x86
+      fail-fast: false
+
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+
+    steps:
+      - name: Setup MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          update: true
+          install: >-
+            ${{ matrix.pkg_prefix }}-toolchain
+            ${{ matrix.pkg_prefix }}-cmake
+            ${{ matrix.pkg_prefix }}-ninja
+            ${{ matrix.pkg_prefix }}-pkg-config
+            git
+            base-devel
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui"
+
+      - name: Build
+        run: |
+          cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+
+      - name: Install
+        run: cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+
+      - name: Package
+        shell: pwsh
+        run: Compress-Archive -Path staging\* -DestinationPath "${{ matrix.archive }}.zip"
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: gh release upload "${{ github.event.release.tag_name }}" "${{ matrix.archive }}.zip" --clobber

.gitignore

@@ -2,4 +2,14 @@
 /out
 *.DS_Store
 /extlibs/vcpkg
-.idea/workspace.xml
+.idea/workspace.xml
+/build/
+/clang-coverage/
+*.gcov
+*.bin
+# pixi lock
+pixi.lock
+# pixi environments
+.pixi/*
+!.pixi/config.toml
+/site/

.idea/editor.xml

@@ -17,7 +17,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppBoostFormatTooManyArgs/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCVQualifierCanNotBeAppliedToReference/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="HINT" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassIsIncomplete/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeedsConstructorBecauseOfUninitializedMember/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
@@ -56,6 +56,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultInitializationWithNoUserConstructor/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultIsUsedAsIdentifier/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultedSpecialMemberFunctionIsImplicitlyDeleted/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefinitionsOrder/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDeletingVoidPointer/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDependentTemplateWithoutTemplateKeyword/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDependentTypeWithoutTypenameKeyword/@EntryIndexedValue" value="WARNING" type="string" />
@@ -109,7 +110,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLambdaCaptureNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMayBeConst/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMightNotBeInitialized/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLongFloat/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeConst/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeStatic/@EntryIndexedValue" value="SUGGESTION" type="string" />
@@ -201,7 +202,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -215,7 +216,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />

.idea/omath.iml

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

.luarc.json

@@ -0,0 +1,5 @@
+{
+    "diagnostics.globals": [
+        "omath"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": " Unit Tests (Debug)",
+            "type": "lldb",
+            "request": "launch",
+            "program": "${workspaceRoot}/out/Debug/unit_tests",
+            "args": [],
+            "cwd": "${workspaceRoot}"
+        },
+        {
+            "name": " Unit Tests (Release)",
+            "type": "lldb",
+            "request": "launch",
+            "program": "${workspaceRoot}/out/Release/unit_tests",
+            "args": [],
+            "cwd": "${workspaceRoot}"
+        }
+    ]
+}

CMakeLists.txt

@@ -6,47 +6,64 @@ project(omath VERSION ${OMATH_VERSION} LANGUAGES CXX)
 include(CMakePackageConfigHelpers)
 include(CheckCXXCompilerFlag)
 
-if (MSVC)
+include(cmake/Coverage.cmake)
+include(cmake/Valgrind.cmake)
+
+if(MSVC)
     check_cxx_compiler_flag("/arch:AVX2" COMPILER_SUPPORTS_AVX2)
-else ()
+else()
     check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
-endif ()
+endif()
 
 option(OMATH_BUILD_TESTS "Build unit tests" OFF)
 option(OMATH_BUILD_BENCHMARK "Build benchmarks" OFF)
-option(OMATH_THREAT_WARNING_AS_ERROR "Set highest level of warnings and force compiler to treat them as errors" ON)
+option(OMATH_THREAT_WARNING_AS_ERROR
+       "Set highest level of warnings and force compiler to treat them as errors" ON)
 option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" ${COMPILER_SUPPORTS_AVX2})
 option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types to imgui types" OFF)
 option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" OFF)
 option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY "Force Omath to link static runtime" OFF)
-option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
-option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" OFF)
-option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" ON)
+option(OMATH_ENABLE_LEGACY
+       "Will enable legacy classes that MUST be used ONLY for backward compatibility" ON)
+option(OMATH_SUPRESS_SAFETY_CHECKS
+       "Supress some safety checks in release build to improve general performance" ON)
+option(OMATH_ENABLE_COVERAGE "Enable coverage" OFF)
+option(OMATH_ENABLE_FORCE_INLINE
+       "Will for compiler to make some functions to be force inlined no matter what" ON)
 
-
-if (VCPKG_MANIFEST_FEATURES)
-    foreach (omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
-        if (omath_feature STREQUAL "imgui")
+option(OMATH_ENABLE_LUA
+        "omath bindings for lua" OFF)
+if(VCPKG_MANIFEST_FEATURES)
+    foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
+        if(omath_feature STREQUAL "imgui")
             set(OMATH_IMGUI_INTEGRATION ON)
-        elseif (omath_feature STREQUAL "avx2")
+        elseif(omath_feature STREQUAL "avx2")
             set(OMATH_USE_AVX2 ${COMPILER_SUPPORTS_AVX2})
-        elseif (omath_feature STREQUAL "tests")
+        elseif(omath_feature STREQUAL "tests")
             set(OMATH_BUILD_TESTS ON)
-        elseif (omath_feature STREQUAL "benchmark")
+        elseif(omath_feature STREQUAL "benchmark")
             set(OMATH_BUILD_BENCHMARK ON)
-        endif ()
+        elseif(omath_feature STREQUAL "examples")
+            set(OMATH_BUILD_EXAMPLES ON)
+        elseif(omath_feature STREQUAL "lua")
+            set(OMATH_ENABLE_LUA ON)
+        endif()
 
-    endforeach ()
-endif ()
+    endforeach()
+endif()
 
-if (OMATH_USE_AVX2 AND NOT COMPILER_SUPPORTS_AVX2)
-    message(WARNING "OMATH_USE_AVX2 requested, but compiler/target does not support AVX2. Disabling.")
+if(OMATH_USE_AVX2 AND NOT COMPILER_SUPPORTS_AVX2)
+    message(
+        WARNING "OMATH_USE_AVX2 requested, but compiler/target does not support AVX2. Disabling.")
     set(OMATH_USE_AVX2 OFF CACHE BOOL "Omath will use AVX2 to boost performance" FORCE)
-endif ()
+endif()
 
-if (${PROJECT_IS_TOP_LEVEL})
-    message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}, compiler ${CMAKE_CXX_COMPILER_ID}")
+if(${PROJECT_IS_TOP_LEVEL})
+    message(
+        STATUS
+            "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}, compiler ${CMAKE_CXX_COMPILER_ID}"
+        )
     message(STATUS "[${PROJECT_NAME}]: Warnings as errors ${OMATH_THREAT_WARNING_AS_ERROR}")
     message(STATUS "[${PROJECT_NAME}]: Build unit tests ${OMATH_BUILD_TESTS}")
     message(STATUS "[${PROJECT_NAME}]: Build benchmark ${OMATH_BUILD_BENCHMARK}")
@@ -58,152 +75,179 @@ if (${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: ImGUI integration feature status ${OMATH_IMGUI_INTEGRATION}")
     message(STATUS "[${PROJECT_NAME}]: Legacy features support ${OMATH_ENABLE_LEGACY}")
     message(STATUS "[${PROJECT_NAME}]: Building using vcpkg ${OMATH_BUILD_VIA_VCPKG}")
-endif ()
+    message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}")
+    message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}")
+    message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}")
+endif()
 
 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)
+if(OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(${PROJECT_NAME} SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
-else ()
+else()
     add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
-endif ()
+endif()
 
+if (OMATH_ENABLE_LUA)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA)
+
+    find_package(Lua REQUIRED)
+    target_include_directories(${PROJECT_NAME} PRIVATE ${LUA_INCLUDE_DIR})
+    target_link_libraries(${PROJECT_NAME} PRIVATE ${LUA_LIBRARIES})
+
+    find_path(SOL2_INCLUDE_DIRS "sol/abort.hpp")
+    target_include_directories(${PROJECT_NAME} PRIVATE ${SOL2_INCLUDE_DIRS})
+endif ()
 
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
 
-if (OMATH_IMGUI_INTEGRATION)
+if(OMATH_IMGUI_INTEGRATION)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_IMGUI_INTEGRATION)
 
     # IMGUI is being linked as submodule
-    if (TARGET imgui)
+    if(TARGET imgui)
         target_link_libraries(${PROJECT_NAME} PUBLIC imgui)
-        install(TARGETS imgui
-                EXPORT omathTargets
-                ARCHIVE DESTINATION lib
-                LIBRARY DESTINATION lib
-                RUNTIME DESTINATION bin)
-    else ()
+        install(
+            TARGETS imgui
+            EXPORT omathTargets
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+            RUNTIME DESTINATION bin)
+    else()
         # Assume that IMGUI linked via VCPKG.
         find_package(imgui CONFIG REQUIRED)
         target_link_libraries(${PROJECT_NAME} PUBLIC imgui::imgui)
-    endif ()
+    endif()
 
-endif ()
+endif()
 
-if (OMATH_USE_AVX2)
+if(OMATH_USE_AVX2)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_USE_AVX2)
-endif ()
+endif()
 
-if (OMATH_SUPRESS_SAFETY_CHECKS)
+if(OMATH_SUPRESS_SAFETY_CHECKS)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_SUPRESS_SAFETY_CHECKS)
-endif ()
+endif()
 
-if (OMATH_ENABLE_LEGACY)
+if(OMATH_ENABLE_LEGACY)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LEGACY)
-endif ()
+endif()
 
-set_target_properties(${PROJECT_NAME} PROPERTIES
-        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        CXX_STANDARD 23
-        CXX_STANDARD_REQUIRED ON)
+if(OMATH_ENABLE_FORCE_INLINE)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_FORCE_INLINE)
+endif()
 
-if (OMATH_USE_UNITY_BUILD)
-    set_target_properties(${PROJECT_NAME} PROPERTIES
-            UNITY_BUILD ON
-            UNITY_BUILD_BATCH_SIZE 20)
-endif ()
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               CXX_STANDARD 23
+               CXX_STANDARD_REQUIRED ON)
 
-if (OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
-    set_target_properties(${PROJECT_NAME} PROPERTIES
-            MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
-    )
-endif ()
+if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
+    set_target_properties(${PROJECT_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY
+                                                     "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+endif()
 
-if (OMATH_USE_AVX2)
-    if (MSVC)
+if(OMATH_USE_AVX2)
+    if(MSVC)
         target_compile_options(${PROJECT_NAME} PUBLIC /arch:AVX2)
-    elseif (EMSCRIPTEN)
+    elseif(EMSCRIPTEN)
         target_compile_options(${PROJECT_NAME} PUBLIC -msimd128 -mavx2)
-    elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
         target_compile_options(${PROJECT_NAME} PUBLIC -mfma -mavx2)
-    endif ()
-endif ()
+    endif()
+endif()
+
+if(EMSCRIPTEN)
+    target_compile_options(${PROJECT_NAME} PUBLIC -fexceptions)
+    target_link_options(${PROJECT_NAME} PUBLIC -fexceptions)
+endif()
 
 target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_23)
 
-if (OMATH_BUILD_TESTS)
+if(OMATH_BUILD_TESTS)
     add_subdirectory(tests)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_BUILD_TESTS)
-endif ()
+    if(OMATH_ENABLE_COVERAGE)
+        omath_setup_coverage(${PROJECT_NAME})
+    endif()
+endif()
 
-if (OMATH_BUILD_BENCHMARK)
+if(OMATH_BUILD_BENCHMARK)
     add_subdirectory(benchmark)
-endif ()
+endif()
 
-if (OMATH_BUILD_EXAMPLES)
+if(OMATH_BUILD_EXAMPLES)
     add_subdirectory(examples)
-endif ()
+endif()
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND OMATH_THREAT_WARNING_AS_ERROR)
     target_compile_options(${PROJECT_NAME} PRIVATE /W4 /WX)
-elseif (OMATH_THREAT_WARNING_AS_ERROR)
+elseif(OMATH_THREAT_WARNING_AS_ERROR)
     target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic -Werror)
-endif ()
+endif()
 
-# Windows SDK redefine min/max via preprocessor and break std::min and std::max
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    target_compile_options(${PROJECT_NAME} PRIVATE /bigobj)
+endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_HOST_SYSTEM_NAME EQUAL "Windows")
+    target_compile_options(${PROJECT_NAME} PRIVATE -mbig-obj)
+endif()
+# Windows SDK redefine min/max via preprocessor and break std::min and std::max
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     target_compile_definitions(${PROJECT_NAME} INTERFACE NOMINMAX)
-endif ()
-
-target_include_directories(${PROJECT_NAME}
-        PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>   # Use this path when building the project
-        $<INSTALL_INTERFACE:include>                             # Use this path when the project is installed
-)
+endif()
 
+target_include_directories(
+    ${PROJECT_NAME}
+    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> # Use this path
+                                                                  # when building
+                                                                  # the project
+           $<INSTALL_INTERFACE:include> # Use this path when the project is
+                                        # installed
+    )
 
 # Installation rules
 
 # Install the library
-install(TARGETS ${PROJECT_NAME}
-        EXPORT ${PROJECT_NAME}Targets
-        ARCHIVE DESTINATION lib COMPONENT ${PROJECT_NAME}   # For static libraries
-        LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME}   # For shared libraries
-        RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME}   # For executables (on Windows)
-)
+install(
+    TARGETS ${PROJECT_NAME}
+    EXPORT ${PROJECT_NAME}Targets
+    ARCHIVE DESTINATION lib COMPONENT ${PROJECT_NAME} # For static libraries
+    LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME} # For shared libraries
+    RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME} # For executables (on
+                                                      # Windows)
+    )
 
 # Install headers as part of omath_component
 install(DIRECTORY include/ DESTINATION include COMPONENT ${PROJECT_NAME})
 
 # Export omath target for CMake find_package support, also under omath_component
-install(EXPORT ${PROJECT_NAME}Targets
-        FILE ${PROJECT_NAME}Targets.cmake
-        NAMESPACE ${PROJECT_NAME}::
-        DESTINATION lib/cmake/${PROJECT_NAME} COMPONENT ${PROJECT_NAME}
-)
-
+install(
+    EXPORT ${PROJECT_NAME}Targets
+    FILE ${PROJECT_NAME}Targets.cmake
+    NAMESPACE ${PROJECT_NAME}::
+    DESTINATION lib/cmake/${PROJECT_NAME}
+    COMPONENT ${PROJECT_NAME})
 
 # Generate the omathConfigVersion.cmake file
-write_basic_package_version_file(
-        "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
-        VERSION ${PROJECT_VERSION}
-        COMPATIBILITY AnyNewerVersion
-)
+write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
+                                 VERSION ${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion)
 
-# Generate the omathConfig.cmake file from the template (which is in the cmake/ folder)
+# Generate the omathConfig.cmake file from the template (which is in the cmake/
+# folder)
 configure_package_config_file(
-        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/omathConfig.cmake.in"  # Path to the .in file
-        "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"           # Output path for the generated file
-        INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
-)
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/omathConfig.cmake.in" # Path to the .in
+                                                             # file
+    "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake" # Output path for the
+                                                    # generated file
+    INSTALL_DESTINATION lib/cmake/${PROJECT_NAME})
 
 # Install the generated config files
-install(FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
-        "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
-        DESTINATION lib/cmake/${PROJECT_NAME}
-)
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
+              "${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
+        DESTINATION lib/cmake/${PROJECT_NAME})

CMakePresets.json

@@ -1,15 +1,49 @@
 {
-  "version": 3,
+  "version": 6,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 25,
+    "patch": 0
+  },
+
   "configurePresets": [
     {
-      "name": "windows-base",
+      "name": "base",
       "hidden": true,
       "generator": "Ninja",
       "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
-      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
+      "installDir": "${sourceDir}/cmake-build/install/${presetName}"
+    },
+    {
+      "name": "vcpkg-base",
+      "hidden": true,
       "cacheVariables": {
-        "CMAKE_CXX_COMPILER": "cl.exe",
-        "CMAKE_MAKE_PROGRAM": "Ninja"
+        "OMATH_BUILD_VIA_VCPKG": "ON",
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed"
+      }
+    },
+    {
+      "name": "debug",
+      "hidden": true,
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
+    {
+      "name": "release",
+      "hidden": true,
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
+    },
+
+    {
+      "name": "windows-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_CXX_COMPILER": "cl.exe"
       },
       "condition": {
         "type": "equals",
@@ -18,59 +52,88 @@
       }
     },
     {
-      "name": "windows-base-vcpkg",
+      "name": "windows-vcpkg-base",
       "hidden": true,
-      "inherits": "windows-base",
+      "inherits": ["windows-base", "vcpkg-base"],
       "cacheVariables": {
-        "OMATH_BUILD_VIA_VCPKG": "ON",
-        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
-        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
       }
     },
     {
       "name": "windows-debug",
-      "displayName": "Debug",
-      "inherits": "windows-base",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
-    },
-    {
-      "name": "windows-debug-vcpkg",
-      "displayName": "Debug",
-      "inherits": "windows-base-vcpkg",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
-    },
-    {
-      "name": "windows-release-vcpkg",
-      "displayName": "Release",
-      "inherits": "windows-base-vcpkg",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "OMATH_BUILD_VIA_VCPKG": "ON"
-      }
+      "displayName": "Windows Debug",
+      "inherits": ["windows-base", "debug"]
     },
     {
       "name": "windows-release",
-      "displayName": "Release",
-      "inherits": "windows-base",
+      "displayName": "Windows Release",
+      "inherits": ["windows-base", "release"]
+    },
+    {
+      "name": "windows-debug-vcpkg",
+      "displayName": "Windows Debug (vcpkg)",
+      "inherits": ["windows-vcpkg-base", "debug"]
+    },
+    {
+      "name": "windows-release-vcpkg",
+      "displayName": "Windows Release (vcpkg)",
+      "inherits": ["windows-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "windows-x86-vcpkg-base",
+      "hidden": true,
+      "inherits": ["windows-base", "vcpkg-base"],
+      "architecture": {
+        "value": "x86",
+        "strategy": "external"
+      },
       "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
+        "VCPKG_TARGET_TRIPLET": "x86-windows",
+        "VCPKG_HOST_TRIPLET": "x64-windows",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
       }
     },
+    {
+      "name": "windows-debug-vcpkg-x86",
+      "displayName": "Windows x86 Debug (vcpkg)",
+      "inherits": ["windows-x86-vcpkg-base", "debug"]
+    },
+    {
+      "name": "windows-release-vcpkg-x86",
+      "displayName": "Windows x86 Release (vcpkg)",
+      "inherits": ["windows-x86-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "windows-arm64-vcpkg-base",
+      "hidden": true,
+      "inherits": ["windows-base", "vcpkg-base"],
+      "architecture": {
+        "value": "arm64",
+        "strategy": "external"
+      },
+      "cacheVariables": {
+        "VCPKG_TARGET_TRIPLET": "arm64-windows",
+        "VCPKG_HOST_TRIPLET": "arm64-windows",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;examples"
+      }
+    },
+    {
+      "name": "windows-debug-vcpkg-arm64",
+      "displayName": "Windows ARM64 Debug (vcpkg)",
+      "inherits": ["windows-arm64-vcpkg-base", "debug"]
+    },
+    {
+      "name": "windows-release-vcpkg-arm64",
+      "displayName": "Windows ARM64 Release (vcpkg)",
+      "inherits": ["windows-arm64-vcpkg-base", "release"]
+    },
+
     {
       "name": "linux-base",
       "hidden": true,
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
-      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
-      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": "clang++",
-        "CMAKE_MAKE_PROGRAM": "ninja"
-      },
+      "inherits": "base",
       "condition": {
         "type": "equals",
         "lhs": "${hostSystemName}",
@@ -78,57 +141,88 @@
       }
     },
     {
-      "name": "linux-base-vcpkg",
+      "name": "linux-vcpkg-base",
       "hidden": true,
-      "inherits": "linux-base",
+      "inherits": ["linux-base", "vcpkg-base"],
       "cacheVariables": {
-        "OMATH_BUILD_VIA_VCPKG": "ON",
-        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
-        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;lua"
       }
     },
     {
       "name": "linux-debug",
       "displayName": "Linux Debug",
-      "inherits": "linux-base",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
-    },
-    {
-      "name": "linux-debug-vcpkg",
-      "displayName": "Linux Debug",
-      "inherits": "linux-base-vcpkg",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
+      "inherits": ["linux-base", "debug"]
     },
     {
       "name": "linux-release",
       "displayName": "Linux Release",
-      "inherits": "linux-debug",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
-      }
+      "inherits": ["linux-base", "release"]
+    },
+    {
+      "name": "linux-debug-vcpkg",
+      "displayName": "Linux Debug (vcpkg)",
+      "inherits": ["linux-vcpkg-base", "debug"]
     },
     {
       "name": "linux-release-vcpkg",
-      "displayName": "Linux Release",
-      "inherits": "linux-base-vcpkg",
+      "displayName": "Linux Release (vcpkg)",
+      "inherits": ["linux-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "linux-x86-vcpkg-base",
+      "hidden": true,
+      "inherits": ["linux-base", "vcpkg-base"],
+      "architecture": {
+        "value": "x86",
+        "strategy": "external"
+      },
       "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
+        "CMAKE_C_FLAGS": "-m32",
+        "CMAKE_CXX_FLAGS": "-m32",
+        "VCPKG_TARGET_TRIPLET": "x86-linux",
+        "VCPKG_HOST_TRIPLET": "x64-linux",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
       }
     },
+    {
+      "name": "linux-debug-vcpkg-x86",
+      "displayName": "Linux x86 Debug (vcpkg)",
+      "inherits": ["linux-x86-vcpkg-base", "debug"]
+    },
+    {
+      "name": "linux-release-vcpkg-x86",
+      "displayName": "Linux x86 Release (vcpkg)",
+      "inherits": ["linux-x86-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "linux-arm64-vcpkg-base",
+      "hidden": true,
+      "inherits": ["linux-base", "vcpkg-base"],
+      "cacheVariables": {
+        "VCPKG_TARGET_TRIPLET": "arm64-linux",
+        "VCPKG_HOST_TRIPLET": "arm64-linux",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+    {
+      "name": "linux-debug-vcpkg-arm64",
+      "displayName": "Linux ARM64 Debug (vcpkg)",
+      "inherits": ["linux-arm64-vcpkg-base", "debug"]
+    },
+    {
+      "name": "linux-release-vcpkg-arm64",
+      "displayName": "Linux ARM64 Release (vcpkg)",
+      "inherits": ["linux-arm64-vcpkg-base", "release"]
+    },
+
     {
       "name": "darwin-base",
       "hidden": true,
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/cmake-build/build/${presetName}",
-      "installDir": "${sourceDir}/cmake-build/install/${presetName}",
+      "inherits": "base",
       "cacheVariables": {
-        "CMAKE_CXX_COMPILER": "clang++",
-        "CMAKE_MAKE_PROGRAM": "ninja"
+        "CMAKE_CXX_COMPILER": "clang++"
       },
       "condition": {
         "type": "equals",
@@ -137,47 +231,456 @@
       }
     },
     {
-      "name": "darwin-base-vcpkg",
+      "name": "darwin-vcpkg-base",
       "hidden": true,
-      "inherits": "darwin-base",
+      "inherits": ["darwin-base", "vcpkg-base"],
       "cacheVariables": {
-        "OMATH_BUILD_VIA_VCPKG": "ON",
-        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
-        "VCPKG_INSTALLED_DIR": "${sourceDir}/cmake-build/vcpkg_installed",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua"
       }
     },
     {
       "name": "darwin-debug",
-      "displayName": "Darwin Debug",
-      "inherits": "darwin-base",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
-    },
-    {
-      "name": "darwin-debug-vcpkg",
-      "displayName": "Darwin Debug",
-      "inherits": "darwin-base-vcpkg",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
-      }
+      "displayName": "macOS Debug",
+      "inherits": ["darwin-base", "debug"]
     },
     {
       "name": "darwin-release",
-      "displayName": "Darwin Release",
-      "inherits": "darwin-base",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
-      }
+      "displayName": "macOS Release",
+      "inherits": ["darwin-base", "release"]
+    },
+    {
+      "name": "darwin-debug-vcpkg",
+      "displayName": "macOS Debug (vcpkg)",
+      "inherits": ["darwin-vcpkg-base", "debug"]
     },
     {
       "name": "darwin-release-vcpkg",
-      "displayName": "Darwin Release",
-      "inherits": "darwin-base-vcpkg",
+      "displayName": "macOS Release (vcpkg)",
+      "inherits": ["darwin-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "darwin-x64-vcpkg-base",
+      "hidden": true,
+      "inherits": ["darwin-base", "vcpkg-base"],
       "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
+        "CMAKE_OSX_ARCHITECTURES": "x86_64",
+        "VCPKG_TARGET_TRIPLET": "x64-osx",
+        "VCPKG_HOST_TRIPLET": "x64-osx",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
       }
+    },
+    {
+      "name": "darwin-debug-vcpkg-x64",
+      "displayName": "macOS x64 Debug (vcpkg)",
+      "inherits": ["darwin-x64-vcpkg-base", "debug"]
+    },
+    {
+      "name": "darwin-release-vcpkg-x64",
+      "displayName": "macOS x64 Release (vcpkg)",
+      "inherits": ["darwin-x64-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "ios-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_SYSTEM_NAME": "iOS",
+        "CMAKE_OSX_DEPLOYMENT_TARGET": "18.5",
+        "CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED": "NO",
+        "CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED": "NO"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Darwin"
+      }
+    },
+    {
+      "name": "ios-vcpkg-base",
+      "hidden": true,
+      "inherits": ["ios-base", "vcpkg-base"],
+      "cacheVariables": {
+        "VCPKG_TARGET_TRIPLET": "arm64-ios",
+        "VCPKG_HOST_TRIPLET": "arm64-osx",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+    {
+      "name": "ios-debug-vcpkg",
+      "displayName": "iOS Debug (vcpkg)",
+      "inherits": ["ios-vcpkg-base", "debug"]
+    },
+    {
+      "name": "ios-release-vcpkg",
+      "displayName": "iOS Release (vcpkg)",
+      "inherits": ["ios-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "freebsd-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "clang",
+        "CMAKE_CXX_COMPILER": "clang++"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "FreeBSD"
+      }
+    },
+    {
+      "name": "freebsd-vcpkg-base",
+      "hidden": true,
+      "inherits": ["freebsd-base", "vcpkg-base"],
+      "cacheVariables": {
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+      }
+    },
+    {
+      "name": "freebsd-debug",
+      "displayName": "FreeBSD Debug",
+      "inherits": ["freebsd-base", "debug"]
+    },
+    {
+      "name": "freebsd-release",
+      "displayName": "FreeBSD Release",
+      "inherits": ["freebsd-base", "release"]
+    },
+    {
+      "name": "freebsd-debug-vcpkg",
+      "displayName": "FreeBSD Debug (vcpkg)",
+      "inherits": ["freebsd-vcpkg-base", "debug"]
+    },
+    {
+      "name": "freebsd-release-vcpkg",
+      "displayName": "FreeBSD Release (vcpkg)",
+      "inherits": ["freebsd-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "android-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_SYSTEM_NAME": "Android",
+        "CMAKE_SYSTEM_VERSION": "24",
+        "CMAKE_ANDROID_NDK": "$env{ANDROID_NDK_HOME}",
+        "CMAKE_ANDROID_STL_TYPE": "c++_static"
+      }
+    },
+    {
+      "name": "android-vcpkg-base",
+      "hidden": true,
+      "inherits": ["android-base", "vcpkg-base"],
+      "cacheVariables": {
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+
+    {
+      "name": "android-arm64-base",
+      "hidden": true,
+      "inherits": "android-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "arm64-v8a"
+      }
+    },
+    {
+      "name": "android-arm64-vcpkg-base",
+      "hidden": true,
+      "inherits": "android-vcpkg-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "arm64-v8a",
+        "VCPKG_TARGET_TRIPLET": "arm64-android"
+      }
+    },
+    {
+      "name": "android-arm64-debug",
+      "displayName": "Android arm64-v8a Debug",
+      "inherits": ["android-arm64-base", "debug"]
+    },
+    {
+      "name": "android-arm64-release",
+      "displayName": "Android arm64-v8a Release",
+      "inherits": ["android-arm64-base", "release"]
+    },
+    {
+      "name": "android-arm64-debug-vcpkg",
+      "displayName": "Android arm64-v8a Debug (vcpkg)",
+      "inherits": ["android-arm64-vcpkg-base", "debug"]
+    },
+    {
+      "name": "android-arm64-release-vcpkg",
+      "displayName": "Android arm64-v8a Release (vcpkg)",
+      "inherits": ["android-arm64-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "android-arm-neon-base",
+      "hidden": true,
+      "inherits": "android-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "armeabi-v7a",
+        "CMAKE_ANDROID_ARM_NEON": "ON"
+      }
+    },
+    {
+      "name": "android-arm-neon-vcpkg-base",
+      "hidden": true,
+      "inherits": "android-vcpkg-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "armeabi-v7a",
+        "CMAKE_ANDROID_ARM_NEON": "ON",
+        "VCPKG_TARGET_TRIPLET": "arm-neon-android"
+      }
+    },
+    {
+      "name": "android-arm-neon-debug",
+      "displayName": "Android armeabi-v7a NEON Debug",
+      "inherits": ["android-arm-neon-base", "debug"]
+    },
+    {
+      "name": "android-arm-neon-release",
+      "displayName": "Android armeabi-v7a NEON Release",
+      "inherits": ["android-arm-neon-base", "release"]
+    },
+    {
+      "name": "android-arm-neon-debug-vcpkg",
+      "displayName": "Android armeabi-v7a NEON Debug (vcpkg)",
+      "inherits": ["android-arm-neon-vcpkg-base", "debug"]
+    },
+    {
+      "name": "android-arm-neon-release-vcpkg",
+      "displayName": "Android armeabi-v7a NEON Release (vcpkg)",
+      "inherits": ["android-arm-neon-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "android-x64-base",
+      "hidden": true,
+      "inherits": "android-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "x86_64"
+      }
+    },
+    {
+      "name": "android-x64-vcpkg-base",
+      "hidden": true,
+      "inherits": "android-vcpkg-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "x86_64",
+        "VCPKG_TARGET_TRIPLET": "x64-android"
+      }
+    },
+    {
+      "name": "android-x64-debug",
+      "displayName": "Android x86_64 Debug",
+      "inherits": ["android-x64-base", "debug"]
+    },
+    {
+      "name": "android-x64-release",
+      "displayName": "Android x86_64 Release",
+      "inherits": ["android-x64-base", "release"]
+    },
+    {
+      "name": "android-x64-debug-vcpkg",
+      "displayName": "Android x86_64 Debug (vcpkg)",
+      "inherits": ["android-x64-vcpkg-base", "debug"]
+    },
+    {
+      "name": "android-x64-release-vcpkg",
+      "displayName": "Android x86_64 Release (vcpkg)",
+      "inherits": ["android-x64-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "android-x86-base",
+      "hidden": true,
+      "inherits": "android-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "x86"
+      }
+    },
+    {
+      "name": "android-x86-vcpkg-base",
+      "hidden": true,
+      "inherits": "android-vcpkg-base",
+      "cacheVariables": {
+        "CMAKE_ANDROID_ARCH_ABI": "x86",
+        "VCPKG_TARGET_TRIPLET": "x86-android"
+      }
+    },
+    {
+      "name": "android-x86-debug",
+      "displayName": "Android x86 Debug",
+      "inherits": ["android-x86-base", "debug"]
+    },
+    {
+      "name": "android-x86-release",
+      "displayName": "Android x86 Release",
+      "inherits": ["android-x86-base", "release"]
+    },
+    {
+      "name": "android-x86-debug-vcpkg",
+      "displayName": "Android x86 Debug (vcpkg)",
+      "inherits": ["android-x86-vcpkg-base", "debug"]
+    },
+    {
+      "name": "android-x86-release-vcpkg",
+      "displayName": "Android x86 Release (vcpkg)",
+      "inherits": ["android-x86-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "android-debug",
+      "displayName": "Android Debug (default: arm64)",
+      "inherits": "android-arm64-debug"
+    },
+    {
+      "name": "android-release",
+      "displayName": "Android Release (default: arm64)",
+      "inherits": "android-arm64-release"
+    },
+    {
+      "name": "android-debug-vcpkg",
+      "displayName": "Android Debug (default: arm64, vcpkg)",
+      "inherits": "android-arm64-debug-vcpkg"
+    },
+    {
+      "name": "android-release-vcpkg",
+      "displayName": "Android Release (default: arm64, vcpkg)",
+      "inherits": "android-arm64-release-vcpkg"
+    },
+
+    {
+      "name": "wasm-base",
+      "hidden": true,
+      "inherits": "base"
+    },
+    {
+      "name": "wasm-vcpkg-base",
+      "hidden": true,
+      "inherits": ["wasm-base", "vcpkg-base"],
+      "cacheVariables": {
+        "VCPKG_CHAINLOAD_TOOLCHAIN_FILE": "$env{EMSDK}/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake",
+        "VCPKG_TARGET_TRIPLET": "wasm32-emscripten",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+    {
+      "name": "wasm-debug-vcpkg",
+      "displayName": "WebAssembly Debug (vcpkg)",
+      "inherits": ["wasm-vcpkg-base", "debug"]
+    },
+    {
+      "name": "wasm-release-vcpkg",
+      "displayName": "WebAssembly Release (vcpkg)",
+      "inherits": ["wasm-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "mingw-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Windows"
+      }
+    },
+    {
+      "name": "mingw-vcpkg-base",
+      "hidden": true,
+      "inherits": ["mingw-base", "vcpkg-base"],
+      "environment": {
+        "VCPKG_DEFAULT_HOST_TRIPLET": "x64-mingw-dynamic"
+      },
+      "cacheVariables": {
+        "VCPKG_TARGET_TRIPLET": "x64-mingw-dynamic",
+        "VCPKG_HOST_TRIPLET": "x64-mingw-dynamic",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+    {
+      "name": "mingw-debug",
+      "displayName": "MinGW x64 Debug",
+      "inherits": ["mingw-base", "debug"]
+    },
+    {
+      "name": "mingw-release",
+      "displayName": "MinGW x64 Release",
+      "inherits": ["mingw-base", "release"]
+    },
+    {
+      "name": "mingw-debug-vcpkg",
+      "displayName": "MinGW x64 Debug (vcpkg)",
+      "inherits": ["mingw-vcpkg-base", "debug"]
+    },
+    {
+      "name": "mingw-release-vcpkg",
+      "displayName": "MinGW x64 Release (vcpkg)",
+      "inherits": ["mingw-vcpkg-base", "release"]
+    },
+    {
+      "name": "mingw-ucrt-release-vcpkg",
+      "displayName": "MinGW UCRT64 Release (vcpkg)",
+      "inherits": ["mingw-vcpkg-base", "release"]
+    },
+
+    {
+      "name": "mingw32-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Windows"
+      }
+    },
+    {
+      "name": "mingw32-vcpkg-base",
+      "hidden": true,
+      "inherits": ["mingw32-base", "vcpkg-base"],
+      "environment": {
+        "VCPKG_DEFAULT_HOST_TRIPLET": "x86-mingw-dynamic"
+      },
+      "cacheVariables": {
+        "VCPKG_TARGET_TRIPLET": "x86-mingw-dynamic",
+        "VCPKG_HOST_TRIPLET": "x86-mingw-dynamic",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui"
+      }
+    },
+    {
+      "name": "mingw32-debug",
+      "displayName": "MinGW x86 Debug",
+      "inherits": ["mingw32-base", "debug"]
+    },
+    {
+      "name": "mingw32-release",
+      "displayName": "MinGW x86 Release",
+      "inherits": ["mingw32-base", "release"]
+    },
+    {
+      "name": "mingw32-debug-vcpkg",
+      "displayName": "MinGW x86 Debug (vcpkg)",
+      "inherits": ["mingw32-vcpkg-base", "debug"]
+    },
+    {
+      "name": "mingw32-release-vcpkg",
+      "displayName": "MinGW x86 Release (vcpkg)",
+      "inherits": ["mingw32-vcpkg-base", "release"]
     }
   ]
-}
+}

CODEOWNERS

@@ -0,0 +1,37 @@
+##   List of maintainers for the omath library
+
+## This file purpose is to give newcomers to the project the responsible
+## developers when submitting a pull request on GitHub, or opening a bug
+## report in issues.
+
+## This file will notably establish who is responsible for a specific
+## area of omath. Being a maintainer means the following:
+##  - that person has good knownledge in the area
+##  - that person is able to enforce consistency in the area
+##  - that person may be available for giving help in the area
+##  - that person has push access on the repository
+## Being a maintainer does not mean the following:
+##  - that person is dedicated to the area
+##  - that person is working full-time on the area/on omath
+##  - that person is paid
+##  - that person is always available
+
+
+# omath core source code
+/source @orange-cpp
+/include @orange-cpp
+
+# Tests and becnchmarks
+/benchmark @orange-cpp
+/tests @orange-cpp @luadebug
+
+# Examples and documentation
+/examples @luadebug @orange-cpp
+/docs @orange-cpp
+
+# Misc like formating
+/scripts @luadebug
+/pixi @luadebug
+
+# CI/CD
+/.github/workflows @luadbg @orange-cpp

INSTALL.md

@@ -1,6 +1,6 @@
 # 📥Installation Guide
 
-## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg (recomended)
 **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:
@@ -28,6 +28,46 @@ target("...")
     add_packages("omath")
 ```
 
+## <img width="28px" src="https://github.githubassets.com/favicons/favicon.svg" /> Using prebuilt binaries (GitHub Releases)
+
+**Note**: This is the fastest option if you don’t want to build from source.
+
+1. **Go to the Releases page**
+   - Open the project’s GitHub **Releases** page and choose the latest version.
+
+2. **Download the correct asset for your platform**
+   - Pick the archive that matches your OS and architecture (for example: Windows x64 / Linux x64 / macOS arm64).
+
+3. **Extract the archive**
+   - You should end up with something like:
+     - `include/` (headers)
+     - `lib/` or `bin/` (library files / DLLs)
+     - sometimes `cmake/` (CMake package config)
+
+4. **Use it in your project**
+
+   ### Option A: CMake package (recommended if the release includes CMake config files)
+   If the extracted folder contains something like `lib/cmake/omath` or `cmake/omath`, you can point CMake to it:
+
+   ```cmake
+   # Example: set this to the extracted prebuilt folder
+   list(APPEND CMAKE_PREFIX_PATH "path/to/omath-prebuilt")
+
+   find_package(omath CONFIG REQUIRED)
+   target_link_libraries(main PRIVATE omath::omath)
+   ```
+   ### Option B: Manual include + link (works with any layout)
+   If there’s no CMake package config, link it manually:
+   ```cmake
+   target_include_directories(main PRIVATE "path/to/omath-prebuilt/include")
+
+    # Choose ONE depending on what you downloaded:
+    # - Static library: .lib / .a
+    # - Shared library: .dll + .lib import (Windows), .so (Linux), .dylib (macOS)
+    
+    target_link_directories(main PRIVATE "path/to/omath-prebuilt/lib")
+    target_link_libraries(main PRIVATE omath)  # or the actual library filename
+    ```
 ## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> Build from source using CMake 
 1. **Preparation**
    

LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2024-2025 Orange++ <orange_github@proton.me>
+Copyright (C) 2023-2026 Orange++ orange_github@proton.me
 
 This software is provided 'as-is', without any express or implied
 warranty. In no event will the authors be held liable for any damages
@@ -15,45 +15,3 @@ freely, subject to the following restrictions:
 2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
 3. This notice may not be removed or altered from any source distribution.
-4. If you are an employee, contractor, volunteer, representative, 
-   or have any other affiliation (past or present)
-   with any of the following entities:
-     * "Advertising Placement Services" LLC
-     * "NEW SOLUTIONS VERTICALS" LLC
-     * "Autoexpert" LLC
-     * "Creditit" LLC
-     * "Yandex.Taxi" LLC
-     * "Yandex.Eda" LLC
-     * "Yandex.Lavka" LLC
-     * "Yandex.Telecom" LLC
-     * "Yandex.Cloud" LLC
-     * "Micromobility" LLC
-     * "MM-Tech" LLC
-     * "Carsharing" LLC
-     * "Yandex.Drive" LLC
-     * "EDADIL PROMO" LLC
-     * "Kinopoisk" LLC
-     * "Yandex.Music" LLC
-     * "Refueling (Yandex.Zapravki)" LLC
-     * "Yandex.Pay" LLC
-     * "Financial and Payment Technologies" LLC
-     * "Yandex.Delivery" LLC
-     * "Delivery Club" LLC
-     * "Yandex.Check" LLC
-     * "SMB-Service" LLC
-     * "ADV-TECH" LLC
-     * "Yandex Fantech" LLC
-     * "Yandex Smena" LLC
-     * "Market.Operations" LLC
-     * "Yandex.Market" LLC
-     * "ID Tech" LLC
-     * "Yandex.Crowd" LLC
-     * "Yandex" LLC
-     * "Rutube" LLC
-     * "Kaspersky" LLC
-   Or if you represent or are associated with any legal, organizational, or 
-   professional entity providing services to or on behalf of the aforementioned entities:
-   You are expressly forbidden from accessing, using, modifying, distributing, or
-   interacting with the Software and its source code in any form. You must immediately 
-   delete or destroy any physical or digital copies of the Software and/or
-   its source code, including any derivative works, tools, or information obtained from the Software.

README.md

@@ -2,12 +2,14 @@
 
 ![banner](docs/images/logos/omath_logo_macro.png)
 
-![Static Badge](https://img.shields.io/badge/license-libomath-orange)
+![GitHub License](https://img.shields.io/github/license/orange-cpp/omath)
 ![GitHub contributors](https://img.shields.io/github/contributors/orange-cpp/omath)
 ![GitHub top language](https://img.shields.io/github/languages/top/orange-cpp/omath)
+![GitHub repo size](https://img.shields.io/github/repo-size/orange-cpp/omath)
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/orange-cpp/omath/cmake-multi-platform.yml)
 [![Vcpkg package](https://repology.org/badge/version-for-repo/vcpkg/orange-math.svg)](https://repology.org/project/orange-math/versions)
+![Conan Center](https://img.shields.io/conan/v/omath)
 ![GitHub forks](https://img.shields.io/github/forks/orange-cpp/omath)
 [![discord badge](https://dcbadge.limes.pink/api/server/https://discord.gg/eDgdaWbqwZ?style=flat)](https://discord.gg/eDgdaWbqwZ)
 [![telegram badge](https://img.shields.io/badge/Telegram-2CA5E0?style=flat-squeare&logo=telegram&logoColor=white)](https://t.me/orangennotes)
@@ -43,7 +45,7 @@ It provides the latest features, is highly customizable, has all for cheat devel
  </a>
 </div>
 
-## 🚀 Quick Example
+## Quick Example
 
 ```cpp
 #include <omath/omath.hpp>
@@ -68,20 +70,22 @@ if (auto screen = camera.world_to_screen(world_position)) {
 }
 ```
 
-**[➡️ See more examples and tutorials][TUTORIALS]**
+**[See more examples and tutorials][TUTORIALS]**
 
-# ✨ Features
-- **🚀 Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
-- **🎯 Versatility**: Includes a wide array of mathematical functions and algorithms.
-- **✅ Ease of Use**: Simplified interface for convenient integration into various projects.
-- **🎮 Projectile Prediction**: Projectile prediction engine with O(N) algo complexity, that can power you projectile aim-bot.
-- **📐 3D Projection**: No need to find view-projection matrix anymore you can make your own projection pipeline.
-- **💥 Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
-- **📦 No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
-- **🔧 Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
-- **🎯 Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine and canonical OpenGL**.
-- **🌍 Cross platform**: Supports Windows, MacOS and Linux.
-- **🔍 Algorithms**: Has ability to scan for byte pattern with wildcards in PE files/modules, binary slices, works even with Wine apps. 
+# Features
+- **Efficiency**: Optimized for performance, ensuring quick computations using AVX2.
+- **Versatility**: Includes a wide array of mathematical functions and algorithms.
+- **Ease of Use**: Simplified interface for convenient integration into various projects.
+- **Projectile Prediction**: Projectile prediction engine with O(N) algo complexity, that can power you projectile aim-bot.
+- **3D Projection**: No need to find view-projection matrix anymore you can make your own projection pipeline.
+- **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
+- **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
+- **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
+- **Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine, CryEngine and canonical OpenGL**.
+- **Cross platform**: Supports Windows, MacOS and Linux.
+- **Algorithms**: Has ability to scan for byte pattern with wildcards in ELF/Mach-O/PE files/modules, binary slices, works even with Wine apps. 
+- **Scripting**: Supports to make scripts in Lua out of box
+- **Battle tested**: It's already used by some big players on the market like wraith.su and bluedream.ltd
 <div align = center>
  
 # Gallery
@@ -106,12 +110,16 @@ if (auto screen = camera.world_to_screen(world_position)) {
 
 ![TF2 Preview]
 
+<br>
+
+![OpenGL Preview]
+
 <br>
 <br>
 
 </div>
 
-## 📚 Documentation
+## Documentation
 
 - **[Getting Started Guide](http://libomath.org/getting_started/)** - Installation and first steps
 - **[API Overview](http://libomath.org/api_overview/)** - Complete API reference
@@ -120,14 +128,14 @@ if (auto screen = camera.world_to_screen(world_position)) {
 - **[Troubleshooting](http://libomath.org/troubleshooting/)** - Solutions to common issues
 - **[Best Practices](http://libomath.org/best_practices/)** - Guidelines for effective usage
 
-## 🤝 Community & Support
+## Community & Support
 
 - **Discord**: [Join our community](https://discord.gg/eDgdaWbqwZ)
 - **Telegram**: [@orangennotes](https://t.me/orangennotes)
 - **Issues**: [Report bugs or request features](https://github.com/orange-cpp/omath/issues)
 - **Contributing**: See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines
 
-# 💘 Acknowledgments
+# Acknowledgments
 -  [All contributors](https://github.com/orange-cpp/omath/graphs/contributors)
 
 <!----------------------------------{ Images }--------------------------------->
@@ -135,6 +143,7 @@ if (auto screen = camera.world_to_screen(world_position)) {
 [BO2 Preview]: docs/images/showcase/cod_bo2.png
 [CS2 Preview]: docs/images/showcase/cs2.jpeg
 [TF2 Preview]: docs/images/showcase/tf2.jpg
+[OpenGL Preview]: docs/images/showcase/opengl.png
 <!----------------------------------{ Buttons }--------------------------------->
 [QUICKSTART]: docs/getting_started.md
 [INSTALL]: INSTALL.md

VERSION

@@ -1 +1 @@
-4.4.0
+5.0.0

benchmark/CMakeLists.txt

@@ -1,19 +1,24 @@
 project(omath_benchmark)
 
-
 file(GLOB_RECURSE OMATH_BENCHMARK_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
 add_executable(${PROJECT_NAME} ${OMATH_BENCHMARK_SOURCES})
 
-set_target_properties(${PROJECT_NAME} PROPERTIES
-        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
-        CXX_STANDARD 23
-        CXX_STANDARD_REQUIRED ON)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               CXX_STANDARD 23
+               CXX_STANDARD_REQUIRED ON)
 
-if (TARGET benchmark::benchmark) # Benchmark is being linked as submodule
+if(TARGET benchmark::benchmark) # Benchmark is being linked as submodule
     target_link_libraries(${PROJECT_NAME} PRIVATE benchmark::benchmark omath)
 else()
-    find_package(benchmark CONFIG REQUIRED) # Benchmark is being linked as vcpkg package
+    find_package(benchmark CONFIG REQUIRED) # Benchmark is being linked as vcpkg
+                                            # package
     target_link_libraries(${PROJECT_NAME} PRIVATE benchmark::benchmark omath)
-endif ()
+endif()
+
+if(OMATH_ENABLE_VALGRIND)
+    omath_setup_valgrind(${PROJECT_NAME})
+endif()

benchmark/benchmark_collision.cpp

@@ -0,0 +1,161 @@
+//
+// Created by Vlad on 3/2/2026.
+//
+#include <benchmark/benchmark.h>
+#include <memory_resource>
+#include <omath/collision/epa_algorithm.hpp>
+#include <omath/collision/gjk_algorithm.hpp>
+#include <omath/engines/source_engine/collider.hpp>
+#include <omath/engines/source_engine/mesh.hpp>
+
+using Mesh = omath::source_engine::Mesh;
+using Collider = omath::source_engine::MeshCollider;
+using Gjk = omath::collision::GjkAlgorithm<Collider>;
+using Epa = omath::collision::Epa<Collider>;
+
+namespace
+{
+    // Unit cube with half-extent 1 — 8 vertices in [-1,1]^3.
+    const std::vector<omath::primitives::Vertex<>> k_cube_vbo = {
+        { { -1.f, -1.f, -1.f }, {}, {} },
+        { { -1.f, -1.f,  1.f }, {}, {} },
+        { { -1.f,  1.f, -1.f }, {}, {} },
+        { { -1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f, -1.f }, {}, {} },
+        { {  1.f, -1.f,  1.f }, {}, {} },
+        { {  1.f, -1.f, -1.f }, {}, {} },
+    };
+    const std::vector<omath::Vector3<std::uint32_t>> k_empty_vao{};
+} // namespace
+
+// ---------------------------------------------------------------------------
+// GJK benchmarks
+// ---------------------------------------------------------------------------
+
+// Separated cubes — origin distance 2.1, no overlap.
+// Exercises the early-exit path and the centroid-based initial direction.
+static void BM_Gjk_Separated(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.f, 2.1f, 0.f});
+    const Collider b{mesh_b};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// Overlapping cubes — B offset by 0.5 along X, ~1.5 units penetration depth.
+static void BM_Gjk_Overlapping(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// Identical cubes at the same origin — deep overlap / worst case for GJK.
+static void BM_Gjk_SameOrigin(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+    const Collider b{Mesh{k_cube_vbo, k_empty_vao}};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// ---------------------------------------------------------------------------
+// EPA benchmarks
+// ---------------------------------------------------------------------------
+
+// EPA with a pre-allocated monotonic buffer (reset each iteration).
+// Isolates algorithmic cost from allocator overhead.
+static void BM_Epa_MonotonicBuffer(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    if (!hit)
+        return; // shouldn't happen, but guard for safety
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    // Pre-allocate a 32 KiB stack buffer — enough for typical polytope growth.
+    constexpr std::size_t k_buf_size = 32768;
+    alignas(std::max_align_t) char buf[k_buf_size];
+    std::pmr::monotonic_buffer_resource mr{buf, k_buf_size, std::pmr::null_memory_resource()};
+
+    for ([[maybe_unused]] auto _ : state)
+    {
+        mr.release(); // reset the buffer without touching the upstream resource
+        benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params, mr));
+    }
+}
+
+// EPA with the default (malloc-backed) memory resource.
+// Shows total cost including allocator pressure.
+static void BM_Epa_DefaultResource(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    if (!hit)
+        return;
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params));
+}
+
+// ---------------------------------------------------------------------------
+// Combined GJK + EPA pipeline
+// ---------------------------------------------------------------------------
+
+// Full collision pipeline: GJK detects contact, EPA resolves penetration.
+// This is the hot path in a physics engine tick.
+static void BM_GjkEpa_Pipeline(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    constexpr std::size_t k_buf_size = 32768;
+    alignas(std::max_align_t) char buf[k_buf_size];
+    std::pmr::monotonic_buffer_resource mr{buf, k_buf_size, std::pmr::null_memory_resource()};
+
+    for ([[maybe_unused]] auto _ : state)
+    {
+        mr.release();
+        const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+        if (hit)
+            benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params, mr));
+    }
+}
+
+BENCHMARK(BM_Gjk_Separated)->Iterations(100'000);
+BENCHMARK(BM_Gjk_Overlapping)->Iterations(100'000);
+BENCHMARK(BM_Gjk_SameOrigin)->Iterations(100'000);
+
+BENCHMARK(BM_Epa_MonotonicBuffer)->Iterations(100'000);
+BENCHMARK(BM_Epa_DefaultResource)->Iterations(100'000);
+
+BENCHMARK(BM_GjkEpa_Pipeline)->Iterations(100'000);

cmake/Coverage.cmake

@@ -0,0 +1,67 @@
+# cmake/Coverage.cmake
+include_guard(GLOBAL)
+
+function(omath_setup_coverage TARGET_NAME)
+    if(ANDROID OR IOS OR EMSCRIPTEN)
+        return()
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
+        target_compile_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping
+                                                      /Zi)
+        target_link_options(
+            ${TARGET_NAME}
+            PRIVATE
+            -fprofile-instr-generate
+            -fcoverage-mapping
+            /DEBUG:FULL
+            /INCREMENTAL:NO
+            /PROFILE)
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
+        target_compile_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping
+                                                      -g -O0)
+        target_link_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping)
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(${TARGET_NAME} PRIVATE --coverage -g -O0)
+        target_link_options(${TARGET_NAME} PRIVATE --coverage)
+    endif()
+
+    if(TARGET coverage)
+        return()
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
+        message(STATUS "MSVC detected: Use VS Code Coverage from CI workflow")
+        add_custom_target(
+            coverage
+            DEPENDS unit_tests
+            COMMAND $<TARGET_FILE:unit_tests>
+            WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+            COMMENT "Running tests for coverage (use VS Code Coverage from CI)")
+
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
+        add_custom_target(
+            coverage
+            DEPENDS unit_tests
+            COMMAND bash "${CMAKE_SOURCE_DIR}/scripts/coverage-llvm.sh" "${CMAKE_SOURCE_DIR}"
+                    "${CMAKE_BINARY_DIR}" "$<TARGET_FILE:unit_tests>" "${CMAKE_BINARY_DIR}/coverage"
+            WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+            COMMENT "Running LLVM coverage")
+
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        add_custom_target(
+            coverage
+            DEPENDS unit_tests
+            COMMAND $<TARGET_FILE:unit_tests> || true
+            COMMAND lcov --capture --directory "${CMAKE_BINARY_DIR}" --output-file
+                    "${CMAKE_BINARY_DIR}/coverage.info" --ignore-errors mismatch,gcov
+            COMMAND
+                lcov --remove "${CMAKE_BINARY_DIR}/coverage.info" "*/tests/*" "*/gtest/*"
+                "*/googletest/*" "*/_deps/*" "/usr/*" --output-file
+                "${CMAKE_BINARY_DIR}/coverage.info" --ignore-errors unused
+            COMMAND genhtml "${CMAKE_BINARY_DIR}/coverage.info" --output-directory
+                    "${CMAKE_BINARY_DIR}/coverage"
+            WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+            COMMENT "Running lcov/genhtml")
+    endif()
+endfunction()

cmake/Valgrind.cmake

@@ -0,0 +1,41 @@
+# cmake/Valgrind.cmake
+
+if(DEFINED __OMATH_VALGRIND_INCLUDED)
+    return()
+endif()
+set(__OMATH_VALGRIND_INCLUDED TRUE)
+
+find_program(VALGRIND_EXECUTABLE valgrind)
+option(OMATH_ENABLE_VALGRIND "Enable Valgrind target for memory checking" ON)
+
+if(OMATH_ENABLE_VALGRIND AND NOT TARGET valgrind_all)
+    add_custom_target(valgrind_all)
+endif()
+
+function(omath_setup_valgrind TARGET_NAME)
+    if(NOT OMATH_ENABLE_VALGRIND)
+        return()
+    endif()
+
+    if(NOT VALGRIND_EXECUTABLE)
+        message(WARNING "OMATH_ENABLE_VALGRIND is ON, but 'valgrind' executable was not found.")
+        return()
+    endif()
+
+    set(VALGRIND_FLAGS --leak-check=full --show-leak-kinds=all --track-origins=yes
+                       --error-exitcode=99)
+
+    set(VALGRIND_TARGET "valgrind_${TARGET_NAME}")
+
+    if(NOT TARGET ${VALGRIND_TARGET})
+        add_custom_target(
+            ${VALGRIND_TARGET}
+            DEPENDS ${TARGET_NAME}
+            COMMAND ${VALGRIND_EXECUTABLE} ${VALGRIND_FLAGS} $<TARGET_FILE:${TARGET_NAME}>
+            WORKING_DIRECTORY $<TARGET_FILE_DIR:${TARGET_NAME}>
+            COMMENT "Running Valgrind memory check on ${TARGET_NAME}..."
+            USES_TERMINAL)
+
+        add_dependencies(valgrind_all ${VALGRIND_TARGET})
+    endif()
+endfunction()

examples/CMakeLists.txt

@@ -1,9 +1,10 @@
-project(examples)
+add_subdirectory(example_barycentric)
+add_subdirectory(example_glfw3)
+add_subdirectory(example_proj_mat_builder)
+add_subdirectory(example_signature_scan)
 
-add_executable(example_projection_matrix_builder example_proj_mat_builder.cpp)
-set_target_properties(example_projection_matrix_builder PROPERTIES CXX_STANDARD 26)
-target_link_libraries(example_projection_matrix_builder PRIVATE omath::omath)
-
-add_executable(example_signature_scan example_signature_scan.cpp)
-set_target_properties(example_signature_scan PROPERTIES CXX_STANDARD 26)
-target_link_libraries(example_signature_scan PRIVATE omath::omath)
+if(OMATH_ENABLE_VALGRIND)
+    omath_setup_valgrind(example_projection_matrix_builder)
+    omath_setup_valgrind(example_signature_scan)
+    omath_setup_valgrind(example_glfw3)
+endif()

examples/example_barycentric/CMakeLists.txt

@@ -0,0 +1,14 @@
+project(example_barycentric)
+
+add_executable(${PROJECT_NAME} example_barycentric.cpp)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES CXX_STANDARD 23
+               ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(OpenGL)
+find_package(GLEW REQUIRED)
+find_package(glfw3 CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath GLEW::GLEW glfw OpenGL::GL)

examples/example_barycentric/example_barycentric.cpp

@@ -0,0 +1,427 @@
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <cmath>
+#include <iostream>
+#include <omath/omath.hpp>
+#include <vector>
+
+using omath::Color;
+using omath::Triangle;
+using omath::Vector3;
+
+static const char* vertexShaderSource = R"(
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+layout (location = 2) in float aPointSize;
+layout (location = 3) in float aIsLine;
+
+out vec3 vColor;
+out float vIsLine;
+
+void main() {
+    gl_Position = vec4(aPos, 1.0);
+    vColor = aColor;
+    gl_PointSize = aPointSize;
+    vIsLine = aIsLine;
+}
+)";
+
+static const char* fragmentShaderSource = R"(
+#version 330 core
+in vec3 vColor;
+in float vIsLine;
+out vec4 FragColor;
+
+void main() {
+    if (vIsLine < 0.5) {
+        // Calculate distance from center of the point
+        vec2 coord = gl_PointCoord - vec2(0.5);
+        if(length(coord) > 0.5)
+            discard;
+    }
+
+    FragColor = vec4(vColor, 1.0);
+}
+)";
+
+GLuint compileShader(GLenum type, const char* src)
+{
+    GLuint shader = glCreateShader(type);
+    glShaderSource(shader, 1, &src, nullptr);
+    glCompileShader(shader);
+    GLint ok;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+    if (!ok)
+    {
+        char log[1024];
+        glGetShaderInfoLog(shader, sizeof(log), nullptr, log);
+        std::cerr << "Shader error: " << log << std::endl;
+    }
+    return shader;
+}
+
+void drawChar(char c, float x, float y, float scale, const Color& color, std::vector<float>& lines)
+{
+    float w = 0.5f * scale;
+    float h = 1.0f * scale;
+
+    auto add = [&](float x1, float y1, float x2, float y2)
+    {
+        lines.push_back(x + x1 * w);
+        lines.push_back(y + y1 * h);
+        lines.push_back(0.0f);
+        lines.push_back(color.x);
+        lines.push_back(color.y);
+        lines.push_back(color.z);
+        lines.push_back(1.0f); // size
+        lines.push_back(1.0f); // isLine
+
+        lines.push_back(x + x2 * w);
+        lines.push_back(y + y2 * h);
+        lines.push_back(0.0f);
+        lines.push_back(color.x);
+        lines.push_back(color.y);
+        lines.push_back(color.z);
+        lines.push_back(1.0f); // size
+        lines.push_back(1.0f); // isLine
+    };
+
+    switch (c)
+    {
+    case '0':
+        add(0, 0, 1, 0);
+        add(1, 0, 1, 1);
+        add(1, 1, 0, 1);
+        add(0, 1, 0, 0);
+        break;
+    case '1':
+        add(0.5f, 0, 0.5f, 1);
+        add(0.25f, 0.75f, 0.5f, 1);
+        add(0.25f, 0, 0.75f, 0);
+        break;
+    case '2':
+        add(0, 1, 1, 1);
+        add(1, 1, 1, 0.5f);
+        add(1, 0.5f, 0, 0.5f);
+        add(0, 0.5f, 0, 0);
+        add(0, 0, 1, 0);
+        break;
+    case '3':
+        add(0, 1, 1, 1);
+        add(1, 1, 1, 0);
+        add(1, 0, 0, 0);
+        add(0, 0.5f, 1, 0.5f);
+        break;
+    case '4':
+        add(0, 1, 0, 0.5f);
+        add(0, 0.5f, 1, 0.5f);
+        add(1, 1, 1, 0);
+        break;
+    case '5':
+        add(1, 1, 0, 1);
+        add(0, 1, 0, 0.5f);
+        add(0, 0.5f, 1, 0.5f);
+        add(1, 0.5f, 1, 0);
+        add(1, 0, 0, 0);
+        break;
+    case '6':
+        add(1, 1, 0, 1);
+        add(0, 1, 0, 0);
+        add(0, 0, 1, 0);
+        add(1, 0, 1, 0.5f);
+        add(1, 0.5f, 0, 0.5f);
+        break;
+    case '7':
+        add(0, 1, 1, 1);
+        add(1, 1, 0.5f, 0);
+        break;
+    case '8':
+        add(0, 0, 1, 0);
+        add(1, 0, 1, 1);
+        add(1, 1, 0, 1);
+        add(0, 1, 0, 0);
+        add(0, 0.5f, 1, 0.5f);
+        break;
+    case '9':
+        add(1, 0.5f, 0, 0.5f);
+        add(0, 0.5f, 0, 1);
+        add(0, 1, 1, 1);
+        add(1, 1, 1, 0);
+        add(1, 0, 0, 0);
+        break;
+    case '.':
+        add(0.4f, 0, 0.6f, 0);
+        add(0.6f, 0, 0.6f, 0.2f);
+        add(0.6f, 0.2f, 0.4f, 0.2f);
+        add(0.4f, 0.2f, 0.4f, 0);
+        break;
+    }
+}
+
+void drawText(const std::string& text, float x, float y, float scale, const Color& color, std::vector<float>& lines)
+{
+    float cursor = x;
+    for (char c : text)
+    {
+        drawChar(c, cursor, y, scale, color, lines);
+        cursor += (c == '.' ? 0.3f : 0.7f) * scale;
+    }
+}
+
+GLFWwindow* initWindow(int width, int height, const char* title)
+{
+    if (!glfwInit())
+    {
+        std::cerr << "Failed to initialize GLFW\n";
+        return nullptr;
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+    GLFWwindow* window = glfwCreateWindow(width, height, title, NULL, NULL);
+    if (!window)
+    {
+        std::cerr << "Failed to create GLFW window\n";
+        glfwTerminate();
+        return nullptr;
+    }
+    glfwMakeContextCurrent(window);
+
+    // Check if context is valid using standard GL
+    const GLubyte* renderer = glGetString(GL_RENDERER);
+    const GLubyte* version = glGetString(GL_VERSION);
+    if (renderer && version)
+    {
+        std::cout << "Renderer: " << renderer << "\n";
+        std::cout << "OpenGL version supported: " << version << "\n";
+    }
+    else
+    {
+        std::cerr << "Failed to get GL_RENDERER or GL_VERSION. Context might be invalid.\n";
+    }
+
+    glewExperimental = GL_TRUE;
+    GLenum glewErr = glewInit();
+    if (glewErr != GLEW_OK)
+    {
+        // Ignore GLEW_ERROR_NO_GLX_DISPLAY if we have a valid context (e.g. Wayland)
+        if (glewErr == GLEW_ERROR_NO_GLX_DISPLAY && renderer)
+        {
+            std::cerr << "GLEW warning: " << glewGetErrorString(glewErr) << " (Ignored because context seems valid)\n";
+        }
+        else
+        {
+            std::cerr << "Failed to initialize GLEW: " << glewGetErrorString(glewErr) << "\n";
+            glfwTerminate();
+            return nullptr;
+        }
+    }
+    return window;
+}
+
+GLuint createShaderProgram()
+{
+    GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
+    GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
+    GLuint shaderProgram = glCreateProgram();
+    glAttachShader(shaderProgram, vs);
+    glAttachShader(shaderProgram, fs);
+    glLinkProgram(shaderProgram);
+    return shaderProgram;
+}
+
+void generatePointCloud(std::vector<float>& pointCloud, const Triangle<Vector3<float>>& triangle)
+{
+    const auto& A = triangle.m_vertex1;
+    const auto& B = triangle.m_vertex2;
+    const auto& C = triangle.m_vertex3;
+    // Iterating over barycentric coordinates (u, v, w) from 0.0 to 1.0
+    for (float u = 0.0f; u <= 1.0f; u += 0.015f)
+    {
+        for (float v = 0.0f; v <= 1.0f - u; v += 0.015f)
+        {
+            float w = 1.0f - u - v;
+            if (w >= 0.0f && w <= 1.0f)
+            {
+                Vector3<float> P = A * u + B * v + C * w;
+                pointCloud.push_back(P.x);
+                pointCloud.push_back(P.y);
+                pointCloud.push_back(P.z);
+                pointCloud.push_back(u);
+                pointCloud.push_back(v);
+                pointCloud.push_back(w);
+                pointCloud.push_back(2.0f); // size
+                pointCloud.push_back(0.0f); // isLine
+            }
+        }
+    }
+}
+
+void setupBuffers(GLuint& VAO_cloud, GLuint& VBO_cloud, const std::vector<float>& pointCloud, GLuint& VAO_dyn,
+                  GLuint& VBO_dyn)
+{
+    glGenVertexArrays(1, &VAO_cloud);
+    glGenBuffers(1, &VBO_cloud);
+    glBindVertexArray(VAO_cloud);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO_cloud);
+    glBufferData(GL_ARRAY_BUFFER, pointCloud.size() * sizeof(float), pointCloud.data(), GL_STATIC_DRAW);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(7 * sizeof(float)));
+    glEnableVertexAttribArray(3);
+
+    glGenVertexArrays(1, &VAO_dyn);
+    glGenBuffers(1, &VBO_dyn);
+    glBindVertexArray(VAO_dyn);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO_dyn);
+    glBufferData(GL_ARRAY_BUFFER, 1000 * 8 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(7 * sizeof(float)));
+    glEnableVertexAttribArray(3);
+}
+
+void updateDynamicData(std::vector<float>& dynData, float u, float v, float w, const Vector3<float>& P,
+                       const Triangle<Vector3<float>>& triangle)
+{
+    const auto& A = triangle.m_vertex1;
+    const auto& B = triangle.m_vertex2;
+    const auto& C = triangle.m_vertex3;
+
+    float sizeA = 10.0f + u * 30.0f;
+    float sizeB = 10.0f + v * 30.0f;
+    float sizeC = 10.0f + w * 30.0f;
+    float sizeP = 12.0f;
+
+    dynData = {// Lines from P to A, B, C
+               P.x, P.y, P.z, u, v, w, 1.0f, 1.0f, A.x, A.y, A.z, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
+
+               P.x, P.y, P.z, u, v, w, 1.0f, 1.0f, B.x, B.y, B.z, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
+
+               P.x, P.y, P.z, u, v, w, 1.0f, 1.0f, C.x, C.y, C.z, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
+
+               // The animated dot itself (White)
+               P.x, P.y, P.z, 1.0f, 1.0f, 1.0f, sizeP, 0.0f,
+
+               // The 3 corner dots
+               A.x, A.y, A.z, 1.0f, 0.0f, 0.0f, sizeA, 0.0f, B.x, B.y, B.z, 0.0f, 1.0f, 0.0f, sizeB, 0.0f, C.x, C.y,
+               C.z, 0.0f, 0.0f, 1.0f, sizeC, 0.0f};
+
+    char bufA[16], bufB[16], bufC[16];
+    snprintf(bufA, sizeof(bufA), "%.2f", u);
+    snprintf(bufB, sizeof(bufB), "%.2f", v);
+    snprintf(bufC, sizeof(bufC), "%.2f", w);
+
+    // Keep text at a fixed distance from the dots
+    float distA = 0.13f;
+    float distB = 0.13f;
+    float distC = 0.13f;
+
+    drawText(bufA, A.x - 0.05f, A.y + distA, 0.1f, Color(1, 0, 0, 1), dynData);
+    drawText(bufB, B.x - 0.15f - distB, B.y - 0.05f - distB, 0.1f, Color(0, 1, 0, 1), dynData);
+    drawText(bufC, C.x + 0.05f + distC, C.y - 0.05f - distC, 0.1f, Color(0, 0, 1, 1), dynData);
+}
+
+int main()
+{
+    GLFWwindow* window = initWindow(800, 800, "Barycentric Coordinates");
+    if (!window)
+        return -1;
+
+    GLuint shaderProgram = createShaderProgram();
+
+    // Triangle vertices as shown in the picture (Red, Green, Blue)
+    // Scaled down slightly to leave room for text
+    Triangle<Vector3<float>> triangle(Vector3<float>(0.0f, 0.6f, 0.0f), // Red dot (top)
+                                      Vector3<float>(-0.6f, -0.6f, 0.0f), // Green dot (bottom left)
+                                      Vector3<float>(0.6f, -0.6f, 0.0f) // Blue dot (bottom right)
+    );
+
+    std::vector<float> pointCloud;
+    generatePointCloud(pointCloud, triangle);
+
+    GLuint VAO_cloud, VBO_cloud, VAO_dyn, VBO_dyn;
+    setupBuffers(VAO_cloud, VBO_cloud, pointCloud, VAO_dyn, VBO_dyn);
+
+    glEnable(GL_PROGRAM_POINT_SIZE);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClearColor(0.02f, 0.02f, 0.02f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glUseProgram(shaderProgram);
+
+        // Draw the point cloud (the iterated points)
+        glBindVertexArray(VAO_cloud);
+        glDrawArrays(GL_POINTS, 0, pointCloud.size() / 8);
+
+        // Animate the white dot to simulate dragging
+        float t = glfwGetTime();
+        float u = (std::sin(t * 1.5f) * 0.5f + 0.5f);
+        float v = (std::cos(t * 1.1f) * 0.5f + 0.5f);
+
+        if (u + v > 1.0f)
+        {
+            u = 1.0f - u;
+            v = 1.0f - v;
+        }
+        float w = 1.0f - u - v;
+
+        if (w > 1.0f)
+        {
+            float diff = w - 1.0f;
+            w = 1.0f;
+            u += diff / 2.0f;
+            v += diff / 2.0f;
+        }
+        else if (w < 0.0f)
+        {
+            float diff = -w;
+            w = 0.0f;
+            u -= diff / 2.0f;
+            v -= diff / 2.0f;
+        }
+
+        Vector3<float> P = triangle.m_vertex1 * u + triangle.m_vertex2 * v + triangle.m_vertex3 * w;
+
+        std::vector<float> dynData;
+        updateDynamicData(dynData, u, v, w, P, triangle);
+
+        glBindVertexArray(VAO_dyn);
+        glBindBuffer(GL_ARRAY_BUFFER, VBO_dyn);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, dynData.size() * sizeof(float), dynData.data());
+
+        // Draw lines
+        glDrawArrays(GL_LINES, 0, 6);
+
+        // Draw text lines
+        int numTextVertices = (dynData.size() / 8) - 10;
+        if (numTextVertices > 0)
+        {
+            glDrawArrays(GL_LINES, 10, numTextVertices);
+        }
+
+        // Draw dots
+        glDrawArrays(GL_POINTS, 6, 4);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    return 0;
+}

examples/example_glfw3/CMakeLists.txt

@@ -0,0 +1,14 @@
+project(example_glfw3)
+
+add_executable(${PROJECT_NAME} example_glfw3.cpp)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES CXX_STANDARD 23
+               ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+               RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(OpenGL)
+find_package(GLEW REQUIRED)
+find_package(glfw3 CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath GLEW::GLEW glfw OpenGL::GL)

examples/example_glfw3/example_glfw3.cpp

@@ -0,0 +1,419 @@
+// main.cpp
+#include <cstdint>
+#include <iostream>
+#include <vector>
+
+// --- OpenGL / windowing ---
+#include <GL/glew.h> // GLEW must come before GLFW
+#include <GLFW/glfw3.h>
+
+// --- your math / engine stuff ---
+#include "omath/3d_primitives/mesh.hpp"
+#include "omath/engines/opengl_engine/camera.hpp"
+#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/engines/opengl_engine/mesh.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+
+using omath::Vector3;
+
+// ---------------- TYPE ALIASES (ADAPT TO YOUR LIB) ----------------
+
+// Your 4x4 matrix type
+using Mat4x4 = omath::opengl_engine::Mat4X4;
+
+// Rotation angles for the Mesh
+using RotationAngles = omath::opengl_engine::ViewAngles;
+
+// For brevity, alias the templates instantiated with your types
+using VertexType = omath::primitives::Vertex<Vector3<float>>;
+using CubeMesh = omath::opengl_engine::Mesh;
+using MyCamera = omath::opengl_engine::Camera;
+
+// ---------------- SHADERS ----------------
+
+static const char* vertexShaderSource = R"(
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in vec3 aUv;
+
+uniform mat4 uMVP;
+uniform mat4 uModel;
+
+out vec3 vNormal;
+out vec3 vUv;
+
+void main() {
+    vNormal = aNormal;
+    vUv = aUv;
+    gl_Position = uMVP * uModel * vec4(aPos, 1.0);
+}
+)";
+
+static const char* fragmentShaderSource = R"(
+#version 330 core
+in vec3 vNormal;
+in vec3 vUv;
+
+out vec4 FragColor;
+
+void main() {
+    vec3 baseColor = normalize(abs(vNormal));
+    FragColor = vec4(baseColor, 1.0);
+}
+)";
+
+GLuint compileShader(GLenum type, const char* src)
+{
+    GLuint shader = glCreateShader(type);
+    glShaderSource(shader, 1, &src, nullptr);
+    glCompileShader(shader);
+
+    GLint ok = GL_FALSE;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+    if (!ok)
+    {
+        char log[1024];
+        glGetShaderInfoLog(shader, sizeof(log), nullptr, log);
+        std::cerr << "Shader compile error: " << log << std::endl;
+    }
+    return shader;
+}
+
+GLuint createShaderProgram()
+{
+    GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
+    GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
+
+    GLuint prog = glCreateProgram();
+    glAttachShader(prog, vs);
+    glAttachShader(prog, fs);
+    glLinkProgram(prog);
+
+    GLint ok = GL_FALSE;
+    glGetProgramiv(prog, GL_LINK_STATUS, &ok);
+    if (!ok)
+    {
+        char log[1024];
+        glGetProgramInfoLog(prog, sizeof(log), nullptr, log);
+        std::cerr << "Program link error: " << log << std::endl;
+    }
+
+    glDeleteShader(vs);
+    glDeleteShader(fs);
+    return prog;
+}
+
+void framebuffer_size_callback(GLFWwindow* /*window*/, int w, int h)
+{
+    glViewport(0, 0, w, h);
+}
+
+// ---------------- MAIN ----------------
+
+int main()
+{
+    // ---------- GLFW init ----------
+    if (!glfwInit())
+    {
+        std::cerr << "Failed to init GLFW\n";
+        return -1;
+    }
+
+    std::cout << "GLFW Version: " << glfwGetVersionString() << "\n";
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    // Force GLX context creation API to ensure compatibility with GLEW
+    glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
+
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    constexpr int SCR_WIDTH = 800;
+    constexpr int SCR_HEIGHT = 600;
+
+    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "omath cube + camera (GLEW)", nullptr, nullptr);
+    if (!window)
+    {
+        std::cerr << "Failed to create GLFW window\n";
+        glfwTerminate();
+        return -1;
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    // Check if context is valid using standard GL
+    const GLubyte* renderer = glGetString(GL_RENDERER);
+    const GLubyte* version = glGetString(GL_VERSION);
+    if (renderer && version)
+    {
+        std::cout << "Renderer: " << renderer << "\n";
+        std::cout << "OpenGL version supported: " << version << "\n";
+    }
+    else
+    {
+        std::cerr << "Failed to get GL_RENDERER or GL_VERSION. Context might be invalid.\n";
+    }
+
+    // ---------- GLEW init ----------
+    glewExperimental = GL_TRUE;
+    GLenum glewErr = glewInit();
+    if (glewErr != GLEW_OK)
+    {
+        // Ignore NO_GLX_DISPLAY if we have a valid context
+        if (glewErr == GLEW_ERROR_NO_GLX_DISPLAY && renderer)
+        {
+            std::cerr << "GLEW warning: " << glewGetErrorString(glewErr) << " (Ignored because context seems valid)\n";
+        }
+        else
+        {
+            std::cerr << "Failed to initialize GLEW: " << reinterpret_cast<const char*>(glewGetErrorString(glewErr))
+                      << "\n";
+            glfwTerminate();
+            return -1;
+        }
+    }
+
+    // ---------- GL state ----------
+    glEnable(GL_DEPTH_TEST);
+
+    // Face culling
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK); // cull back faces
+    glFrontFace(GL_CCW); // counter-clockwise is front
+
+    // ---------- Build Cube Mesh (CPU side) ----------
+    std::vector<VertexType> vbo;
+    vbo.reserve(8);
+
+    Vector3<float> p000{-0.5f, -0.5f, -0.5f};
+    Vector3<float> p001{-0.5f, -0.5f, 0.5f};
+    Vector3<float> p010{-0.5f, 0.5f, -0.5f};
+    Vector3<float> p011{-0.5f, 0.5f, 0.5f};
+    Vector3<float> p100{0.5f, -0.5f, -0.5f};
+    Vector3<float> p101{0.5f, -0.5f, 0.5f};
+    Vector3<float> p110{0.5f, 0.5f, -0.5f};
+    Vector3<float> p111{0.5f, 0.5f, 0.5f};
+
+    VertexType v0{p000, Vector3<float>{-1, -1, -1}, omath::Vector2<float>{0, 0}};
+    VertexType v1{p001, Vector3<float>{-1, -1, 1}, omath::Vector2<float>{0, 1}};
+    VertexType v2{p010, Vector3<float>{-1, 1, -1}, omath::Vector2<float>{1, 0}};
+    VertexType v3{p011, Vector3<float>{-1, 1, 1}, omath::Vector2<float>{1, 1}};
+    VertexType v4{p100, Vector3<float>{1, -1, -1}, omath::Vector2<float>{0, 0}};
+    VertexType v5{p101, Vector3<float>{1, -1, 1}, omath::Vector2<float>{0, 1}};
+    VertexType v6{p110, Vector3<float>{1, 1, -1}, omath::Vector2<float>{1, 0}};
+    VertexType v7{p111, Vector3<float>{1, 1, 1}, omath::Vector2<float>{1, 1}};
+
+    vbo.push_back(v0); // 0
+    vbo.push_back(v1); // 1
+    vbo.push_back(v2); // 2
+    vbo.push_back(v3); // 3
+    vbo.push_back(v4); // 4
+    vbo.push_back(v5); // 5
+    vbo.push_back(v6); // 6
+    vbo.push_back(v7); // 7
+
+    using Idx = Vector3<std::uint32_t>;
+    std::vector<Idx> ebo;
+    ebo.reserve(12);
+
+    // front (z+)
+    ebo.emplace_back(1, 5, 7);
+    ebo.emplace_back(1, 7, 3);
+
+    // back (z-)
+    ebo.emplace_back(0, 2, 6);
+    ebo.emplace_back(0, 6, 4);
+
+    // left (x-)
+    ebo.emplace_back(0, 1, 3);
+    ebo.emplace_back(0, 3, 2);
+
+    // right (x+)
+    ebo.emplace_back(4, 6, 7);
+    ebo.emplace_back(4, 7, 5);
+
+    // bottom (y-)
+    ebo.emplace_back(0, 4, 5);
+    ebo.emplace_back(0, 5, 1);
+
+    // top (y+)
+    ebo.emplace_back(2, 3, 7);
+    ebo.emplace_back(2, 7, 6);
+
+    CubeMesh cube{std::move(vbo), std::move(ebo)};
+    cube.set_origin({0.f, 0.f, 0.f});
+    cube.set_scale({2.f, 2.f, 2.f});
+    cube.set_rotation(RotationAngles{});
+
+    // ---------- OpenGL buffers ----------
+    GLuint VAO = 0, VBO = 0, EBO_GL = 0;
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glGenBuffers(1, &EBO_GL);
+
+    glBindVertexArray(VAO);
+
+    // upload vertex buffer
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, cube.m_vertex_buffer.size() * sizeof(VertexType), cube.m_vertex_buffer.data(),
+                 GL_STATIC_DRAW);
+
+    // flatten EBO to GL indices
+    std::vector<GLuint> flatIndices;
+    flatIndices.reserve(cube.m_element_buffer_object.size() * 3);
+    for (const auto& tri : cube.m_element_buffer_object)
+    {
+        flatIndices.push_back(tri.x);
+        flatIndices.push_back(tri.y);
+        flatIndices.push_back(tri.z);
+    }
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO_GL);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, flatIndices.size() * sizeof(GLuint), flatIndices.data(), GL_STATIC_DRAW);
+
+    // vertex layout: position / normal / uv (each Vector3<float>)
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, position));
+
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, normal));
+
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(VertexType), (void*)offsetof(VertexType, uv));
+
+    glBindVertexArray(0);
+
+    // ---------- Camera setup ----------
+    omath::projection::ViewPort viewPort{static_cast<float>(SCR_WIDTH), static_cast<float>(SCR_HEIGHT)};
+
+    Vector3<float> camPos{0.f, 0.f, 3.f};
+
+    float nearPlane = 0.1f;
+    float farPlane = 100.f;
+    auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+
+    MyCamera camera{camPos, {}, viewPort, fov, nearPlane, farPlane};
+
+    // ---------- Shader ----------
+    GLuint shaderProgram = createShaderProgram();
+    GLint uMvpLoc = glGetUniformLocation(shaderProgram, "uMVP");
+    GLint uModel = glGetUniformLocation(shaderProgram, "uModel");
+
+    static float old_frame_time = glfwGetTime();
+
+    float lastX = 640.0f / 2.0f;
+    float lastY = 480.0f / 2.0f;
+    bool firstMouse = true;
+    bool mouse_capture = false;
+    float mouseSensitivity = 0.1f;
+    // ---------- Main loop ----------
+    static double old_mouse_time = glfwGetTime();
+    while (!glfwWindowShouldClose(window))
+    {
+        glfwPollEvents();
+        omath::Vector3<float> move_dir;
+        if (glfwGetKey(window, GLFW_KEY_W))
+            move_dir += camera.get_forward();
+
+        if (glfwGetKey(window, GLFW_KEY_A))
+            move_dir -= camera.get_right();
+
+        if (glfwGetKey(window, GLFW_KEY_S))
+            move_dir -= camera.get_forward();
+
+        if (glfwGetKey(window, GLFW_KEY_D))
+            move_dir += camera.get_right();
+
+        if (glfwGetKey(window, GLFW_KEY_SPACE))
+            move_dir += camera.get_up();
+
+        if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL))
+            move_dir -= camera.get_up();
+
+
+        auto delta = glfwGetTime() - old_mouse_time;
+        if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) && delta > 0.4)
+        {
+            old_mouse_time = glfwGetTime();
+            mouse_capture = !mouse_capture;
+
+            glfwSetInputMode(window, GLFW_CURSOR, mouse_capture ? GLFW_CURSOR_HIDDEN : GLFW_CURSOR_NORMAL);
+        }
+        if (mouse_capture)
+        {
+            int x, y;
+            glfwGetWindowSize(window, &x, &y);
+
+            camera.set_origin(camera.get_origin() + (move_dir.normalized() * 0.4f));
+
+            double xpos, ypos;
+            glfwGetCursorPos(window, &xpos, &ypos);
+            float xoffset = (float)xpos - x / 2.f;
+            float yoffset = y / 2.f - ypos ; // reversed: y-coordinates go bottom->top for pitch
+
+            xoffset *= mouseSensitivity;
+            yoffset *= mouseSensitivity;
+
+            auto new_angles = camera.get_view_angles();
+            new_angles.pitch += decltype(new_angles.pitch)::from_degrees(yoffset);
+            new_angles.yaw -= decltype(new_angles.yaw)::from_degrees(xoffset);
+            camera.set_view_angles(new_angles);
+            glfwSetCursorPos(window, x / 2., y / 2);
+        }
+        float currentTime = glfwGetTime();
+        float deltaTime = currentTime - old_frame_time;
+        old_frame_time = currentTime;
+
+        int fbW = 0, fbH = 0;
+        glfwGetFramebufferSize(window, &fbW, &fbH);
+        glViewport(0, 0, fbW, fbH);
+
+        viewPort.m_width = static_cast<float>(fbW);
+        viewPort.m_height = static_cast<float>(fbH);
+        camera.set_view_port(viewPort);
+
+        glClearColor(0.1f, 0.15f, 0.2f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        RotationAngles rot = cube.get_rotation_angles();
+        rot.yaw += omath::opengl_engine::YawAngle ::from_degrees(40.f * deltaTime);
+        rot.roll += omath::opengl_engine::RollAngle::from_degrees(40.f * deltaTime);
+
+        if (rot.pitch.as_degrees() == 90.f)
+            rot.pitch = omath::opengl_engine::PitchAngle::from_degrees(-90.f);
+        rot.pitch += omath::opengl_engine::PitchAngle::from_degrees(40.f * deltaTime);
+        cube.set_rotation(rot);
+
+        const Mat4x4& viewProj = camera.get_view_projection_matrix();
+        const auto& model = cube.get_to_world_matrix();
+
+        glUseProgram(shaderProgram);
+
+        // Send matrices to GPU
+        const float* mvpPtr = viewProj.raw_array().data();
+        const float* modelPtr = model.raw_array().data();
+
+        glUniformMatrix4fv(uMvpLoc, 1, GL_FALSE, mvpPtr);
+        glUniformMatrix4fv(uModel, 1, GL_FALSE, modelPtr);
+
+        glBindVertexArray(VAO);
+        glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(flatIndices.size()), GL_UNSIGNED_INT, nullptr);
+
+        glfwSwapBuffers(window);
+    }
+
+    // ---------- Cleanup ----------
+    glDeleteVertexArrays(1, &VAO);
+    glDeleteBuffers(1, &VBO);
+    glDeleteBuffers(1, &EBO_GL);
+    glDeleteProgram(shaderProgram);
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}

examples/example_proj_mat_builder/CMakeLists.txt

@@ -0,0 +1,10 @@
+project(example_projection_matrix_builder)
+
+add_executable(${PROJECT_NAME} example_proj_mat_builder.cpp)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES CXX_STANDARD 23
+               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}")
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath)

examples/example_signature_scan/CMakeLists.txt

@@ -0,0 +1,10 @@
+project(example_signature_scan)
+
+add_executable(${PROJECT_NAME} example_signature_scan.cpp)
+set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES CXX_STANDARD 23
+               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}")
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath)

include/omath/3d_primitives/box.hpp

@@ -3,14 +3,60 @@
 //
 
 #pragma once
+#include "mesh.hpp"
+#include "omath/engines/opengl_engine/camera.hpp"
+#include "omath/engines/opengl_engine/traits/mesh_trait.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include <array>
 
 namespace omath::primitives
 {
+    template<class BoxMeshType>
     [[nodiscard]]
-    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
-                                             const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
-                                             float ratio = 4.f) noexcept;
-}
+    BoxMeshType create_box(const Vector3<float>& top, const Vector3<float>& bottom, const Vector3<float>& dir_forward,
+                           const Vector3<float>& dir_right, const float ratio = 4.f) noexcept
+    {
+        const auto height = top.distance_to(bottom);
+        const auto side_size = height / ratio;
+
+        // corner layout (0‑3 bottom, 4‑7 top)
+        std::array<Vector3<float>, 8> p;
+        p[0] = bottom + (dir_forward + dir_right) * side_size; // front‑right‑bottom
+        p[1] = bottom + (dir_forward - dir_right) * side_size; // front‑left‑bottom
+        p[2] = bottom + (-dir_forward + dir_right) * side_size; // back‑right‑bottom
+        p[3] = bottom + (-dir_forward - dir_right) * side_size; // back‑left‑bottom
+        p[4] = top + (dir_forward + dir_right) * side_size; // front‑right‑top
+        p[5] = top + (dir_forward - dir_right) * side_size; // front‑left‑top
+        p[6] = top + (-dir_forward + dir_right) * side_size; // back‑right‑top
+        p[7] = top + (-dir_forward - dir_right) * side_size; // back‑left‑top
+
+        std::array<Vector3<std::uint32_t>, 12> poly;
+
+        // bottom face (+Y up ⇒ wind CW when viewed from above)
+        poly[0] = {0, 2, 3};
+        poly[1] = {0, 3, 1};
+
+        // top face
+        poly[2] = {4, 7, 6};
+        poly[3] = {4, 5, 7};
+
+        // front face
+        poly[4] = {0, 5, 1};
+        poly[5] = {0, 4, 5};
+
+        // right face
+        poly[6] = {0, 6, 2};
+        poly[7] = {0, 4, 6};
+
+        // back face
+        poly[8] = {2, 7, 3};
+        poly[9] = {2, 6, 7};
+
+        // left face
+        poly[10] = {1, 7, 5};
+        poly[11] = {1, 3, 7};
+
+        return BoxMeshType{std::move(p), std::move(poly)};
+    }
+} // namespace omath::primitives

include/omath/3d_primitives/mesh.hpp

@@ -6,35 +6,58 @@
 #include <omath/linear_algebra/mat.hpp>
 #include <omath/linear_algebra/vector3.hpp>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace omath::primitives
 {
-    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class Type = float>
+    template<class VecType = Vector3<float>, class UvT = Vector2<float>>
+    struct Vertex final
+    {
+        using VectorType = VecType;
+        using UvType = UvT;
+        VectorType position;
+        VectorType normal;
+        UvType uv;
+    };
+
+    template<typename T> concept HasPosition = requires(T vertex) { vertex.position; };
+    template<typename T> concept HasNormal = requires(T vertex) { vertex.normal; };
+    template<typename T> concept HasUv = requires(T vertex) { vertex.uv; };
+
+    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex<>,
+             class VboType = std::vector<VertType>, class EboType = std::vector<Vector3<std::uint32_t>>>
     class Mesh final
     {
     public:
-        using NumericType = Type;
+        using VectorType = VertType::VectorType;
+        using VertexType = VboType::value_type;
 
     private:
-        using Vbo = std::vector<Vector3<NumericType>>;
-        using Vao = std::vector<Vector3<std::size_t>>;
+        using Vbo = VboType;
+        using Ebo = EboType;
 
     public:
         Vbo m_vertex_buffer;
-        Vao m_vertex_array_object;
+        Ebo m_element_buffer_object;
 
-        Mesh(Vbo vbo, Vao vao, const Vector3<NumericType> scale = {1, 1, 1,})
-            : m_vertex_buffer(std::move(vbo)), m_vertex_array_object(std::move(vao)), m_scale(std::move(scale))
+        Mesh(Vbo vbo, Ebo vao,
+             const VectorType scale =
+                     {
+                             1,
+                             1,
+                             1,
+                     })
+            : m_vertex_buffer(std::move(vbo)), m_element_buffer_object(std::move(vao)), m_scale(std::move(scale))
         {
         }
-        void set_origin(const Vector3<NumericType>& new_origin)
+        void set_origin(const VectorType& new_origin)
         {
             m_origin = new_origin;
             m_to_world_matrix = std::nullopt;
         }
 
-        void set_scale(const Vector3<NumericType>& new_scale)
+        void set_scale(const VectorType& new_scale)
         {
             m_scale = new_scale;
             m_to_world_matrix = std::nullopt;
@@ -47,13 +70,13 @@ namespace omath::primitives
         }
 
         [[nodiscard]]
-        const Vector3<NumericType>& get_origin() const
+        const VectorType& get_origin() const
         {
             return m_origin;
         }
 
         [[nodiscard]]
-        const Vector3<NumericType>& get_scale() const
+        const VectorType& get_scale() const
         {
             return m_scale;
         }
@@ -69,31 +92,40 @@ namespace omath::primitives
         {
             if (m_to_world_matrix)
                 return m_to_world_matrix.value();
-            m_to_world_matrix =
-                    mat_translation(m_origin) * mat_scale(m_scale) * MeshTypeTrait::rotation_matrix(m_rotation_angles);
+            m_to_world_matrix = mat_translation<float, Mat4X4::get_store_ordering()>(m_origin)
+                                * MeshTypeTrait::rotation_matrix(m_rotation_angles)
+                                * mat_scale<float, Mat4X4::get_store_ordering()>(m_scale);
 
             return m_to_world_matrix.value();
         }
 
         [[nodiscard]]
-        Vector3<float> vertex_to_world_space(const Vector3<float>& vertex) const
+        VectorType vertex_position_to_world_space(const Vector3<float>& vertex_position) const
         {
-            auto abs_vec = get_to_world_matrix() * mat_column_from_vector(vertex);
+            auto abs_vec = get_to_world_matrix()
+                           * mat_column_from_vector<typename Mat4X4::ContainedType, Mat4X4::get_store_ordering()>(
+                                   vertex_position);
 
             return {abs_vec.at(0, 0), abs_vec.at(1, 0), abs_vec.at(2, 0)};
         }
 
         [[nodiscard]]
-        Triangle<Vector3<float>> make_face_in_world_space(const Vao::const_iterator vao_iterator) const
+        Triangle<VectorType> make_face_in_world_space(const Ebo::const_iterator vao_iterator) const
         {
-            return {vertex_to_world_space(m_vertex_buffer.at(vao_iterator->x)),
-                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->y)),
-                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->z))};
+            if constexpr (HasPosition<VertexType>)
+            {
+                return {vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->x).position),
+                        vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->y).position),
+                        vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->z).position)};
+            }
+            return {vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->x)),
+                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->y)),
+                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->z))};
         }
 
     private:
-        Vector3<NumericType> m_origin;
-        Vector3<NumericType> m_scale;
+        VectorType m_origin;
+        VectorType m_scale;
 
         RotationAngles m_rotation_angles;
 

include/omath/3d_primitives/plane.hpp

@@ -3,14 +3,30 @@
 //
 
 #pragma once
+#include "mesh.hpp"
+#include "omath/engines/opengl_engine/camera.hpp"
+#include "omath/engines/opengl_engine/mesh.hpp"
+#include "omath/engines/opengl_engine/traits/mesh_trait.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include <array>
 
 namespace omath::primitives
 {
+    template<class PlaneMeshType>
     [[nodiscard]]
-    std::array<Triangle<Vector3<float>>, 2> create_plane(const Vector3<float>& vertex_a,
-                                                          const Vector3<float>& vertex_b,
-                                                          const Vector3<float>& direction, float size) noexcept;
-}
+    PlaneMeshType create_plane(const Vector3<float>& vertex_a, const Vector3<float>& vertex_b,
+                           const Vector3<float>& direction, const float size) noexcept
+    {
+        const auto second_vertex_a = vertex_a + direction * size;
+        const auto second_vertex_b = vertex_b + direction * size;
+
+        std::array<Vector3<float>, 4> grid = {vertex_a, vertex_b, second_vertex_a, second_vertex_b};
+
+        std::array<Vector3<std::uint32_t>, 2> poly;
+        poly[0] = {1, 1, 2};
+        poly[1] = {0, 1, 3};
+
+        return PlaneMeshType(std::move(grid), std::move(poly));
+    }
+} // namespace omath::primitives

include/omath/collision/collider_interface.hpp

@@ -0,0 +1,23 @@
+//
+// Created by Vladislav on 06.12.2025.
+//
+#pragma once
+#include <omath/linear_algebra/vector3.hpp>
+
+namespace omath::collision
+{
+    template<class VecType = Vector3<float>>
+    class ColliderInterface
+    {
+    public:
+        using VectorType = VecType;
+        virtual ~ColliderInterface() = default;
+
+        [[nodiscard]]
+        virtual VectorType find_abs_furthest_vertex_position(const VectorType& direction) const = 0;
+
+        [[nodiscard]]
+        virtual const VectorType& get_origin() const = 0;
+        virtual void set_origin(const VectorType& new_origin) = 0;
+    };
+}

include/omath/collision/epa_algorithm.hpp

@@ -1,37 +1,46 @@
 #pragma once
 #include "simplex.hpp"
-#include <algorithm> // find_if
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <memory>
+#include <memory_resource>
 #include <queue>
+#include <unordered_map>
+#include <utility>
 #include <vector>
 
 namespace omath::collision
 {
-    template<class V>
-    concept EpaVector = requires(const V& a, const V& b, float s) {
+    template<class V, class FloatingType>
+    concept EpaVector = requires(const V& a, const V& b, FloatingType s) {
         { a - b } -> std::same_as<V>;
         { a.cross(b) } -> std::same_as<V>;
-        { a.dot(b) } -> std::same_as<float>;
+        { a.dot(b) } -> std::same_as<FloatingType>;
         { -a } -> std::same_as<V>;
-        { a* s } -> std::same_as<V>;
+        { a * s } -> std::same_as<V>;
         { a / s } -> std::same_as<V>;
     };
 
-    template<class ColliderType>
+    template<class ColliderInterfaceType>
     class Epa final
     {
     public:
-        using Vertex = typename ColliderType::VertexType;
-        static_assert(EpaVector<Vertex>, "VertexType must satisfy EpaVector concept");
+        using VectorType = ColliderInterfaceType::VectorType;
+        static_assert(EpaVector<VectorType, typename VectorType::ContainedType>,
+                      "VertexType must satisfy EpaVector concept");
 
+    private:
+        using FloatingType = VectorType::ContainedType;
+
+    public:
         struct Result final
         {
-            Vertex normal{}; // outward normal (from B to A)
-            Vertex penetration_vector;
-            float depth{0.0f};
+            VectorType normal{}; // from A to B
+            VectorType penetration_vector;
+            FloatingType depth{0.0};
             int iterations{0};
             int num_vertices{0};
             int num_faces{0};
@@ -40,140 +49,94 @@ namespace omath::collision
         struct Params final
         {
             int max_iterations{64};
-            float tolerance{1e-4f}; // absolute tolerance on distance growth
+            FloatingType tolerance{1e-4}; // absolute tolerance on distance growth
         };
-
         // Precondition: simplex.size()==4 and contains the origin.
         [[nodiscard]]
-        static std::optional<Result> solve(const ColliderType& a, const ColliderType& b, const Simplex<Vertex>& simplex,
-                                           const Params params = {})
+        static std::optional<Result> solve(const ColliderInterfaceType& a, const ColliderInterfaceType& b,
+                                           const Simplex<VectorType>& simplex, const Params params = {},
+                                           std::pmr::memory_resource& mem_resource = *std::pmr::get_default_resource())
         {
-            // --- Build initial polytope from simplex (4 points) ---
-            std::vector<Vertex> vertexes;
-            vertexes.reserve(64);
-            for (std::size_t i = 0; i < simplex.size(); ++i)
-                vertexes.push_back(simplex[i]);
+            std::pmr::vector<VectorType> vertexes = build_initial_polytope_from_simplex(simplex, mem_resource);
+            std::pmr::vector<Face> faces = create_initial_tetra_faces(mem_resource, vertexes);
 
-            // Initial tetra faces (windings corrected in make_face)
-            std::vector<Face> faces;
-            faces.reserve(128);
-            faces.emplace_back(make_face(vertexes, 0, 1, 2));
-            faces.emplace_back(make_face(vertexes, 0, 2, 3));
-            faces.emplace_back(make_face(vertexes, 0, 3, 1));
-            faces.emplace_back(make_face(vertexes, 1, 3, 2));
-
-            auto heap = rebuild_heap(faces);
+            // Build initial min-heap by distance.
+            Heap heap = rebuild_heap(faces, mem_resource);
 
             Result out{};
 
+            // Hoisted outside the loop to reuse bucket allocation across iterations.
+            // Initial bucket count 16 covers a typical horizon without rehashing.
+            BoundaryMap boundary{16, &mem_resource};
+
             for (int it = 0; it < params.max_iterations; ++it)
             {
-                // If heap might be stale after face edits, rebuild lazily.
-                if (heap.empty())
-                    break;
-                // Rebuild when the "closest" face changed (simple cheap guard)
-                // (We could keep face handles; this is fine for small Ns.)
-
-                if (const auto top = heap.top(); faces[top.idx].d != top.d)
-                    heap = rebuild_heap(faces);
+                // Lazily discard stale (deleted or index-mismatched) heap entries.
+                discard_stale_heap_entries(faces, heap);
 
                 if (heap.empty())
                     break;
 
-                const int fidx = heap.top().idx;
-                const Face f = faces[fidx];
+                const Face& face = faces[heap.top().idx];
 
-                // Get farthest point in face normal direction
-                const Vertex p = support_point(a, b, f.n);
-                const float p_dist = f.n.dot(p);
+                const VectorType p = support_point(a, b, face.n);
+                const auto p_dist = face.n.dot(p);
 
-                // Converged if we can’t push the face closer than tolerance
-                if (p_dist - f.d <= params.tolerance)
+                // Converged: new support can't push the face closer than tolerance.
+                if (p_dist - face.d <= params.tolerance)
                 {
-                    out.normal = f.n;
-                    out.depth = f.d; // along unit normal
+                    out.normal = face.n;
+                    out.depth = face.d;
                     out.iterations = it + 1;
                     out.num_vertices = static_cast<int>(vertexes.size());
                     out.num_faces = static_cast<int>(faces.size());
-
-                    const auto centers = b.get_origin() - a.get_origin();
-                    const auto sign = out.normal.dot(centers) >= 0 ? 1 : -1;
-
-                    out.penetration_vector = out.normal * out.depth * sign;
+                    out.penetration_vector = out.normal * out.depth;
                     return out;
                 }
 
-                // Add new vertex
                 const int new_idx = static_cast<int>(vertexes.size());
-                vertexes.push_back(p);
+                vertexes.emplace_back(p);
 
-                // Mark faces visible from p and collect their horizon
-                std::vector<char> to_delete(faces.size(), 0);
-                std::vector<Edge> boundary;
-                boundary.reserve(faces.size() * 2);
+                // Tombstone visible faces and collect the horizon boundary.
+                // This avoids copying the faces array (O(n)) each iteration.
+                tombstone_visible_faces(faces, boundary, p);
 
-                for (int i = 0; i < static_cast<int>(faces.size()); ++i)
+                // Stitch new faces around the horizon and push them directly onto the
+                // heap — no full O(n log n) rebuild needed.
+                for (const auto& [key, e] : boundary)
                 {
-                    if (to_delete[i])
-                        continue;
-                    if (visible_from(faces[i], p))
-                    {
-                        const auto& rf = faces[i];
-                        to_delete[i] = 1;
-                        add_edge_boundary(boundary, rf.i0, rf.i1);
-                        add_edge_boundary(boundary, rf.i1, rf.i2);
-                        add_edge_boundary(boundary, rf.i2, rf.i0);
-                    }
+                    const int fi = static_cast<int>(faces.size());
+                    faces.emplace_back(make_face(vertexes, e.a, e.b, new_idx));
+                    heap.emplace(faces.back().d, fi);
                 }
 
-                // Remove visible faces
-                std::vector<Face> new_faces;
-                new_faces.reserve(faces.size() + boundary.size());
-                for (int i = 0; i < static_cast<int>(faces.size()); ++i)
-                    if (!to_delete[i])
-                        new_faces.push_back(faces[i]);
-                faces.swap(new_faces);
-
-                // Stitch new faces around the horizon
-                for (const auto& e : boundary)
-                    faces.push_back(make_face(vertexes, e.a, e.b, new_idx));
-
-                // Rebuild heap after topology change
-                heap = rebuild_heap(faces);
-
                 if (!std::isfinite(vertexes.back().dot(vertexes.back())))
                     break; // safety
+
                 out.iterations = it + 1;
             }
 
-            // Fallback: pick closest face as best-effort answer
-            if (!faces.empty())
-            {
-                auto best = faces[0];
-                for (const auto& f : faces)
-                    if (f.d < best.d)
-                        best = f;
-                out.normal = best.n;
-                out.depth = best.d;
-                out.num_vertices = static_cast<int>(vertexes.size());
-                out.num_faces = static_cast<int>(faces.size());
+            // Find the best surviving (non-deleted) face.
+            const Face* best = find_best_surviving_face(faces);
 
-                const auto centers = b.get_origin() - a.get_origin();
-                const auto sign = out.normal.dot(centers) >= 0 ? 1 : -1;
+            if (!best)
+                return std::nullopt;
 
-                out.penetration_vector = out.normal * out.depth * sign;
-
-                return out;
-            }
-            return std::nullopt;
+            out.normal = best->n;
+            out.depth = best->d;
+            out.num_vertices = static_cast<int>(vertexes.size());
+            out.num_faces = static_cast<int>(faces.size());
+            out.penetration_vector = out.normal * out.depth;
+            return out;
         }
 
     private:
         struct Face final
         {
             int i0, i1, i2;
-            Vertex n; // unit outward normal
-            float d; // n · v0  (>=0 ideally because origin is inside)
+            VectorType n; // unit outward normal
+            FloatingType d; // n · v0  (>= 0 ideally because origin is inside)
+            bool deleted{false}; // tombstone flag — avoids O(n) compaction per iteration
         };
 
         struct Edge final
@@ -183,77 +146,93 @@ namespace omath::collision
 
         struct HeapItem final
         {
-            float d;
+            FloatingType d;
             int idx;
         };
+
         struct HeapCmp final
         {
-            bool operator()(const HeapItem& lhs, const HeapItem& rhs) const noexcept
+            [[nodiscard]]
+            static bool operator()(const HeapItem& lhs, const HeapItem& rhs) noexcept
             {
                 return lhs.d > rhs.d; // min-heap by distance
             }
         };
-        using Heap = std::priority_queue<HeapItem, std::vector<HeapItem>, HeapCmp>;
+
+        using Heap = std::priority_queue<HeapItem, std::pmr::vector<HeapItem>, HeapCmp>;
+
+        // Horizon boundary: maps packed(a,b) → Edge.
+        // Opposite edges cancel in O(1) via hash lookup instead of O(h) linear scan.
+        using BoundaryMap = std::pmr::unordered_map<std::int64_t, Edge>;
 
         [[nodiscard]]
-        static Heap rebuild_heap(const std::vector<Face>& faces)
+        static constexpr std::int64_t pack_edge(const int a, const int b) noexcept
         {
-            Heap h;
+            return (static_cast<std::int64_t>(a) << 32) | static_cast<std::uint32_t>(b);
+        }
+
+        [[nodiscard]]
+        static Heap rebuild_heap(const std::pmr::vector<Face>& faces, auto& memory_resource)
+        {
+            std::pmr::vector<HeapItem> storage{&memory_resource};
+            storage.reserve(faces.size());
+            Heap h{HeapCmp{}, std::move(storage)};
             for (int i = 0; i < static_cast<int>(faces.size()); ++i)
-                h.push({faces[i].d, i});
+                if (!faces[i].deleted)
+                    h.emplace(faces[i].d, i);
             return h;
         }
 
         [[nodiscard]]
-        static bool visible_from(const Face& f, const Vertex& p)
+        static bool visible_from(const Face& f, const VectorType& p)
         {
-            // positive if p is in front of the face
-            return (f.n.dot(p) - f.d) > 1e-7f;
+            return f.n.dot(p) - f.d > static_cast<FloatingType>(1e-7);
         }
 
-        static void add_edge_boundary(std::vector<Edge>& boundary, int a, int b)
+        static void add_edge_boundary(BoundaryMap& boundary, int a, int b)
         {
-            // Keep edges that appear only once; erase if opposite already present
-            auto itb =
-                    std::find_if(boundary.begin(), boundary.end(), [&](const Edge& e) { return e.a == b && e.b == a; });
-            if (itb != boundary.end())
-                boundary.erase(itb); // internal edge cancels out
+            // O(1) cancel: if the opposite edge (b→a) is already in the map it is an
+            // internal edge shared by two visible faces and must be removed.
+            // Otherwise this is a horizon edge and we insert it.
+            const std::int64_t rev = pack_edge(b, a);
+            if (const auto it = boundary.find(rev); it != boundary.end())
+                boundary.erase(it);
             else
-                boundary.push_back({a, b}); // horizon edge (directed)
+                boundary.emplace(pack_edge(a, b), Edge{a, b});
         }
 
         [[nodiscard]]
-        static Face make_face(const std::vector<Vertex>& vertexes, int i0, int i1, int i2)
+        static Face make_face(const std::pmr::vector<VectorType>& vertexes, int i0, int i1, int i2)
         {
-            const Vertex& a0 = vertexes[i0];
-            const Vertex& a1 = vertexes[i1];
-            const Vertex& a2 = vertexes[i2];
-            Vertex n = (a1 - a0).cross(a2 - a0);
-            if (n.dot(n) <= 1e-30f)
-            {
+            const VectorType& a0 = vertexes[i0];
+            const VectorType& a1 = vertexes[i1];
+            const VectorType& a2 = vertexes[i2];
+            VectorType n = (a1 - a0).cross(a2 - a0);
+            if (n.dot(n) <= static_cast<FloatingType>(1e-30))
                 n = any_perp_vec(a1 - a0); // degenerate guard
-            }
             // Ensure normal points outward (away from origin): require n·a0 >= 0
-            if (n.dot(a0) < 0.0f)
+            if (n.dot(a0) < static_cast<FloatingType>(0.0))
             {
                 std::swap(i1, i2);
                 n = -n;
             }
-            const float inv_len = 1.0f / std::sqrt(std::max(n.dot(n), 1e-30f));
+            const auto inv_len =
+                    static_cast<FloatingType>(1.0) / std::sqrt(std::max(n.dot(n), static_cast<FloatingType>(1e-30)));
             n = n * inv_len;
-            const float d = n.dot(a0);
+            const auto d = n.dot(a0);
             return {i0, i1, i2, n, d};
         }
 
         [[nodiscard]]
-        static Vertex support_point(const ColliderType& a, const ColliderType& b, const Vertex& dir)
+        static VectorType support_point(const ColliderInterfaceType& a, const ColliderInterfaceType& b,
+                                        const VectorType& dir)
         {
-            return a.find_abs_furthest_vertex(dir) - b.find_abs_furthest_vertex(-dir);
+            return a.find_abs_furthest_vertex_position(dir) - b.find_abs_furthest_vertex_position(-dir);
         }
 
         template<class V>
         [[nodiscard]]
-        static constexpr bool near_zero_vec(const V& v, const float eps = 1e-7f)
+        static constexpr bool near_zero_vec(const V& v, const FloatingType eps = 1e-7f)
         {
             return v.dot(v) <= eps * eps;
         }
@@ -267,5 +246,65 @@ namespace omath::collision
                     return d;
             return V{1, 0, 0};
         }
+
+        [[nodiscard]]
+        static std::pmr::vector<Face> create_initial_tetra_faces(std::pmr::memory_resource& mem_resource,
+                                                                 const std::pmr::vector<VectorType>& vertexes)
+        {
+            std::pmr::vector<Face> faces{&mem_resource};
+            faces.reserve(4);
+            faces.emplace_back(make_face(vertexes, 0, 1, 2));
+            faces.emplace_back(make_face(vertexes, 0, 2, 3));
+            faces.emplace_back(make_face(vertexes, 0, 3, 1));
+            faces.emplace_back(make_face(vertexes, 1, 3, 2));
+            return faces;
+        }
+
+        [[nodiscard]]
+        static std::pmr::vector<VectorType> build_initial_polytope_from_simplex(const Simplex<VectorType>& simplex,
+                                                                                std::pmr::memory_resource& mem_resource)
+        {
+            std::pmr::vector<VectorType> vertexes{&mem_resource};
+            vertexes.reserve(simplex.size());
+            for (std::size_t i = 0; i < simplex.size(); ++i)
+                vertexes.emplace_back(simplex[i]);
+            return vertexes;
+        }
+
+        static const Face* find_best_surviving_face(const std::pmr::vector<Face>& faces)
+        {
+            const Face* best = nullptr;
+            for (const auto& f : faces)
+                if (!f.deleted && (best == nullptr || f.d < best->d))
+                    best = &f;
+            return best;
+        }
+        static void tombstone_visible_faces(std::pmr::vector<Face>& faces, BoundaryMap& boundary,
+                                            const VectorType& p)
+        {
+            boundary.clear();
+            for (auto& f : faces)
+            {
+                if (!f.deleted && visible_from(f, p))
+                {
+                    f.deleted = true;
+                    add_edge_boundary(boundary, f.i0, f.i1);
+                    add_edge_boundary(boundary, f.i1, f.i2);
+                    add_edge_boundary(boundary, f.i2, f.i0);
+                }
+            }
+        }
+
+        static void discard_stale_heap_entries(const std::pmr::vector<Face>& faces,
+                                               std::priority_queue<HeapItem, std::pmr::vector<HeapItem>, HeapCmp>& heap)
+        {
+            while (!heap.empty())
+            {
+                const auto& top = heap.top();
+                if (!faces[top.idx].deleted && faces[top.idx].d == top.d)
+                    break;
+                heap.pop();
+            }
+        }
     };
 } // namespace omath::collision

include/omath/collision/gjk_algorithm.hpp

@@ -14,41 +14,60 @@ namespace omath::collision
         Simplex<VertexType> simplex; // valid only if hit == true and size==4
     };
 
-    template<class ColliderType>
+    struct GjkSettings final
+    {
+        float epsilon = 1e-6f;
+        std::size_t max_iterations = 64;
+    };
+    template<class ColliderInterfaceType>
     class GjkAlgorithm final
     {
-        using VertexType = typename ColliderType::VertexType;
-
+        using VectorType = ColliderInterfaceType::VectorType;
     public:
         [[nodiscard]]
-        static VertexType find_support_vertex(const ColliderType& collider_a, const ColliderType& collider_b,
-                                              const VertexType& direction)
+        static VectorType find_support_vertex(const ColliderInterfaceType& collider_a,
+                                              const ColliderInterfaceType& collider_b, const VectorType& direction)
         {
-            return collider_a.find_abs_furthest_vertex(direction) - collider_b.find_abs_furthest_vertex(-direction);
+            return collider_a.find_abs_furthest_vertex_position(direction)
+                   - collider_b.find_abs_furthest_vertex_position(-direction);
         }
 
         [[nodiscard]]
-        static bool is_collide(const ColliderType& collider_a, const ColliderType& collider_b)
+        static bool is_collide(const ColliderInterfaceType& collider_a, const ColliderInterfaceType& collider_b)
         {
             return is_collide_with_simplex_info(collider_a, collider_b).hit;
         }
 
         [[nodiscard]]
-        static GjkHitInfo<VertexType> is_collide_with_simplex_info(const ColliderType& collider_a,
-                                                                   const ColliderType& collider_b)
+        static GjkHitInfo<VectorType> is_collide_with_simplex_info(const ColliderInterfaceType& collider_a,
+                                                                   const ColliderInterfaceType& collider_b,
+                                                                   const GjkSettings& settings = {})
         {
-            auto support = find_support_vertex(collider_a, collider_b, {1, 0, 0});
+            // Use centroid difference as initial direction — greatly reduces iterations for separated shapes.
+            VectorType initial_dir;
+            if constexpr (requires { collider_b.get_origin() - collider_a.get_origin(); })
+            {
+                initial_dir = collider_b.get_origin() - collider_a.get_origin();
+                if (initial_dir.dot(initial_dir) < settings.epsilon * settings.epsilon)
+                    initial_dir = VectorType{1, 0, 0};
+            }
+            else
+            {
+                initial_dir = VectorType{1, 0, 0};
+            }
 
-            Simplex<VertexType> simplex;
+            auto support = find_support_vertex(collider_a, collider_b, initial_dir);
+
+            Simplex<VectorType> simplex;
             simplex.push_front(support);
 
             auto direction = -support;
 
-            while (true)
+            for (std::size_t iteration = 0; iteration < settings.max_iterations; ++iteration)
             {
                 support = find_support_vertex(collider_a, collider_b, direction);
 
-                if (support.dot(direction) <= 0.f)
+                if (support.dot(direction) <= settings.epsilon)
                     return {false, simplex};
 
                 simplex.push_front(support);
@@ -56,6 +75,7 @@ namespace omath::collision
                 if (simplex.handle(direction))
                     return {true, simplex};
             }
+            return {false, simplex};
         }
     };
 } // namespace omath::collision

include/omath/collision/line_tracer.hpp

@@ -8,30 +8,103 @@
 
 namespace omath::collision
 {
-    class Ray
+    template<class T = Vector3<float>>
+    class Ray final
     {
     public:
-        Vector3<float> start;
-        Vector3<float> end;
+        using VectorType = T;
+        VectorType start;
+        VectorType end;
         bool infinite_length = false;
 
         [[nodiscard]]
-        Vector3<float> direction_vector() const noexcept;
+        constexpr VectorType direction_vector() const noexcept
+        {
+            return end - start;
+        }
 
         [[nodiscard]]
-        Vector3<float> direction_vector_normalized() const noexcept;
+        constexpr VectorType direction_vector_normalized() const noexcept
+        {
+            return direction_vector().normalized();
+        }
     };
-    class LineTracer
+
+    template<class RayType = Ray<>>
+    class LineTracer final
     {
+        using TriangleType = Triangle<typename RayType::VectorType>;
+
     public:
         LineTracer() = delete;
 
         [[nodiscard]]
-        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+        constexpr static bool can_trace_line(const RayType& ray, const TriangleType& triangle) noexcept
+        {
+            return get_ray_hit_point(ray, triangle) == ray.end;
+        }
 
         // Realization of Möller–Trumbore intersection algorithm
         // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
         [[nodiscard]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+        constexpr static auto get_ray_hit_point(const RayType& ray, const TriangleType& triangle) noexcept
+        {
+            constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
+
+            const auto side_a = triangle.side_a_vector();
+            const auto side_b = triangle.side_b_vector();
+
+            const auto ray_dir = ray.direction_vector();
+
+            const auto p = ray_dir.cross(side_b);
+            const auto det = side_a.dot(p);
+
+            if (std::abs(det) < k_epsilon)
+                return ray.end;
+
+            const auto inv_det = 1 / det;
+            const auto t = ray.start - triangle.m_vertex2;
+            const auto u = t.dot(p) * inv_det;
+
+            if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
+                return ray.end;
+
+            const auto q = t.cross(side_a);
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const auto v = ray_dir.dot(q) * inv_det;
+
+            if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
+                return ray.end;
+
+            const auto t_hit = side_b.dot(q) * inv_det;
+
+            if (ray.infinite_length && t_hit <= k_epsilon)
+                return ray.end;
+
+            if (t_hit <= k_epsilon || t_hit > 1 - k_epsilon)
+                return ray.end;
+
+            return ray.start + ray_dir * t_hit;
+        }
+
+        template<class MeshType>
+        [[nodiscard]]
+        constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept
+        {
+            auto mesh_hit = ray.end;
+
+            const auto begin = mesh.m_element_buffer_object.cbegin();
+            const auto end = mesh.m_element_buffer_object.cend();
+            for (auto current = begin; current < end; current = std::next(current))
+            {
+                const auto face = mesh.make_face_in_world_space(current);
+
+                auto ray_stop_point = get_ray_hit_point(ray, face);
+                if (ray_stop_point.distance_to(ray.start) < mesh_hit.distance_to(ray.start))
+                    mesh_hit = ray_stop_point;
+            }
+
+            return mesh_hit;
+        }
     };
 } // namespace omath::collision

include/omath/collision/mesh_collider.hpp

@@ -3,40 +3,80 @@
 //
 
 #pragma once
+#include "collider_interface.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 
+#ifdef OMATH_BUILD_TESTS
+// ReSharper disable once CppInconsistentNaming
+class UnitTestColider_FindFurthestVertex_Test;
+#endif
+
 namespace omath::collision
 {
     template<class MeshType>
-    class MeshCollider
+    class MeshCollider final : public ColliderInterface<typename MeshType::VertexType::VectorType>
     {
+#ifdef OMATH_BUILD_TESTS
+        friend UnitTestColider_FindFurthestVertex_Test;
+#endif
     public:
-        using NumericType = typename MeshType::NumericType;
-
-        using VertexType = Vector3<NumericType>;
+        using VertexType = MeshType::VertexType;
+        using VectorType = MeshType::VertexType::VectorType;
         explicit MeshCollider(MeshType mesh): m_mesh(std::move(mesh))
         {
         }
 
         [[nodiscard]]
-        const VertexType& find_furthest_vertex(const VertexType& direction) const
+        VectorType find_abs_furthest_vertex_position(const VectorType& direction) const override
         {
-            return *std::ranges::max_element(m_mesh.m_vertex_buffer, [&direction](const auto& first, const auto& second)
-                                             { return first.dot(direction) < second.dot(direction); });
+            return m_mesh.vertex_position_to_world_space(find_furthest_vertex(direction).position);
         }
 
         [[nodiscard]]
-        VertexType find_abs_furthest_vertex(const VertexType& direction) const
-        {
-            return m_mesh.vertex_to_world_space(find_furthest_vertex(direction));
-        }
-
-        [[nodiscard]]
-        const VertexType& get_origin() const
+        const VectorType& get_origin() const override
         {
             return m_mesh.get_origin();
         }
+        void set_origin(const VectorType& new_origin) override
+        {
+            m_mesh.set_origin(new_origin);
+        }
+
+        [[nodiscard]]
+        const MeshType& get_mesh() const
+        {
+            return m_mesh;
+        }
+        [[nodiscard]]
+        MeshType& get_mesh()
+        {
+            return m_mesh;
+        }
     private:
+        [[nodiscard]]
+        const VertexType& find_furthest_vertex(const VectorType& direction) const
+        {
+            // The support query arrives in world space, but vertex positions are stored
+            // in local space.  We need argmax_v { world(v) · d }.
+            //
+            // world(v) = M·v  (ignoring translation, which is constant across vertices)
+            // world(v) · d = v · Mᵀ·d
+            //
+            // So we transform the direction to local space once — O(1) — then compare
+            // raw local positions, which is far cheaper than calling
+            // vertex_position_to_world_space (full 4×4 multiply) for every vertex.
+            //
+            // d_local = upper-left 3×3 of M, transposed, times d_world:
+            //   d_local[j] = sum_i  M.at(i,j) * d[i]   (i.e. column j of M dotted with d)
+            const auto& m = m_mesh.get_to_world_matrix();
+            const VectorType d_local = {
+                    m[0, 0] * direction.x + m[1, 0] * direction.y + m[2, 0] * direction.z,
+                    m[0, 1] * direction.x + m[1, 1] * direction.y + m[2, 1] * direction.z,
+                    m[0, 2] * direction.x + m[1, 2] * direction.y + m[2, 2] * direction.z,
+            };
+            return *std::ranges::max_element(m_mesh.m_vertex_buffer, [&d_local](const auto& first, const auto& second)
+                                             { return first.position.dot(d_local) < second.position.dot(d_local); });
+        }
         MeshType m_mesh;
     };
 } // namespace omath::collision

include/omath/collision/simplex.hpp

@@ -130,7 +130,7 @@ namespace omath::collision
 
         template<class V>
         [[nodiscard]]
-        static constexpr bool near_zero(const V& v, const float eps = 1e-7f)
+        static constexpr bool near_zero(const V& v, const float eps = 1e-7f) noexcept
         {
             return v.dot(v) <= eps * eps;
         }
@@ -146,7 +146,7 @@ namespace omath::collision
         }
 
         [[nodiscard]]
-        constexpr bool handle_line(VectorType& direction)
+        constexpr bool handle_line(VectorType& direction) noexcept
         {
             const auto& a = m_points[0];
             const auto& b = m_points[1];
@@ -158,21 +158,11 @@ namespace omath::collision
             {
                 // ReSharper disable once CppTooWideScopeInitStatement
                 auto n = ab.cross(ao); // Needed to valid handle collision if colliders placed at same origin pos
-                if (near_zero(n))
-                {
-                    // collinear: origin lies on ray AB (often on segment), pick any perp to escape
-                    direction = any_perp(ab);
-                }
-                else
-                {
-                    direction = n.cross(ab);
-                }
-            }
-            else
-            {
-                *this = {a};
-                direction = ao;
+                direction = near_zero(n) ? any_perp(ab) : n.cross(ab);
+                return false;
             }
+            *this = {a};
+            direction = ao;
             return false;
         }
 

include/omath/containers/encrypted_variable.hpp

@@ -0,0 +1,194 @@
+//
+// Created by Vladislav on 04.01.2026.
+//
+#pragma once
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#ifdef OMATH_ENABLE_FORCE_INLINE
+#ifdef _MSC_VER
+#define OMATH_FORCE_INLINE __forceinline
+#else
+#define OMATH_FORCE_INLINE __attribute__((always_inline)) inline
+#endif
+#else
+#define OMATH_FORCE_INLINE
+#endif
+
+namespace omath::detail
+{
+    [[nodiscard]]
+    consteval std::uint64_t fnv1a_64(const char* s)
+    {
+        std::uint64_t h = 14695981039346656037ull;
+        while (*s)
+        {
+            h ^= static_cast<unsigned char>(*s++);
+            h *= 1099511628211ull;
+        }
+        return h;
+    }
+
+    // SplitMix64 mixer (good quality for seeding / scrambling)
+    [[nodiscard]]
+    consteval std::uint64_t splitmix64(std::uint64_t x)
+    {
+        x += 0x9E3779B97F4A7C15ull;
+        x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9ull;
+        x = (x ^ (x >> 27)) * 0x94D049BB133111EBull;
+        return x ^ (x >> 31);
+    }
+
+    // Choose your policy:
+    // - If you want reproducible builds, REMOVE __DATE__/__TIME__.
+    // - If you want "different each build", keep them.
+    [[nodiscard]]
+    consteval std::uint64_t base_seed()
+    {
+        std::uint64_t h = 0;
+        h ^= fnv1a_64(__FILE__);
+        h ^= splitmix64(fnv1a_64(__DATE__));
+        h ^= splitmix64(fnv1a_64(__TIME__));
+        return splitmix64(h);
+    }
+
+    // Produce a "random" 64-bit value for a given stream index (compile-time)
+    template<std::uint64_t Stream>
+    [[nodiscard]]
+    consteval std::uint64_t rand_u64()
+    {
+        // Stream is usually __COUNTER__ so each call site differs
+        return splitmix64(base_seed() + 0xD1B54A32D192ED03ull * (Stream + 1));
+    }
+
+    template<std::int64_t Lo, std::int64_t Hi, std::uint64_t Stream>
+    [[nodiscard]]
+    consteval std::int64_t rand_uint8_t()
+    {
+        static_assert(Lo <= Hi);
+        const std::uint64_t r = rand_u64<Stream>();
+        return static_cast<std::int64_t>(r) + Lo;
+    }
+    [[nodiscard]]
+    consteval std::uint64_t rand_u64(const std::uint64_t seed, const std::uint64_t i)
+    {
+        return splitmix64(seed + 0xD1B54A32D192ED03ull * (i + 1ull));
+    }
+
+    // Convert to int (uses low 32 bits; you can also use high bits if you prefer)
+    [[nodiscard]]
+    consteval std::uint8_t rand_uint8t(const std::uint64_t seed, const std::uint64_t i)
+    {
+        return static_cast<std::uint8_t>(rand_u64(seed, i)); // narrowing is fine/deterministic
+    }
+    template<std::size_t N, std::uint64_t Seed, std::size_t... I>
+    [[nodiscard]]
+    consteval std::array<std::uint8_t, N> make_array_impl(std::index_sequence<I...>)
+    {
+        return {rand_uint8t(Seed, static_cast<std::uint64_t>(I))...};
+    }
+
+    template<std::size_t N, std::uint64_t Seed>
+    [[nodiscard]]
+    consteval std::array<std::uint8_t, N> make_array()
+    {
+        return make_array_impl<N, Seed>(std::make_index_sequence<N>{});
+    }
+} // namespace omath::detail
+
+namespace omath
+{
+    template<class T>
+    class VarAnchor;
+
+    template<class T, std::size_t key_size, std::array<std::uint8_t, key_size> key>
+    class EncryptedVariable final
+    {
+        using value_type = std::remove_cvref_t<T>;
+
+        bool m_is_encrypted{};
+        value_type m_data{};
+
+        OMATH_FORCE_INLINE constexpr void xor_contained_var_by_key()
+        {
+            // Safe, keeps const-correctness, and avoids reinterpret_cast issues
+            auto bytes = std::as_writable_bytes(std::span<value_type, 1>{&m_data, 1});
+
+            for (std::size_t i = 0; i < bytes.size(); ++i)
+            {
+                const std::uint8_t k = static_cast<std::uint8_t>(key[i % key_size] + (i * key_size));
+                bytes[i] ^= static_cast<std::byte>(k);
+            }
+        }
+
+    public:
+        OMATH_FORCE_INLINE constexpr explicit EncryptedVariable(const value_type& data)
+            : m_is_encrypted(false), m_data(data)
+        {
+            encrypt();
+        }
+
+        [[nodiscard]] constexpr bool is_encrypted() const
+        {
+            return m_is_encrypted;
+        }
+
+        OMATH_FORCE_INLINE constexpr void decrypt()
+        {
+            if (!m_is_encrypted)
+                return;
+            xor_contained_var_by_key();
+            m_is_encrypted = false;
+        }
+
+        OMATH_FORCE_INLINE constexpr void encrypt()
+        {
+            if (m_is_encrypted)
+                return;
+            xor_contained_var_by_key();
+            m_is_encrypted = true;
+        }
+
+        [[nodiscard]] OMATH_FORCE_INLINE constexpr value_type& value()
+        {
+            return m_data;
+        }
+        [[nodiscard]] OMATH_FORCE_INLINE constexpr const value_type& value() const
+        {
+            return m_data;
+        }
+
+        constexpr OMATH_FORCE_INLINE ~EncryptedVariable()
+        {
+            decrypt();
+        }
+
+        [[nodiscard]] constexpr OMATH_FORCE_INLINE auto drop_anchor()
+        {
+            return VarAnchor{*this};
+        }
+    };
+
+    template<class EncryptedVarType>
+    class VarAnchor final
+    {
+    public:
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        OMATH_FORCE_INLINE constexpr VarAnchor(EncryptedVarType& var): m_var(var)
+        {
+            m_var.decrypt();
+        }
+        OMATH_FORCE_INLINE constexpr ~VarAnchor()
+        {
+            m_var.encrypt();
+        }
+
+    private:
+        EncryptedVarType& m_var;
+    };
+} // namespace omath
+
+#define OMATH_CT_RAND_ARRAY_BYTE(N)                                                                                    \
+    (::omath::detail::make_array<(N), (::omath::detail::base_seed() ^ static_cast<std::uint64_t>(__COUNTER__))>())
+#define OMATH_DEF_CRYPT_VAR(TYPE, KEY_SIZE) omath::EncryptedVariable<TYPE, KEY_SIZE, OMATH_CT_RAND_ARRAY_BYTE(KEY_SIZE)>

include/omath/engines/cry_engine/camera.hpp

@@ -0,0 +1,13 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/cry_engine/constants.hpp"
+#include "omath/projection/camera.hpp"
+#include "traits/camera_trait.hpp"
+
+namespace omath::cry_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+} // namespace omath::cry_engine

include/omath/engines/cry_engine/constants.hpp

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

include/omath/engines/cry_engine/formulas.hpp

@@ -0,0 +1,74 @@
+//
+// Created by Vlad on 3/22/2025.
+//
+
+#pragma once
+#include "omath/engines/cry_engine/constants.hpp"
+
+namespace omath::cry_engine
+{
+    [[nodiscard]]
+    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
+} // namespace omath::cry_engine

include/omath/engines/cry_engine/mesh.hpp

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

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

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

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

@@ -0,0 +1,19 @@
+//
+// Created by Vladislav on 09.11.2025.
+//
+#pragma once
+#include <omath/engines/cry_engine/constants.hpp>
+#include <omath/engines/cry_engine/formulas.hpp>
+
+namespace omath::cry_engine
+{
+    class MeshTrait final
+    {
+    public:
+        [[nodiscard]]
+        static Mat4X4 rotation_matrix(const ViewAngles& rotation)
+        {
+            return cry_engine::rotation_matrix(rotation);
+        }
+    };
+} // namespace omath::cry_engine

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

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

include/omath/engines/frostbite_engine/formulas.hpp

@@ -23,4 +23,52 @@ namespace omath::frostbite_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::unity_engine
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
+} // namespace omath::frostbite_engine

include/omath/engines/frostbite_engine/mesh.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::frostbite_engine
 {
-    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, float>;
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
 }

include/omath/engines/frostbite_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/frostbite_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::frostbite_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                                       std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::frostbite_engine

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

@@ -55,7 +55,7 @@ namespace omath::frostbite_engine
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
             const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
 
-            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+            return {predicted_target_position.x, projectile.m_origin.y + height, predicted_target_position.z};
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down

include/omath/engines/iw_engine/formulas.hpp

@@ -23,4 +23,54 @@ namespace omath::iw_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
+        return units * centimeter_in_unit;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units_to_centimeters(units) / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
+        return centimeters / centimeter_in_unit;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return centimeters_to_units(meters * static_cast<FloatingType>(100));
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
 } // namespace omath::iw_engine

include/omath/engines/iw_engine/mesh.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::iw_engine
 {
-    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, float>;
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
 }

include/omath/engines/iw_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/iw_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::iw_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                           std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::iw_engine

include/omath/engines/opengl_engine/camera.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::opengl_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, true>;
 } // namespace omath::opengl_engine

include/omath/engines/opengl_engine/formulas.hpp

@@ -4,7 +4,6 @@
 #pragma once
 #include "omath/engines/opengl_engine/constants.hpp"
 
-
 namespace omath::opengl_engine
 {
     [[nodiscard]]
@@ -23,4 +22,52 @@ namespace omath::opengl_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
 } // namespace omath::opengl_engine

include/omath/engines/opengl_engine/mesh.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::opengl_engine
 {
-    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, float>;
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
 }

include/omath/engines/opengl_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/opengl_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::opengl_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                           std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::opengl_engine

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

@@ -55,7 +55,7 @@ namespace omath::opengl_engine
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
             const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
 
-            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+            return {predicted_target_position.x, projectile.m_origin.y + height, predicted_target_position.z};
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down

include/omath/engines/source_engine/formulas.hpp

@@ -22,4 +22,54 @@ namespace omath::source_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
+        return units * centimeter_in_unit;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units_to_centimeters(units) / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
+        return centimeters / centimeter_in_unit;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return centimeters_to_units(meters * static_cast<FloatingType>(100));
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
 } // namespace omath::source_engine

include/omath/engines/source_engine/mesh.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::source_engine
 {
-    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, float>;
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
 }

include/omath/engines/source_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/source_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::source_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                           std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::source_engine

include/omath/engines/unity_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::unity_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
 } // namespace omath::unity_engine

include/omath/engines/unity_engine/formulas.hpp

@@ -23,4 +23,52 @@ namespace omath::unity_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
 } // namespace omath::unity_engine

include/omath/engines/unity_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/unity_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::unity_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                           std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::unity_engine

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

@@ -55,7 +55,7 @@ namespace omath::unity_engine
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
             const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
 
-            return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
+            return {predicted_target_position.x, projectile.m_origin.y + height, predicted_target_position.z};
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down

include/omath/engines/unreal_engine/formulas.hpp

@@ -23,4 +23,52 @@ namespace omath::unreal_engine
 
     [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_centimeters(const FloatingType& units)
+    {
+        return units;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_meters(const FloatingType& units)
+    {
+        return units / static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType units_to_kilometers(const FloatingType& units)
+    {
+        return units_to_meters(units) / static_cast<FloatingType>(1000);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
+    {
+        return centimeters;
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType meters_to_units(const FloatingType& meters)
+    {
+        return meters * static_cast<FloatingType>(100);
+    }
+
+    template<class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
+    {
+        return meters_to_units(kilometers * static_cast<FloatingType>(1000));
+    }
 } // namespace omath::unreal_engine

include/omath/engines/unreal_engine/primitives.hpp

@@ -0,0 +1,17 @@
+//
+// Created by Vladislav on 27.01.2026.
+//
+
+#pragma once
+#include "mesh.hpp"
+#include "omath/engines/unreal_engine/traits/mesh_trait.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+namespace omath::unreal_engine
+{
+    using BoxMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>, std::array<Vector3<float>, 8>,
+                                     std::array<Vector3<std::uint32_t>, 12>>;
+
+    using PlaneMesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, primitives::Vertex<>,
+                           std::array<Vector3<float>, 4>, std::array<Vector3<std::uint32_t>, 2>>;
+} // namespace omath::unreal_engine

include/omath/linear_algebra/mat.hpp

@@ -17,6 +17,13 @@
 
 #undef near
 #undef far
+// Undefine FreeBSD/BSD system macros that conflict with method names
+#ifdef minor
+#undef minor
+#endif
+#ifdef major
+#undef major
+#endif
 namespace omath
 {
     struct MatSize
@@ -46,7 +53,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr static MatStoreType get_store_ordering() noexcept
+        consteval static MatStoreType get_store_ordering() noexcept
         {
             return StoreType;
         }
@@ -373,7 +380,7 @@ namespace omath
         {
             const auto det = determinant();
 
-            if (det == 0)
+            if (std::abs(det) < std::numeric_limits<Type>::epsilon())
                 return std::nullopt;
 
             const auto transposed_mat = transposed();

include/omath/linear_algebra/quaternion.hpp

@@ -0,0 +1,219 @@
+//
+// Created by vlad on 3/1/2026.
+//
+#pragma once
+
+#include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+#include <cmath>
+#include <format>
+
+namespace omath
+{
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    class Quaternion
+    {
+    public:
+        using ContainedType = Type;
+
+        Type x = static_cast<Type>(0);
+        Type y = static_cast<Type>(0);
+        Type z = static_cast<Type>(0);
+        Type w = static_cast<Type>(1);  // identity quaternion
+
+        constexpr Quaternion() noexcept = default;
+
+        constexpr Quaternion(const Type& x, const Type& y, const Type& z, const Type& w) noexcept
+            : x(x), y(y), z(z), w(w)
+        {
+        }
+
+        // Factory: build from a normalized axis and an angle in radians
+        [[nodiscard]]
+        static Quaternion from_axis_angle(const Vector3<Type>& axis, const Type& angle_rad) noexcept
+        {
+            const Type half = angle_rad / static_cast<Type>(2);
+            const Type s = std::sin(half);
+            return {axis.x * s, axis.y * s, axis.z * s, std::cos(half)};
+        }
+
+        [[nodiscard]] constexpr bool operator==(const Quaternion& other) const noexcept
+        {
+            return x == other.x && y == other.y && z == other.z && w == other.w;
+        }
+
+        [[nodiscard]] constexpr bool operator!=(const Quaternion& other) const noexcept
+        {
+            return !(*this == other);
+        }
+
+        // Hamilton product: this * other
+        [[nodiscard]] constexpr Quaternion operator*(const Quaternion& other) const noexcept
+        {
+            return {
+                w * other.x + x * other.w + y * other.z - z * other.y,
+                w * other.y - x * other.z + y * other.w + z * other.x,
+                w * other.z + x * other.y - y * other.x + z * other.w,
+                w * other.w - x * other.x - y * other.y - z * other.z,
+            };
+        }
+
+        constexpr Quaternion& operator*=(const Quaternion& other) noexcept
+        {
+            return *this = *this * other;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator*(const Type& scalar) const noexcept
+        {
+            return {x * scalar, y * scalar, z * scalar, w * scalar};
+        }
+
+        constexpr Quaternion& operator*=(const Type& scalar) noexcept
+        {
+            x *= scalar;
+            y *= scalar;
+            z *= scalar;
+            w *= scalar;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator+(const Quaternion& other) const noexcept
+        {
+            return {x + other.x, y + other.y, z + other.z, w + other.w};
+        }
+
+        constexpr Quaternion& operator+=(const Quaternion& other) noexcept
+        {
+            x += other.x;
+            y += other.y;
+            z += other.z;
+            w += other.w;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator-() const noexcept
+        {
+            return {-x, -y, -z, -w};
+        }
+
+        // Conjugate: negates the vector part (x, y, z)
+        [[nodiscard]] constexpr Quaternion conjugate() const noexcept
+        {
+            return {-x, -y, -z, w};
+        }
+
+        [[nodiscard]] constexpr Type dot(const Quaternion& other) const noexcept
+        {
+            return x * other.x + y * other.y + z * other.z + w * other.w;
+        }
+
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        {
+            return x * x + y * y + z * z + w * w;
+        }
+
+#ifndef _MSC_VER
+        [[nodiscard]] constexpr Type length() const noexcept
+        {
+            return std::sqrt(length_sqr());
+        }
+
+        [[nodiscard]] constexpr Quaternion normalized() const noexcept
+        {
+            const Type len = length();
+            return len != static_cast<Type>(0) ? *this * (static_cast<Type>(1) / len) : *this;
+        }
+#else
+        [[nodiscard]] Type length() const noexcept
+        {
+            return std::sqrt(length_sqr());
+        }
+
+        [[nodiscard]] Quaternion normalized() const noexcept
+        {
+            const Type len = length();
+            return len != static_cast<Type>(0) ? *this * (static_cast<Type>(1) / len) : *this;
+        }
+#endif
+
+        // Inverse: q* / |q|^2  (for unit quaternions inverse == conjugate)
+        [[nodiscard]] constexpr Quaternion inverse() const noexcept
+        {
+            return conjugate() * (static_cast<Type>(1) / length_sqr());
+        }
+
+        // Rotate a 3D vector: v' = q * pure(v) * q^-1
+        // Computed via Rodrigues' formula to avoid full quaternion product overhead
+        [[nodiscard]] constexpr Vector3<Type> rotate(const Vector3<Type>& v) const noexcept
+        {
+            const Vector3<Type> q_vec{x, y, z};
+            const Vector3<Type> cross = q_vec.cross(v);
+            return v + cross * (static_cast<Type>(2) * w) + q_vec.cross(cross) * static_cast<Type>(2);
+        }
+
+        // 3x3 rotation matrix from this (unit) quaternion
+        [[nodiscard]] constexpr Mat<3, 3, Type> to_rotation_matrix3() const noexcept
+        {
+            const Type xx = x * x, yy = y * y, zz = z * z;
+            const Type xy = x * y, xz = x * z, yz = y * z;
+            const Type wx = w * x, wy = w * y, wz = w * z;
+            const Type one = static_cast<Type>(1);
+            const Type two = static_cast<Type>(2);
+
+            return {
+                {one - two * (yy + zz), two * (xy - wz),       two * (xz + wy)      },
+                {two * (xy + wz),       one - two * (xx + zz), two * (yz - wx)      },
+                {two * (xz - wy),       two * (yz + wx),       one - two * (xx + yy)},
+            };
+        }
+
+        // 4x4 rotation matrix (with homogeneous row/column)
+        [[nodiscard]] constexpr Mat<4, 4, Type> to_rotation_matrix4() const noexcept
+        {
+            const Type xx = x * x, yy = y * y, zz = z * z;
+            const Type xy = x * y, xz = x * z, yz = y * z;
+            const Type wx = w * x, wy = w * y, wz = w * z;
+            const Type one = static_cast<Type>(1);
+            const Type two = static_cast<Type>(2);
+            const Type zero = static_cast<Type>(0);
+
+            return {
+                {one - two * (yy + zz), two * (xy - wz),       two * (xz + wy),       zero},
+                {two * (xy + wz),       one - two * (xx + zz), two * (yz - wx),       zero},
+                {two * (xz - wy),       two * (yz + wx),       one - two * (xx + yy), zero},
+                {zero,                  zero,                   zero,                  one },
+            };
+        }
+
+        [[nodiscard]] constexpr std::array<Type, 4> as_array() const noexcept
+        {
+            return {x, y, z, w};
+        }
+    };
+} // namespace omath
+
+template<class Type>
+struct std::formatter<omath::Quaternion<Type>> // NOLINT(*-dcl58-cpp)
+{
+    [[nodiscard]]
+    static constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<class FormatContext>
+    [[nodiscard]]
+    static auto format(const omath::Quaternion<Type>& q, FormatContext& ctx)
+    {
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
+            return std::format_to(ctx.out(), "[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+
+        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
+            return std::format_to(ctx.out(), L"[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
+            return std::format_to(ctx.out(), u8"[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+    }
+};

include/omath/linear_algebra/vector2.hpp

@@ -220,6 +220,12 @@ namespace omath
         {
             return std::make_tuple(x, y);
         }
+
+        [[nodiscard]]
+        constexpr std::array<Type, 2> as_array() const noexcept
+        {
+            return {x, y};
+        }
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
         constexpr ImVec2 to_im_vec2() const noexcept

include/omath/linear_algebra/vector3.hpp

@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "omath/trigonometry/angle.hpp"
 #include "omath/linear_algebra/vector2.hpp"
+#include "omath/trigonometry/angle.hpp"
 #include <cstdint>
 #include <expected>
 #include <functional>
@@ -233,10 +233,11 @@ namespace omath
             return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
         }
 
-        [[nodiscard]] bool is_perpendicular(const Vector3& other) const noexcept
+        [[nodiscard]] bool is_perpendicular(const Vector3& other,
+                                            Type epsilon = static_cast<Type>(0.0001)) const noexcept
         {
             if (const auto angle = angle_between(other))
-                return angle->as_degrees() == static_cast<Type>(90);
+                return std::abs(angle->as_degrees() - static_cast<Type>(90)) <= epsilon;
 
             return false;
         }
@@ -274,6 +275,12 @@ namespace omath
         {
             return length() >= other.length();
         }
+
+        [[nodiscard]]
+        constexpr std::array<Type, 3> as_array() const noexcept
+        {
+            return {this->x, this->y, z};
+        }
     };
 } // namespace omath
 

include/omath/linear_algebra/vector4.hpp

@@ -3,8 +3,8 @@
 //
 #pragma once
 
-#include <algorithm>
 #include "omath/linear_algebra/vector3.hpp"
+#include <algorithm>
 
 namespace omath
 {
@@ -183,6 +183,12 @@ namespace omath
             return length() >= other.length();
         }
 
+        [[nodiscard]]
+        constexpr std::array<Type, 4> as_array() const noexcept
+        {
+            return {this->x, this->y, this->z, w};
+        }
+
 #ifdef OMATH_IMGUI_INTEGRATION
         [[nodiscard]]
         constexpr ImVec4 to_im_vec4() const noexcept
@@ -200,7 +206,7 @@ namespace omath
             return {static_cast<Type>(other.x), static_cast<Type>(other.y), static_cast<Type>(other.z)};
         }
 #endif
-};
+    };
 } // namespace omath
 
 template<> struct std::hash<omath::Vector4<float>>

include/omath/lua/lua.hpp

@@ -0,0 +1,25 @@
+//
+// Created by orange on 07.03.2026.
+//
+#pragma once
+#ifdef OMATH_ENABLE_LUA
+#include <sol/forward.hpp>
+namespace omath::lua
+{
+    class LuaInterpreter final
+    {
+    public:
+        static void register_lib(lua_State* lua_state);
+
+    private:
+        static void register_vec2(sol::table& omath_table);
+        static void register_vec3(sol::table& omath_table);
+        static void register_vec4(sol::table& omath_table);
+        static void register_color(sol::table& omath_table);
+        static void register_triangle(sol::table& omath_table);
+        static void register_shared_types(sol::table& omath_table);
+        static void register_engines(sol::table& omath_table);
+        static void register_pattern_scan(sol::table& omath_table);
+    };
+}
+#endif

include/omath/omath.hpp

@@ -17,6 +17,9 @@
 // Matrix classes
 #include "omath/linear_algebra/mat.hpp"
 
+// Quaternion
+#include "omath/linear_algebra/quaternion.hpp"
+
 // Color functionality
 #include "omath/utility/color.hpp"
 
@@ -30,7 +33,8 @@
 
 // Collision detection
 #include "omath/collision/line_tracer.hpp"
-
+#include "omath/collision/gjk_algorithm.hpp"
+#include "omath/collision/epa_algorithm.hpp"
 // Pathfinding algorithms
 #include "omath/pathfinding/a_star.hpp"
 #include "omath/pathfinding/navigation_mesh.hpp"

include/omath/pathfinding/navigation_mesh.hpp

@@ -6,7 +6,9 @@
 
 #include "omath/linear_algebra/vector3.hpp"
 #include <expected>
+#include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace omath::pathfinding
@@ -28,10 +30,20 @@ namespace omath::pathfinding
         [[nodiscard]]
         bool empty() const;
 
-        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
+        // Events -- per-vertex optional tag (e.g. "jump", "teleport")
+        void set_event(const Vector3<float>& vertex, const std::string_view& event_id);
+        void clear_event(const Vector3<float>& vertex);
 
-        void deserialize(const std::vector<uint8_t>& raw) noexcept;
+        [[nodiscard]]
+        std::optional<std::string> get_event(const Vector3<float>& vertex) const noexcept;
+
+        [[nodiscard]] std::string serialize() const noexcept;
+
+        void deserialize(const std::string& raw);
 
         std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+
+    private:
+        std::unordered_map<Vector3<float>, std::string> m_vertex_events;
     };
 } // namespace omath::pathfinding

include/omath/projection/camera.hpp

@@ -5,8 +5,10 @@
 #pragma once
 
 #include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 #include "omath/projection/error_codes.hpp"
+#include <cmath>
 #include <expected>
 #include <omath/trigonometry/angle.hpp>
 #include <type_traits>
@@ -50,7 +52,7 @@ namespace omath::projection
                 requires noexcept(T::calc_projection_matrix(fov, viewport, znear, zfar));
             };
 
-    template<class Mat4X4Type, class ViewAnglesType, class TraitClass>
+    template<class Mat4X4Type, class ViewAnglesType, class TraitClass, bool inverted_z = false>
     requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
     class Camera final
     {
@@ -78,59 +80,96 @@ namespace omath::projection
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
             m_view_projection_matrix = std::nullopt;
+            m_view_matrix = std::nullopt;
         }
 
-    protected:
-        [[nodiscard]] Mat4X4Type calc_view_projection_matrix() const noexcept
+        [[nodiscard]]
+        Vector3<float> get_forward() const noexcept
         {
-            return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance,
-                                                      m_far_plane_distance)
-                   * TraitClass::calc_view_matrix(m_view_angles, m_origin);
+            const auto& view_matrix = get_view_matrix();
+
+            if constexpr (inverted_z)
+                return -Vector3<float>{view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
+            return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
+        }
+
+        [[nodiscard]]
+        Vector3<float> get_right() const noexcept
+        {
+            const auto& view_matrix = get_view_matrix();
+            return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
+        }
+
+        [[nodiscard]]
+        Vector3<float> get_up() const noexcept
+        {
+            const auto& view_matrix = get_view_matrix();
+            return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
         }
 
-    public:
         [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
         {
             if (!m_view_projection_matrix.has_value())
-                m_view_projection_matrix = calc_view_projection_matrix();
+                m_view_projection_matrix = get_projection_matrix() * get_view_matrix();
 
             return m_view_projection_matrix.value();
         }
 
+        [[nodiscard]] const Mat4X4Type& get_view_matrix() const noexcept
+        {
+            if (!m_view_matrix.has_value())
+                m_view_matrix = TraitClass::calc_view_matrix(m_view_angles, m_origin);
+
+            return m_view_matrix.value();
+        }
+        [[nodiscard]] const Mat4X4Type& get_projection_matrix() const noexcept
+        {
+            if (!m_projection_matrix.has_value())
+                m_projection_matrix = TraitClass::calc_projection_matrix(m_field_of_view, m_view_port,
+                                                                         m_near_plane_distance, m_far_plane_distance);
+
+            return m_projection_matrix.value();
+        }
+
         void set_field_of_view(const FieldOfView& fov) noexcept
         {
             m_field_of_view = fov;
             m_view_projection_matrix = std::nullopt;
+            m_projection_matrix = std::nullopt;
         }
 
         void set_near_plane(const float near) noexcept
         {
             m_near_plane_distance = near;
             m_view_projection_matrix = std::nullopt;
+            m_projection_matrix = std::nullopt;
         }
 
         void set_far_plane(const float far) noexcept
         {
             m_far_plane_distance = far;
             m_view_projection_matrix = std::nullopt;
+            m_projection_matrix = std::nullopt;
         }
 
         void set_view_angles(const ViewAnglesType& view_angles) noexcept
         {
             m_view_angles = view_angles;
             m_view_projection_matrix = std::nullopt;
+            m_view_matrix = std::nullopt;
         }
 
         void set_origin(const Vector3<float>& origin) noexcept
         {
             m_origin = origin;
             m_view_projection_matrix = std::nullopt;
+            m_view_matrix = std::nullopt;
         }
-
         void set_view_port(const ViewPort& view_port) noexcept
         {
             m_view_port = view_port;
             m_view_projection_matrix = std::nullopt;
+            m_projection_matrix = std::nullopt;
         }
 
         [[nodiscard]] const FieldOfView& get_field_of_view() const noexcept
@@ -175,16 +214,64 @@ namespace omath::projection
                 std::unreachable();
         }
 
+        [[nodiscard]] bool is_culled_by_frustum(const Triangle<Vector3<float>>& triangle) const noexcept
+        {
+            // Transform to clip space (before perspective divide)
+            auto to_clip = [this](const Vector3<float>& point)
+            {
+                auto clip = get_view_projection_matrix()
+                            * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(point);
+                return std::array<float, 4>{
+                        clip.at(0, 0), // x
+                        clip.at(1, 0), // y
+                        clip.at(2, 0), // z
+                        clip.at(3, 0) // w
+                };
+            };
+
+            const auto c0 = to_clip(triangle.m_vertex1);
+            const auto c1 = to_clip(triangle.m_vertex2);
+            const auto c2 = to_clip(triangle.m_vertex3);
+
+            // If all vertices are behind the camera (w <= 0), trivially reject
+            if (c0[3] <= 0.f && c1[3] <= 0.f && c2[3] <= 0.f)
+                return true;
+
+            // Helper: all three vertices outside the same clip plane
+            auto all_outside_plane = [](const int axis, const std::array<float, 4>& a, const std::array<float, 4>& b,
+                                        const std::array<float, 4>& c, const bool positive_side)
+            {
+                if (positive_side)
+                    return a[axis] > a[3] && b[axis] > b[3] && c[axis] > c[3];
+                return a[axis] < -a[3] && b[axis] < -b[3] && c[axis] < -c[3];
+            };
+
+            // Clip volume in clip space (OpenGL-style):
+            // -w <= x <= w
+            // -w <= y <= w
+            // -w <= z <= w
+
+            for (int i = 0; i < 3; i++)
+            {
+                if (all_outside_plane(i, c0, c1, c2, false))
+                    return true; // x < -w (left)
+                if (all_outside_plane(i, c0, c1, c2, true))
+                    return true; // x >  w (right)
+            }
+            return false;
+        }
+
         [[nodiscard]] std::expected<Vector3<float>, Error>
         world_to_view_port(const Vector3<float>& world_position) const noexcept
         {
             auto projected = get_view_projection_matrix()
                              * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
 
-            if (projected.at(3, 0) == 0.0f)
+            const auto& w = projected.at(3, 0);
+            if (w <= std::numeric_limits<float>::epsilon())
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            projected /= projected.at(3, 0);
+            projected /= w;
 
             if (is_ndc_out_of_bounds(projected))
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
@@ -202,10 +289,12 @@ namespace omath::projection
             auto inverted_projection =
                     inv_view_proj.value() * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(ndc);
 
-            if (!inverted_projection.at(3, 0))
+            const auto& w = inverted_projection.at(3, 0);
+
+            if (std::abs(w) < std::numeric_limits<float>::epsilon())
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            inverted_projection /= inverted_projection.at(3, 0);
+            inverted_projection /= w;
 
             return Vector3<float>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
                                   inverted_projection.at(2, 0)};
@@ -231,7 +320,8 @@ namespace omath::projection
         Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_field_of_view;
 
         mutable std::optional<Mat4X4Type> m_view_projection_matrix;
-
+        mutable std::optional<Mat4X4Type> m_projection_matrix;
+        mutable std::optional<Mat4X4Type> m_view_matrix;
         float m_far_plane_distance;
         float m_near_plane_distance;
 
@@ -242,7 +332,9 @@ namespace omath::projection
         template<class Type>
         [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
         {
-            return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
+            constexpr auto eps = std::numeric_limits<float>::epsilon();
+            return std::ranges::any_of(ndc.raw_array(),
+                                       [](const auto& val) { return val < -1.0f - eps || val > 1.0f + eps; });
         }
 
         // NDC REPRESENTATION:
@@ -299,7 +391,7 @@ namespace omath::projection
             if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)
                 return {screen_pos.x / m_view_port.m_width * 2.f - 1.f, 1.f - screen_pos.y / m_view_port.m_height * 2.f,
                         screen_pos.z};
-            else if (screen_start == ScreenStart::BOTTOM_LEFT_CORNER)
+            else if constexpr (screen_start == ScreenStart::BOTTOM_LEFT_CORNER)
                 return {screen_pos.x / m_view_port.m_width * 2.f - 1.f,
                         (screen_pos.y / m_view_port.m_height - 0.5f) * 2.f, screen_pos.z};
             else

include/omath/utility/color.hpp

@@ -16,19 +16,28 @@ namespace omath
         float value{};
     };
 
-    class Color final : public Vector4<float>
+    class Color final
     {
+        Vector4<float> m_value;
     public:
-        constexpr Color(const float r, const float g, const float b, const float a) noexcept: Vector4(r, g, b, a)
+        constexpr const Vector4<float>& value() const
         {
-            clamp(0.f, 1.f);
+            return m_value;
+        }
+        constexpr Color(const float r, const float g, const float b, const float a) noexcept: m_value(r, g, b, a)
+        {
+            m_value.clamp(0.f, 1.f);
         }
 
+        constexpr explicit Color(const Vector4<float>& value) : m_value(value)
+        {
+            m_value.clamp(0.f, 1.f);
+        }
         constexpr explicit Color() noexcept = default;
         [[nodiscard]]
         constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) noexcept
         {
-            return Color{Vector4(r, g, b, a) / 255.f};
+            return Color(Vector4<float>(r, g, b, a) / 255.f);
         }
 
         [[nodiscard]]
@@ -46,27 +55,26 @@ namespace omath
 
             switch (i % 6)
             {
-            case 0:
-                r = value, g = t, b = p;
-                break;
-            case 1:
-                r = q, g = value, b = p;
-                break;
-            case 2:
-                r = p, g = value, b = t;
-                break;
-            case 3:
-                r = p, g = q, b = value;
-                break;
-            case 4:
-                r = t, g = p, b = value;
-                break;
-            case 5:
-                r = value, g = p, b = q;
-                break;
-
-            default:
-                return {0.f, 0.f, 0.f, 0.f};
+                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:
+                    std::unreachable();
             }
 
             return {r, g, b, 1.f};
@@ -83,9 +91,9 @@ namespace omath
         {
             Hsv hsv_data;
 
-            const float& red = x;
-            const float& green = y;
-            const float& blue = z;
+            const float& red = m_value.x;
+            const float& green = m_value.y;
+            const float& blue = m_value.z;
 
             const float max = std::max({red, green, blue});
             const float min = std::min({red, green, blue});
@@ -110,11 +118,6 @@ namespace omath
 
             return hsv_data;
         }
-
-        constexpr explicit Color(const Vector4& vec) noexcept: Vector4(vec)
-        {
-            clamp(0.f, 1.f);
-        }
         constexpr void set_hue(const float hue) noexcept
         {
             auto hsv = to_hsv();
@@ -142,7 +145,7 @@ namespace omath
         constexpr Color blend(const Color& other, float ratio) const noexcept
         {
             ratio = std::clamp(ratio, 0.f, 1.f);
-            return Color(*this * (1.f - ratio) + other * ratio);
+            return Color(this->m_value * (1.f - ratio) + other.m_value * ratio);
         }
 
         [[nodiscard]] static constexpr Color red()
@@ -161,16 +164,26 @@ namespace omath
         [[nodiscard]]
         ImColor to_im_color() const noexcept
         {
-            return {to_im_vec4()};
+            return {m_value.to_im_vec4()};
         }
 #endif
         [[nodiscard]] std::string to_string() const noexcept
         {
             return std::format("[r:{}, g:{}, b:{}, a:{}]",
-                            static_cast<int>(x * 255.f),
-                            static_cast<int>(y * 255.f),
-                            static_cast<int>(z * 255.f),
-                            static_cast<int>(w * 255.f));
+                            static_cast<int>(m_value.x * 255.f),
+                            static_cast<int>(m_value.y * 255.f),
+                            static_cast<int>(m_value.z * 255.f),
+                            static_cast<int>(m_value.w * 255.f));
+        }
+        [[nodiscard]] std::string to_rgbf_string() const noexcept
+        {
+            return std::format("[r:{}, g:{}, b:{}, a:{}]",
+                            m_value.x, m_value.y, m_value.z, m_value.w);
+        }
+        [[nodiscard]] std::string to_hsv_string() const noexcept
+        {
+            const auto [hue, saturation, value] = to_hsv();
+            return std::format("[h:{}, s:{}, v:{}]", hue, saturation, value);
         }
         [[nodiscard]] std::wstring to_wstring() const noexcept
         {
@@ -189,24 +202,56 @@ namespace omath
 template<>
 struct std::formatter<omath::Color> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
-    static constexpr auto parse(std::format_parse_context& ctx)
+    enum class ColorFormat { rgb, rgbf, hsv };
+    ColorFormat color_format = ColorFormat::rgb;
+
+    constexpr auto parse(std::format_parse_context& ctx)
     {
-        return ctx.begin();
+        const auto it = ctx.begin();
+        const auto end = ctx.end();
+
+        if (it == end || *it == '}')
+            return it;
+
+        const std::string_view spec(it, end);
+
+        if (spec.starts_with("rgbf"))
+        {
+            color_format = ColorFormat::rgbf;
+            return it + 4;
+        }
+        if (spec.starts_with("rgb"))
+        {
+            color_format = ColorFormat::rgb;
+            return it + 3;
+        }
+        if (spec.starts_with("hsv"))
+        {
+            color_format = ColorFormat::hsv;
+            return it + 3;
+        }
+
+        throw std::format_error("Invalid format specifier for omath::Color. Use rgb, rgbf, or hsv.");
     }
 
     template<class FormatContext>
-    [[nodiscard]]
-    static auto format(const omath::Color& col, FormatContext& ctx)
+    auto format(const omath::Color& col, FormatContext& ctx) const
     {
+        std::string str;
+        switch (color_format)
+        {
+            case ColorFormat::rgb:  str = col.to_string();      break;
+            case ColorFormat::rgbf: str = col.to_rgbf_string(); break;
+            case ColorFormat::hsv:  str = col.to_hsv_string();  break;
+        }
+
         if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
-            return std::format_to(ctx.out(), "{}", col.to_string());
+            return std::format_to(ctx.out(), "{}", str);
         if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
-            return std::format_to(ctx.out(), L"{}", col.to_wstring());
-
+            return std::format_to(ctx.out(), L"{}", std::wstring(str.cbegin(), str.cend()));
         if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
-            return std::format_to(ctx.out(), u8"{}", col.to_u8string());
+            return std::format_to(ctx.out(), u8"{}", std::u8string(str.cbegin(), str.cend()));
 
-        return std::unreachable();
+        std::unreachable();
     }
 };

include/omath/utility/elf_pattern_scan.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Vladislav on 30.12.2025.
+//
+#pragma once
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include "section_scan_result.hpp"
+namespace omath
+{
+    class ElfPatternScanner final
+    {
+    public:
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
+                                          const std::string_view& target_section_name = ".text");
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
+                                 const std::string_view& target_section_name = ".text");
+    };
+} // namespace omath

include/omath/utility/macho_pattern_scan.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Copilot on 04.02.2026.
+//
+#pragma once
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include "section_scan_result.hpp"
+namespace omath
+{
+    class MachOPatternScanner final
+    {
+    public:
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
+                                          const std::string_view& target_section_name = "__text");
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
+                                 const std::string_view& target_section_name = "__text");
+    };
+} // namespace omath

include/omath/utility/pattern_scan.hpp

@@ -51,9 +51,13 @@ namespace omath
 
             const auto whole_range_size = static_cast<std::ptrdiff_t>(std::distance(begin, end));
 
-            const std::ptrdiff_t scan_size = whole_range_size - static_cast<std::ptrdiff_t>(pattern.size());
+            const auto pattern_size = static_cast<std::ptrdiff_t>(parsed_pattern->size());
+            const std::ptrdiff_t scan_size = whole_range_size - pattern_size;
 
-            for (std::ptrdiff_t i = 0; i < scan_size; i++)
+            if (scan_size < 0)
+                return end;
+
+            for (std::ptrdiff_t i = 0; i <= scan_size; i++)
             {
                 bool found = true;
 

include/omath/utility/pe_pattern_scan.hpp

@@ -7,23 +7,20 @@
 #include <filesystem>
 #include <optional>
 #include <string_view>
+#include "section_scan_result.hpp"
 namespace omath
 {
-    struct PeSectionScanResult
-    {
-        std::uint64_t virtual_base_addr;
-        std::uint64_t raw_base_addr;
-        std::ptrdiff_t target_offset;
-    };
+
     class PePatternScanner final
     {
     public:
         [[nodiscard]]
-        static std::optional<std::uintptr_t> scan_for_pattern_in_loaded_module(const void* module_base_address,
-                                                                               const std::string_view& pattern);
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
+                                          const std::string_view& target_section_name = ".text");
 
         [[nodiscard]]
-        static std::optional<PeSectionScanResult>
+        static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = ".text");
     };

include/omath/utility/section_scan_result.hpp

@@ -0,0 +1,16 @@
+//
+// Created by Vladislav on 01.01.2026.
+//
+
+#pragma once
+#include <cstddef>
+#include <cstdint>
+namespace omath
+{
+    struct SectionScanResult final
+    {
+        std::uintptr_t virtual_base_addr;
+        std::uintptr_t raw_base_addr;
+        std::ptrdiff_t target_offset;
+    };
+}

pixi.toml

@@ -0,0 +1,69 @@
+[workspace]
+name = "omath"
+version = "5.7.0"
+description = "Cross-platform modern general purpose math library written in C++23 that suitable for cheat/game development."
+authors = [
+    "orange-cpp <orange_github@proton.me>"
+]
+
+license = "Zlib"
+license-file = "LICENSE"
+readme = "README.md"
+documentation = "http://libomath.org"
+repository = "https://github.com/orange-cpp/omath"
+
+channels = ["conda-forge"]
+platforms = ["win-64", "linux-64", "linux-aarch64", "osx-64", "osx-arm64"]
+
+[tasks]
+format = { cwd = "pixi", cmd = "cmake -P fmt.cmake" }
+configure = { cmd = "cmake -G Ninja -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DOMATH_USE_AVX2=OFF -DOMATH_IMGUI_INTEGRATION=ON -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=ON -DOMATH_BUILD_EXAMPLES=ON .", depends-on = ["format"] }
+build = { cmd = "cmake --build build --config Debug -j", depends-on = ["configure"] }
+examples = { cwd = "pixi", cmd = "cmake -DCMAKE_BUILD_TYPE=Debug -P run.examples.cmake", depends-on = ["build"] }
+tests = { cwd = "pixi", cmd = "cmake -DCMAKE_BUILD_TYPE=Debug -P run.unit.tests.cmake", depends-on = ["build"] }
+benchmark = { cwd = "pixi", cmd = "cmake -DCMAKE_BUILD_TYPE=Debug -P run.benchmark.cmake", depends-on = ["build"] }
+
+[dependencies]
+benchmark = ">=1.9.5,<2"
+ccache = ">=4.12.2,<5"
+cmake = ">=4.2.3,<5"
+cmake-format = ">=0.6.13,<0.7"
+cxx-compiler = ">=1.11.0,<2"
+imgui = ">=1.92.3,<2"
+gtest = ">=1.17.0,<2"
+glew = ">=2.3.0,<3"
+glfw = ">=3.4,<4"
+ninja = ">=1.13.2,<2"
+
+[target.linux-64.dependencies]
+mesa-libgl-devel-cos7-x86_64 = ">=18.3.4,<19"
+xorg-x11-server-xvfb-cos7-x86_64 = ">=1.20.4,<2"
+
+[target.linux-64.activation.env]
+__GLX_VENDOR_LIBRARY_NAME = "mesa"
+EGL_PLATFORM = "x11"
+GLFW_PLATFORM = "x11"
+
+[target.linux-64.tasks]
+examples = { cwd = "pixi", cmd = "xvfb-run -a -s '-screen 0 1024x768x24 +extension GLX +render' cmake -DCMAKE_BUILD_TYPE=Debug -P run.examples.cmake", depends-on = ["build"] }
+
+[target.win-64.dependencies]
+mesa-libgl-devel-cos7-x86_64 = ">=18.3.4,<19"
+
+[target.osx-64.dependencies]
+mesa-libgl-devel-cos7-x86_64 = ">=18.3.4,<19"
+
+[target.osx-arm64.dependencies]
+mesa-libgl-devel-cos7-aarch64 = ">=18.3.4,<19"
+
+[target.linux-aarch64.dependencies]
+mesa-libgl-devel-cos7-aarch64 = ">=18.3.4,<19"
+xorg-x11-server-xvfb-cos7-aarch64 = ">=1.20.4,<2"
+
+[target.linux-aarch64.activation.env]
+__GLX_VENDOR_LIBRARY_NAME = "mesa"
+EGL_PLATFORM = "x11"
+GLFW_PLATFORM = "x11"
+
+[target.linux-aarch64.tasks]
+examples = { cwd = "pixi", cmd = "xvfb-run -a -s '-screen 0 1024x768x24 +extension GLX +render' cmake -DCMAKE_BUILD_TYPE=Debug -P run.examples.cmake", depends-on = ["build"] }

pixi/fmt.cmake

@@ -0,0 +1,36 @@
+# cmake/Format.cmake
+
+# Find cmake-format executable
+find_program(CMAKE_FORMAT_EXECUTABLE NAMES cmake-format)
+
+if(NOT CMAKE_FORMAT_EXECUTABLE)
+    message(FATAL_ERROR "cmake-format not found. Please install it first.")
+endif()
+
+# Get the project root directory (assuming this script is in cmake/
+# subdirectory)
+get_filename_component(PROJECT_ROOT "../${CMAKE_CURRENT_LIST_DIR}" ABSOLUTE)
+
+# Iterate over all files in the project root
+file(GLOB_RECURSE ALL_FILES "${PROJECT_ROOT}/*")
+
+foreach(FILE ${ALL_FILES})
+    # Basic ignores for common directories to avoid formatting external/build
+    # files Note: We check for substrings in the full path
+    if("${FILE}" MATCHES "/\\.git/"
+       OR "${FILE}" MATCHES "/build/"
+       OR "${FILE}" MATCHES "/cmake-build/"
+       OR "${FILE}" MATCHES "/\\.pixi/"
+       OR "${FILE}" MATCHES "/vcpkg_installed/")
+        continue()
+    endif()
+
+    get_filename_component(FILENAME "${FILE}" NAME)
+
+    # Check if file ends with .cmake or matches exactly to CMakeLists.txt
+    if("${FILENAME}" STREQUAL "CMakeLists.txt" OR "${FILENAME}" MATCHES "\\.cmake$")
+        message(STATUS "Formatting ${FILE}")
+        execute_process(COMMAND ${CMAKE_FORMAT_EXECUTABLE} --config-files
+                                "${PROJECT_ROOT}/.cmake-format" -i "${FILE}")
+    endif()
+endforeach()

pixi/run.benchmark.cmake

@@ -0,0 +1,63 @@
+# cmake/run.examples.cmake
+
+# Get the project root directory (assuming this script is in cmake/ subdirectory)
+get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
+
+# Default to Debug if CMAKE_BUILD_TYPE is not specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Debug")
+else()
+    message(STATUS "CMAKE_BUILD_TYPE is set to: ${CMAKE_BUILD_TYPE}")
+endif()
+
+# Define the directory where executables are located
+# Based on CMakeLists.txt: "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+set(EXAMPLES_BIN_DIR "${PROJECT_ROOT}/out/${CMAKE_BUILD_TYPE}")
+
+if(NOT EXISTS "${EXAMPLES_BIN_DIR}")
+    message(
+        FATAL_ERROR
+            "Examples binary directory not found: ${EXAMPLES_BIN_DIR}. Please build the project first."
+        )
+endif()
+
+message(STATUS "Looking for benchmark executables in: ${EXAMPLES_BIN_DIR}")
+
+# Find all files starting with "omath_benchmark"
+file(GLOB EXAMPLE_FILES "${EXAMPLES_BIN_DIR}/omath_benchmark*")
+
+foreach(EXAMPLE_PATH ${EXAMPLE_FILES})
+    # Skip directories
+    if(IS_DIRECTORY "${EXAMPLE_PATH}")
+        continue()
+    endif()
+
+    get_filename_component(FILENAME "${EXAMPLE_PATH}" NAME)
+    get_filename_component(EXTENSION "${EXAMPLE_PATH}" EXT)
+
+    # Filter out potential debug symbols or non-executable artifacts
+    if(EXTENSION STREQUAL ".pdb" OR EXTENSION STREQUAL ".ilk" OR EXTENSION STREQUAL ".obj")
+        continue()
+    endif()
+
+    # On Windows, we expect .exe
+    if(MSVC AND NOT EXTENSION STREQUAL ".exe")
+        continue()
+    endif()
+
+    # On Linux/macOS, check permissions or just try to run it.
+
+    message(STATUS "-------------------------------------------------")
+    message(STATUS "Running benchmark: ${FILENAME}")
+    message(STATUS "-------------------------------------------------")
+
+    execute_process(COMMAND "${EXAMPLE_PATH}" WORKING_DIRECTORY "${PROJECT_ROOT}"
+                    RESULT_VARIABLE EXIT_CODE)
+
+    if(NOT EXIT_CODE EQUAL 0)
+        message(WARNING "Benchmark ${FILENAME} exited with error code: ${EXIT_CODE}")
+    else()
+        message(STATUS "Benchmark ${FILENAME} completed successfully.")
+    endif()
+
+endforeach()

pixi/run.examples.cmake

@@ -0,0 +1,63 @@
+# cmake/run.examples.cmake
+
+# Get the project root directory (assuming this script is in cmake/ subdirectory)
+get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
+
+# Default to Debug if CMAKE_BUILD_TYPE is not specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Debug")
+else()
+    message(STATUS "CMAKE_BUILD_TYPE is set to: ${CMAKE_BUILD_TYPE}")
+endif()
+
+# Define the directory where executables are located
+# Based on CMakeLists.txt: "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+set(EXAMPLES_BIN_DIR "${PROJECT_ROOT}/out/${CMAKE_BUILD_TYPE}")
+
+if(NOT EXISTS "${EXAMPLES_BIN_DIR}")
+    message(
+        FATAL_ERROR
+            "Examples binary directory not found: ${EXAMPLES_BIN_DIR}. Please build the project first."
+        )
+endif()
+
+message(STATUS "Looking for example executables in: ${EXAMPLES_BIN_DIR}")
+
+# Find all files starting with "example_"
+file(GLOB EXAMPLE_FILES "${EXAMPLES_BIN_DIR}/example_*")
+
+foreach(EXAMPLE_PATH ${EXAMPLE_FILES})
+    # Skip directories
+    if(IS_DIRECTORY "${EXAMPLE_PATH}")
+        continue()
+    endif()
+
+    get_filename_component(FILENAME "${EXAMPLE_PATH}" NAME)
+    get_filename_component(EXTENSION "${EXAMPLE_PATH}" EXT)
+
+    # Filter out potential debug symbols or non-executable artifacts
+    if(EXTENSION STREQUAL ".pdb" OR EXTENSION STREQUAL ".ilk" OR EXTENSION STREQUAL ".obj")
+        continue()
+    endif()
+
+    # On Windows, we expect .exe
+    if(MSVC AND NOT EXTENSION STREQUAL ".exe")
+        continue()
+    endif()
+
+    # On Linux/macOS, check permissions or just try to run it.
+
+    message(STATUS "-------------------------------------------------")
+    message(STATUS "Running example: ${FILENAME}")
+    message(STATUS "-------------------------------------------------")
+
+    execute_process(COMMAND "${EXAMPLE_PATH}" WORKING_DIRECTORY "${PROJECT_ROOT}"
+                    RESULT_VARIABLE EXIT_CODE)
+
+    if(NOT EXIT_CODE EQUAL 0)
+        message(WARNING "Example ${FILENAME} exited with error code: ${EXIT_CODE}")
+    else()
+        message(STATUS "Example ${FILENAME} completed successfully.")
+    endif()
+
+endforeach()

pixi/run.unit.tests.cmake

@@ -0,0 +1,63 @@
+# cmake/run.examples.cmake
+
+# Get the project root directory (assuming this script is in cmake/ subdirectory)
+get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
+
+# Default to Debug if CMAKE_BUILD_TYPE is not specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Debug")
+else()
+    message(STATUS "CMAKE_BUILD_TYPE is set to: ${CMAKE_BUILD_TYPE}")
+endif()
+
+# Define the directory where executables are located
+# Based on CMakeLists.txt: "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+set(EXAMPLES_BIN_DIR "${PROJECT_ROOT}/out/${CMAKE_BUILD_TYPE}")
+
+if(NOT EXISTS "${EXAMPLES_BIN_DIR}")
+    message(
+        FATAL_ERROR
+            "Examples binary directory not found: ${EXAMPLES_BIN_DIR}. Please build the project first."
+        )
+endif()
+
+message(STATUS "Looking for unit test executables in: ${EXAMPLES_BIN_DIR}")
+
+# Find all files starting with "unit_tests"
+file(GLOB EXAMPLE_FILES "${EXAMPLES_BIN_DIR}/unit_tests*")
+
+foreach(EXAMPLE_PATH ${EXAMPLE_FILES})
+    # Skip directories
+    if(IS_DIRECTORY "${EXAMPLE_PATH}")
+        continue()
+    endif()
+
+    get_filename_component(FILENAME "${EXAMPLE_PATH}" NAME)
+    get_filename_component(EXTENSION "${EXAMPLE_PATH}" EXT)
+
+    # Filter out potential debug symbols or non-executable artifacts
+    if(EXTENSION STREQUAL ".pdb" OR EXTENSION STREQUAL ".ilk" OR EXTENSION STREQUAL ".obj")
+        continue()
+    endif()
+
+    # On Windows, we expect .exe
+    if(MSVC AND NOT EXTENSION STREQUAL ".exe")
+        continue()
+    endif()
+
+    # On Linux/macOS, check permissions or just try to run it.
+
+    message(STATUS "-------------------------------------------------")
+    message(STATUS "Running unit_tests: ${FILENAME}")
+    message(STATUS "-------------------------------------------------")
+
+    execute_process(COMMAND "${EXAMPLE_PATH}" WORKING_DIRECTORY "${PROJECT_ROOT}"
+                    RESULT_VARIABLE EXIT_CODE)
+
+    if(NOT EXIT_CODE EQUAL 0)
+        message(WARNING "Example ${FILENAME} exited with error code: ${EXIT_CODE}")
+    else()
+        message(STATUS "Example ${FILENAME} completed successfully.")
+    endif()
+
+endforeach()

scripts/cmake-format.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Format all CMakeLists.txt and *.cmake files in the repo (excluding common build dirs)
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+cd "$REPO_ROOT"
+
+find . \
+  -path "./build" -prune -o \
+  -path "./cmake-build*" -prune -o \
+  -path "./out" -prune -o \
+  -path "./.git" -prune -o \
+  \( -name "CMakeLists.txt" -o -name "*.cmake" \) -print0 \
+| xargs -0 cmake-format -i

scripts/coverage-llvm.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# scripts/coverage-llvm.sh
+# LLVM coverage script that generates LCOV-style reports
+
+set -e
+
+SOURCE_DIR="${1:-.}"
+BINARY_DIR="${2:-cmake-build/build}"
+TEST_BINARY="${3:-}"
+OUTPUT_DIR="${4:-${BINARY_DIR}/coverage}"
+
+echo "[*] Source dir: ${SOURCE_DIR}"
+echo "[*] Binary dir: ${BINARY_DIR}"
+echo "[*] Output dir: ${OUTPUT_DIR}"
+
+# Find llvm tools - handle versioned names (Linux) and xcrun (macOS)
+find_llvm_tool() {
+    local tool_name="$1"
+    
+    # macOS: use xcrun
+    if [[ "$(uname)" == "Darwin" ]]; then
+        if xcrun --find "${tool_name}" &>/dev/null; then
+            echo "xcrun ${tool_name}"
+            return 0
+        fi
+    fi
+    
+    # Try versioned names (Linux with LLVM 21, 20, 19, etc.)
+    for version in 21 20 19 18 17 ""; do
+        local versioned_name="${tool_name}${version:+-$version}"
+        if command -v "${versioned_name}" &>/dev/null; then
+            echo "${versioned_name}"
+            return 0
+        fi
+    done
+    
+    echo ""
+    return 1
+}
+
+LLVM_PROFDATA=$(find_llvm_tool "llvm-profdata")
+LLVM_COV=$(find_llvm_tool "llvm-cov")
+
+if [[ -z "${LLVM_PROFDATA}" ]] || [[ -z "${LLVM_COV}" ]]; then
+    echo "Error: llvm-profdata or llvm-cov not found" >&2
+    echo "On Linux, install llvm or clang package" >&2
+    echo "On macOS, Xcode command line tools should provide these" >&2
+    exit 1
+fi
+
+echo "[*] Using: ${LLVM_PROFDATA}"
+echo "[*] Using: ${LLVM_COV}"
+
+# Find test binary
+if [[ -z "${TEST_BINARY}" ]]; then
+    for path in \
+        "${SOURCE_DIR}/out/Debug/unit_tests" \
+        "${SOURCE_DIR}/out/Release/unit_tests" \
+        "${BINARY_DIR}/unit_tests" \
+        "${BINARY_DIR}/tests/unit_tests"; do
+        if [[ -x "${path}" ]]; then
+            TEST_BINARY="${path}"
+            break
+        fi
+    done
+fi
+
+if [[ -z "${TEST_BINARY}" ]] || [[ ! -x "${TEST_BINARY}" ]]; then
+    echo "Error: unit_tests binary not found" >&2
+    echo "Searched in: out/Debug, out/Release, ${BINARY_DIR}" >&2
+    exit 1
+fi
+
+echo "[*] Test binary: ${TEST_BINARY}"
+
+# Clean previous coverage data
+rm -rf "${OUTPUT_DIR}"
+rm -f "${BINARY_DIR}"/*.profraw "${BINARY_DIR}"/*.profdata
+mkdir -p "${OUTPUT_DIR}"
+
+# Run tests with profiling enabled
+PROFILE_FILE="${BINARY_DIR}/default_%p.profraw"
+echo "[*] Running tests with LLVM_PROFILE_FILE=${PROFILE_FILE}"
+
+export LLVM_PROFILE_FILE="${PROFILE_FILE}"
+"${TEST_BINARY}" || echo "[!] Some tests failed, continuing with coverage..."
+
+# Find all generated .profraw files
+PROFRAW_FILES=$(find "${BINARY_DIR}" -name "*.profraw" -type f 2>/dev/null)
+if [[ -z "${PROFRAW_FILES}" ]]; then
+    # Also check current directory
+    PROFRAW_FILES=$(find . -maxdepth 3 -name "*.profraw" -type f 2>/dev/null)
+fi
+
+if [[ -z "${PROFRAW_FILES}" ]]; then
+    echo "Error: No .profraw files generated" >&2
+    echo "Make sure the binary was built with -fprofile-instr-generate -fcoverage-mapping" >&2
+    exit 1
+fi
+
+echo "[*] Found profraw files:"
+echo "${PROFRAW_FILES}"
+
+# Merge profiles
+PROFDATA_FILE="${BINARY_DIR}/coverage.profdata"
+echo "[*] Merging profiles into ${PROFDATA_FILE}"
+${LLVM_PROFDATA} merge -sparse ${PROFRAW_FILES} -o "${PROFDATA_FILE}"
+
+# Generate text summary
+echo "[*] Coverage Summary:"
+${LLVM_COV} report "${TEST_BINARY}" \
+    -instr-profile="${PROFDATA_FILE}" \
+    -ignore-filename-regex="tests/.*" \
+    -ignore-filename-regex="googletest/.*" \
+    -ignore-filename-regex="gtest/.*" \
+    -ignore-filename-regex="_deps/.*" \
+    -ignore-filename-regex="vcpkg_installed/.*"
+
+# Export lcov format (for tools like codecov)
+LCOV_FILE="${OUTPUT_DIR}/coverage.lcov"
+echo "[*] Exporting LCOV format to ${LCOV_FILE}"
+${LLVM_COV} export "${TEST_BINARY}" \
+    -instr-profile="${PROFDATA_FILE}" \
+    -format=lcov \
+    -ignore-filename-regex="tests/.*" \
+    -ignore-filename-regex="googletest/.*" \
+    -ignore-filename-regex="gtest/.*" \
+    -ignore-filename-regex="_deps/.*" \
+    -ignore-filename-regex="vcpkg_installed/.*" \
+    > "${LCOV_FILE}" || true
+
+# Generate LCOV-style HTML report using genhtml
+if command -v genhtml >/dev/null 2>&1; then
+    echo "[*] Generating LCOV-style HTML report using genhtml"
+    genhtml "${LCOV_FILE}" \
+        --ignore-errors inconsistent,corrupt \
+        --output-directory "${OUTPUT_DIR}" \
+        --title "Omath Coverage Report" \
+        --show-details \
+        --legend \
+        --demangle-cpp \
+        --num-spaces 4 \
+        --sort \
+        --function-coverage \
+        --branch-coverage
+    
+    echo "[*] LCOV-style HTML report generated at: ${OUTPUT_DIR}/index.html"
+else
+    echo "[!] genhtml not found. Installing lcov package..."
+    echo "[!] On Ubuntu/Debian: sudo apt-get install lcov"
+    echo "[!] On macOS: brew install lcov"
+    echo "[!] Falling back to LLVM HTML report..."
+    
+    # Fall back to LLVM HTML report
+    ${LLVM_COV} show "${TEST_BINARY}" \
+        -instr-profile="${PROFDATA_FILE}" \
+        -format=html \
+        -output-dir="${OUTPUT_DIR}" \
+        -show-line-counts-or-regions \
+        -show-instantiations=false \
+        -ignore-filename-regex="tests/.*" \
+        -ignore-filename-regex="googletest/.*" \
+        -ignore-filename-regex="gtest/.*" \
+        -ignore-filename-regex="_deps/.*" \
+        -ignore-filename-regex="vcpkg_installed/.*"
+fi
+
+echo "[*] Coverage report generated at: ${OUTPUT_DIR}/index.html"
+echo "[*] LCOV file at: ${LCOV_FILE}"

scripts/coverage.bat.in

@@ -0,0 +1,8 @@
+@echo off
+REM scripts/coverage.bat.in
+REM Simple wrapper to run coverage.ps1
+
+set SOURCE_DIR=@CMAKE_SOURCE_DIR@
+set BINARY_DIR=@CMAKE_BINARY_DIR@
+
+powershell -ExecutionPolicy Bypass -File "%BINARY_DIR%\scripts\coverage.ps1" -SourceDir "%SOURCE_DIR%" -BinaryDir "%BINARY_DIR%" %*

scripts/coverage.ps1.in

@@ -0,0 +1,132 @@
+# scripts/coverage.ps1.in
+# Windows coverage script using OpenCppCoverage
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$SourceDir,
+    
+    [Parameter(Mandatory=$true)]
+    [string]$BinaryDir,
+    
+    [string]$TestBinary = "",
+    [switch]$Cobertura,
+    [switch]$Html
+)
+
+$ErrorActionPreference = "Stop"
+
+# CMake-injected variables
+$LCOV_IGNORE_ERRORS = '@LCOV_IGNORE_ERRORS@'
+
+# Resolve paths
+$SourceDir = Resolve-Path $SourceDir
+$BinaryDir = Resolve-Path $BinaryDir
+
+Write-Host "[*] Source directory: $SourceDir" -ForegroundColor Cyan
+Write-Host "[*] Binary directory: $BinaryDir" -ForegroundColor Cyan
+
+# Find test binary
+if (-not $TestBinary) {
+    $searchPaths = @(
+        "$BinaryDir\Debug\unit_tests.exe",
+        "$BinaryDir\Release\unit_tests.exe",
+        "$BinaryDir\unit_tests.exe",
+        "$SourceDir\out\Debug\unit_tests.exe",
+        "$SourceDir\out\Release\unit_tests.exe"
+    )
+    
+    foreach ($path in $searchPaths) {
+        if (Test-Path $path) {
+            $TestBinary = $path
+            break
+        }
+    }
+}
+
+if (-not $TestBinary -or -not (Test-Path $TestBinary)) {
+    Write-Error "unit_tests.exe not found. Searched: $($searchPaths -join ', ')"
+    exit 1
+}
+
+$TestBinary = Resolve-Path $TestBinary
+Write-Host "[*] Test binary: $TestBinary" -ForegroundColor Cyan
+
+# Check for OpenCppCoverage
+$opencppcov = Get-Command "OpenCppCoverage" -ErrorAction SilentlyContinue
+if (-not $opencppcov) {
+    # Try common installation paths
+    $possiblePaths = @(
+        "$env:ProgramFiles\OpenCppCoverage\OpenCppCoverage.exe",
+        "${env:ProgramFiles(x86)}\OpenCppCoverage\OpenCppCoverage.exe",
+        "$env:LOCALAPPDATA\Programs\OpenCppCoverage\OpenCppCoverage.exe"
+    )
+    
+    foreach ($path in $possiblePaths) {
+        if (Test-Path $path) {
+            $opencppcov = Get-Item $path
+            break
+        }
+    }
+}
+
+if (-not $opencppcov) {
+    Write-Host @"
+OpenCppCoverage not found!
+
+Install it from: https://github.com/OpenCppCoverage/OpenCppCoverage/releases
+
+Or via Chocolatey:
+    choco install opencppcoverage
+
+Or via winget:
+    winget install OpenCppCoverage.OpenCppCoverage
+"@ -ForegroundColor Red
+    exit 1
+}
+
+$OpenCppCoveragePath = if ($opencppcov.Source) { $opencppcov.Source } else { $opencppcov.FullName }
+Write-Host "[*] Using OpenCppCoverage: $OpenCppCoveragePath" -ForegroundColor Cyan
+
+# Create output directory
+$CoverageDir = Join-Path $BinaryDir "coverage"
+if (-not (Test-Path $CoverageDir)) {
+    New-Item -ItemType Directory -Path $CoverageDir | Out-Null
+}
+
+# Build OpenCppCoverage arguments
+$coverageArgs = @(
+    "--sources", "$SourceDir\include",
+    "--sources", "$SourceDir\source",
+    "--excluded_sources", "*\tests\*",
+    "--excluded_sources", "*\googletest\*",
+    "--excluded_sources", "*\gtest\*",
+    "--excluded_sources", "*\_deps\*",
+    "--excluded_sources", "*\vcpkg_installed\*",
+    "--export_type", "html:$CoverageDir",
+    "--export_type", "cobertura:$CoverageDir\coverage.xml",
+    "--cover_children",
+    "--"
+)
+
+Write-Host "[*] Running OpenCppCoverage..." -ForegroundColor Cyan
+Write-Host "    Command: $OpenCppCoveragePath $($coverageArgs -join ' ') $TestBinary"
+
+& $OpenCppCoveragePath @coverageArgs $TestBinary
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Warning "OpenCppCoverage exited with code $LASTEXITCODE (tests may have failed)"
+}
+
+# Check outputs
+$htmlIndex = Join-Path $CoverageDir "index.html"
+$coberturaXml = Join-Path $CoverageDir "coverage.xml"
+
+if (Test-Path $htmlIndex) {
+    Write-Host "[*] HTML coverage report: $htmlIndex" -ForegroundColor Green
+}
+
+if (Test-Path $coberturaXml) {
+    Write-Host "[*] Cobertura XML report: $coberturaXml" -ForegroundColor Green
+}
+
+Write-Host "[*] Coverage collection complete!" -ForegroundColor Green

scripts/valgrind.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+
+# =============================================================================
+# Local Reproduction of "Valgrind Analysis" GitHub Action
+# =============================================================================
+
+# Stop on error, undefined variables, or pipe failures
+set -euo pipefail
+
+# --- 1. Environment Setup ---
+
+# Determine VCPKG_ROOT
+# If VCPKG_ROOT is not set in your shell, we check if a local folder exists.
+if [[ -z "${VCPKG_ROOT:-}" ]]; then
+    if [[ -d "./vcpkg" ]]; then
+        export VCPKG_ROOT="$(pwd)/vcpkg"
+        echo "Found local vcpkg at: $VCPKG_ROOT"
+        
+        # Bootstrap vcpkg if the executable doesn't exist
+        if [[ ! -f "$VCPKG_ROOT/vcpkg" ]]; then
+            echo "Bootstrapping vcpkg..."
+            "$VCPKG_ROOT/bootstrap-vcpkg.sh"
+        fi
+    else
+        echo "Error: VCPKG_ROOT is not set and ./vcpkg directory not found."
+        echo "Please install vcpkg or set the VCPKG_ROOT environment variable."
+        exit 1
+    fi
+else
+    echo "Using existing VCPKG_ROOT: $VCPKG_ROOT"
+fi
+
+# Set the build directory matching the YAML's preset expectation
+# Assuming the preset writes to: cmake-build/build/linux-release-vcpkg
+BUILD_DIR="cmake-build/build/linux-release-vcpkg"
+
+# Check if Valgrind is installed
+if ! command -v valgrind &> /dev/null; then
+    echo "Error: valgrind is not installed. Please install it (e.g., sudo apt install valgrind)."
+    exit 1
+fi
+
+echo "----------------------------------------------------"
+echo "Starting Configuration (Debug Build with Valgrind)..."
+echo "----------------------------------------------------"
+
+# --- 2. Configure (CMake) ---
+# We force CMAKE_BUILD_TYPE=Debug even though the preset says 'release'
+# to ensure Valgrind has access to debug symbols (line numbers).
+
+cmake --preset linux-release-vcpkg \
+    -DCMAKE_BUILD_TYPE=Debug \
+    -DOMATH_BUILD_EXAMPLES=OFF \
+    -DOMATH_BUILD_TESTS=ON \
+    -DOMATH_BUILD_BENCHMARK=ON \
+    -DOMATH_ENABLE_VALGRIND=ON \
+    -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;benchmark"
+
+echo "----------------------------------------------------"
+echo "Building Targets..."
+echo "----------------------------------------------------"
+
+# --- 3. Build ---
+# Using the specific build directory defined by the preset structure
+cmake --build "$BUILD_DIR"
+
+echo "----------------------------------------------------"
+echo "Running Valgrind Analysis..."
+echo "----------------------------------------------------"
+
+# --- 4. Run Valgrind ---
+# Runs the specific custom target defined in your CMakeLists.txt
+cmake --build "$BUILD_DIR" --target valgrind_all
+
+echo "----------------------------------------------------"
+echo "Valgrind Analysis Complete."
+echo "----------------------------------------------------"

source/3d_primitives/box.cpp

@@ -1,54 +0,0 @@
-//
-// Created by Vlad on 4/18/2025.
-//
-#include "omath/3d_primitives/box.hpp"
-
-namespace omath::primitives
-{
-    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
-                                                        const Vector3<float>& dir_forward,
-                                                        const Vector3<float>& dir_right, const float ratio) noexcept
-    {
-        const auto height = top.distance_to(bottom);
-        const auto side_size = height / ratio;
-
-        // corner layout (0‑3 bottom, 4‑7 top)
-        std::array<Vector3<float>, 8> p;
-        p[0] = bottom + (dir_forward + dir_right) * side_size; // front‑right‑bottom
-        p[1] = bottom + (dir_forward - dir_right) * side_size; // front‑left‑bottom
-        p[2] = bottom + (-dir_forward + dir_right) * side_size; // back‑right‑bottom
-        p[3] = bottom + (-dir_forward - dir_right) * side_size; // back‑left‑bottom
-        p[4] = top + (dir_forward + dir_right) * side_size; // front‑right‑top
-        p[5] = top + (dir_forward - dir_right) * side_size; // front‑left‑top
-        p[6] = top + (-dir_forward + dir_right) * side_size; // back‑right‑top
-        p[7] = top + (-dir_forward - dir_right) * side_size; // back‑left‑top
-
-        std::array<Triangle<Vector3<float>>, 12> poly;
-
-        // bottom face (+Y up ⇒ wind CW when viewed from above)
-        poly[0] = {p[0], p[2], p[3]};
-        poly[1] = {p[0], p[3], p[1]};
-
-        // top face
-        poly[2] = {p[4], p[7], p[6]};
-        poly[3] = {p[4], p[5], p[7]};
-
-        // front face
-        poly[4] = {p[0], p[5], p[1]};
-        poly[5] = {p[0], p[4], p[5]};
-
-        // right face
-        poly[6] = {p[0], p[6], p[2]};
-        poly[7] = {p[0], p[4], p[6]};
-
-        // back face
-        poly[8] = {p[2], p[7], p[3]};
-        poly[9] = {p[2], p[6], p[7]};
-
-        // left face
-        poly[10] = {p[1], p[7], p[5]};
-        poly[11] = {p[1], p[3], p[7]};
-
-        return poly;
-    }
-} // namespace omath::primitives

source/3d_primitives/plane.cpp

@@ -1,19 +0,0 @@
-//
-// Created by Vlad on 8/28/2025.
-//
-#include "omath/3d_primitives/plane.hpp"
-
-namespace omath::primitives
-{
-    std::array<Triangle<Vector3<float>>, 2> create_plane(const Vector3<float>& vertex_a,
-                                                          const Vector3<float>& vertex_b,
-                                                          const Vector3<float>& direction, const float size) noexcept
-    {
-        const auto second_vertex_a = vertex_a + direction * size;
-        return std::array
-        {
-            Triangle{second_vertex_a, vertex_a, vertex_b},
-            Triangle{second_vertex_a, vertex_b + direction * size, vertex_b}
-        };
-    }
-} // namespace omath::primitives

source/collision/line_tracer.cpp

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

source/engines/cry_engine/formulas.cpp

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

source/engines/cry_engine/traits/camera_trait.cpp

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