added std namspace to int64_t type

Feature/color update

.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/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

@@ -5,4 +5,11 @@
 .idea/workspace.xml
 /build/
 /clang-coverage/
-*.gcov
+*.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" />

.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

@@ -9,49 +9,56 @@ include(CheckCXXCompilerFlag)
 include(cmake/Coverage.cmake)
 include(cmake/Valgrind.cmake)
 
-if (MSVC)
+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_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")
             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)
-        elseif (omath_feature STREQUAL "examples")
+        elseif(omath_feature STREQUAL "examples")
             set(OMATH_BUILD_EXAMPLES ON)
-        endif ()
+        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}")
@@ -65,84 +72,78 @@ if (${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: Building using vcpkg ${OMATH_BUILD_VIA_VCPKG}")
     message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}")
     message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}")
-endif ()
+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()
 
 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()
 
-if (OMATH_ENABLE_FORCE_INLINE)
+if(OMATH_ENABLE_FORCE_INLINE)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_FORCE_INLINE)
-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)
+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_USE_UNITY_BUILD)
-    set_target_properties(${PROJECT_NAME} PROPERTIES
-            UNITY_BUILD ON
-            UNITY_BUILD_BATCH_SIZE 20)
-endif ()
+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)
@@ -151,79 +152,79 @@ 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)
     if(OMATH_ENABLE_COVERAGE)
         omath_setup_coverage(${PROJECT_NAME})
     endif()
-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")
+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})

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**
    

README.md

@@ -80,9 +80,10 @@ if (auto screen = camera.world_to_screen(world_position)) {
 - **Collision Detection**: Production ready code to handle collision detection by using simple interfaces.
 - **No Additional Dependencies**: No additional dependencies need to use OMath except unit test execution
 - **Ready for meta-programming**: Omath use templates for common types like Vectors, Matrixes etc, to handle all types!
-- **Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine and canonical OpenGL**.
+- **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 PE files/modules, binary slices, works even with Wine apps. 
+- **Algorithms**: Has ability to scan for byte pattern with wildcards in ELF/Mach-O/PE files/modules, binary slices, works even with Wine apps. 
+- **Battle tested**: It's already used by some big players on the market like wraith.su and bluedream.ltd
 <div align = center>
  
 # Gallery

VERSION

@@ -1 +1 @@
-4.6.0
+5.0.0

benchmark/CMakeLists.txt

@@ -1,22 +1,23 @@
 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})

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

@@ -7,38 +7,23 @@ function(omath_setup_coverage TARGET_NAME)
     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
+        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
-        )
+            /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
-        )
+        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
-        )
+        target_compile_options(${TARGET_NAME} PRIVATE --coverage -g -O0)
+        target_link_options(${TARGET_NAME} PRIVATE --coverage)
     endif()
 
     if(TARGET coverage)
@@ -47,40 +32,36 @@ function(omath_setup_coverage TARGET_NAME)
 
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
         message(STATUS "MSVC detected: Use VS Code Coverage from CI workflow")
-        add_custom_target(coverage
+        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)"
-        )
+            COMMENT "Running tests for coverage (use VS Code Coverage from CI)")
 
     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
-        add_custom_target(coverage
+        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"
+            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"
-        )
+            COMMENT "Running LLVM coverage")
 
     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        add_custom_target(coverage
+        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"
+            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"
-        )
+            COMMENT "Running lcov/genhtml")
     endif()
 endfunction()

cmake/Valgrind.cmake

@@ -22,23 +22,19 @@ function(omath_setup_valgrind TARGET_NAME)
         return()
     endif()
 
-    set(VALGRIND_FLAGS 
-        --leak-check=full 
-        --show-leak-kinds=all
-        --track-origins=yes 
-        --error-exitcode=99
-    )
+    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}
+        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
-        )
+            USES_TERMINAL)
 
         add_dependencies(valgrind_all ${VALGRIND_TARGET})
     endif()

examples/CMakeLists.txt

@@ -1,37 +1,10 @@
-project(examples)
-
-add_executable(example_projection_matrix_builder example_proj_mat_builder.cpp)
-set_target_properties(example_projection_matrix_builder PROPERTIES
-        CXX_STANDARD 26
-        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(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
-        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(example_signature_scan PRIVATE omath::omath)
-
-
-add_executable(example_glfw3 example_glfw3.cpp)
-set_target_properties(example_glfw3 PROPERTIES CXX_STANDARD 26
-        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(GLEW REQUIRED)
-find_package(glfw3 CONFIG REQUIRED)
-target_link_libraries(example_glfw3 PRIVATE omath::omath GLEW::GLEW glfw)
+add_subdirectory(example_barycentric)
+add_subdirectory(example_glfw3)
+add_subdirectory(example_proj_mat_builder)
+add_subdirectory(example_signature_scan)
 
 if(OMATH_ENABLE_VALGRIND)
-        omath_setup_valgrind(example_projection_matrix_builder)
-        omath_setup_valgrind(example_signature_scan)
-        omath_setup_valgrind(example_glfw3)
+    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

@@ -120,9 +120,14 @@ int main()
         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
@@ -141,15 +146,36 @@ int main()
     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)
     {
-        std::cerr << "Failed to initialize GLEW: " << reinterpret_cast<const char*>(glewGetErrorString(glewErr))
-                  << "\n";
-        glfwTerminate();
-        return -1;
+        // 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 ----------
@@ -280,11 +306,65 @@ int main()
 
     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;

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/collision/epa_algorithm.hpp

@@ -8,16 +8,17 @@
 #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>;
@@ -28,13 +29,18 @@ namespace omath::collision
     {
     public:
         using VectorType = ColliderInterfaceType::VectorType;
-        static_assert(EpaVector<VectorType>, "VertexType must satisfy EpaVector concept");
+        static_assert(EpaVector<VectorType, typename VectorType::ContainedType>,
+                      "VertexType must satisfy EpaVector concept");
 
+    private:
+        using FloatingType = VectorType::ContainedType;
+
+    public:
         struct Result final
         {
             VectorType normal{}; // from A to B
             VectorType penetration_vector;
-            float depth{0.0f};
+            FloatingType depth{0.0};
             int iterations{0};
             int num_vertices{0};
             int num_faces{0};
@@ -43,7 +49,7 @@ 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]]
@@ -51,83 +57,76 @@ namespace omath::collision
                                            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::pmr::vector<VectorType> vertexes = build_initial_polytope_from_simplex(simplex, mem_resource);
-
-            // Initial tetra faces (windings corrected in make_face)
             std::pmr::vector<Face> faces = create_initial_tetra_faces(mem_resource, vertexes);
 
-            auto heap = rebuild_heap(faces, mem_resource);
+            // 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, mem_resource);
+                // Lazily discard stale (deleted or index-mismatched) heap entries.
+                discard_stale_heap_entries(faces, heap);
 
                 if (heap.empty())
                     break;
 
-                //FIXME: STORE REF VALUE, DO NOT USE
-                // AFTER IF STATEMENT BLOCK
                 const Face& face = faces[heap.top().idx];
 
-                // Get the furthest point in face normal direction
                 const VectorType p = support_point(a, b, face.n);
-                const float p_dist = face.n.dot(p);
+                const auto p_dist = face.n.dot(p);
 
-                // Converged if we can’t push the face closer than tolerance
+                // Converged: new support can't push the face closer than tolerance.
                 if (p_dist - face.d <= params.tolerance)
                 {
                     out.normal = face.n;
-                    out.depth = face.d; // along unit normal
+                    out.depth = face.d;
                     out.iterations = it + 1;
                     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;
                 }
 
-                // Add new vertex
                 const int new_idx = static_cast<int>(vertexes.size());
                 vertexes.emplace_back(p);
 
-                const auto [to_delete, boundary] = mark_visible_and_collect_horizon(faces, p);
+                // Tombstone visible faces and collect the horizon boundary.
+                // This avoids copying the faces array (O(n)) each iteration.
+                tombstone_visible_faces(faces, boundary, p);
 
-                erase_marked(faces, to_delete);
-
-                // Stitch new faces around the horizon
-                for (const auto& e : boundary)
+                // 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)
+                {
+                    const int fi = static_cast<int>(faces.size());
                     faces.emplace_back(make_face(vertexes, e.a, e.b, new_idx));
-
-                // Rebuild heap after topology change
-                heap = rebuild_heap(faces, mem_resource);
+                    heap.emplace(faces.back().d, fi);
+                }
 
                 if (!std::isfinite(vertexes.back().dot(vertexes.back())))
                     break; // safety
+
                 out.iterations = it + 1;
             }
 
-            if (faces.empty())
+            // Find the best surviving (non-deleted) face.
+            const Face* best = find_best_surviving_face(faces);
+
+            if (!best)
                 return std::nullopt;
 
-            const auto best = *std::ranges::min_element(faces, [](const auto& first, const auto& second)
-                                                        { return first.d < second.d; });
-            out.normal = best.n;
-            out.depth = best.d;
+            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;
         }
 
@@ -136,7 +135,8 @@ namespace omath::collision
         {
             int i0, i1, i2;
             VectorType n; // unit outward normal
-            float d; // n · v0  (>=0 ideally because origin is inside)
+            FloatingType d; // n · v0  (>= 0 ideally because origin is inside)
+            bool deleted{false}; // tombstone flag — avoids O(n) compaction per iteration
         };
 
         struct Edge final
@@ -146,9 +146,10 @@ namespace omath::collision
 
         struct HeapItem final
         {
-            float d;
+            FloatingType d;
             int idx;
         };
+
         struct HeapCmp final
         {
             [[nodiscard]]
@@ -160,35 +161,44 @@ namespace omath::collision
 
         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 constexpr std::int64_t pack_edge(const int a, const int b) noexcept
+        {
+            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()); // optional but recommended
-
+            storage.reserve(faces.size());
             Heap h{HeapCmp{}, std::move(storage)};
-
             for (int i = 0; i < static_cast<int>(faces.size()); ++i)
-                h.emplace(faces[i].d, i);
-
-            return h; // allocator is preserved
+                if (!faces[i].deleted)
+                    h.emplace(faces[i].d, i);
+            return h;
         }
 
         [[nodiscard]]
         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::pmr::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::ranges::find_if(boundary, [&](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.emplace_back(a, b); // horizon edge (directed)
+                boundary.emplace(pack_edge(a, b), Edge{a, b});
         }
 
         [[nodiscard]]
@@ -198,19 +208,18 @@ namespace omath::collision
             const VectorType& a1 = vertexes[i1];
             const VectorType& a2 = vertexes[i2];
             VectorType n = (a1 - a0).cross(a2 - a0);
-            if (n.dot(n) <= 1e-30f)
-            {
+            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};
         }
 
@@ -223,7 +232,7 @@ namespace omath::collision
 
         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;
         }
@@ -237,6 +246,7 @@ 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)
@@ -256,48 +266,45 @@ namespace omath::collision
         {
             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 void erase_marked(std::pmr::vector<Face>& faces, const std::pmr::vector<bool>& to_delete)
+
+        static const Face* find_best_surviving_face(const std::pmr::vector<Face>& faces)
         {
-            auto* mr = faces.get_allocator().resource(); // keep same resource
-            std::pmr::vector<Face> kept{mr};
-            kept.reserve(faces.size());
-
-            for (std::size_t i = 0; i < faces.size(); ++i)
-                if (!to_delete[i])
-                    kept.emplace_back(faces[i]);
-
-            faces.swap(kept);
+            const Face* best = nullptr;
+            for (const auto& f : faces)
+                if (!f.deleted && (best == nullptr || f.d < best->d))
+                    best = &f;
+            return best;
         }
-        struct Horizon
+        static void tombstone_visible_faces(std::pmr::vector<Face>& faces, BoundaryMap& boundary,
+                                            const VectorType& p)
         {
-            std::pmr::vector<bool> to_delete;
-            std::pmr::vector<Edge> boundary;
-        };
-
-        static Horizon mark_visible_and_collect_horizon(const std::pmr::vector<Face>& faces, const VectorType& p)
-        {
-            auto* mr = faces.get_allocator().resource();
-
-            Horizon horizon{std::pmr::vector<bool>(faces.size(), false, mr), std::pmr::vector<Edge>(mr)};
-            horizon.boundary.reserve(faces.size());
-
-            for (std::size_t i = 0; i < faces.size(); ++i)
-                if (visible_from(faces[i], p))
+            boundary.clear();
+            for (auto& f : faces)
+            {
+                if (!f.deleted && visible_from(f, p))
                 {
-                    const auto& rf = faces[i];
-                    horizon.to_delete[i] = true;
-                    add_edge_boundary(horizon.boundary, rf.i0, rf.i1);
-                    add_edge_boundary(horizon.boundary, rf.i1, rf.i2);
-                    add_edge_boundary(horizon.boundary, rf.i2, rf.i0);
+                    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);
                 }
+            }
+        }
 
-            return horizon;
+        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,11 +14,15 @@ namespace omath::collision
         Simplex<VertexType> simplex; // valid only if hit == true and size==4
     };
 
+    struct GjkSettings final
+    {
+        float epsilon = 1e-6f;
+        std::size_t max_iterations = 64;
+    };
     template<class ColliderInterfaceType>
     class GjkAlgorithm final
     {
         using VectorType = ColliderInterfaceType::VectorType;
-
     public:
         [[nodiscard]]
         static VectorType find_support_vertex(const ColliderInterfaceType& collider_a,
@@ -36,20 +40,34 @@ namespace omath::collision
 
         [[nodiscard]]
         static GjkHitInfo<VectorType> is_collide_with_simplex_info(const ColliderInterfaceType& collider_a,
-                                                                   const ColliderInterfaceType& collider_b)
+                                                                   const ColliderInterfaceType& collider_b,
+                                                                   const GjkSettings& settings = {})
         {
-            auto support = find_support_vertex(collider_a, collider_b, VectorType{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};
+            }
+
+            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);
@@ -57,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,43 +8,96 @@
 
 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]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const MeshType& mesh) noexcept
+        constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept
         {
-            Vector3<float> mesh_hit = ray.end;
+            auto mesh_hit = ray.end;
 
-            auto begin = mesh.m_element_buffer_object.cbegin();
-            auto end = mesh.m_element_buffer_object.cend();
+            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))
             {
-                auto face = mesh.make_face_in_world_space(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))

include/omath/collision/mesh_collider.hpp

@@ -42,13 +42,40 @@ namespace omath::collision
             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
         {
-            return *std::ranges::max_element(
-                    m_mesh.m_vertex_buffer, [&direction](const auto& first, const auto& second)
-                    { return first.position.dot(direction) < second.position.dot(direction); });
+            // 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;
     };

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

@@ -62,20 +62,13 @@ namespace omath::detail
         return splitmix64(base_seed() + 0xD1B54A32D192ED03ull * (Stream + 1));
     }
 
-    [[nodiscard]]
-    consteval std::uint64_t bounded_u64(const std::uint64_t x, const std::uint64_t bound)
-    {
-        return (x * bound) >> 64;
-    }
-
     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 span = static_cast<std::uint64_t>(Hi - Lo) + 1ull;
         const std::uint64_t r = rand_u64<Stream>();
-        return static_cast<std::int64_t>(bounded_u64(r, span)) + Lo;
+        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)

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/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/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/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/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/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/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,7 +233,8 @@ 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, Type epsilon = static_cast<Type>(0.0001)) 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 std::abs(angle->as_degrees() - static_cast<Type>(90)) <= epsilon;
@@ -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/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"
 

include/omath/projection/camera.hpp

@@ -52,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
     {
@@ -80,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
@@ -283,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;
 

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]]
@@ -82,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});
@@ -109,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();
@@ -141,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()
@@ -160,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
         {
@@ -188,23 +202,55 @@ namespace omath
 template<>
 struct std::formatter<omath::Color> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
-    static constexpr auto parse(const 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
     {
-        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
-            return std::format_to(ctx.out(), "{}", col.to_string());
-        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
-            return std::format_to(ctx.out(), L"{}", col.to_wstring());
+        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(), "{}", str);
+        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
+            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()));
 
         std::unreachable();
     }

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

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

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

source/utility/macho_pattern_scan.cpp

@@ -0,0 +1,349 @@
+//
+// Created by Copilot on 04.02.2026.
+//
+#include "omath/utility/macho_pattern_scan.hpp"
+#include "omath/utility/pattern_scan.hpp"
+#include <cstring>
+#include <fstream>
+#include <variant>
+#include <vector>
+
+#pragma pack(push, 1)
+
+namespace
+{
+    // Mach-O magic numbers
+    constexpr std::uint32_t mh_magic_32 = 0xFEEDFACE;
+    constexpr std::uint32_t mh_magic_64 = 0xFEEDFACF;
+    constexpr std::uint32_t mh_cigam_32 = 0xCEFAEDFE; // Byte-swapped 32-bit
+    constexpr std::uint32_t mh_cigam_64 = 0xCFFAEDFE; // Byte-swapped 64-bit
+
+    // Load command types
+    constexpr std::uint32_t lc_segment = 0x1;
+    constexpr std::uint32_t lc_segment_64 = 0x19;
+
+    // ReSharper disable CppDeclaratorNeverUsed
+    // Mach-O header for 32-bit
+    struct MachHeader32 final
+    {
+        std::uint32_t magic;
+        std::uint32_t cputype;
+        std::uint32_t cpusubtype;
+        std::uint32_t filetype;
+        std::uint32_t ncmds;
+        std::uint32_t sizeofcmds;
+        std::uint32_t flags;
+    };
+
+    // Mach-O header for 64-bit
+    struct MachHeader64 final
+    {
+        std::uint32_t magic;
+        std::uint32_t cputype;
+        std::uint32_t cpusubtype;
+        std::uint32_t filetype;
+        std::uint32_t ncmds;
+        std::uint32_t sizeofcmds;
+        std::uint32_t flags;
+        std::uint32_t reserved;
+    };
+
+    // Load command header
+    struct LoadCommand final
+    {
+        std::uint32_t cmd;
+        std::uint32_t cmdsize;
+    };
+
+    // Segment command for 32-bit
+    struct SegmentCommand32 final
+    {
+        std::uint32_t cmd;
+        std::uint32_t cmdsize;
+        char segname[16];
+        std::uint32_t vmaddr;
+        std::uint32_t vmsize;
+        std::uint32_t fileoff;
+        std::uint32_t filesize;
+        std::uint32_t maxprot;
+        std::uint32_t initprot;
+        std::uint32_t nsects;
+        std::uint32_t flags;
+    };
+
+    // Segment command for 64-bit
+    struct SegmentCommand64 final
+    {
+        std::uint32_t cmd;
+        std::uint32_t cmdsize;
+        char segname[16];
+        std::uint64_t vmaddr;
+        std::uint64_t vmsize;
+        std::uint64_t fileoff;
+        std::uint64_t filesize;
+        std::uint32_t maxprot;
+        std::uint32_t initprot;
+        std::uint32_t nsects;
+        std::uint32_t flags;
+    };
+
+    // Section for 32-bit
+    struct Section32 final
+    {
+        char sectname[16];
+        char segname[16];
+        std::uint32_t addr;
+        std::uint32_t size;
+        std::uint32_t offset;
+        std::uint32_t align;
+        std::uint32_t reloff;
+        std::uint32_t nreloc;
+        std::uint32_t flags;
+        std::uint32_t reserved1;
+        std::uint32_t reserved2;
+    };
+
+    // Section for 64-bit
+    struct Section64 final
+    {
+        char sectname[16];
+        char segname[16];
+        std::uint64_t addr;
+        std::uint64_t size;
+        std::uint32_t offset;
+        std::uint32_t align;
+        std::uint32_t reloff;
+        std::uint32_t nreloc;
+        std::uint32_t flags;
+        std::uint32_t reserved1;
+        std::uint32_t reserved2;
+        std::uint32_t reserved3;
+    };
+    // ReSharper enable CppDeclaratorNeverUsed
+#pragma pack(pop)
+
+    enum class MachOArch : std::int8_t
+    {
+        x32,
+        x64,
+    };
+
+    struct ExtractedSection final
+    {
+        std::uintptr_t virtual_base_addr{};
+        std::uintptr_t raw_base_addr{};
+        std::vector<std::byte> data;
+    };
+
+    [[nodiscard]]
+    std::optional<MachOArch> get_macho_arch(std::fstream& file)
+    {
+        std::uint32_t magic{};
+        const std::streampos backup_pos = file.tellg();
+
+        file.seekg(0, std::ios_base::beg);
+        file.read(reinterpret_cast<char*>(&magic), sizeof(magic));
+        file.seekg(backup_pos, std::ios_base::beg);
+
+        if (magic == mh_magic_64 || magic == mh_cigam_64)
+            return MachOArch::x64;
+
+        if (magic == mh_magic_32 || magic == mh_cigam_32)
+            return MachOArch::x32;
+
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool is_macho_file(std::fstream& file)
+    {
+        return get_macho_arch(file).has_value();
+    }
+
+    [[nodiscard]]
+    std::string_view get_section_name(const char* sectname)
+    {
+        // Mach-O section names are fixed 16-byte arrays, not necessarily null-terminated
+        return std::string_view(sectname, std::min(std::strlen(sectname), std::size_t{16}));
+    }
+
+    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd>
+    std::optional<ExtractedSection> extract_section_impl(std::fstream& file, const std::string_view& section_name)
+    {
+        HeaderType header{};
+        file.seekg(0, std::ios_base::beg);
+        if (!file.read(reinterpret_cast<char*>(&header), sizeof(header))) [[unlikely]]
+            return std::nullopt;
+
+        std::streamoff cmd_offset = sizeof(header);
+
+        for (std::uint32_t i = 0; i < header.ncmds; ++i)
+        {
+            LoadCommand lc{};
+            file.seekg(cmd_offset, std::ios_base::beg);
+            if (!file.read(reinterpret_cast<char*>(&lc), sizeof(lc))) [[unlikely]]
+                return std::nullopt;
+
+            if (lc.cmd != segment_cmd)
+            {
+                cmd_offset += static_cast<std::streamoff>(lc.cmdsize);
+                continue;
+            }
+            SegmentType segment{};
+            file.seekg(cmd_offset, std::ios_base::beg);
+            if (!file.read(reinterpret_cast<char*>(&segment), sizeof(segment))) [[unlikely]]
+                return std::nullopt;
+
+            if (!segment.nsects)
+            {
+                cmd_offset += static_cast<std::streamoff>(lc.cmdsize);
+                continue;
+            }
+            std::streamoff sect_offset = cmd_offset + static_cast<std::streamoff>(sizeof(segment));
+
+            for (std::uint32_t j = 0; j < segment.nsects; ++j)
+            {
+                SectionType section{};
+                file.seekg(sect_offset, std::ios_base::beg);
+                if (!file.read(reinterpret_cast<char*>(&section), sizeof(section))) [[unlikely]]
+                    return std::nullopt;
+
+                if (get_section_name(section.sectname) != section_name)
+                {
+                    sect_offset += static_cast<std::streamoff>(sizeof(section));
+                    continue;
+                }
+
+                ExtractedSection out;
+                out.virtual_base_addr = static_cast<std::uintptr_t>(section.addr);
+                out.raw_base_addr = static_cast<std::uintptr_t>(section.offset);
+                out.data.resize(static_cast<std::size_t>(section.size));
+
+                file.seekg(static_cast<std::streamoff>(section.offset), std::ios_base::beg);
+                if (!file.read(reinterpret_cast<char*>(out.data.data()), static_cast<std::streamsize>(out.data.size())))
+                        [[unlikely]]
+                    return std::nullopt;
+
+                return out;
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    std::optional<ExtractedSection> get_macho_section_by_name(const std::filesystem::path& path,
+                                                              const std::string_view& section_name)
+    {
+        std::fstream file(path, std::ios::binary | std::ios::in);
+
+        if (!file.is_open()) [[unlikely]]
+            return std::nullopt;
+
+        if (!is_macho_file(file)) [[unlikely]]
+            return std::nullopt;
+
+        const auto arch = get_macho_arch(file);
+
+        if (!arch.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        if (arch.value() == MachOArch::x64)
+            return extract_section_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(file, section_name);
+        return extract_section_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(file, section_name);
+    }
+
+    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd>
+    std::optional<std::uintptr_t> scan_in_module_impl(const std::byte* base, const std::string_view pattern,
+                                                      const std::string_view target_section_name)
+    {
+        const auto* header = reinterpret_cast<const HeaderType*>(base);
+
+        std::size_t cmd_offset = sizeof(HeaderType);
+
+        for (std::uint32_t i = 0; i < header->ncmds; ++i)
+        {
+            const auto* lc = reinterpret_cast<const LoadCommand*>(base + cmd_offset);
+
+            if (lc->cmd != segment_cmd)
+            {
+                cmd_offset += lc->cmdsize;
+                continue;
+            }
+            const auto* segment = reinterpret_cast<const SegmentType*>(base + cmd_offset);
+            std::size_t sect_offset = cmd_offset + sizeof(SegmentType);
+
+            for (std::uint32_t j = 0; j < segment->nsects; ++j)
+            {
+                const auto* section = reinterpret_cast<const SectionType*>(base + sect_offset);
+
+                if (get_section_name(section->sectname) != target_section_name && section->size > 0)
+                {
+                    sect_offset += sizeof(SectionType);
+                    continue;
+                }
+                const auto* section_begin = base + static_cast<std::size_t>(section->addr);
+                const auto* section_end = section_begin + static_cast<std::size_t>(section->size);
+
+                const auto scan_result = omath::PatternScanner::scan_for_pattern(section_begin, section_end, pattern);
+
+                if (scan_result != section_end)
+                    return reinterpret_cast<std::uintptr_t>(scan_result);
+            }
+        }
+
+        return std::nullopt;
+    }
+
+} // namespace
+
+namespace omath
+{
+    std::optional<std::uintptr_t>
+    MachOPatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                                           const std::string_view& pattern,
+                                                           const std::string_view& target_section_name)
+    {
+        if (module_base_address == nullptr) [[unlikely]]
+            return std::nullopt;
+
+        const auto* base = static_cast<const std::byte*>(module_base_address);
+
+        // Read magic to determine architecture
+        std::uint32_t magic{};
+        std::memcpy(&magic, base, sizeof(magic));
+
+        if (magic == mh_magic_64 || magic == mh_cigam_64)
+            return scan_in_module_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(base, pattern,
+                                                                                                 target_section_name);
+
+        if (magic == mh_magic_32 || magic == mh_cigam_32)
+            return scan_in_module_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(base, pattern,
+                                                                                              target_section_name);
+
+        return std::nullopt;
+    }
+
+    std::optional<SectionScanResult>
+    MachOPatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                  const std::string_view& pattern,
+                                                  const std::string_view& target_section_name)
+    {
+        const auto macho_section = get_macho_section_by_name(path_to_file, target_section_name);
+
+        if (!macho_section.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        const auto scan_result =
+                PatternScanner::scan_for_pattern(macho_section->data.cbegin(), macho_section->data.cend(), pattern);
+
+        if (scan_result == macho_section->data.cend())
+            return std::nullopt;
+
+        const auto offset = std::distance(macho_section->data.begin(), scan_result);
+
+        return SectionScanResult{.virtual_base_addr = macho_section->virtual_base_addr,
+                                 .raw_base_addr = macho_section->raw_base_addr,
+                                 .target_offset = offset};
+    }
+} // namespace omath

source/utility/pe_pattern_scan.cpp

@@ -237,7 +237,7 @@ namespace
                           variant);
     }
 
-    struct ExtractedSection
+    struct ExtractedSection final
     {
         std::uintptr_t virtual_base_addr;
         std::uintptr_t raw_base_addr;

tests/CMakeLists.txt

@@ -7,14 +7,15 @@ include(GoogleTest)
 file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
 add_executable(${PROJECT_NAME} ${UNIT_TESTS_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 gtest) # GTest is being linked as submodule
+if(TARGET gtest) # GTest is being linked as submodule
     target_link_libraries(${PROJECT_NAME} PRIVATE gtest gtest_main omath::omath)
 else() # GTest is being linked as vcpkg package
     find_package(GTest CONFIG REQUIRED)
@@ -30,7 +31,8 @@ if(OMATH_ENABLE_VALGRIND)
     omath_setup_valgrind(${PROJECT_NAME})
 endif()
 
-# Skip test discovery for Android/iOS builds or when cross-compiling - binaries cannot run on host
-if (NOT (ANDROID OR IOS OR EMSCRIPTEN))
+# Skip test discovery for Android/iOS builds or when cross-compiling - binaries
+# cannot run on host
+if(NOT (ANDROID OR IOS OR EMSCRIPTEN))
     gtest_discover_tests(${PROJECT_NAME})
 endif()

tests/engines/unit_test_cry_engine.cpp

@@ -0,0 +1,240 @@
+//
+// Created by Vladislav on 19.02.2026.
+//
+#include <gtest/gtest.h>
+#include <omath/engines/cry_engine/camera.hpp>
+#include <omath/engines/cry_engine/constants.hpp>
+#include <omath/engines/cry_engine/formulas.hpp>
+#include <random>
+#include <ranges>
+
+using namespace omath;
+TEST(unit_test_cry_engine, look_at_forward)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), cry_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_cry_engine, look_at_right)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), cry_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_cry_engine, look_at_up)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), cry_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_cry_engine, look_at_back)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, -cry_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-cry_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_cry_engine, look_at_left)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, -cry_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-cry_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_cry_engine, look_at_down)
+{
+    const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, -cry_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = cry_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-cry_engine::k_abs_up).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_cry_engine, RightVector)
+{
+    const auto right = omath::cry_engine::right_vector({});
+
+    EXPECT_EQ(right, omath::cry_engine::k_abs_right);
+}
+
+TEST(unit_test_cry_engine, UpVector)
+{
+    const auto up = omath::cry_engine::up_vector({});
+    EXPECT_EQ(up, omath::cry_engine::k_abs_up);
+}
+
+TEST(unit_test_cry_engine, ProjectTargetMovedFromCamera)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.01f, 1000.f);
+
+    for (float distance = 0.02f; distance < 100.f; distance += 0.01f)
+    {
+        const auto projected = cam.world_to_screen({0, distance, 0});
+
+        EXPECT_TRUE(projected.has_value());
+
+        if (!projected.has_value())
+            continue;
+
+        EXPECT_NEAR(projected->x, 640, 0.00001f);
+        EXPECT_NEAR(projected->y, 360, 0.00001f);
+    }
+}
+
+TEST(unit_test_cry_engine, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
+
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+
+TEST(unit_test_cry_engine, CameraSetAndGetOrigin)
+{
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
+
+    EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
+}
+TEST(unit_test_cry_engine, loook_at_random_all_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.0001f || std::abs(projected_pos->y - 0.f) >= 0.0001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_cry_engine, loook_at_random_x_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{dist(gen), 0.f, 0.f};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.001f || std::abs(projected_pos->y - 0.f) >= 0.001f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_cry_engine, loook_at_random_y_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_cry_engine, loook_at_random_z_axis)
+{
+    std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
+    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::cry_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
+
+    std::size_t failed_points = 0;
+    for (int i = 0; i < 1000; i++)
+    {
+        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+        if (cam.get_origin().distance_to(position_to_look) < 10)
+            continue;
+
+        cam.look_at(position_to_look);
+
+        auto projected_pos = cam.world_to_view_port(position_to_look);
+
+        EXPECT_TRUE(projected_pos.has_value());
+
+        if (!projected_pos)
+            continue;
+
+        if (std::abs(projected_pos->x - 0.f) >= 0.01f || std::abs(projected_pos->y - 0.f) >= 0.01f)
+            failed_points++;
+    }
+    EXPECT_LE(failed_points, 100);
+}

tests/engines/unit_test_frostbite_engine.cpp

@@ -7,7 +7,127 @@
 #include <omath/engines/frostbite_engine/formulas.hpp>
 #include <print>
 #include <random>
+#include <ranges>
 
+TEST(unit_test_frostbite_engine, UnitsToCentimeters_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::units_to_centimeters(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::units_to_centimeters(1.0f), 0.01f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::units_to_centimeters(100.0f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::units_to_centimeters(-250.0f), -2.5f);
+}
+
+TEST(unit_test_frostbite_engine, UnitsToMeters_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::units_to_meters(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::units_to_meters(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::units_to_meters(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::units_to_meters(-42.0), -42.0);
+}
+
+TEST(unit_test_frostbite_engine, UnitsToKilometers_BasicValues)
+{
+    EXPECT_NEAR(omath::frostbite_engine::units_to_kilometers(0.0), 0.0, 1e-15);
+    EXPECT_NEAR(omath::frostbite_engine::units_to_kilometers(1.0), 0.001, 1e-15);
+    EXPECT_NEAR(omath::frostbite_engine::units_to_kilometers(1000.0), 1.0, 1e-12);
+    EXPECT_NEAR(omath::frostbite_engine::units_to_kilometers(-2500.0), -2.5, 1e-12);
+}
+
+TEST(unit_test_frostbite_engine, CentimetersToUnits_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::centimeters_to_units(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::centimeters_to_units(0.01f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::centimeters_to_units(1.0f), 100.0f);
+    EXPECT_FLOAT_EQ(omath::frostbite_engine::centimeters_to_units(-2.5f), -250.0f);
+}
+
+TEST(unit_test_frostbite_engine, MetersToUnits_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::meters_to_units(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::meters_to_units(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::meters_to_units(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::frostbite_engine::meters_to_units(-42.0), -42.0);
+}
+
+TEST(unit_test_frostbite_engine, KilometersToUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::frostbite_engine::kilometers_to_units(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::frostbite_engine::kilometers_to_units(0.001), 1.0, 1e-12);
+    EXPECT_NEAR(omath::frostbite_engine::kilometers_to_units(1.0), 1000.0, 1e-9);
+    EXPECT_NEAR(omath::frostbite_engine::kilometers_to_units(-2.5), -2500.0, 1e-9);
+}
+
+TEST(unit_test_frostbite_engine, RoundTrip_UnitsCentimeters)
+{
+    constexpr float units_f = 12345.678f;
+    const auto cm_f = omath::frostbite_engine::units_to_centimeters(units_f);
+    const auto units_f_back = omath::frostbite_engine::centimeters_to_units(cm_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-3f);
+
+    constexpr double units_d = -987654.321;
+    const auto cm_d = omath::frostbite_engine::units_to_centimeters(units_d);
+    const auto units_d_back = omath::frostbite_engine::centimeters_to_units(cm_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-9);
+}
+
+TEST(unit_test_frostbite_engine, RoundTrip_UnitsMeters)
+{
+    constexpr float units_f = 5432.125f;
+    constexpr auto m_f = omath::frostbite_engine::units_to_meters(units_f);
+    constexpr auto units_f_back = omath::frostbite_engine::meters_to_units(m_f);
+    EXPECT_FLOAT_EQ(units_f_back, units_f);
+
+    constexpr double units_d = -123456.789;
+    constexpr auto m_d = omath::frostbite_engine::units_to_meters(units_d);
+    constexpr auto units_d_back = omath::frostbite_engine::meters_to_units(m_d);
+    EXPECT_DOUBLE_EQ(units_d_back, units_d);
+}
+
+TEST(unit_test_frostbite_engine, RoundTrip_UnitsKilometers)
+{
+    constexpr float units_f = 100000.0f;
+    constexpr auto km_f = omath::frostbite_engine::units_to_kilometers(units_f);
+    constexpr auto units_f_back = omath::frostbite_engine::kilometers_to_units(km_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-2f);
+
+    constexpr double units_d = -7654321.123;
+    constexpr auto km_d = omath::frostbite_engine::units_to_kilometers(units_d);
+    constexpr auto units_d_back = omath::frostbite_engine::kilometers_to_units(km_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-6);
+}
+
+TEST(unit_test_frostbite_engine, ConversionChainConsistency)
+{
+    const double units = 424242.42;
+
+    const auto cm_direct = omath::frostbite_engine::units_to_centimeters(units);
+    const auto cm_via_units = units / 100.0;
+    EXPECT_NEAR(cm_direct, cm_via_units, 1e-12);
+
+    const auto km_direct = omath::frostbite_engine::units_to_kilometers(units);
+    const auto km_via_meters = omath::frostbite_engine::units_to_meters(units) / 1000.0;
+    EXPECT_NEAR(km_direct, km_via_meters, 1e-12);
+}
+
+TEST(unit_test_frostbite_engine, SupportsFloatAndDouble)
+{
+    static_assert(std::is_same_v<decltype(omath::frostbite_engine::units_to_centimeters(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::frostbite_engine::units_to_centimeters(1.0)), double>);
+    static_assert(std::is_same_v<decltype(omath::frostbite_engine::meters_to_units(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::frostbite_engine::kilometers_to_units(1.0)), double>);
+}
+
+TEST(unit_test_frostbite_engine, ConstexprConversions)
+{
+    constexpr double units = 1000.0;
+    constexpr double cm = omath::frostbite_engine::units_to_centimeters(units);
+    constexpr double m = omath::frostbite_engine::units_to_meters(units);
+    constexpr double km = omath::frostbite_engine::units_to_kilometers(units);
+
+    static_assert(cm == 10.0, "units_to_centimeters constexpr failed");
+    static_assert(m == 1000.0, "units_to_meters constexpr failed");
+    static_assert(km == 1.0, "units_to_kilometers constexpr failed");
+}
 TEST(unit_test_frostbite_engine, ForwardVector)
 {
     const auto forward = omath::frostbite_engine::forward_vector({});
@@ -233,4 +353,55 @@ TEST(unit_test_frostbite_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
-}
+}
+TEST(unit_test_frostbite_engine, look_at_right)
+{
+    const auto angles = omath::frostbite_engine::CameraTrait::calc_look_at_angle({}, omath::frostbite_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::frostbite_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), omath::frostbite_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_frostbite_engine, look_at_up)
+{
+    const auto angles = omath::frostbite_engine::CameraTrait::calc_look_at_angle({}, omath::frostbite_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::frostbite_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), omath::frostbite_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_frostbite_engine, look_at_back)
+{
+    const auto angles = omath::frostbite_engine::CameraTrait::calc_look_at_angle({}, -omath::frostbite_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::frostbite_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::frostbite_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_frostbite_engine, look_at_left)
+{
+    const auto angles = omath::frostbite_engine::CameraTrait::calc_look_at_angle({}, -omath::frostbite_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::frostbite_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::frostbite_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_frostbite_engine, look_at_down)
+{
+    const auto angles = omath::frostbite_engine::CameraTrait::calc_look_at_angle({}, -omath::frostbite_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::frostbite_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::frostbite_engine::k_abs_up).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}

tests/engines/unit_test_iw_engine.cpp

@@ -6,6 +6,7 @@
 #include <omath/engines/iw_engine/constants.hpp>
 #include <omath/engines/iw_engine/formulas.hpp>
 #include <random>
+#include <ranges>
 
 TEST(unit_test_iw_engine, ForwardVector)
 {
@@ -223,4 +224,60 @@ TEST(unit_test_iw_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
+}
+TEST(unit_test_iw_engine, look_at_forward)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, omath::iw_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::iw_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_iw_engine, look_at_right)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, omath::iw_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::iw_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_iw_engine, look_at_up)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, omath::iw_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::iw_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_iw_engine, look_at_back)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, -omath::iw_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::iw_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_iw_engine, look_at_left)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, -omath::iw_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::iw_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_iw_engine, look_at_down)
+{
+    const auto angles = omath::iw_engine::CameraTrait::calc_look_at_angle({}, -omath::iw_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::iw_engine::forward_vector(angles);
+    EXPECT_NEAR(dir_vector.z, -0.99984f, 0.0001f);
+    EXPECT_NEAR(dir_vector.x,- 0.017f, 0.01f);
+    EXPECT_NEAR(dir_vector.y, 0.f, 0.001f);
 }

tests/engines/unit_test_open_gl.cpp

@@ -6,7 +6,127 @@
 #include <omath/engines/opengl_engine/constants.hpp>
 #include <omath/engines/opengl_engine/formulas.hpp>
 #include <random>
+#include <ranges>
 
+TEST(unit_test_opengl, UnitsToCentimeters_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::opengl_engine::units_to_centimeters(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::units_to_centimeters(1.0f), 0.01f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::units_to_centimeters(100.0f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::units_to_centimeters(-250.0f), -2.5f);
+}
+
+TEST(unit_test_opengl, UnitsToMeters_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::units_to_meters(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::units_to_meters(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::units_to_meters(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::units_to_meters(-42.0), -42.0);
+}
+
+TEST(unit_test_opengl, UnitsToKilometers_BasicValues)
+{
+    EXPECT_NEAR(omath::opengl_engine::units_to_kilometers(0.0), 0.0, 1e-15);
+    EXPECT_NEAR(omath::opengl_engine::units_to_kilometers(1.0), 0.001, 1e-15);
+    EXPECT_NEAR(omath::opengl_engine::units_to_kilometers(1000.0), 1.0, 1e-12);
+    EXPECT_NEAR(omath::opengl_engine::units_to_kilometers(-2500.0), -2.5, 1e-12);
+}
+
+TEST(unit_test_opengl, CentimetersToUnits_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::opengl_engine::centimeters_to_units(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::centimeters_to_units(0.01f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::centimeters_to_units(1.0f), 100.0f);
+    EXPECT_FLOAT_EQ(omath::opengl_engine::centimeters_to_units(-2.5f), -250.0f);
+}
+
+TEST(unit_test_opengl, MetersToUnits_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::meters_to_units(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::meters_to_units(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::meters_to_units(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::opengl_engine::meters_to_units(-42.0), -42.0);
+}
+
+TEST(unit_test_opengl, KilometersToUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::opengl_engine::kilometers_to_units(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::opengl_engine::kilometers_to_units(0.001), 1.0, 1e-12);
+    EXPECT_NEAR(omath::opengl_engine::kilometers_to_units(1.0), 1000.0, 1e-9);
+    EXPECT_NEAR(omath::opengl_engine::kilometers_to_units(-2.5), -2500.0, 1e-9);
+}
+
+TEST(unit_test_opengl, RoundTrip_UnitsCentimeters)
+{
+    constexpr float units_f = 12345.678f;
+    const auto cm_f = omath::opengl_engine::units_to_centimeters(units_f);
+    const auto units_f_back = omath::opengl_engine::centimeters_to_units(cm_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-3f);
+
+    constexpr double units_d = -987654.321;
+    const auto cm_d = omath::opengl_engine::units_to_centimeters(units_d);
+    const auto units_d_back = omath::opengl_engine::centimeters_to_units(cm_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-9);
+}
+
+TEST(unit_test_opengl, RoundTrip_UnitsMeters)
+{
+    constexpr float units_f = 5432.125f;
+    const auto m_f = omath::opengl_engine::units_to_meters(units_f);
+    const auto units_f_back = omath::opengl_engine::meters_to_units(m_f);
+    EXPECT_FLOAT_EQ(units_f_back, units_f);
+
+    constexpr double units_d = -123456.789;
+    const auto m_d = omath::opengl_engine::units_to_meters(units_d);
+    const auto units_d_back = omath::opengl_engine::meters_to_units(m_d);
+    EXPECT_DOUBLE_EQ(units_d_back, units_d);
+}
+
+TEST(unit_test_opengl, RoundTrip_UnitsKilometers)
+{
+    constexpr float units_f = 100000.0f;
+    const auto km_f = omath::opengl_engine::units_to_kilometers(units_f);
+    const auto units_f_back = omath::opengl_engine::kilometers_to_units(km_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-2f);
+
+    constexpr double units_d = -7654321.123;
+    const auto km_d = omath::opengl_engine::units_to_kilometers(units_d);
+    const auto units_d_back = omath::opengl_engine::kilometers_to_units(km_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-6);
+}
+
+TEST(unit_test_opengl, ConversionChainConsistency)
+{
+    const double units = 424242.42;
+
+    const auto cm_direct = omath::opengl_engine::units_to_centimeters(units);
+    const auto cm_via_units = units / 100.0;
+    EXPECT_NEAR(cm_direct, cm_via_units, 1e-12);
+
+    const auto km_direct = omath::opengl_engine::units_to_kilometers(units);
+    const auto km_via_meters = omath::opengl_engine::units_to_meters(units) / 1000.0;
+    EXPECT_NEAR(km_direct, km_via_meters, 1e-12);
+}
+
+TEST(unit_test_opengl, SupportsFloatAndDouble)
+{
+    static_assert(std::is_same_v<decltype(omath::opengl_engine::units_to_centimeters(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::opengl_engine::units_to_centimeters(1.0)), double>);
+    static_assert(std::is_same_v<decltype(omath::opengl_engine::meters_to_units(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::opengl_engine::kilometers_to_units(1.0)), double>);
+}
+
+TEST(unit_test_opengl, ConstexprConversions)
+{
+    constexpr double units = 1000.0;
+    constexpr double cm = omath::opengl_engine::units_to_centimeters(units);
+    constexpr double m = omath::opengl_engine::units_to_meters(units);
+    constexpr double km = omath::opengl_engine::units_to_kilometers(units);
+
+    static_assert(cm == 10.0, "units_to_centimeters constexpr failed");
+    static_assert(m == 1000.0, "units_to_meters constexpr failed");
+    static_assert(km == 1.0, "units_to_kilometers constexpr failed");
+}
 TEST(unit_test_opengl, ForwardVector)
 {
     const auto forward = omath::opengl_engine::forward_vector({});
@@ -218,4 +338,60 @@ TEST(unit_test_opengl_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
+}
+
+TEST(unit_test_opengl_engine, look_at_forward)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, omath::opengl_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::opengl_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_opengl_engine, look_at_right)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, omath::opengl_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::opengl_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_opengl_engine, look_at_up)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, omath::opengl_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::opengl_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_opengl_engine, look_at_back)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, -omath::opengl_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::opengl_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_opengl_engine, look_at_left)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, -omath::opengl_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::opengl_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_opengl_engine, look_at_down)
+{
+    const auto angles = omath::opengl_engine::CameraTrait::calc_look_at_angle({}, -omath::opengl_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::opengl_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::opengl_engine::k_abs_up).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
 }

tests/engines/unit_test_source_engine.cpp

@@ -6,6 +6,130 @@
 #include <omath/engines/source_engine/constants.hpp>
 #include <omath/engines/source_engine/formulas.hpp>
 #include <random>
+#include <ranges>
+
+TEST(unit_test_source_engine_units, HammerUnitsToCentimeters_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::source_engine::units_to_centimeters(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::source_engine::units_to_centimeters(1.0f), 2.54f);
+    EXPECT_FLOAT_EQ(omath::source_engine::units_to_centimeters(10.0f), 25.4f);
+    EXPECT_FLOAT_EQ(omath::source_engine::units_to_centimeters(-2.0f), -5.08f);
+}
+
+TEST(unit_test_source_engine_units, HammerUnitsToMeters_BasicValues)
+{
+    EXPECT_NEAR(omath::source_engine::units_to_meters(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::source_engine::units_to_meters(1.0), 0.0254, 1e-12);
+    EXPECT_NEAR(omath::source_engine::units_to_meters(100.0), 2.54, 1e-12);
+    EXPECT_NEAR(omath::source_engine::units_to_meters(-4.0), -0.1016, 1e-12);
+}
+
+TEST(unit_test_source_engine_units, HammerUnitsToKilometers_BasicValues)
+{
+    EXPECT_NEAR(omath::source_engine::units_to_kilometers(0.0), 0.0, 1e-15);
+    EXPECT_NEAR(omath::source_engine::units_to_kilometers(1.0), 0.0000254, 1e-15);
+    EXPECT_NEAR(omath::source_engine::units_to_kilometers(1000.0), 0.0254, 1e-15);
+    EXPECT_NEAR(omath::source_engine::units_to_kilometers(-10.0), -0.000254, 1e-15);
+}
+
+TEST(unit_test_source_engine_units, CentimetersToHammerUnits_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::source_engine::centimeters_to_units(0.0f), 0.0f);
+    EXPECT_NEAR(omath::source_engine::centimeters_to_units(2.54f), 1.0f, 1e-6f);
+    EXPECT_NEAR(omath::source_engine::centimeters_to_units(25.4f), 10.0f, 1e-5f);
+    EXPECT_NEAR(omath::source_engine::centimeters_to_units(-5.08f), -2.0f, 1e-6f);
+}
+
+TEST(unit_test_source_engine_units, MetersToHammerUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::source_engine::meters_to_units(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::source_engine::meters_to_units(0.0254), 1.0, 1e-12);
+    EXPECT_NEAR(omath::source_engine::meters_to_units(2.54), 100.0, 1e-10);
+    EXPECT_NEAR(omath::source_engine::meters_to_units(-0.0508), -2.0, 1e-12);
+}
+
+TEST(unit_test_source_engine_units, KilometersToHammerUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::source_engine::kilometers_to_units(0.0), 0.0, 1e-9);
+    EXPECT_NEAR(omath::source_engine::kilometers_to_units(0.0000254), 1.0, 1e-9);
+    EXPECT_NEAR(omath::source_engine::kilometers_to_units(0.00254), 100.0, 1e-7);
+    EXPECT_NEAR(omath::source_engine::kilometers_to_units(-0.0000508), -2.0, 1e-9);
+}
+
+TEST(unit_test_source_engine_units, RoundTrip_HammerToCentimetersToHammer)
+{
+    constexpr float hu_f = 123.456f;
+    constexpr auto cm_f = omath::source_engine::units_to_centimeters(hu_f);
+    constexpr auto hu_f_back = omath::source_engine::centimeters_to_units(cm_f);
+    EXPECT_NEAR(hu_f_back, hu_f, 1e-5f);
+
+    constexpr double hu_d = -98765.4321;
+    constexpr auto cm_d = omath::source_engine::units_to_centimeters(hu_d);
+    constexpr auto hu_d_back = omath::source_engine::centimeters_to_units(cm_d);
+    EXPECT_NEAR(hu_d_back, hu_d, 1e-10);
+}
+
+TEST(unit_test_source_engine_units, RoundTrip_HammerToMetersToHammer)
+{
+    constexpr float hu_f = 2500.25f;
+    constexpr auto m_f = omath::source_engine::units_to_meters(hu_f);
+    constexpr auto hu_f_back = omath::source_engine::meters_to_units(m_f);
+    EXPECT_NEAR(hu_f_back, hu_f, 1e-4f);
+
+    constexpr double hu_d = -42000.125;
+    constexpr auto m_d = omath::source_engine::units_to_meters(hu_d);
+    constexpr auto hu_d_back = omath::source_engine::meters_to_units(m_d);
+    EXPECT_NEAR(hu_d_back, hu_d, 1e-10);
+}
+
+TEST(unit_test_source_engine_units, RoundTrip_HammerToKilometersToHammer)
+{
+    constexpr float hu_f = 100000.0f;
+    constexpr auto km_f = omath::source_engine::units_to_kilometers(hu_f);
+    constexpr auto hu_f_back = omath::source_engine::kilometers_to_units(km_f);
+    EXPECT_NEAR(hu_f_back, hu_f, 1e-2f); // looser due to float scaling
+
+    constexpr double hu_d = -1234567.89;
+    constexpr auto km_d = omath::source_engine::units_to_kilometers(hu_d);
+    constexpr auto hu_d_back = omath::source_engine::kilometers_to_units(km_d);
+    EXPECT_NEAR(hu_d_back, hu_d, 1e-7);
+}
+
+TEST(unit_test_source_engine_units, ConversionChainConsistency)
+{
+    // hu -> cm -> m -> km should match direct helpers
+    constexpr auto hu = 54321.123;
+
+    constexpr auto cm = omath::source_engine::units_to_centimeters(hu);
+    constexpr auto m_via_cm = cm / 100.0;
+    constexpr auto km_via_cm = m_via_cm / 1000.0;
+
+    constexpr auto m_direct = omath::source_engine::units_to_meters(hu);
+    constexpr auto km_direct = omath::source_engine::units_to_kilometers(hu);
+
+    EXPECT_NEAR(m_direct, m_via_cm, 1e-12);
+    EXPECT_NEAR(km_direct, km_via_cm, 1e-15);
+}
+
+TEST(unit_test_source_engine_units, SupportsFloatAndDoubleTypes)
+{
+    static_assert(std::is_same_v<decltype(omath::source_engine::units_to_centimeters(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::source_engine::units_to_centimeters(1.0)), double>);
+    static_assert(std::is_same_v<decltype(omath::source_engine::meters_to_units(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::source_engine::kilometers_to_units(1.0)), double>);
+}
+
+TEST(unit_test_source_engine_units, ConstexprEvaluation)
+{
+    constexpr double hu = 10.0;
+    constexpr double cm = omath::source_engine::units_to_centimeters(hu);
+    constexpr double m = omath::source_engine::units_to_meters(hu);
+    constexpr double km = omath::source_engine::units_to_kilometers(hu);
+
+    static_assert(cm == 25.4, "constexpr hu->cm failed");
+    static_assert(m == 0.254, "constexpr hu->m failed");
+    static_assert(km == 0.000254, "constexpr hu->km failed");
+}
 
 TEST(unit_test_source_engine, ForwardVector)
 {
@@ -242,4 +366,60 @@ TEST(unit_test_source_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
+}
+TEST(unit_test_source_engine, look_at_forward)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, omath::source_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::source_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_source_engine, look_at_right)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, omath::source_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::source_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_source_engine, look_at_up)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, omath::source_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::source_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_source_engine, look_at_back)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, -omath::source_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::source_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_source_engine, look_at_left)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, -omath::source_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::source_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_source_engine, look_at_down)
+{
+    const auto angles = omath::source_engine::CameraTrait::calc_look_at_angle({}, -omath::source_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::source_engine::forward_vector(angles);
+    EXPECT_NEAR(dir_vector.z, -0.99984f, 0.0001f);
+    EXPECT_NEAR(dir_vector.x,- 0.017f, 0.01f);
+    EXPECT_NEAR(dir_vector.y, 0.f, 0.001f);
 }

tests/engines/unit_test_unity_engine.cpp

@@ -7,6 +7,127 @@
 #include <omath/engines/unity_engine/formulas.hpp>
 #include <print>
 #include <random>
+#include <ranges>
+
+TEST(unit_test_unity_engine, UnitsToCentimeters_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::unity_engine::units_to_centimeters(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::units_to_centimeters(1.0f), 0.01f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::units_to_centimeters(100.0f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::units_to_centimeters(-250.0f), -2.5f);
+}
+
+TEST(unit_test_unity_engine, UnitsToMeters_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::unity_engine::units_to_meters(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::units_to_meters(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::units_to_meters(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::units_to_meters(-42.0), -42.0);
+}
+
+TEST(unit_test_unity_engine, UnitsToKilometers_BasicValues)
+{
+    EXPECT_NEAR(omath::unity_engine::units_to_kilometers(0.0), 0.0, 1e-15);
+    EXPECT_NEAR(omath::unity_engine::units_to_kilometers(1.0), 0.001, 1e-15);
+    EXPECT_NEAR(omath::unity_engine::units_to_kilometers(1000.0), 1.0, 1e-12);
+    EXPECT_NEAR(omath::unity_engine::units_to_kilometers(-2500.0), -2.5, 1e-12);
+}
+
+TEST(unit_test_unity_engine, CentimetersToUnits_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::unity_engine::centimeters_to_units(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::centimeters_to_units(0.01f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::centimeters_to_units(1.0f), 100.0f);
+    EXPECT_FLOAT_EQ(omath::unity_engine::centimeters_to_units(-2.5f), -250.0f);
+}
+
+TEST(unit_test_unity_engine, MetersToUnits_BasicValues)
+{
+    EXPECT_DOUBLE_EQ(omath::unity_engine::meters_to_units(0.0), 0.0);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::meters_to_units(1.0), 1.0);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::meters_to_units(123.456), 123.456);
+    EXPECT_DOUBLE_EQ(omath::unity_engine::meters_to_units(-42.0), -42.0);
+}
+
+TEST(unit_test_unity_engine, KilometersToUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::unity_engine::kilometers_to_units(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::unity_engine::kilometers_to_units(0.001), 1.0, 1e-12);
+    EXPECT_NEAR(omath::unity_engine::kilometers_to_units(1.0), 1000.0, 1e-9);
+    EXPECT_NEAR(omath::unity_engine::kilometers_to_units(-2.5), -2500.0, 1e-9);
+}
+
+TEST(unit_test_unity_engine, RoundTrip_UnitsCentimeters)
+{
+    constexpr float units_f = 12345.678f;
+    constexpr auto cm_f = omath::unity_engine::units_to_centimeters(units_f);
+    constexpr auto units_f_back = omath::unity_engine::centimeters_to_units(cm_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-3f);
+
+    constexpr double units_d = -987654.321;
+    constexpr auto cm_d = omath::unity_engine::units_to_centimeters(units_d);
+    constexpr auto units_d_back = omath::unity_engine::centimeters_to_units(cm_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-9);
+}
+
+TEST(unit_test_unity_engine, RoundTrip_UnitsMeters)
+{
+    constexpr float units_f = 5432.125f;
+    constexpr auto m_f = omath::unity_engine::units_to_meters(units_f);
+    constexpr auto units_f_back = omath::unity_engine::meters_to_units(m_f);
+    EXPECT_FLOAT_EQ(units_f_back, units_f);
+
+    constexpr double units_d = -123456.789;
+    constexpr auto m_d = omath::unity_engine::units_to_meters(units_d);
+    constexpr auto units_d_back = omath::unity_engine::meters_to_units(m_d);
+    EXPECT_DOUBLE_EQ(units_d_back, units_d);
+}
+
+TEST(unit_test_unity_engine, RoundTrip_UnitsKilometers)
+{
+    constexpr float units_f = 100000.0f;
+    constexpr auto km_f = omath::unity_engine::units_to_kilometers(units_f);
+    constexpr auto units_f_back = omath::unity_engine::kilometers_to_units(km_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-2f);
+
+    constexpr double units_d = -7654321.123;
+    constexpr auto km_d = omath::unity_engine::units_to_kilometers(units_d);
+    constexpr auto units_d_back = omath::unity_engine::kilometers_to_units(km_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-6);
+}
+
+TEST(unit_test_unity_engine, ConversionChainConsistency)
+{
+    constexpr double units = 424242.42;
+
+    constexpr auto cm_direct = omath::unity_engine::units_to_centimeters(units);
+    constexpr auto cm_via_units = units / 100.0;
+    EXPECT_NEAR(cm_direct, cm_via_units, 1e-12);
+
+    constexpr auto km_direct = omath::unity_engine::units_to_kilometers(units);
+    constexpr auto km_via_meters = omath::unity_engine::units_to_meters(units) / 1000.0;
+    EXPECT_NEAR(km_direct, km_via_meters, 1e-12);
+}
+
+TEST(unit_test_unity_engine, SupportsFloatAndDouble)
+{
+    static_assert(std::is_same_v<decltype(omath::unity_engine::units_to_centimeters(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::unity_engine::units_to_centimeters(1.0)), double>);
+    static_assert(std::is_same_v<decltype(omath::unity_engine::meters_to_units(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::unity_engine::kilometers_to_units(1.0)), double>);
+}
+
+TEST(unit_test_unity_engine, ConstexprConversions)
+{
+    constexpr double units = 1000.0;
+    constexpr double cm = omath::unity_engine::units_to_centimeters(units);
+    constexpr double m = omath::unity_engine::units_to_meters(units);
+    constexpr double km = omath::unity_engine::units_to_kilometers(units);
+
+    static_assert(cm == 10.0, "units_to_centimeters constexpr failed");
+    static_assert(m == 1000.0, "units_to_meters constexpr failed");
+    static_assert(km == 1.0, "units_to_kilometers constexpr failed");
+}
 
 TEST(unit_test_unity_engine, ForwardVector)
 {
@@ -87,7 +208,8 @@ TEST(unit_test_unity_engine, Project)
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
 
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
-    const auto proj = cam.world_to_screen<omath::unity_engine::Camera::ScreenStart::BOTTOM_LEFT_CORNER>({10.f, 3, 10.f});
+    const auto proj =
+            cam.world_to_screen<omath::unity_engine::Camera::ScreenStart::BOTTOM_LEFT_CORNER>({10.f, 3, 10.f});
 
     EXPECT_NEAR(proj->x, 1263.538, 0.001f);
     EXPECT_NEAR(proj->y, 547.061f, 0.001f);
@@ -233,4 +355,65 @@ TEST(unit_test_unity_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
-}
+}
+TEST(unit_test_unity_engine, look_at_forward)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, omath::unity_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), omath::unity_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unity_engine, look_at_right)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, omath::unity_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), omath::unity_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unity_engine, look_at_up)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, omath::unity_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), omath::unity_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_unity_engine, look_at_back)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, -omath::unity_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::unity_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unity_engine, look_at_left)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, -omath::unity_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::unity_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unity_engine, look_at_down)
+{
+    const auto angles = omath::unity_engine::CameraTrait::calc_look_at_angle({}, -omath::unity_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unity_engine::forward_vector(angles);
+    for (const auto& [result, etalon] :
+         std::views::zip(dir_vector.as_array(), (-omath::unity_engine::k_abs_up).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}

tests/engines/unit_test_unreal_engine.cpp

@@ -7,6 +7,7 @@
 #include <omath/engines/unreal_engine/formulas.hpp>
 #include <print>
 #include <random>
+#include <ranges>
 
 TEST(unit_test_unreal_engine, ForwardVector)
 {
@@ -238,4 +239,182 @@ TEST(unit_test_unreal_engine, loook_at_random_z_axis)
             failed_points++;
     }
     EXPECT_LE(failed_points, 100);
+}
+TEST(unit_test_unreal_engine, UnitsToCentimeters_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::unreal_engine::units_to_centimeters(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::units_to_centimeters(1.0f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::units_to_centimeters(250.0f), 250.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::units_to_centimeters(-42.5f), -42.5f);
+}
+
+TEST(unit_test_unreal_engine, UnitsToMeters_BasicValues)
+{
+    EXPECT_NEAR(omath::unreal_engine::units_to_meters(0.0), 0.0, 1e-15);
+    EXPECT_NEAR(omath::unreal_engine::units_to_meters(1.0), 0.01, 1e-15);
+    EXPECT_NEAR(omath::unreal_engine::units_to_meters(100.0), 1.0, 1e-12);
+    EXPECT_NEAR(omath::unreal_engine::units_to_meters(-250.0), -2.5, 1e-12);
+}
+
+TEST(unit_test_unreal_engine, UnitsToKilometers_BasicValues)
+{
+    EXPECT_NEAR(omath::unreal_engine::units_to_kilometers(0.0), 0.0, 1e-18);
+    EXPECT_NEAR(omath::unreal_engine::units_to_kilometers(1.0), 0.00001, 1e-18);
+    EXPECT_NEAR(omath::unreal_engine::units_to_kilometers(100000.0), 1.0, 1e-12);
+    EXPECT_NEAR(omath::unreal_engine::units_to_kilometers(-250000.0), -2.5, 1e-12);
+}
+
+TEST(unit_test_unreal_engine, CentimetersToUnits_BasicValues)
+{
+    EXPECT_FLOAT_EQ(omath::unreal_engine::centimeters_to_units(0.0f), 0.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::centimeters_to_units(1.0f), 1.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::centimeters_to_units(250.0f), 250.0f);
+    EXPECT_FLOAT_EQ(omath::unreal_engine::centimeters_to_units(-42.5f), -42.5f);
+}
+
+TEST(unit_test_unreal_engine, MetersToUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::unreal_engine::meters_to_units(0.0), 0.0, 1e-12);
+    EXPECT_NEAR(omath::unreal_engine::meters_to_units(0.01), 1.0, 1e-12);
+    EXPECT_NEAR(omath::unreal_engine::meters_to_units(1.0), 100.0, 1e-9);
+    EXPECT_NEAR(omath::unreal_engine::meters_to_units(-2.5), -250.0, 1e-9);
+}
+
+TEST(unit_test_unreal_engine, KilometersToUnits_BasicValues)
+{
+    EXPECT_NEAR(omath::unreal_engine::kilometers_to_units(0.0), 0.0, 1e-9);
+    EXPECT_NEAR(omath::unreal_engine::kilometers_to_units(0.00001), 1.0, 1e-9);
+    EXPECT_NEAR(omath::unreal_engine::kilometers_to_units(1.0), 100000.0, 1e-6);
+    EXPECT_NEAR(omath::unreal_engine::kilometers_to_units(-2.5), -250000.0, 1e-3);
+}
+
+TEST(unit_test_unreal_engine, RoundTrip_UnitsCentimeters)
+{
+    constexpr float units_f = 12345.678f;
+    constexpr auto cm_f = omath::unreal_engine::units_to_centimeters(units_f);
+    constexpr auto units_f_back = omath::unreal_engine::centimeters_to_units(cm_f);
+    EXPECT_FLOAT_EQ(units_f_back, units_f);
+
+    constexpr double units_d = -987654.321;
+    constexpr auto cm_d = omath::unreal_engine::units_to_centimeters(units_d);
+    constexpr auto units_d_back = omath::unreal_engine::centimeters_to_units(cm_d);
+    EXPECT_DOUBLE_EQ(units_d_back, units_d);
+}
+
+TEST(unit_test_unreal_engine, RoundTrip_UnitsMeters)
+{
+    constexpr float units_f = 5432.125f;
+    constexpr auto m_f = omath::unreal_engine::units_to_meters(units_f);
+    constexpr auto units_f_back = omath::unreal_engine::meters_to_units(m_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-3f);
+
+    constexpr double units_d = -123456.789;
+    constexpr auto m_d = omath::unreal_engine::units_to_meters(units_d);
+    constexpr auto units_d_back = omath::unreal_engine::meters_to_units(m_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-9);
+}
+
+TEST(unit_test_unreal_engine, RoundTrip_UnitsKilometers)
+{
+    constexpr float units_f = 100000.0f;
+    constexpr auto km_f = omath::unreal_engine::units_to_kilometers(units_f);
+    constexpr auto units_f_back = omath::unreal_engine::kilometers_to_units(km_f);
+    EXPECT_NEAR(units_f_back, units_f, 1e-2f);
+
+    constexpr double units_d = -7654321.123;
+    constexpr auto km_d = omath::unreal_engine::units_to_kilometers(units_d);
+    constexpr auto units_d_back = omath::unreal_engine::kilometers_to_units(km_d);
+    EXPECT_NEAR(units_d_back, units_d, 1e-6);
+}
+
+TEST(unit_test_unreal_engine, ConversionChainConsistency)
+{
+    constexpr double units = 424242.42;
+
+    constexpr auto cm_direct = omath::unreal_engine::units_to_centimeters(units);
+    constexpr auto cm_expected = units; // 1 uu == 1 cm
+    EXPECT_NEAR(cm_direct, cm_expected, 1e-12);
+
+    constexpr auto m_direct = omath::unreal_engine::units_to_meters(units);
+    constexpr auto m_via_cm = cm_direct / 100.0;
+    EXPECT_NEAR(m_direct, m_via_cm, 1e-12);
+
+    constexpr auto km_direct = omath::unreal_engine::units_to_kilometers(units);
+    constexpr auto km_via_m = m_direct / 1000.0;
+    EXPECT_NEAR(km_direct, km_via_m, 1e-15);
+}
+
+TEST(unit_test_unreal_engine, SupportsFloatAndDouble)
+{
+    static_assert(std::is_same_v<decltype(omath::unreal_engine::units_to_centimeters(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::unreal_engine::units_to_centimeters(1.0)), double>);
+    static_assert(std::is_same_v<decltype(omath::unreal_engine::meters_to_units(1.0f)), float>);
+    static_assert(std::is_same_v<decltype(omath::unreal_engine::kilometers_to_units(1.0)), double>);
+}
+
+TEST(unit_test_unreal_engine, ConstexprConversions)
+{
+    constexpr double units = 100000.0;
+    constexpr double cm = omath::unreal_engine::units_to_centimeters(units);
+    constexpr double m = omath::unreal_engine::units_to_meters(units);
+    constexpr double km = omath::unreal_engine::units_to_kilometers(units);
+
+    static_assert(cm == 100000.0, "units_to_centimeters constexpr failed");
+    static_assert(m == 1000.0, "units_to_meters constexpr failed");
+    static_assert(km == 1.0, "units_to_kilometers constexpr failed");
+}
+TEST(unit_test_unreal_engine, look_at_forward)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, omath::unreal_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::unreal_engine::k_abs_forward.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unreal_engine, look_at_right)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, omath::unreal_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::unreal_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unreal_engine, look_at_up)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, omath::unreal_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), omath::unreal_engine::k_abs_right.as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+
+TEST(unit_test_unreal_engine, look_at_back)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, -omath::unreal_engine::k_abs_forward);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::unreal_engine::k_abs_forward).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unreal_engine, look_at_left)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, -omath::unreal_engine::k_abs_right);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::unreal_engine::k_abs_right).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
+}
+TEST(unit_test_unreal_engine, look_at_down)
+{
+    const auto angles = omath::unreal_engine::CameraTrait::calc_look_at_angle({}, -omath::unreal_engine::k_abs_up);
+
+    // ReSharper disable once CppTooWideScopeInitStatement
+    const auto dir_vector = omath::unreal_engine::forward_vector(angles);
+    for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::unreal_engine::k_abs_up).as_array()))
+        EXPECT_NEAR(result, etalon, 0.0001f);
 }

tests/general/unit_test_color_grouped.cpp

@@ -26,38 +26,38 @@ protected:
 TEST_F(UnitTestColorGrouped, Constructor_Float)
 {
     constexpr Color color(0.5f, 0.5f, 0.5f, 1.0f);
-    EXPECT_FLOAT_EQ(color.x, 0.5f);
-    EXPECT_FLOAT_EQ(color.y, 0.5f);
-    EXPECT_FLOAT_EQ(color.z, 0.5f);
-    EXPECT_FLOAT_EQ(color.w, 1.0f);
+    EXPECT_FLOAT_EQ(color.value().x, 0.5f);
+    EXPECT_FLOAT_EQ(color.value().y, 0.5f);
+    EXPECT_FLOAT_EQ(color.value().z, 0.5f);
+    EXPECT_FLOAT_EQ(color.value().w, 1.0f);
 }
 
 TEST_F(UnitTestColorGrouped, Constructor_Vector4)
 {
     constexpr omath::Vector4 vec(0.2f, 0.4f, 0.6f, 0.8f);
     constexpr Color color(vec);
-    EXPECT_FLOAT_EQ(color.x, 0.2f);
-    EXPECT_FLOAT_EQ(color.y, 0.4f);
-    EXPECT_FLOAT_EQ(color.z, 0.6f);
-    EXPECT_FLOAT_EQ(color.w, 0.8f);
+    EXPECT_FLOAT_EQ(color.value().x, 0.2f);
+    EXPECT_FLOAT_EQ(color.value().y, 0.4f);
+    EXPECT_FLOAT_EQ(color.value().z, 0.6f);
+    EXPECT_FLOAT_EQ(color.value().w, 0.8f);
 }
 
 TEST_F(UnitTestColorGrouped, FromRGBA)
 {
     constexpr Color color = Color::from_rgba(128, 64, 32, 255);
-    EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
-    EXPECT_FLOAT_EQ(color.y, 64.0f / 255.0f);
-    EXPECT_FLOAT_EQ(color.z, 32.0f / 255.0f);
-    EXPECT_FLOAT_EQ(color.w, 1.0f);
+    EXPECT_FLOAT_EQ(color.value().x, 128.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.value().y, 64.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.value().z, 32.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.value().w, 1.0f);
 }
 
 TEST_F(UnitTestColorGrouped, FromHSV)
 {
     constexpr Color color = Color::from_hsv(0.0f, 1.0f, 1.0f); // Red in HSV
-    EXPECT_FLOAT_EQ(color.x, 1.0f);
-    EXPECT_FLOAT_EQ(color.y, 0.0f);
-    EXPECT_FLOAT_EQ(color.z, 0.0f);
-    EXPECT_FLOAT_EQ(color.w, 1.0f);
+    EXPECT_FLOAT_EQ(color.value().x, 1.0f);
+    EXPECT_FLOAT_EQ(color.value().y, 0.0f);
+    EXPECT_FLOAT_EQ(color.value().z, 0.0f);
+    EXPECT_FLOAT_EQ(color.value().w, 1.0f);
 }
 
 TEST_F(UnitTestColorGrouped, ToHSV)
@@ -71,10 +71,10 @@ TEST_F(UnitTestColorGrouped, ToHSV)
 TEST_F(UnitTestColorGrouped, Blend)
 {
     const Color blended = color1.blend(color2, 0.5f);
-    EXPECT_FLOAT_EQ(blended.x, 0.5f);
-    EXPECT_FLOAT_EQ(blended.y, 0.5f);
-    EXPECT_FLOAT_EQ(blended.z, 0.0f);
-    EXPECT_FLOAT_EQ(blended.w, 1.0f);
+    EXPECT_FLOAT_EQ(blended.value().x, 0.5f);
+    EXPECT_FLOAT_EQ(blended.value().y, 0.5f);
+    EXPECT_FLOAT_EQ(blended.value().z, 0.0f);
+    EXPECT_FLOAT_EQ(blended.value().w, 1.0f);
 }
 
 TEST_F(UnitTestColorGrouped, PredefinedColors)
@@ -83,20 +83,20 @@ TEST_F(UnitTestColorGrouped, PredefinedColors)
     constexpr Color green = Color::green();
     constexpr Color blue = Color::blue();
 
-    EXPECT_FLOAT_EQ(red.x, 1.0f);
-    EXPECT_FLOAT_EQ(red.y, 0.0f);
-    EXPECT_FLOAT_EQ(red.z, 0.0f);
-    EXPECT_FLOAT_EQ(red.w, 1.0f);
+    EXPECT_FLOAT_EQ(red.value().x, 1.0f);
+    EXPECT_FLOAT_EQ(red.value().y, 0.0f);
+    EXPECT_FLOAT_EQ(red.value().z, 0.0f);
+    EXPECT_FLOAT_EQ(red.value().w, 1.0f);
 
-    EXPECT_FLOAT_EQ(green.x, 0.0f);
-    EXPECT_FLOAT_EQ(green.y, 1.0f);
-    EXPECT_FLOAT_EQ(green.z, 0.0f);
-    EXPECT_FLOAT_EQ(green.w, 1.0f);
+    EXPECT_FLOAT_EQ(green.value().x, 0.0f);
+    EXPECT_FLOAT_EQ(green.value().y, 1.0f);
+    EXPECT_FLOAT_EQ(green.value().z, 0.0f);
+    EXPECT_FLOAT_EQ(green.value().w, 1.0f);
 
-    EXPECT_FLOAT_EQ(blue.x, 0.0f);
-    EXPECT_FLOAT_EQ(blue.y, 0.0f);
-    EXPECT_FLOAT_EQ(blue.z, 1.0f);
-    EXPECT_FLOAT_EQ(blue.w, 1.0f);
+    EXPECT_FLOAT_EQ(blue.value().x, 0.0f);
+    EXPECT_FLOAT_EQ(blue.value().y, 0.0f);
+    EXPECT_FLOAT_EQ(blue.value().z, 1.0f);
+    EXPECT_FLOAT_EQ(blue.value().w, 1.0f);
 }
 
 TEST_F(UnitTestColorGrouped, BlendVector3)
@@ -104,9 +104,9 @@ TEST_F(UnitTestColorGrouped, BlendVector3)
     constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
     constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green
     constexpr Color blended = v1.blend(v2, 0.5f);
-    EXPECT_FLOAT_EQ(blended.x, 0.5f);
-    EXPECT_FLOAT_EQ(blended.y, 0.5f);
-    EXPECT_FLOAT_EQ(blended.z, 0.0f);
+    EXPECT_FLOAT_EQ(blended.value().x, 0.5f);
+    EXPECT_FLOAT_EQ(blended.value().y, 0.5f);
+    EXPECT_FLOAT_EQ(blended.value().z, 0.0f);
 }
 
 // From unit_test_color_extra.cpp
@@ -148,37 +148,37 @@ TEST(UnitTestColorGrouped_Extra, BlendEdgeCases)
     constexpr Color a = Color::red();
     constexpr Color b = Color::blue();
     constexpr auto r0 = a.blend(b, 0.f);
-    EXPECT_FLOAT_EQ(r0.x, a.x);
+    EXPECT_FLOAT_EQ(r0.value().x, a.value().x);
     constexpr auto r1 = a.blend(b, 1.f);
-    EXPECT_FLOAT_EQ(r1.x, b.x);
+    EXPECT_FLOAT_EQ(r1.value().x, b.value().x);
 }
 
 // From unit_test_color_more.cpp
 TEST(UnitTestColorGrouped_More, DefaultCtorIsZero)
 {
     constexpr Color c;
-    EXPECT_FLOAT_EQ(c.x, 0.0f);
-    EXPECT_FLOAT_EQ(c.y, 0.0f);
-    EXPECT_FLOAT_EQ(c.z, 0.0f);
-    EXPECT_FLOAT_EQ(c.w, 0.0f);
+    EXPECT_FLOAT_EQ(c.value().x, 0.0f);
+    EXPECT_FLOAT_EQ(c.value().y, 0.0f);
+    EXPECT_FLOAT_EQ(c.value().z, 0.0f);
+    EXPECT_FLOAT_EQ(c.value().w, 0.0f);
 }
 
 TEST(UnitTestColorGrouped_More, FloatCtorAndClampForRGB)
 {
     constexpr Color c(1.2f, -0.5f, 0.5f, 2.0f);
-    EXPECT_FLOAT_EQ(c.x, 1.0f);
-    EXPECT_FLOAT_EQ(c.y, 0.0f);
-    EXPECT_FLOAT_EQ(c.z, 0.5f);
-    EXPECT_FLOAT_EQ(c.w, 2.0f);
+    EXPECT_FLOAT_EQ(c.value().x, 1.0f);
+    EXPECT_FLOAT_EQ(c.value().y, 0.0f);
+    EXPECT_FLOAT_EQ(c.value().z, 0.5f);
+    EXPECT_FLOAT_EQ(c.value().w, 2.0f);
 }
 
 TEST(UnitTestColorGrouped_More, FromRgbaProducesScaledComponents)
 {
     constexpr Color c = Color::from_rgba(25u, 128u, 230u, 64u);
-    EXPECT_NEAR(c.x, 25.0f/255.0f, 1e-6f);
-    EXPECT_NEAR(c.y, 128.0f/255.0f, 1e-6f);
-    EXPECT_NEAR(c.z, 230.0f/255.0f, 1e-6f);
-    EXPECT_NEAR(c.w, 64.0f/255.0f, 1e-6f);
+    EXPECT_NEAR(c.value().x, 25.0f/255.0f, 1e-6f);
+    EXPECT_NEAR(c.value().y, 128.0f/255.0f, 1e-6f);
+    EXPECT_NEAR(c.value().z, 230.0f/255.0f, 1e-6f);
+    EXPECT_NEAR(c.value().w, 64.0f/255.0f, 1e-6f);
 }
 
 TEST(UnitTestColorGrouped_More, BlendProducesIntermediate)
@@ -186,10 +186,10 @@ TEST(UnitTestColorGrouped_More, BlendProducesIntermediate)
     constexpr Color c0(0.0f, 0.0f, 0.0f, 1.0f);
     constexpr Color c1(1.0f, 1.0f, 1.0f, 0.0f);
     constexpr Color mid = c0.blend(c1, 0.5f);
-    EXPECT_FLOAT_EQ(mid.x, 0.5f);
-    EXPECT_FLOAT_EQ(mid.y, 0.5f);
-    EXPECT_FLOAT_EQ(mid.z, 0.5f);
-    EXPECT_FLOAT_EQ(mid.w, 0.5f);
+    EXPECT_FLOAT_EQ(mid.value().x, 0.5f);
+    EXPECT_FLOAT_EQ(mid.value().y, 0.5f);
+    EXPECT_FLOAT_EQ(mid.value().z, 0.5f);
+    EXPECT_FLOAT_EQ(mid.value().w, 0.5f);
 }
 
 TEST(UnitTestColorGrouped_More, HsvRoundTrip)
@@ -197,9 +197,9 @@ TEST(UnitTestColorGrouped_More, HsvRoundTrip)
     constexpr Color red = Color::red();
     const auto hsv = red.to_hsv();
     const Color back = Color::from_hsv(hsv);
-    EXPECT_NEAR(back.x, 1.0f, 1e-6f);
-    EXPECT_NEAR(back.y, 0.0f, 1e-6f);
-    EXPECT_NEAR(back.z, 0.0f, 1e-6f);
+    EXPECT_NEAR(back.value().x, 1.0f, 1e-6f);
+    EXPECT_NEAR(back.value().y, 0.0f, 1e-6f);
+    EXPECT_NEAR(back.value().z, 0.0f, 1e-6f);
 }
 
 TEST(UnitTestColorGrouped_More, ToStringContainsComponents)
@@ -230,18 +230,18 @@ TEST(UnitTestColorGrouped_More2, FromHsvCases)
     auto check_hue = [&](float h) {
         SCOPED_TRACE(::testing::Message() << "h=" << h);
         Color c = Color::from_hsv(h, 1.f, 1.f);
-        EXPECT_TRUE(std::isfinite(c.x));
-        EXPECT_TRUE(std::isfinite(c.y));
-        EXPECT_TRUE(std::isfinite(c.z));
-        EXPECT_GE(c.x, -eps);
-        EXPECT_LE(c.x, 1.f + eps);
-        EXPECT_GE(c.y, -eps);
-        EXPECT_LE(c.y, 1.f + eps);
-        EXPECT_GE(c.z, -eps);
-        EXPECT_LE(c.z, 1.f + eps);
+        EXPECT_TRUE(std::isfinite(c.value().x));
+        EXPECT_TRUE(std::isfinite(c.value().y));
+        EXPECT_TRUE(std::isfinite(c.value().z));
+        EXPECT_GE(c.value().x, -eps);
+        EXPECT_LE(c.value().x, 1.f + eps);
+        EXPECT_GE(c.value().y, -eps);
+        EXPECT_LE(c.value().y, 1.f + eps);
+        EXPECT_GE(c.value().z, -eps);
+        EXPECT_LE(c.value().z, 1.f + eps);
 
-        float mx = std::max({c.x, c.y, c.z});
-        float mn = std::min({c.x, c.y, c.z});
+        float mx = std::max({c.value().x, c.value().y, c.value().z});
+        float mn = std::min({c.value().x, c.value().y, c.value().z});
         EXPECT_GE(mx, 0.999f);
         EXPECT_LE(mn, 1e-3f + 1e-4f);
     };
@@ -261,13 +261,13 @@ TEST(UnitTestColorGrouped_More2, ToHsvAndSetters)
     EXPECT_NEAR(hsv.value, 0.6f, 1e-6f);
 
     c.set_hue(0.0f);
-    EXPECT_TRUE(std::isfinite(c.x));
+    EXPECT_TRUE(std::isfinite(c.value().x));
 
     c.set_saturation(0.0f);
-    EXPECT_TRUE(std::isfinite(c.y));
+    EXPECT_TRUE(std::isfinite(c.value().y));
 
     c.set_value(0.5f);
-    EXPECT_TRUE(std::isfinite(c.z));
+    EXPECT_TRUE(std::isfinite(c.value().z));
 }
 
 TEST(UnitTestColorGrouped_More2, BlendAndStaticColors)
@@ -275,14 +275,14 @@ TEST(UnitTestColorGrouped_More2, BlendAndStaticColors)
     constexpr Color a = Color::red();
     constexpr Color b = Color::blue();
     constexpr auto mid = a.blend(b, 0.5f);
-    EXPECT_GT(mid.x, 0.f);
-    EXPECT_GT(mid.z, 0.f);
+    EXPECT_GT(mid.value().x, 0.f);
+    EXPECT_GT(mid.value().z, 0.f);
 
     constexpr auto all_a = a.blend(b, -1.f);
-    EXPECT_NEAR(all_a.x, a.x, 1e-6f);
+    EXPECT_NEAR(all_a.value().x, a.value().x, 1e-6f);
 
     constexpr auto all_b = a.blend(b, 2.f);
-    EXPECT_NEAR(all_b.z, b.z, 1e-6f);
+    EXPECT_NEAR(all_b.value().z, b.value().z, 1e-6f);
 }
 
 TEST(UnitTestColorGrouped_More2, FormatterUsesToString)
@@ -291,3 +291,35 @@ TEST(UnitTestColorGrouped_More2, FormatterUsesToString)
     const auto formatted = std::format("{}", c);
     EXPECT_NE(formatted.find("r:10"), std::string::npos);
 }
+
+TEST(UnitTestColorGrouped_More2, FormatterRgb)
+{
+    constexpr Color c = Color::from_rgba(255, 128, 0, 64);
+    const auto s = std::format("{:rgb}", c);
+    EXPECT_NE(s.find("r:255"), std::string::npos);
+    EXPECT_NE(s.find("g:128"), std::string::npos);
+    EXPECT_NE(s.find("b:0"), std::string::npos);
+    EXPECT_NE(s.find("a:64"), std::string::npos);
+}
+
+TEST(UnitTestColorGrouped_More2, FormatterRgbf)
+{
+    constexpr Color c(0.5f, 0.25f, 1.0f, 0.75f);
+    const auto s = std::format("{:rgbf}", c);
+    EXPECT_NE(s.find("r:"), std::string::npos);
+    EXPECT_NE(s.find("g:"), std::string::npos);
+    EXPECT_NE(s.find("b:"), std::string::npos);
+    EXPECT_NE(s.find("a:"), std::string::npos);
+    // Values should be in [0,1] float range, not 0-255
+    EXPECT_EQ(s.find("r:127"), std::string::npos);
+    EXPECT_EQ(s.find("r:255"), std::string::npos);
+}
+
+TEST(UnitTestColorGrouped_More2, FormatterHsv)
+{
+    const Color c = Color::red();
+    const auto s = std::format("{:hsv}", c);
+    EXPECT_NE(s.find("h:"), std::string::npos);
+    EXPECT_NE(s.find("s:"), std::string::npos);
+    EXPECT_NE(s.find("v:"), std::string::npos);
+}

tests/general/unit_test_epa_comprehensive.cpp

@@ -0,0 +1,471 @@
+//
+// Comprehensive EPA tests.
+// Covers: all 3 axis directions, multiple depth levels, penetration-vector
+// round-trips, depth monotonicity, symmetry, asymmetric sizes, memory
+// resource variants, tolerance sensitivity, and iteration bookkeeping.
+//
+#include <cmath>
+#include <gtest/gtest.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>;
+using Vec3     = omath::Vector3<float>;
+
+namespace
+{
+    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_ebo{};
+
+    constexpr Epa::Params k_default_params{ .max_iterations = 64, .tolerance = 1e-4f };
+
+    Collider make_cube(const Vec3& origin = {}, const Vec3& scale = { 1, 1, 1 })
+    {
+        Mesh m{ k_cube_vbo, k_empty_ebo, scale };
+        m.set_origin(origin);
+        return Collider{ m };
+    }
+
+    // Run GJK then EPA; asserts GJK hit and EPA converged.
+    Epa::Result solve(const Collider& a, const Collider& b,
+                      const Epa::Params& params = k_default_params)
+    {
+        const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+        EXPECT_TRUE(hit) << "GJK must detect collision before EPA can run";
+        auto result = Epa::solve(a, b, simplex, params);
+        EXPECT_TRUE(result.has_value()) << "EPA must converge";
+        return *result;
+    }
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Normal direction per axis
+// ---------------------------------------------------------------------------
+
+// For two unit cubes (half-extent 1) with B offset by d along an axis:
+//   depth = 2 - d   (distance from origin to nearest face of Minkowski diff)
+//   normal component along that axis ≈ ±1
+
+TEST(EpaComprehensive, NormalAlongX_Positive)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 }));
+    EXPECT_NEAR(std::abs(r.normal.x), 1.f, 1e-3f);
+    EXPECT_NEAR(r.normal.y, 0.f, 1e-3f);
+    EXPECT_NEAR(r.normal.z, 0.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, NormalAlongX_Negative)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ -0.5f, 0, 0 }));
+    EXPECT_NEAR(std::abs(r.normal.x), 1.f, 1e-3f);
+    EXPECT_NEAR(r.normal.y, 0.f, 1e-3f);
+    EXPECT_NEAR(r.normal.z, 0.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, NormalAlongY_Positive)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 0.5f, 0 }));
+    EXPECT_NEAR(r.normal.x, 0.f, 1e-3f);
+    EXPECT_NEAR(std::abs(r.normal.y), 1.f, 1e-3f);
+    EXPECT_NEAR(r.normal.z, 0.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, NormalAlongY_Negative)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, -0.5f, 0 }));
+    EXPECT_NEAR(r.normal.x, 0.f, 1e-3f);
+    EXPECT_NEAR(std::abs(r.normal.y), 1.f, 1e-3f);
+    EXPECT_NEAR(r.normal.z, 0.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, NormalAlongZ_Positive)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 0.5f }));
+    EXPECT_NEAR(r.normal.x, 0.f, 1e-3f);
+    EXPECT_NEAR(r.normal.y, 0.f, 1e-3f);
+    EXPECT_NEAR(std::abs(r.normal.z), 1.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, NormalAlongZ_Negative)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, -0.5f }));
+    EXPECT_NEAR(r.normal.x, 0.f, 1e-3f);
+    EXPECT_NEAR(r.normal.y, 0.f, 1e-3f);
+    EXPECT_NEAR(std::abs(r.normal.z), 1.f, 1e-3f);
+}
+
+// ---------------------------------------------------------------------------
+// Depth correctness  (depth = 2 - offset for unit cubes)
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, Depth_ShallowOverlap)
+{
+    // offset 1.9 → depth 0.1
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.9f, 0, 0 }));
+    EXPECT_NEAR(r.depth, 0.1f, 1e-2f);
+}
+
+TEST(EpaComprehensive, Depth_QuarterOverlap)
+{
+    // offset 1.5 → depth 0.5
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.5f, 0, 0 }));
+    EXPECT_NEAR(r.depth, 0.5f, 1e-2f);
+}
+
+TEST(EpaComprehensive, Depth_HalfOverlap)
+{
+    // offset 1.0 → depth 1.0
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.0f, 0, 0 }));
+    EXPECT_NEAR(r.depth, 1.0f, 1e-2f);
+}
+
+TEST(EpaComprehensive, Depth_ThreeQuarterOverlap)
+{
+    // offset 0.5 → depth 1.5
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 }));
+    EXPECT_NEAR(r.depth, 1.5f, 1e-2f);
+}
+
+TEST(EpaComprehensive, Depth_AlongY_HalfOverlap)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 1.0f, 0 }));
+    EXPECT_NEAR(r.depth, 1.0f, 1e-2f);
+}
+
+TEST(EpaComprehensive, Depth_AlongZ_HalfOverlap)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 1.0f }));
+    EXPECT_NEAR(r.depth, 1.0f, 1e-2f);
+}
+
+// ---------------------------------------------------------------------------
+// Depth monotonicity — deeper overlap → larger depth
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, DepthMonotonic_AlongX)
+{
+    const float d1 = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.9f, 0, 0 })).depth; // ~0.1
+    const float d2 = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.5f, 0, 0 })).depth; // ~0.5
+    const float d3 = solve(make_cube({ 0, 0, 0 }), make_cube({ 1.0f, 0, 0 })).depth; // ~1.0
+    const float d4 = solve(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 })).depth; // ~1.5
+
+    EXPECT_LT(d1, d2);
+    EXPECT_LT(d2, d3);
+    EXPECT_LT(d3, d4);
+}
+
+// ---------------------------------------------------------------------------
+// Normal is a unit vector
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, NormalIsUnit_AlongX)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 }));
+    EXPECT_NEAR(r.normal.dot(r.normal), 1.f, 1e-5f);
+}
+
+TEST(EpaComprehensive, NormalIsUnit_AlongY)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 1.2f, 0 }));
+    EXPECT_NEAR(r.normal.dot(r.normal), 1.f, 1e-5f);
+}
+
+TEST(EpaComprehensive, NormalIsUnit_AlongZ)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 0.8f }));
+    EXPECT_NEAR(r.normal.dot(r.normal), 1.f, 1e-5f);
+}
+
+// ---------------------------------------------------------------------------
+// Penetration vector = normal * depth
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, PenetrationVectorLength_EqualsDepth)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 }));
+    const float pen_len = std::sqrt(r.penetration_vector.dot(r.penetration_vector));
+    EXPECT_NEAR(pen_len, r.depth, 1e-5f);
+}
+
+TEST(EpaComprehensive, PenetrationVectorDirection_ParallelToNormal)
+{
+    const auto r = solve(make_cube({ 0, 0, 0 }), make_cube({ 0, 1.0f, 0 }));
+    // penetration_vector = normal * depth → cross product must be ~zero
+    const auto cross = r.penetration_vector.cross(r.normal);
+    EXPECT_NEAR(cross.dot(cross), 0.f, 1e-8f);
+}
+
+// ---------------------------------------------------------------------------
+// Round-trip: applying penetration_vector separates the shapes
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, RoundTrip_AlongX)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    Mesh mesh_b{ k_cube_vbo, k_empty_ebo };
+    mesh_b.set_origin({ 0.5f, 0, 0 });
+    const auto b = Collider{ mesh_b };
+
+    const auto r = solve(a, b);
+    constexpr float margin = 1.f + 1e-3f;
+
+    // Move B along the penetration vector; it should separate from A
+    Mesh mesh_sep{ k_cube_vbo, k_empty_ebo };
+    mesh_sep.set_origin(mesh_b.get_origin() + r.penetration_vector * margin);
+    EXPECT_FALSE(Gjk::is_collide(a, Collider{ mesh_sep })) << "Applying pen vector must separate";
+
+    // Moving the wrong way must still collide
+    Mesh mesh_wrong{ k_cube_vbo, k_empty_ebo };
+    mesh_wrong.set_origin(mesh_b.get_origin() - r.penetration_vector * margin);
+    EXPECT_TRUE(Gjk::is_collide(a, Collider{ mesh_wrong })) << "Opposite direction must still collide";
+}
+
+TEST(EpaComprehensive, RoundTrip_AlongY)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    Mesh mesh_b{ k_cube_vbo, k_empty_ebo };
+    mesh_b.set_origin({ 0, 0.8f, 0 });
+    const auto b = Collider{ mesh_b };
+
+    const auto r = solve(a, b);
+    constexpr float margin = 1.f + 1e-3f;
+
+    Mesh mesh_sep{ k_cube_vbo, k_empty_ebo };
+    mesh_sep.set_origin(mesh_b.get_origin() + r.penetration_vector * margin);
+    EXPECT_FALSE(Gjk::is_collide(a, Collider{ mesh_sep }));
+
+    Mesh mesh_wrong{ k_cube_vbo, k_empty_ebo };
+    mesh_wrong.set_origin(mesh_b.get_origin() - r.penetration_vector * margin);
+    EXPECT_TRUE(Gjk::is_collide(a, Collider{ mesh_wrong }));
+}
+
+TEST(EpaComprehensive, RoundTrip_AlongZ)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    Mesh mesh_b{ k_cube_vbo, k_empty_ebo };
+    mesh_b.set_origin({ 0, 0, 1.2f });
+    const auto b = Collider{ mesh_b };
+
+    const auto r = solve(a, b);
+    constexpr float margin = 1.f + 1e-3f;
+
+    Mesh mesh_sep{ k_cube_vbo, k_empty_ebo };
+    mesh_sep.set_origin(mesh_b.get_origin() + r.penetration_vector * margin);
+    EXPECT_FALSE(Gjk::is_collide(a, Collider{ mesh_sep }));
+}
+
+// ---------------------------------------------------------------------------
+// Symmetry — swapping A and B preserves depth
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, Symmetry_DepthIsIndependentOfOrder)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+
+    const float depth_ab = solve(a, b).depth;
+    const float depth_ba = solve(b, a).depth;
+
+    EXPECT_NEAR(depth_ab, depth_ba, 1e-2f);
+}
+
+TEST(EpaComprehensive, Symmetry_NormalsAreOpposite)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+
+    const Vec3 n_ab = solve(a, b).normal;
+    const Vec3 n_ba = solve(b, a).normal;
+
+    // The normals should be anti-parallel: n_ab · n_ba ≈ -1
+    EXPECT_NEAR(n_ab.dot(n_ba), -1.f, 1e-3f);
+}
+
+// ---------------------------------------------------------------------------
+// Asymmetric sizes
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, LargeVsSmall_DepthCorrect)
+{
+    // Big (half-ext 2) at origin, small (half-ext 0.5) at (2.0, 0, 0)
+    // Minkowski diff closest face in X at distance 0.5
+    const auto r = solve(make_cube({ 0, 0, 0 }, { 2, 2, 2 }), make_cube({ 2.0f, 0, 0 }, { 0.5f, 0.5f, 0.5f }));
+    EXPECT_NEAR(r.depth, 0.5f, 1e-2f);
+    EXPECT_NEAR(std::abs(r.normal.x), 1.f, 1e-3f);
+}
+
+TEST(EpaComprehensive, LargeVsSmall_RoundTrip)
+{
+    const auto a = make_cube({ 0, 0, 0 }, { 2, 2, 2 });
+
+    Mesh mesh_b{ k_cube_vbo, k_empty_ebo, { 0.5f, 0.5f, 0.5f } };
+    mesh_b.set_origin({ 2.0f, 0, 0 });
+    const auto b = Collider{ mesh_b };
+
+    const auto r = solve(a, b);
+    constexpr float margin = 1.f + 1e-3f;
+
+    Mesh mesh_sep{ k_cube_vbo, k_empty_ebo, { 0.5f, 0.5f, 0.5f } };
+    mesh_sep.set_origin(mesh_b.get_origin() + r.penetration_vector * margin);
+    EXPECT_FALSE(Gjk::is_collide(a, Collider{ mesh_sep }));
+}
+
+// ---------------------------------------------------------------------------
+// Memory resource variants
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, MonotonicBuffer_ConvergesCorrectly)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    constexpr std::size_t k_buf = 32768;
+    alignas(std::max_align_t) char buf[k_buf];
+    std::pmr::monotonic_buffer_resource mr{ buf, k_buf, std::pmr::null_memory_resource() };
+
+    const auto r = Epa::solve(a, b, simplex, k_default_params, mr);
+    ASSERT_TRUE(r.has_value());
+    EXPECT_NEAR(r->depth, 1.5f, 1e-2f);
+}
+
+TEST(EpaComprehensive, MonotonicBuffer_MultipleReleaseCycles)
+{
+    // Verify mr.release() correctly resets the buffer across multiple calls
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    constexpr std::size_t k_buf = 32768;
+    alignas(std::max_align_t) char buf[k_buf];
+    std::pmr::monotonic_buffer_resource mr{ buf, k_buf, std::pmr::null_memory_resource() };
+
+    float first_depth = 0.f;
+    for (int i = 0; i < 5; ++i)
+    {
+        mr.release();
+        const auto r = Epa::solve(a, b, simplex, k_default_params, mr);
+        ASSERT_TRUE(r.has_value()) << "solve must converge on iteration " << i;
+        if (i == 0)
+            first_depth = r->depth;
+        else
+            EXPECT_NEAR(r->depth, first_depth, 1e-6f) << "depth must be deterministic";
+    }
+}
+
+TEST(EpaComprehensive, DefaultResource_ConvergesCorrectly)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 1.0f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    const auto r = Epa::solve(a, b, simplex);
+    ASSERT_TRUE(r.has_value());
+    EXPECT_NEAR(r->depth, 1.0f, 1e-2f);
+}
+
+// ---------------------------------------------------------------------------
+// Tolerance sensitivity
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, TighterTolerance_MoreAccurateDepth)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 1.0f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    const Epa::Params loose{ .max_iterations = 64, .tolerance = 1e-2f };
+    const Epa::Params tight{ .max_iterations = 64, .tolerance = 1e-5f };
+
+    const auto r_loose = Epa::solve(a, b, simplex, loose);
+    const auto r_tight = Epa::solve(a, b, simplex, tight);
+    ASSERT_TRUE(r_loose.has_value());
+    ASSERT_TRUE(r_tight.has_value());
+
+    // Tighter tolerance must yield a result at least as accurate
+    EXPECT_LE(std::abs(r_tight->depth - 1.0f), std::abs(r_loose->depth - 1.0f) + 1e-4f);
+}
+
+// ---------------------------------------------------------------------------
+// Bookkeeping fields
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, Bookkeeping_IterationsInBounds)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+    const auto r = solve(a, b);
+
+    EXPECT_GT(r.iterations, 0);
+    EXPECT_LE(r.iterations, k_default_params.max_iterations);
+}
+
+TEST(EpaComprehensive, Bookkeeping_FacesAndVerticesGrow)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+    const auto r = solve(a, b);
+
+    // Started with a tetrahedron (4 faces, 4 vertices); EPA must have expanded it
+    EXPECT_GE(r.num_faces, 4);
+    EXPECT_GE(r.num_vertices, 4);
+}
+
+TEST(EpaComprehensive, Bookkeeping_MaxIterationsRespected)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.5f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    constexpr Epa::Params tight{ .max_iterations = 3, .tolerance = 1e-10f };
+    const auto r = Epa::solve(a, b, simplex, tight);
+
+    // Must return something (fallback best-face path) and respect the cap
+    if (r.has_value())
+        EXPECT_LE(r->iterations, tight.max_iterations);
+}
+
+// ---------------------------------------------------------------------------
+// Determinism
+// ---------------------------------------------------------------------------
+
+TEST(EpaComprehensive, Deterministic_SameResultOnRepeatedCalls)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 0.7f, 0, 0 });
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    ASSERT_TRUE(hit);
+
+    const auto first = Epa::solve(a, b, simplex);
+    ASSERT_TRUE(first.has_value());
+
+    for (int i = 0; i < 5; ++i)
+    {
+        const auto r = Epa::solve(a, b, simplex);
+        ASSERT_TRUE(r.has_value());
+        EXPECT_NEAR(r->depth, first->depth, 1e-6f);
+        EXPECT_NEAR(r->normal.x, first->normal.x, 1e-6f);
+        EXPECT_NEAR(r->normal.y, first->normal.y, 1e-6f);
+        EXPECT_NEAR(r->normal.z, first->normal.z, 1e-6f);
+    }
+}

tests/general/unit_test_gjk_comprehensive.cpp

@@ -0,0 +1,277 @@
+//
+// Comprehensive GJK tests.
+// Covers: all 6 axis directions, diagonal cases, boundary touching,
+// asymmetric sizes, nesting, symmetry, simplex info, far separation.
+//
+#include <gtest/gtest.h>
+#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 Vec3     = omath::Vector3<float>;
+
+namespace
+{
+    // Unit cube [-1, 1]^3 in local space.
+    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_ebo{};
+
+    Collider make_cube(const Vec3& origin = {}, const Vec3& scale = { 1, 1, 1 })
+    {
+        Mesh m{ k_cube_vbo, k_empty_ebo, scale };
+        m.set_origin(origin);
+        return Collider{ m };
+    }
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Separation — expect false
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, Separated_AlongPosX)
+{
+    // A extends to x=1, B starts at x=1.1 → clear gap
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 2.1f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, Separated_AlongNegX)
+{
+    // B to the left of A
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ -2.1f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, Separated_AlongPosY)
+{
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, 2.1f, 0 })));
+}
+
+TEST(GjkComprehensive, Separated_AlongNegY)
+{
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, -2.1f, 0 })));
+}
+
+TEST(GjkComprehensive, Separated_AlongPosZ)
+{
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 2.1f })));
+}
+
+TEST(GjkComprehensive, Separated_AlongNegZ)
+{
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, -2.1f })));
+}
+
+TEST(GjkComprehensive, Separated_AlongDiagonal)
+{
+    // All components exceed 2.0 — no overlap on any axis
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 2.1f, 2.1f, 2.1f })));
+}
+
+TEST(GjkComprehensive, Separated_LargeDistance)
+{
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 100.f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, Separated_AsymmetricSizes)
+{
+    // Big (scale 2, half-ext 2), small (scale 0.5, half-ext 0.5) at 2.6 → gap of 0.1
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }, { 2, 2, 2 }), make_cube({ 2.6f, 0, 0 }, { 0.5f, 0.5f, 0.5f })));
+}
+
+// ---------------------------------------------------------------------------
+// Overlap — expect true
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, Overlapping_AlongPosX)
+{
+    // B offset 1.5 → overlap depth 0.5 in X
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 1.5f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, Overlapping_AlongNegX)
+{
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ -1.5f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, Overlapping_AlongPosZ)
+{
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 1.5f })));
+}
+
+TEST(GjkComprehensive, Overlapping_AlongNegZ)
+{
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, -1.5f })));
+}
+
+TEST(GjkComprehensive, Overlapping_AlongDiagonalXY)
+{
+    // Minkowski sum extends ±2 on each axis; offset (1,1,0) is inside
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 1.f, 1.f, 0.f })));
+}
+
+TEST(GjkComprehensive, Overlapping_AlongDiagonalXYZ)
+{
+    // All three axes overlap: (1,1,1) is inside the Minkowski sum
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 1.f, 1.f, 1.f })));
+}
+
+TEST(GjkComprehensive, FullyNested_SmallInsideBig)
+{
+    // Small cube (half-ext 0.5) fully inside big cube (half-ext 2)
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }, { 2, 2, 2 }), make_cube({ 0, 0, 0 }, { 0.5f, 0.5f, 0.5f })));
+}
+
+TEST(GjkComprehensive, FullyNested_OffCenter)
+{
+    // Small at (0.5, 0, 0) still fully inside big (half-ext 2)
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }, { 2, 2, 2 }), make_cube({ 0.5f, 0, 0 }, { 0.5f, 0.5f, 0.5f })));
+}
+
+TEST(GjkComprehensive, Overlapping_AsymmetricSizes)
+{
+    // Big (scale 2, half-ext 2) and small (scale 0.5, half-ext 0.5) at 2.0 → overlap 0.5 in X
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }, { 2, 2, 2 }), make_cube({ 2.0f, 0, 0 }, { 0.5f, 0.5f, 0.5f })));
+}
+
+// ---------------------------------------------------------------------------
+// Boundary cases
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, BoundaryCase_JustColliding)
+{
+    // B at 1.999 — 0.001 overlap in X
+    EXPECT_TRUE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 1.999f, 0, 0 })));
+}
+
+TEST(GjkComprehensive, BoundaryCase_JustSeparated)
+{
+    // B at 2.001 — 0.001 gap in X
+    EXPECT_FALSE(Gjk::is_collide(make_cube({ 0, 0, 0 }), make_cube({ 2.001f, 0, 0 })));
+}
+
+// ---------------------------------------------------------------------------
+// Symmetry
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, Symmetry_WhenColliding)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 1.5f, 0, 0 });
+    EXPECT_EQ(Gjk::is_collide(a, b), Gjk::is_collide(b, a));
+}
+
+TEST(GjkComprehensive, Symmetry_WhenSeparated)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 2.1f, 0.5f, 0 });
+    EXPECT_EQ(Gjk::is_collide(a, b), Gjk::is_collide(b, a));
+}
+
+TEST(GjkComprehensive, Symmetry_DiagonalSeparation)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 1.5f, 1.5f, 1.5f });
+    EXPECT_EQ(Gjk::is_collide(a, b), Gjk::is_collide(b, a));
+}
+
+// ---------------------------------------------------------------------------
+// Simplex info
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, SimplexInfo_HitProducesSimplex4)
+{
+    // On collision the simplex must be a full tetrahedron (4 points)
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(make_cube({ 0, 0, 0 }), make_cube({ 0.5f, 0, 0 }));
+    EXPECT_TRUE(hit);
+    EXPECT_EQ(simplex.size(), 4u);
+}
+
+TEST(GjkComprehensive, SimplexInfo_MissProducesLessThan4)
+{
+    // On non-collision the simplex can never be a full tetrahedron
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(make_cube({ 0, 0, 0 }), make_cube({ 2.1f, 0, 0 }));
+    EXPECT_FALSE(hit);
+    EXPECT_LT(simplex.size(), 4u);
+}
+
+TEST(GjkComprehensive, SimplexInfo_HitAlongY)
+{
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(make_cube({ 0, 0, 0 }), make_cube({ 0, 1.5f, 0 }));
+    EXPECT_TRUE(hit);
+    EXPECT_EQ(simplex.size(), 4u);
+}
+
+TEST(GjkComprehensive, SimplexInfo_HitAlongZ)
+{
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(make_cube({ 0, 0, 0 }), make_cube({ 0, 0, 1.5f }));
+    EXPECT_TRUE(hit);
+    EXPECT_EQ(simplex.size(), 4u);
+}
+
+TEST(GjkComprehensive, SimplexInfo_MissAlongDiagonal)
+{
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(make_cube({ 0, 0, 0 }), make_cube({ 2.1f, 2.1f, 2.1f }));
+    EXPECT_FALSE(hit);
+    EXPECT_LT(simplex.size(), 4u);
+}
+
+// ---------------------------------------------------------------------------
+// Non-trivial geometry — tetrahedron shaped colliders
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, TetrahedronShapes_Overlapping)
+{
+    // A rough tetrahedron mesh; two of them close enough to overlap
+    const std::vector<omath::primitives::Vertex<>> tet_vbo = {
+        { {  0.f,  1.f,  0.f }, {}, {} },
+        { { -1.f, -1.f,  1.f }, {}, {} },
+        { {  1.f, -1.f,  1.f }, {}, {} },
+        { {  0.f, -1.f, -1.f }, {}, {} },
+    };
+
+    Mesh m_a{ tet_vbo, k_empty_ebo };
+    Mesh m_b{ tet_vbo, k_empty_ebo };
+    m_b.set_origin({ 0.5f, 0.f, 0.f });
+
+    EXPECT_TRUE(Gjk::is_collide(Collider{ m_a }, Collider{ m_b }));
+}
+
+TEST(GjkComprehensive, TetrahedronShapes_Separated)
+{
+    const std::vector<omath::primitives::Vertex<>> tet_vbo = {
+        { {  0.f,  1.f,  0.f }, {}, {} },
+        { { -1.f, -1.f,  1.f }, {}, {} },
+        { {  1.f, -1.f,  1.f }, {}, {} },
+        { {  0.f, -1.f, -1.f }, {}, {} },
+    };
+
+    Mesh m_a{ tet_vbo, k_empty_ebo };
+    Mesh m_b{ tet_vbo, k_empty_ebo };
+    m_b.set_origin({ 3.f, 0.f, 0.f });
+
+    EXPECT_FALSE(Gjk::is_collide(Collider{ m_a }, Collider{ m_b }));
+}
+
+// ---------------------------------------------------------------------------
+// Determinism
+// ---------------------------------------------------------------------------
+
+TEST(GjkComprehensive, Deterministic_SameResultOnRepeatedCalls)
+{
+    const auto a = make_cube({ 0, 0, 0 });
+    const auto b = make_cube({ 1.2f, 0.3f, 0.1f });
+    const bool first = Gjk::is_collide(a, b);
+    for (int i = 0; i < 10; ++i)
+        EXPECT_EQ(Gjk::is_collide(a, b), first);
+}

tests/general/unit_test_line_trace.cpp

@@ -47,7 +47,7 @@ namespace
     // -----------------------------------------------------------------------------
     struct TraceCase
     {
-        Ray ray;
+        Ray<> ray;
         bool expected_clear; // true => segment does NOT hit the triangle
         friend std::ostream& operator<<(std::ostream& os, const TraceCase& tc)
         {
@@ -66,7 +66,7 @@ namespace
     TEST_P(CanTraceLineParam, VariousRays)
     {
         const auto& [ray, expected_clear] = GetParam();
-        EXPECT_EQ(LineTracer::can_trace_line(ray, triangle), expected_clear);
+        EXPECT_EQ(LineTracer<>::can_trace_line(ray, triangle), expected_clear);
     }
 
     INSTANTIATE_TEST_SUITE_P(
@@ -91,7 +91,7 @@ namespace
         constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
         constexpr Vec3 expected{0.3f, 0.3f, 0.f};
 
-        const Vec3 hit = LineTracer::get_ray_hit_point(ray, triangle);
+        const Vec3 hit = LineTracer<>::get_ray_hit_point(ray, triangle);
         ASSERT_FALSE(vec_equal(hit, ray.end));
         EXPECT_TRUE(vec_equal(hit, expected));
     }
@@ -106,7 +106,7 @@ namespace
                                          {1001.f, 1000.f, 1000.f},
                                          {1000.f, 1001.f, 1000.f}};
 
-        EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
+        EXPECT_TRUE(LineTracer<>::can_trace_line(short_ray, distant));
     }
 
     TEST(unit_test_unity_engine, CantHit)
@@ -115,13 +115,13 @@ namespace
 
         constexpr Ray ray{{}, {1.0, 0, 0}, false};
 
-        EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
+        EXPECT_TRUE(omath::collision::LineTracer<>::can_trace_line(ray, triangle));
     }
     TEST(unit_test_unity_engine, CanHit)
     {
         constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
 
         constexpr Ray ray{{}, {2.1, 0, 0}, false};
-        EXPECT_FALSE(omath::collision::LineTracer::can_trace_line(ray, triangle));
+        EXPECT_FALSE(omath::collision::LineTracer<>::can_trace_line(ray, triangle));
     }
 } // namespace

tests/general/unit_test_line_tracer.cpp

@@ -15,9 +15,9 @@ TEST(LineTracerTests, ParallelRayReturnsEnd)
     ray.end = Vector3<float>{1.f,1.f,1.f};
 
     // For a ray parallel to the triangle plane the algorithm should return ray.end
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_TRUE(hit == ray.end);
-    EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, tri));
+    EXPECT_TRUE(omath::collision::LineTracer<>::can_trace_line(ray, tri));
 }
 
 TEST(LineTracerTests, MissesTriangleReturnsEnd)
@@ -27,7 +27,7 @@ TEST(LineTracerTests, MissesTriangleReturnsEnd)
     ray.start = Vector3<float>{2.f,2.f,-1.f};
     ray.end = Vector3<float>{2.f,2.f,1.f}; // passes above the triangle area
 
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_TRUE(hit == ray.end);
 }
 
@@ -38,7 +38,7 @@ TEST(LineTracerTests, HitTriangleReturnsPointInsideSegment)
     ray.start = Vector3<float>{0.25f,0.25f,-1.f};
     ray.end = Vector3<float>{0.25f,0.25f,1.f};
 
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
     // Should return a point between start and end (z approximately 0)
     EXPECT_NE(hit, ray.end);
     EXPECT_NEAR(hit.z, 0.f, 1e-4f);
@@ -60,6 +60,6 @@ TEST(LineTracerTests, InfiniteLengthEarlyOut)
 
     // If t_hit <= epsilon the algorithm should return ray.end when infinite_length is true.
     // Using start on the triangle plane should produce t_hit <= epsilon.
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_TRUE(hit == ray.end);
 }

tests/general/unit_test_line_tracer_extra.cpp

@@ -10,7 +10,7 @@ TEST(LineTracerExtra, MissParallel)
 {
     constexpr Triangle<Vector3<float>> tri({0,0,0},{1,0,0},{0,1,0});
     constexpr Ray ray{ {0.3f,0.3f,1.f}, {0.3f,0.3f,2.f}, false }; // parallel above triangle
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -18,7 +18,7 @@ TEST(LineTracerExtra, HitCenter)
 {
     constexpr Triangle<Vector3<float>> tri({0,0,0},{1,0,0},{0,1,0});
     constexpr Ray ray{ {0.3f,0.3f,-1.f}, {0.3f,0.3f,1.f}, false };
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     ASSERT_FALSE(hit == ray.end);
     EXPECT_NEAR(hit.x, 0.3f, 1e-6f);
     EXPECT_NEAR(hit.y, 0.3f, 1e-6f);
@@ -30,7 +30,7 @@ TEST(LineTracerExtra, HitOnEdge)
     constexpr Triangle<Vector3<float>> tri({0,0,0},{1,0,0},{0,1,0});
     constexpr Ray ray{ {0.0f,0.0f,1.f}, {0.0f,0.0f,0.f}, false };
     // hitting exact vertex/edge may be considered miss; ensure function handles without crash
-    if (const auto hit = LineTracer::get_ray_hit_point(ray, tri); hit != ray.end)
+    if (const auto hit = LineTracer<>::get_ray_hit_point(ray, tri); hit != ray.end)
     {
         EXPECT_NEAR(hit.x, 0.0f, 1e-6f);
         EXPECT_NEAR(hit.y, 0.0f, 1e-6f);
@@ -42,6 +42,6 @@ TEST(LineTracerExtra, InfiniteRayIgnoredIfBehind)
     constexpr Triangle<Vector3<float>> tri({0,0,0},{1,0,0},{0,1,0});
     // Ray pointing away but infinite_length true should be ignored
     constexpr Ray ray{ {0.5f,0.5f,-1.f}, {0.5f,0.5f,-2.f}, true };
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }

tests/general/unit_test_line_tracer_more.cpp

@@ -14,7 +14,7 @@ TEST(LineTracerMore, ParallelRayReturnsEnd)
     constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
     Ray ray; ray.start = {0.f,0.f,1.f}; ray.end = {1.f,0.f,1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -24,7 +24,7 @@ TEST(LineTracerMore, UOutOfRangeReturnsEnd)
     constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
     Ray ray; ray.start = {-1.f,-1.f,-1.f}; ray.end = {-0.5f,-1.f,1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -34,7 +34,7 @@ TEST(LineTracerMore, VOutOfRangeReturnsEnd)
     constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
     Ray ray; ray.start = {2.f,2.f,-1.f}; ray.end = {2.f,2.f,1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -43,7 +43,7 @@ TEST(LineTracerMore, THitTooSmallReturnsEnd)
     constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
     Ray ray; ray.start = {0.f,0.f,0.0000000001f}; ray.end = {0.f,0.f,1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -53,7 +53,7 @@ TEST(LineTracerMore, THitGreaterThanOneReturnsEnd)
     // Choose a ray and compute t_hit locally to assert consistency
     Ray ray; ray.start = {0.f,0.f,-1.f}; ray.end = {0.f,0.f,-0.5f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
 
     constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
     constexpr auto side_a = tri.side_a_vector();
@@ -87,7 +87,7 @@ TEST(LineTracerMore, InfiniteLengthWithSmallTHitReturnsEnd)
     // Create triangle slightly behind so t_hit <= eps
     tri = tri2;
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -96,7 +96,7 @@ TEST(LineTracerMore, SuccessfulHitReturnsPoint)
     constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
     Ray ray; ray.start = {0.1f,0.1f,-1.f}; ray.end = {0.1f,0.1f,1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_NE(hit, ray.end);
     // Hit should be on plane z=0 and near x=0.1,y=0.1
     EXPECT_NEAR(hit.z, 0.f, 1e-6f);

tests/general/unit_test_line_tracer_more2.cpp

@@ -14,7 +14,7 @@ TEST(LineTracerMore2, UGreaterThanOneReturnsEnd)
     // choose ray so barycentric u > 1
     Ray ray; ray.start = {2.f, -1.f, -1.f}; ray.end = {2.f, -1.f, 1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -24,7 +24,7 @@ TEST(LineTracerMore2, VGreaterThanOneReturnsEnd)
     // choose ray so barycentric v > 1
     Ray ray; ray.start = {-1.f, 2.f, -1.f}; ray.end = {-1.f, 2.f, 1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -34,7 +34,7 @@ TEST(LineTracerMore2, UPlusVGreaterThanOneReturnsEnd)
     // Ray aimed so u+v > 1 (outside triangle region)
     Ray ray; ray.start = {1.f, 1.f, -1.f}; ray.end = {1.f, 1.f, 1.f};
 
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }
 
@@ -52,6 +52,6 @@ TEST(LineTracerMore2, ZeroLengthRayHandled)
     Ray ray; ray.start = {0.f,0.f,0.f}; ray.end = {0.f,0.f,0.f};
 
     // Zero-length ray: direction length == 0; algorithm should handle without crash
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
     EXPECT_EQ(hit, ray.end);
 }

tests/general/unit_test_macho_scanner.cpp

@@ -0,0 +1,358 @@
+//
+// Created by Copilot on 04.02.2026.
+//
+// Unit tests for MachOPatternScanner
+#include <gtest/gtest.h>
+#include <omath/utility/macho_pattern_scan.hpp>
+#include <cstdint>
+#include <cstring>
+#include <fstream>
+#include <vector>
+
+using namespace omath;
+
+namespace
+{
+    // Mach-O magic numbers
+    constexpr std::uint32_t mh_magic_64 = 0xFEEDFACF;
+    constexpr std::uint32_t mh_magic_32 = 0xFEEDFACE;
+    constexpr std::uint32_t lc_segment = 0x1;
+    constexpr std::uint32_t lc_segment_64 = 0x19;
+
+    constexpr std::string_view segment_name = "__TEXT";
+    constexpr std::string_view section_name = "__text";
+#pragma pack(push, 1)
+    struct MachHeader64
+    {
+        std::uint32_t magic;
+        std::uint32_t cputype;
+        std::uint32_t cpusubtype;
+        std::uint32_t filetype;
+        std::uint32_t ncmds;
+        std::uint32_t sizeofcmds;
+        std::uint32_t flags;
+        std::uint32_t reserved;
+    };
+
+    struct MachHeader32
+    {
+        std::uint32_t magic;
+        std::uint32_t cputype;
+        std::uint32_t cpusubtype;
+        std::uint32_t filetype;
+        std::uint32_t ncmds;
+        std::uint32_t sizeofcmds;
+        std::uint32_t flags;
+    };
+
+    struct SegmentCommand64
+    {
+        std::uint32_t cmd;
+        std::uint32_t cmdsize;
+        char segname[16];
+        std::uint64_t vmaddr;
+        std::uint64_t vmsize;
+        std::uint64_t fileoff;
+        std::uint64_t filesize;
+        std::uint32_t maxprot;
+        std::uint32_t initprot;
+        std::uint32_t nsects;
+        std::uint32_t flags;
+    };
+
+    struct SegmentCommand32
+    {
+        std::uint32_t cmd;
+        std::uint32_t cmdsize;
+        char segname[16];
+        std::uint32_t vmaddr;
+        std::uint32_t vmsize;
+        std::uint32_t fileoff;
+        std::uint32_t filesize;
+        std::uint32_t maxprot;
+        std::uint32_t initprot;
+        std::uint32_t nsects;
+        std::uint32_t flags;
+    };
+
+    struct Section64
+    {
+        char sectname[16];
+        char segname[16];
+        std::uint64_t addr;
+        std::uint64_t size;
+        std::uint32_t offset;
+        std::uint32_t align;
+        std::uint32_t reloff;
+        std::uint32_t nreloc;
+        std::uint32_t flags;
+        std::uint32_t reserved1;
+        std::uint32_t reserved2;
+        std::uint32_t reserved3;
+    };
+
+    struct Section32
+    {
+        char sectname[16];
+        char segname[16];
+        std::uint32_t addr;
+        std::uint32_t size;
+        std::uint32_t offset;
+        std::uint32_t align;
+        std::uint32_t reloff;
+        std::uint32_t nreloc;
+        std::uint32_t flags;
+        std::uint32_t reserved1;
+        std::uint32_t reserved2;
+    };
+#pragma pack(pop)
+
+    // Helper function to create a minimal 64-bit Mach-O file with a __text section
+    bool write_minimal_macho64_file(const std::string& path, const std::vector<std::uint8_t>& section_bytes)
+    {
+        std::ofstream f(path, std::ios::binary);
+        if (!f.is_open())
+            return false;
+
+        // Calculate sizes
+        constexpr std::size_t header_size = sizeof(MachHeader64);
+        constexpr std::size_t segment_size = sizeof(SegmentCommand64);
+        constexpr std::size_t section_size = sizeof(Section64);
+        constexpr std::size_t load_cmd_size = segment_size + section_size;
+        // Section data will start after headers
+        const std::size_t section_offset = header_size + load_cmd_size;
+
+        // Create Mach-O header
+        MachHeader64 header{};
+        header.magic = mh_magic_64;
+        header.cputype = 0x01000007;  // CPU_TYPE_X86_64
+        header.cpusubtype = 0x3;       // CPU_SUBTYPE_X86_64_ALL
+        header.filetype = 0x2;         // MH_EXECUTE
+        header.ncmds = 1;
+        header.sizeofcmds = static_cast<std::uint32_t>(load_cmd_size);
+        header.flags = 0;
+        header.reserved = 0;
+
+        f.write(reinterpret_cast<const char*>(&header), sizeof(header));
+
+        // Create segment command
+        SegmentCommand64 segment{};
+        segment.cmd = lc_segment_64;
+        segment.cmdsize = static_cast<std::uint32_t>(load_cmd_size);
+        std::ranges::copy(segment_name, segment.segname);
+        segment.vmaddr = 0x100000000;
+        segment.vmsize = section_bytes.size();
+        segment.fileoff = section_offset;
+        segment.filesize = section_bytes.size();
+        segment.maxprot = 7;   // VM_PROT_ALL
+        segment.initprot = 5;  // VM_PROT_READ | VM_PROT_EXECUTE
+        segment.nsects = 1;
+        segment.flags = 0;
+
+        f.write(reinterpret_cast<const char*>(&segment), sizeof(segment));
+
+        // Create section
+        Section64 section{};
+        std::ranges::copy(section_name, section.sectname);
+        std::ranges::copy(segment_name, segment.segname);
+        section.addr = 0x100000000;
+        section.size = section_bytes.size();
+        section.offset = static_cast<std::uint32_t>(section_offset);
+        section.align = 0;
+        section.reloff = 0;
+        section.nreloc = 0;
+        section.flags = 0;
+        section.reserved1 = 0;
+        section.reserved2 = 0;
+        section.reserved3 = 0;
+
+        f.write(reinterpret_cast<const char*>(&section), sizeof(section));
+
+        // Write section data
+        f.write(reinterpret_cast<const char*>(section_bytes.data()), static_cast<std::streamsize>(section_bytes.size()));
+
+        f.close();
+        return true;
+    }
+
+    // Helper function to create a minimal 32-bit Mach-O file with a __text section
+    bool write_minimal_macho32_file(const std::string& path, const std::vector<std::uint8_t>& section_bytes)
+    {
+        std::ofstream f(path, std::ios::binary);
+        if (!f.is_open())
+            return false;
+
+        // Calculate sizes
+        constexpr std::size_t header_size = sizeof(MachHeader32);
+        constexpr std::size_t segment_size = sizeof(SegmentCommand32);
+        constexpr std::size_t section_size = sizeof(Section32);
+        constexpr std::size_t load_cmd_size = segment_size + section_size;
+
+        // Section data will start after headers
+        constexpr std::size_t section_offset = header_size + load_cmd_size;
+
+        // Create Mach-O header
+        MachHeader32 header{};
+        header.magic = mh_magic_32;
+        header.cputype = 0x7;          // CPU_TYPE_X86
+        header.cpusubtype = 0x3;       // CPU_SUBTYPE_X86_ALL
+        header.filetype = 0x2;         // MH_EXECUTE
+        header.ncmds = 1;
+        header.sizeofcmds = static_cast<std::uint32_t>(load_cmd_size);
+        header.flags = 0;
+
+        f.write(reinterpret_cast<const char*>(&header), sizeof(header));
+
+        // Create segment command
+        SegmentCommand32 segment{};
+        segment.cmd = lc_segment;
+        segment.cmdsize = static_cast<std::uint32_t>(load_cmd_size);
+        std::ranges::copy(segment_name, segment.segname);
+        segment.vmaddr = 0x1000;
+        segment.vmsize = static_cast<std::uint32_t>(section_bytes.size());
+        segment.fileoff = static_cast<std::uint32_t>(section_offset);
+        segment.filesize = static_cast<std::uint32_t>(section_bytes.size());
+        segment.maxprot = 7;   // VM_PROT_ALL
+        segment.initprot = 5;  // VM_PROT_READ | VM_PROT_EXECUTE
+        segment.nsects = 1;
+        segment.flags = 0;
+
+        f.write(reinterpret_cast<const char*>(&segment), sizeof(segment));
+
+        // Create section
+        Section32 section{};
+        std::ranges::copy(section_name, section.sectname);
+        std::ranges::copy(segment_name, segment.segname);
+        section.addr = 0x1000;
+        section.size = static_cast<std::uint32_t>(section_bytes.size());
+        section.offset = static_cast<std::uint32_t>(section_offset);
+        section.align = 0;
+        section.reloff = 0;
+        section.nreloc = 0;
+        section.flags = 0;
+        section.reserved1 = 0;
+        section.reserved2 = 0;
+
+        f.write(reinterpret_cast<const char*>(&section), sizeof(section));
+
+        // Write section data
+        f.write(reinterpret_cast<const char*>(section_bytes.data()), static_cast<std::streamsize>(section_bytes.size()));
+
+        f.close();
+        return true;
+    }
+
+} // namespace
+
+// Test scanning for a pattern that exists in a 64-bit Mach-O file
+TEST(unit_test_macho_pattern_scan_file, ScanFindsPattern64)
+{
+    constexpr std::string_view path = "./test_minimal_macho64.bin";
+    const std::vector<std::uint8_t> bytes = {0x55, 0x48, 0x89, 0xE5, 0x90, 0x90}; // push rbp; mov rbp, rsp; nop; nop
+    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48 89 E5", "__text");
+    EXPECT_TRUE(res.has_value());
+    if (res.has_value())
+    {
+        EXPECT_EQ(res->target_offset, 0);
+    }
+}
+
+// Test scanning for a pattern that exists in a 32-bit Mach-O file
+TEST(unit_test_macho_pattern_scan_file, ScanFindsPattern32)
+{
+    constexpr std::string_view path = "./test_minimal_macho32.bin";
+    const std::vector<std::uint8_t> bytes = {0x55, 0x89, 0xE5, 0x90, 0x90}; // push ebp; mov ebp, esp; nop; nop
+    ASSERT_TRUE(write_minimal_macho32_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 89 E5", "__text");
+    EXPECT_TRUE(res.has_value());
+    if (res.has_value())
+    {
+        EXPECT_EQ(res->target_offset, 0);
+    }
+}
+
+// Test scanning for a pattern that does not exist
+TEST(unit_test_macho_pattern_scan_file, ScanMissingPattern)
+{
+    constexpr std::string_view path = "./test_minimal_macho_missing.bin";
+    const std::vector<std::uint8_t> bytes = {0x00, 0x01, 0x02, 0x03};
+    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "FF EE DD", "__text");
+    EXPECT_FALSE(res.has_value());
+}
+
+// Test scanning for a pattern at a non-zero offset
+TEST(unit_test_macho_pattern_scan_file, ScanPatternAtOffset)
+{
+    constexpr std::string_view path = "./test_minimal_macho_offset.bin";
+    const std::vector<std::uint8_t> bytes = {0x90, 0x90, 0x90, 0x55, 0x48, 0x89, 0xE5}; // nops then pattern
+    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48 89 E5", "__text");
+    EXPECT_TRUE(res.has_value());
+    if (res.has_value())
+    {
+        EXPECT_EQ(res->target_offset, 3);
+    }
+}
+
+// Test scanning with wildcards
+TEST(unit_test_macho_pattern_scan_file, ScanWithWildcard)
+{
+    constexpr std::string_view path = "./test_minimal_macho_wildcard.bin";
+    const std::vector<std::uint8_t> bytes = {0x55, 0x48, 0x89, 0xE5, 0x90};
+    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 ? 89 E5", "__text");
+    EXPECT_TRUE(res.has_value());
+}
+
+// Test scanning a non-existent file
+TEST(unit_test_macho_pattern_scan_file, ScanNonExistentFile)
+{
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file("/non/existent/file.bin", "55 48", "__text");
+    EXPECT_FALSE(res.has_value());
+}
+
+// Test scanning an invalid (non-Mach-O) file
+TEST(unit_test_macho_pattern_scan_file, ScanInvalidFile)
+{
+    constexpr std::string_view path = "./test_invalid_macho.bin";
+    std::ofstream f(path.data(), std::ios::binary);
+    const std::vector<std::uint8_t> garbage = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
+    f.write(reinterpret_cast<const char*>(garbage.data()), static_cast<std::streamsize>(garbage.size()));
+    f.close();
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48", "__text");
+    EXPECT_FALSE(res.has_value());
+}
+
+// Test scanning for a non-existent section
+TEST(unit_test_macho_pattern_scan_file, ScanNonExistentSection)
+{
+    constexpr std::string_view path = "./test_minimal_macho_nosect.bin";
+    const std::vector<std::uint8_t> bytes = {0x55, 0x48, 0x89, 0xE5};
+    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48", "__nonexistent");
+    EXPECT_FALSE(res.has_value());
+}
+
+// Test scanning with null module base address
+TEST(unit_test_macho_pattern_scan_loaded, ScanNullModule)
+{
+    const auto res = MachOPatternScanner::scan_for_pattern_in_loaded_module(nullptr, "55 48", "__text");
+    EXPECT_FALSE(res.has_value());
+}
+
+// Test scanning in loaded module with invalid magic
+TEST(unit_test_macho_pattern_scan_loaded, ScanInvalidMagic)
+{
+    std::vector<std::uint8_t> invalid_data(256, 0x00);
+    const auto res = MachOPatternScanner::scan_for_pattern_in_loaded_module(invalid_data.data(), "55 48", "__text");
+    EXPECT_FALSE(res.has_value());
+}

tests/general/unit_test_primitive_box.cpp

@@ -12,5 +12,5 @@ TEST(test, test)
             {0.f, 30.f, 0.f}, {}, omath::opengl_engine::k_abs_forward, omath::opengl_engine::k_abs_right);
 
     omath::collision::Ray ray{.start = {0, 0, 0}, .end = {-100, 0, 0}};
-    std::ignore = omath::collision::LineTracer::get_ray_hit_point(ray, result);
+    std::ignore = omath::collision::LineTracer<>::get_ray_hit_point(ray, result);
 }

tests/general/unit_test_quaternion.cpp

@@ -0,0 +1,402 @@
+//
+// Created by vlad on 3/1/2026.
+//
+#include <omath/linear_algebra/quaternion.hpp>
+#include <cmath>
+#include <gtest/gtest.h>
+#include <numbers>
+
+using namespace omath;
+
+static constexpr float kEps = 1e-5f;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+static void expect_quat_near(const Quaternion<float>& a, const Quaternion<float>& b, float eps = kEps)
+{
+    EXPECT_NEAR(a.x, b.x, eps);
+    EXPECT_NEAR(a.y, b.y, eps);
+    EXPECT_NEAR(a.z, b.z, eps);
+    EXPECT_NEAR(a.w, b.w, eps);
+}
+
+static void expect_vec3_near(const Vector3<float>& a, const Vector3<float>& b, float eps = kEps)
+{
+    EXPECT_NEAR(a.x, b.x, eps);
+    EXPECT_NEAR(a.y, b.y, eps);
+    EXPECT_NEAR(a.z, b.z, eps);
+}
+
+// ── Constructors ─────────────────────────────────────────────────────────────
+
+TEST(Quaternion, DefaultConstructorIsIdentity)
+{
+    constexpr Quaternion<float> q;
+    EXPECT_FLOAT_EQ(q.x, 0.f);
+    EXPECT_FLOAT_EQ(q.y, 0.f);
+    EXPECT_FLOAT_EQ(q.z, 0.f);
+    EXPECT_FLOAT_EQ(q.w, 1.f);
+}
+
+TEST(Quaternion, ValueConstructor)
+{
+    constexpr Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    EXPECT_FLOAT_EQ(q.x, 1.f);
+    EXPECT_FLOAT_EQ(q.y, 2.f);
+    EXPECT_FLOAT_EQ(q.z, 3.f);
+    EXPECT_FLOAT_EQ(q.w, 4.f);
+}
+
+TEST(Quaternion, DoubleInstantiation)
+{
+    constexpr Quaternion<double> q{0.0, 0.0, 0.0, 1.0};
+    EXPECT_DOUBLE_EQ(q.w, 1.0);
+}
+
+// ── Equality ─────────────────────────────────────────────────────────────────
+
+TEST(Quaternion, EqualityOperators)
+{
+    constexpr Quaternion<float> a{1.f, 2.f, 3.f, 4.f};
+    constexpr Quaternion<float> b{1.f, 2.f, 3.f, 4.f};
+    constexpr Quaternion<float> c{1.f, 2.f, 3.f, 5.f};
+
+    EXPECT_TRUE(a == b);
+    EXPECT_FALSE(a == c);
+    EXPECT_FALSE(a != b);
+    EXPECT_TRUE(a != c);
+}
+
+// ── Arithmetic ───────────────────────────────────────────────────────────────
+
+TEST(Quaternion, ScalarMultiply)
+{
+    constexpr Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    constexpr auto r = q * 2.f;
+    EXPECT_FLOAT_EQ(r.x, 2.f);
+    EXPECT_FLOAT_EQ(r.y, 4.f);
+    EXPECT_FLOAT_EQ(r.z, 6.f);
+    EXPECT_FLOAT_EQ(r.w, 8.f);
+}
+
+TEST(Quaternion, ScalarMultiplyAssign)
+{
+    Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    q *= 3.f;
+    EXPECT_FLOAT_EQ(q.x, 3.f);
+    EXPECT_FLOAT_EQ(q.y, 6.f);
+    EXPECT_FLOAT_EQ(q.z, 9.f);
+    EXPECT_FLOAT_EQ(q.w, 12.f);
+}
+
+TEST(Quaternion, Addition)
+{
+    constexpr Quaternion<float> a{1.f, 2.f, 3.f, 4.f};
+    constexpr Quaternion<float> b{4.f, 3.f, 2.f, 1.f};
+    constexpr auto r = a + b;
+    EXPECT_FLOAT_EQ(r.x, 5.f);
+    EXPECT_FLOAT_EQ(r.y, 5.f);
+    EXPECT_FLOAT_EQ(r.z, 5.f);
+    EXPECT_FLOAT_EQ(r.w, 5.f);
+}
+
+TEST(Quaternion, AdditionAssign)
+{
+    Quaternion<float> a{1.f, 0.f, 0.f, 0.f};
+    const Quaternion<float> b{0.f, 1.f, 0.f, 0.f};
+    a += b;
+    EXPECT_FLOAT_EQ(a.x, 1.f);
+    EXPECT_FLOAT_EQ(a.y, 1.f);
+}
+
+TEST(Quaternion, UnaryNegation)
+{
+    constexpr Quaternion<float> q{1.f, -2.f, 3.f, -4.f};
+    constexpr auto r = -q;
+    EXPECT_FLOAT_EQ(r.x, -1.f);
+    EXPECT_FLOAT_EQ(r.y,  2.f);
+    EXPECT_FLOAT_EQ(r.z, -3.f);
+    EXPECT_FLOAT_EQ(r.w,  4.f);
+}
+
+// ── Hamilton product ──────────────────────────────────────────────────────────
+
+TEST(Quaternion, MultiplyByIdentityIsNoop)
+{
+    constexpr Quaternion<float> identity;
+    constexpr Quaternion<float> q{0.5f, 0.5f, 0.5f, 0.5f};
+    expect_quat_near(q * identity, q);
+    expect_quat_near(identity * q, q);
+}
+
+TEST(Quaternion, MultiplyAssign)
+{
+    constexpr Quaternion<float> identity;
+    Quaternion<float> q{0.5f, 0.5f, 0.5f, 0.5f};
+    q *= identity;
+    expect_quat_near(q, {0.5f, 0.5f, 0.5f, 0.5f});
+}
+
+TEST(Quaternion, MultiplyKnownResult)
+{
+    // i * j = k  →  (1,0,0,0) * (0,1,0,0) = (0,0,1,0)
+    constexpr Quaternion<float> i{1.f, 0.f, 0.f, 0.f};
+    constexpr Quaternion<float> j{0.f, 1.f, 0.f, 0.f};
+    constexpr auto k = i * j;
+    EXPECT_FLOAT_EQ(k.x, 0.f);
+    EXPECT_FLOAT_EQ(k.y, 0.f);
+    EXPECT_FLOAT_EQ(k.z, 1.f);
+    EXPECT_FLOAT_EQ(k.w, 0.f);
+}
+
+TEST(Quaternion, MultiplyByInverseGivesIdentity)
+{
+    const Quaternion<float> q = Quaternion<float>::from_axis_angle({0.f, 0.f, 1.f},
+                                                                     std::numbers::pi_v<float> / 3.f);
+    const auto result = q * q.inverse();
+    expect_quat_near(result, Quaternion<float>{});
+}
+
+// ── Conjugate ────────────────────────────────────────────────────────────────
+
+TEST(Quaternion, Conjugate)
+{
+    constexpr Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    constexpr auto c = q.conjugate();
+    EXPECT_FLOAT_EQ(c.x, -1.f);
+    EXPECT_FLOAT_EQ(c.y, -2.f);
+    EXPECT_FLOAT_EQ(c.z, -3.f);
+    EXPECT_FLOAT_EQ(c.w,  4.f);
+}
+
+TEST(Quaternion, ConjugateOfIdentityIsIdentity)
+{
+    constexpr Quaternion<float> id;
+    constexpr auto c = id.conjugate();
+    EXPECT_FLOAT_EQ(c.x, 0.f);
+    EXPECT_FLOAT_EQ(c.y, 0.f);
+    EXPECT_FLOAT_EQ(c.z, 0.f);
+    EXPECT_FLOAT_EQ(c.w, 1.f);
+}
+
+// ── Dot / length ─────────────────────────────────────────────────────────────
+
+TEST(Quaternion, Dot)
+{
+    constexpr Quaternion<float> a{1.f, 0.f, 0.f, 0.f};
+    constexpr Quaternion<float> b{0.f, 1.f, 0.f, 0.f};
+    EXPECT_FLOAT_EQ(a.dot(b), 0.f);
+    EXPECT_FLOAT_EQ(a.dot(a), 1.f);
+}
+
+TEST(Quaternion, LengthSqrIdentity)
+{
+    constexpr Quaternion<float> id;
+    EXPECT_FLOAT_EQ(id.length_sqr(), 1.f);
+}
+
+TEST(Quaternion, LengthSqrGeneral)
+{
+    constexpr Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    EXPECT_FLOAT_EQ(q.length_sqr(), 30.f);
+}
+
+TEST(Quaternion, LengthIdentity)
+{
+    const Quaternion<float> id;
+    EXPECT_NEAR(id.length(), 1.f, kEps);
+}
+
+TEST(Quaternion, Normalized)
+{
+    const Quaternion<float> q{1.f, 1.f, 1.f, 1.f};
+    const auto n = q.normalized();
+    EXPECT_NEAR(n.length(), 1.f, kEps);
+    EXPECT_NEAR(n.x, 0.5f, kEps);
+    EXPECT_NEAR(n.y, 0.5f, kEps);
+    EXPECT_NEAR(n.z, 0.5f, kEps);
+    EXPECT_NEAR(n.w, 0.5f, kEps);
+}
+
+TEST(Quaternion, NormalizedOfZeroLengthReturnsSelf)
+{
+    // length_sqr = 0 would be UB, but zero-vector part + zero w is degenerate;
+    // we just verify the guard branch (divides by zero) doesn't crash by
+    // keeping length > 0 via the default constructor path.
+    const Quaternion<float> unit;
+    const auto n = unit.normalized();
+    expect_quat_near(n, unit);
+}
+
+// ── Inverse ───────────────────────────────────────────────────────────────────
+
+TEST(Quaternion, InverseOfUnitIsConjugate)
+{
+    const Quaternion<float> q = Quaternion<float>::from_axis_angle({1.f, 0.f, 0.f},
+                                                                     std::numbers::pi_v<float> / 4.f);
+    const auto inv = q.inverse();
+    const auto conj = q.conjugate();
+    expect_quat_near(inv, conj);
+}
+
+// ── from_axis_angle ──────────────────────────────────────────────────────────
+
+TEST(Quaternion, FromAxisAngleZeroAngleIsIdentity)
+{
+    const auto q = Quaternion<float>::from_axis_angle({1.f, 0.f, 0.f}, 0.f);
+    EXPECT_NEAR(q.x, 0.f, kEps);
+    EXPECT_NEAR(q.y, 0.f, kEps);
+    EXPECT_NEAR(q.z, 0.f, kEps);
+    EXPECT_NEAR(q.w, 1.f, kEps);
+}
+
+TEST(Quaternion, FromAxisAngle90DegZ)
+{
+    const float half_pi = std::numbers::pi_v<float> / 2.f;
+    const auto q = Quaternion<float>::from_axis_angle({0.f, 0.f, 1.f}, half_pi);
+    const float s = std::sin(half_pi / 2.f);
+    const float c = std::cos(half_pi / 2.f);
+    EXPECT_NEAR(q.x, 0.f, kEps);
+    EXPECT_NEAR(q.y, 0.f, kEps);
+    EXPECT_NEAR(q.z, s,   kEps);
+    EXPECT_NEAR(q.w, c,   kEps);
+}
+
+// ── rotate ───────────────────────────────────────────────────────────────────
+
+TEST(Quaternion, RotateByIdentityIsNoop)
+{
+    constexpr Quaternion<float> id;
+    constexpr Vector3<float> v{1.f, 2.f, 3.f};
+    const auto r = id.rotate(v);
+    expect_vec3_near(r, v);
+}
+
+TEST(Quaternion, Rotate90DegAroundZ)
+{
+    // Rotating (1,0,0) by 90° around Z should give (0,1,0)
+    const auto q = Quaternion<float>::from_axis_angle({0.f, 0.f, 1.f}, std::numbers::pi_v<float> / 2.f);
+    const auto r = q.rotate({1.f, 0.f, 0.f});
+    expect_vec3_near(r, {0.f, 1.f, 0.f});
+}
+
+TEST(Quaternion, Rotate180DegAroundY)
+{
+    // Rotating (1,0,0) by 180° around Y should give (-1,0,0)
+    const auto q = Quaternion<float>::from_axis_angle({0.f, 1.f, 0.f}, std::numbers::pi_v<float>);
+    const auto r = q.rotate({1.f, 0.f, 0.f});
+    expect_vec3_near(r, {-1.f, 0.f, 0.f});
+}
+
+TEST(Quaternion, Rotate90DegAroundX)
+{
+    // Rotating (0,1,0) by 90° around X should give (0,0,1)
+    const auto q = Quaternion<float>::from_axis_angle({1.f, 0.f, 0.f}, std::numbers::pi_v<float> / 2.f);
+    const auto r = q.rotate({0.f, 1.f, 0.f});
+    expect_vec3_near(r, {0.f, 0.f, 1.f});
+}
+
+// ── to_rotation_matrix3 ───────────────────────────────────────────────────────
+
+TEST(Quaternion, RotationMatrix3FromIdentityIsIdentityMatrix)
+{
+    constexpr Quaternion<float> id;
+    constexpr auto m = id.to_rotation_matrix3();
+    for (size_t i = 0; i < 3; ++i)
+        for (size_t j = 0; j < 3; ++j)
+            EXPECT_NEAR(m.at(i, j), i == j ? 1.f : 0.f, kEps);
+}
+
+TEST(Quaternion, RotationMatrix3From90DegZ)
+{
+    //  Expected:  | 0 -1  0 |
+    //             | 1  0  0 |
+    //             | 0  0  1 |
+    const auto q = Quaternion<float>::from_axis_angle({0.f, 0.f, 1.f}, std::numbers::pi_v<float> / 2.f);
+    const auto m = q.to_rotation_matrix3();
+    EXPECT_NEAR(m.at(0, 0),  0.f, kEps);
+    EXPECT_NEAR(m.at(0, 1), -1.f, kEps);
+    EXPECT_NEAR(m.at(0, 2),  0.f, kEps);
+    EXPECT_NEAR(m.at(1, 0),  1.f, kEps);
+    EXPECT_NEAR(m.at(1, 1),  0.f, kEps);
+    EXPECT_NEAR(m.at(1, 2),  0.f, kEps);
+    EXPECT_NEAR(m.at(2, 0),  0.f, kEps);
+    EXPECT_NEAR(m.at(2, 1),  0.f, kEps);
+    EXPECT_NEAR(m.at(2, 2),  1.f, kEps);
+}
+
+TEST(Quaternion, RotationMatrix3ConsistentWithRotate)
+{
+    // Matrix-vector multiply must agree with the rotate() method
+    const auto q = Quaternion<float>::from_axis_angle({1.f, 1.f, 0.f}, std::numbers::pi_v<float> / 3.f);
+    const Vector3<float> v{2.f, -1.f, 0.5f};
+
+    const auto rotated = q.rotate(v);
+    const auto m = q.to_rotation_matrix3();
+
+    // manual mat-vec multiply (row-major)
+    const float rx = m.at(0, 0) * v.x + m.at(0, 1) * v.y + m.at(0, 2) * v.z;
+    const float ry = m.at(1, 0) * v.x + m.at(1, 1) * v.y + m.at(1, 2) * v.z;
+    const float rz = m.at(2, 0) * v.x + m.at(2, 1) * v.y + m.at(2, 2) * v.z;
+
+    EXPECT_NEAR(rotated.x, rx, kEps);
+    EXPECT_NEAR(rotated.y, ry, kEps);
+    EXPECT_NEAR(rotated.z, rz, kEps);
+}
+
+// ── to_rotation_matrix4 ───────────────────────────────────────────────────────
+
+TEST(Quaternion, RotationMatrix4FromIdentityIsIdentityMatrix)
+{
+    constexpr Quaternion<float> id;
+    constexpr auto m = id.to_rotation_matrix4();
+    for (size_t i = 0; i < 4; ++i)
+        for (size_t j = 0; j < 4; ++j)
+            EXPECT_NEAR(m.at(i, j), i == j ? 1.f : 0.f, kEps);
+}
+
+TEST(Quaternion, RotationMatrix4HomogeneousRowAndColumn)
+{
+    const auto q = Quaternion<float>::from_axis_angle({1.f, 0.f, 0.f}, std::numbers::pi_v<float> / 5.f);
+    const auto m = q.to_rotation_matrix4();
+
+    // Last row and last column must be (0,0,0,1)
+    for (size_t i = 0; i < 3; ++i)
+    {
+        EXPECT_NEAR(m.at(3, i), 0.f, kEps);
+        EXPECT_NEAR(m.at(i, 3), 0.f, kEps);
+    }
+    EXPECT_NEAR(m.at(3, 3), 1.f, kEps);
+}
+
+TEST(Quaternion, RotationMatrix4Upper3x3MatchesMatrix3)
+{
+    const auto q = Quaternion<float>::from_axis_angle({0.f, 1.f, 0.f}, std::numbers::pi_v<float> / 7.f);
+    const auto m3 = q.to_rotation_matrix3();
+    const auto m4 = q.to_rotation_matrix4();
+
+    for (size_t i = 0; i < 3; ++i)
+        for (size_t j = 0; j < 3; ++j)
+            EXPECT_NEAR(m4.at(i, j), m3.at(i, j), kEps);
+}
+
+// ── as_array ──────────────────────────────────────────────────────────────────
+
+TEST(Quaternion, AsArray)
+{
+    constexpr Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    constexpr auto arr = q.as_array();
+    EXPECT_FLOAT_EQ(arr[0], 1.f);
+    EXPECT_FLOAT_EQ(arr[1], 2.f);
+    EXPECT_FLOAT_EQ(arr[2], 3.f);
+    EXPECT_FLOAT_EQ(arr[3], 4.f);
+}
+
+// ── std::formatter ────────────────────────────────────────────────────────────
+
+TEST(Quaternion, Formatter)
+{
+    const Quaternion<float> q{1.f, 2.f, 3.f, 4.f};
+    const auto s = std::format("{}", q);
+    EXPECT_EQ(s, "[1, 2, 3, 4]");
+}

vcpkg.json

@@ -27,10 +27,11 @@
       ]
     },
     "examples": {
-      "description": "Build benchmarks",
+      "description": "Build examples",
       "dependencies": [
         "glfw3",
-        "glew"
+        "glew",
+        "opengl"
       ]
     },
     "imgui": {