Merge pull request #161 from orange-cpp/feature/lua-bindings

Feature/lua bindings

.cmake-format

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

.gitattributes

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

.github/FUNDING.yml

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

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

@@ -107,7 +107,7 @@ jobs:
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
             -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
@@ -145,9 +145,9 @@ jobs:
             cmake-build/build/${{ matrix.preset }}/**/*.log
             ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
 
-  ##############################################################################
-  # 2)  Windows  –  MSVC / Ninja
-  ##############################################################################
+##############################################################################
+# 2)  Windows  –  MSVC / Ninja
+##############################################################################
   windows-build-and-test:
     name: ${{ matrix.name }}
     runs-on: ${{ matrix.runner }}
@@ -188,7 +188,12 @@ jobs:
 
       - name: Configure (cmake --preset)
         shell: bash
-        run: cmake --preset ${{ matrix.preset }} -DOMATH_BUILD_TESTS=ON -DOMATH_BUILD_BENCHMARK=OFF -DOMATH_ENABLE_COVERAGE=OFF -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+        run: |
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DOMATH_ENABLE_COVERAGE=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
@@ -198,35 +203,121 @@ jobs:
         shell: bash
         run: ./out/Release/unit_tests.exe
 
-      - name: Install OpenCppCoverage with Chocolatey
+      ##########################################################################
+      # Coverage (x64-windows only)
+      ##########################################################################
+      - name: Install LLVM
         if: ${{ matrix.triplet == 'x64-windows' }}
-        run: choco install opencppcoverage -y
+        run: |
+          choco install llvm -y
+
+      - name: Clean Build Directory for Coverage
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: pwsh
+        run: |
+          $buildDir = "cmake-build/build/${{ matrix.preset }}"
+          if (Test-Path $buildDir) {
+            Write-Host "Cleaning build directory to prevent compiler conflict: $buildDir"
+            Remove-Item -Path $buildDir -Recurse -Force
+          }
 
       - name: Build Debug for Coverage
         if: ${{ matrix.triplet == 'x64-windows' }}
         shell: bash
         run: |
           cmake --preset ${{ matrix.preset }} \
+            -DCMAKE_C_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" \
+            -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" \
+            -DCMAKE_LINKER="C:/Program Files/LLVM/bin/lld-link.exe" \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
             -DOMATH_ENABLE_COVERAGE=ON \
+            -DOMATH_THREAT_WARNING_AS_ERROR=OFF \
             -DCMAKE_BUILD_TYPE=Debug \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
           cmake --build cmake-build/build/${{ matrix.preset }} --config Debug --target unit_tests omath
 
-      - name: Run Coverage
+      - name: Run Tests (Generates .profraw)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: pwsh
+        env:
+          LLVM_PROFILE_FILE: "cmake-build/build/${{ matrix.preset }}/unit_tests.profraw"
+        run: |
+          ./out/Debug/unit_tests.exe
+
+      - name: Process Coverage (llvm-profdata & llvm-cov)
         if: ${{ matrix.triplet == 'x64-windows' }}
         shell: pwsh
         run: |
-          $env:Path = "C:\Program Files\OpenCppCoverage;$env:Path"
-          cmake --build cmake-build/build/${{ matrix.preset }} --target coverage --config Debug
-        
-      - name: Upload Coverage
+          $BUILD_DIR = "cmake-build/build/${{ matrix.preset }}"
+          $EXE_PATH = "./out/Debug/unit_tests.exe"
+          
+          # 1. Merge raw profile data (essential step)
+          & "C:/Program Files/LLVM/bin/llvm-profdata.exe" merge `
+            -sparse "$BUILD_DIR/unit_tests.profraw" `
+            -o "$BUILD_DIR/unit_tests.profdata"
+
+          # 2. Export to LCOV format
+          #    NOTE: We explicitly ignore vcpkg_installed and system headers
+          & "C:/Program Files/LLVM/bin/llvm-cov.exe" export "$EXE_PATH" `
+            -instr-profile="$BUILD_DIR/unit_tests.profdata" `
+            -format=lcov `
+            -ignore-filename-regex="vcpkg_installed|external|tests" `
+            > "$BUILD_DIR/lcov.info"
+
+          if (Test-Path "$BUILD_DIR/lcov.info") {
+            Write-Host "✅ LCOV info created at $BUILD_DIR/lcov.info"
+          } else {
+            Write-Error "Failed to create LCOV info"
+            exit 1
+          }
+
+      - name: Install LCOV (for genhtml)
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        run: choco install lcov -y
+
+      - name: Generate HTML Report
+        if: ${{ matrix.triplet == 'x64-windows' }}
+        shell: bash
+        run: |
+          BUILD_DIR="cmake-build/build/${{ matrix.preset }}"
+          LCOV_INFO="${BUILD_DIR}/lcov.info"
+          HTML_DIR="${BUILD_DIR}/coverage-html"
+
+          # Fix paths for genhtml (Perl hates backslashes)
+          sed -i 's|\\|/|g' "${LCOV_INFO}"
+          
+          # Locate genhtml provided by 'choco install lcov'
+          # It is typically in ProgramData/chocolatey/lib/lcov/tools/bin
+          GENHTML=$(find /c/ProgramData/chocolatey -name genhtml -print -quit)
+          
+          if [ -z "$GENHTML" ]; then
+            echo "Error: genhtml executable not found"
+            exit 1
+          fi
+          
+          echo "Using genhtml: $GENHTML"
+          mkdir -p "$HTML_DIR"
+          
+          # Run genhtml
+          # Added --demangle-cpp if your version supports it, otherwise remove it
+          perl "$GENHTML" \
+            "${LCOV_INFO}" \
+            --output-directory "$HTML_DIR" \
+            --title "OMath Coverage Report" \
+            --legend \
+            --show-details \
+            --branch-coverage \
+            --ignore-errors source
+            
+          echo "✅ LCOV HTML report generated at $HTML_DIR"
+
+      - name: Upload Coverage (HTML Report)
         if: ${{ matrix.triplet == 'x64-windows' }}
         uses: actions/upload-artifact@v4
         with:
-          name: coverage-report-windows
-          path: cmake-build/build/${{ matrix.preset }}/coverage/
+          name: coverage-html-windows
+          path: cmake-build/build/${{ matrix.preset }}/coverage-html/
 
       - name: Upload logs on failure
         if: ${{ failure() }}
@@ -282,7 +373,7 @@ jobs:
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
             -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
 
       - name: Build
         shell: bash
@@ -359,7 +450,7 @@ jobs:
             -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
         shell: bash
@@ -418,7 +509,7 @@ jobs:
             cmake --preset ${{ matrix.preset }} \
               -DOMATH_BUILD_TESTS=ON \
               -DOMATH_BUILD_BENCHMARK=OFF \
-              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests" \
+              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" \
               -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
             cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
             ./out/Release/unit_tests
@@ -490,7 +581,7 @@ jobs:
             -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
         shell: bash
@@ -559,7 +650,7 @@ jobs:
             -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
         shell: bash
@@ -644,7 +735,7 @@ jobs:
             -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
         run: |
@@ -662,3 +753,61 @@ jobs:
           path: |
             cmake-build/build/${{ matrix.preset }}/**/*.log
             ${{ env.VCPKG_ROOT }}/buildtrees/**/*.log
+
+
+  ##############################################################################
+  # 9)  Valgrind Memory Check
+  ##############################################################################
+  valgrind-memory-check:
+    name: Valgrind Analysis (All Targets)
+    runs-on: ubuntu-latest
+    needs: [linux-build-and-test]
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+    steps:
+      - name: Install toolchain
+        shell: bash
+        run: |
+          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+          sudo add-apt-repository -y "deb http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main"
+          sudo apt-get update
+          sudo apt-get install -y git build-essential cmake ninja-build \
+            zip unzip curl pkg-config ca-certificates \
+            clang-21 lld-21 libc++-21-dev libc++abi-21-dev \
+            llvm-21 valgrind libxmu-dev libxi-dev libgl-dev libxinerama-dev libxcursor-dev xorg-dev libglu1-mesa-dev
+          sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-21 100
+          sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-21 100
+          sudo update-alternatives --install /usr/bin/lld lld /usr/bin/lld-21 100
+
+      - name: Checkout repository (with sub-modules)
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up vcpkg
+        shell: bash
+        run: |
+          git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+
+      - name: Configure (cmake --preset)
+        shell: bash
+        run: |
+          cmake --preset linux-release-vcpkg \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DOMATH_BUILD_EXAMPLES=OFF \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=ON \
+            -DOMATH_ENABLE_VALGRIND=ON \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;lua;tests;benchmark"
+
+      - name: Build All Targets
+        shell: bash
+        run: cmake --build cmake-build/build/linux-release-vcpkg
+
+      - name: Run Valgrind (All Registered Targets)
+        shell: bash
+        working-directory: cmake-build/build/linux-release-vcpkg
+        run: |
+          cmake --build . --target valgrind_all

.github/workflows/release.yml

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

.gitignore

@@ -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" />

.luarc.json

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

.vscode/launch.json

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

CMakeLists.txt

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

CMakePresets.json

@@ -145,7 +145,7 @@
       "hidden": true,
       "inherits": ["linux-base", "vcpkg-base"],
       "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;lua"
       }
     },
     {
@@ -235,7 +235,7 @@
       "hidden": true,
       "inherits": ["darwin-base", "vcpkg-base"],
       "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua"
       }
     },
     {

CODEOWNERS

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

INSTALL.md

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

LICENSE

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

README.md

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

VERSION

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

benchmark/CMakeLists.txt

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

benchmark/benchmark_collision.cpp

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

cmake/Coverage.cmake

@@ -6,117 +6,62 @@ function(omath_setup_coverage TARGET_NAME)
         return()
     endif()
 
-    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
-        # Apply to ALL configs when coverage is enabled (not just Debug)
-        target_compile_options(${TARGET_NAME} PRIVATE
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
+        target_compile_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping
+                                                      /Zi)
+        target_link_options(
+            ${TARGET_NAME}
+            PRIVATE
             -fprofile-instr-generate
             -fcoverage-mapping
-            -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
-        )
-
-    elseif(MSVC)
-        target_compile_options(${TARGET_NAME} PRIVATE
-            /Zi
-            /Od
-            /Ob0
-        )
-        target_link_options(${TARGET_NAME} PRIVATE
             /DEBUG:FULL
             /INCREMENTAL:NO
-        )
+            /PROFILE)
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
+        target_compile_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping
+                                                      -g -O0)
+        target_link_options(${TARGET_NAME} PRIVATE -fprofile-instr-generate -fcoverage-mapping)
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(${TARGET_NAME} PRIVATE --coverage -g -O0)
+        target_link_options(${TARGET_NAME} PRIVATE --coverage)
     endif()
 
-    # Create coverage target only once
     if(TARGET coverage)
         return()
     endif()
 
-    if(MSVC OR MINGW)
-        # Windows: OpenCppCoverage
-        find_program(OPENCPPCOVERAGE_EXECUTABLE 
-            NAMES OpenCppCoverage OpenCppCoverage.exe
-            PATHS
-                "$ENV{ProgramFiles}/OpenCppCoverage"
-                "$ENV{ProgramW6432}/OpenCppCoverage"
-                "C:/Program Files/OpenCppCoverage"
-            DOC "Path to OpenCppCoverage executable"
-        )
-
-        if(NOT OPENCPPCOVERAGE_EXECUTABLE)
-            message(WARNING "OpenCppCoverage not found. Install with: choco install opencppcoverage")
-            set(OPENCPPCOVERAGE_EXECUTABLE "C:/Program Files/OpenCppCoverage/OpenCppCoverage.exe")
-        else()
-            message(STATUS "Found OpenCppCoverage: ${OPENCPPCOVERAGE_EXECUTABLE}")
-        endif()
-
-        file(TO_NATIVE_PATH "${CMAKE_SOURCE_DIR}" COVERAGE_ROOT_PATH)
-        file(TO_NATIVE_PATH "${CMAKE_BINARY_DIR}/coverage" COVERAGE_OUTPUT_PATH)
-        file(TO_NATIVE_PATH "${CMAKE_BINARY_DIR}/coverage.xml" COVERAGE_XML_PATH)
-        file(TO_NATIVE_PATH "${OPENCPPCOVERAGE_EXECUTABLE}" OPENCPPCOVERAGE_NATIVE)
-
-        add_custom_target(coverage
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
+        message(STATUS "MSVC detected: Use VS Code Coverage from CI workflow")
+        add_custom_target(
+            coverage
             DEPENDS unit_tests
-            COMMAND "${OPENCPPCOVERAGE_NATIVE}"
-                --verbose
-                --sources "${COVERAGE_ROOT_PATH}"
-                --modules "${COVERAGE_ROOT_PATH}"
-                --excluded_sources "*\\tests\\*"
-                --excluded_sources "*\\gtest\\*"
-                --excluded_sources "*\\googletest\\*"
-                --excluded_sources "*\\_deps\\*"
-                --excluded_sources "*\\vcpkg_installed\\*"
-                --export_type "html:${COVERAGE_OUTPUT_PATH}"
-                --export_type "cobertura:${COVERAGE_XML_PATH}"
-                --cover_children
-                -- "$<TARGET_FILE:unit_tests>"
+            COMMAND $<TARGET_FILE:unit_tests>
             WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-            COMMENT "Running OpenCppCoverage"
-        )
+            COMMENT "Running tests for coverage (use VS Code Coverage from CI)")
 
     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang")
-        # Linux/macOS: LLVM coverage via script
-        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")
-        # GCC: lcov/gcov
-        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

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

examples/CMakeLists.txt

@@ -1,32 +1,10 @@
-project(examples)
+add_subdirectory(example_barycentric)
+add_subdirectory(example_glfw3)
+add_subdirectory(example_proj_mat_builder)
+add_subdirectory(example_signature_scan)
 
-add_executable(example_projection_matrix_builder example_proj_mat_builder.cpp)
-set_target_properties(example_projection_matrix_builder PROPERTIES
-        CXX_STANDARD 26
-        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)
+if(OMATH_ENABLE_VALGRIND)
+    omath_setup_valgrind(example_projection_matrix_builder)
+    omath_setup_valgrind(example_signature_scan)
+    omath_setup_valgrind(example_glfw3)
+endif()

examples/example_barycentric/CMakeLists.txt

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

examples/example_barycentric/example_barycentric.cpp

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

examples/example_glfw3/CMakeLists.txt

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

examples/example_glfw3/example_glfw3.cpp

@@ -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 ----------
@@ -239,8 +265,8 @@ int main()
 
     // flatten EBO to GL indices
     std::vector<GLuint> flatIndices;
-    flatIndices.reserve(cube.m_vertex_array_object.size() * 3);
-    for (const auto& tri : cube.m_vertex_array_object)
+    flatIndices.reserve(cube.m_element_buffer_object.size() * 3);
+    for (const auto& tri : cube.m_element_buffer_object)
     {
         flatIndices.push_back(tri.x);
         flatIndices.push_back(tri.y);
@@ -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/3d_primitives/box.hpp

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

include/omath/3d_primitives/mesh.hpp

@@ -25,16 +25,17 @@ namespace omath::primitives
     template<typename T> concept HasNormal = requires(T vertex) { vertex.normal; };
     template<typename T> concept HasUv = requires(T vertex) { vertex.uv; };
 
-    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex<>>
+    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex<>,
+             class VboType = std::vector<VertType>, class EboType = std::vector<Vector3<std::uint32_t>>>
     class Mesh final
     {
     public:
         using VectorType = VertType::VectorType;
-        using VertexType = VertType;
+        using VertexType = VboType::value_type;
 
     private:
-        using Vbo = std::vector<VertexType>;
-        using Ebo = std::vector<Vector3<std::uint32_t>>;
+        using Vbo = VboType;
+        using Ebo = EboType;
 
     public:
         Vbo m_vertex_buffer;
@@ -100,20 +101,26 @@ namespace omath::primitives
 
         [[nodiscard]]
         VectorType vertex_position_to_world_space(const Vector3<float>& vertex_position) const
-        requires HasPosition<VertexType>
         {
-            auto abs_vec = get_to_world_matrix() * mat_column_from_vector<typename Mat4X4::ContainedType, Mat4X4::get_store_ordering()>(vertex_position);
+            auto abs_vec = get_to_world_matrix()
+                           * mat_column_from_vector<typename Mat4X4::ContainedType, Mat4X4::get_store_ordering()>(
+                                   vertex_position);
 
             return {abs_vec.at(0, 0), abs_vec.at(1, 0), abs_vec.at(2, 0)};
         }
 
         [[nodiscard]]
         Triangle<VectorType> make_face_in_world_space(const Ebo::const_iterator vao_iterator) const
-        requires HasPosition<VertexType>
         {
-            return {vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->x).position),
-                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->y).position),
-                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->z).position)};
+            if constexpr (HasPosition<VertexType>)
+            {
+                return {vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->x).position),
+                        vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->y).position),
+                        vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->z).position)};
+            }
+            return {vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->x)),
+                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->y)),
+                    vertex_position_to_world_space(m_vertex_buffer.at(vao_iterator->z))};
         }
 
     private:

include/omath/3d_primitives/plane.hpp

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

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

include/omath/collision/mesh_collider.hpp

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

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

include/omath/engines/cry_engine/camera.hpp

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

include/omath/engines/cry_engine/constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Vlad on 10/21/2025.
+//
+
+#pragma once
+#include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <omath/trigonometry/angle.hpp>
+#include <omath/trigonometry/view_angles.hpp>
+
+namespace omath::cry_engine
+{
+    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<float> k_abs_right = {1, 0, 0};
+    constexpr Vector3<float> k_abs_forward = {0, 1, 0};
+
+    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
+    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+
+    using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
+} // namespace omath::cry_engine

include/omath/engines/cry_engine/formulas.hpp

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

include/omath/engines/cry_engine/mesh.hpp

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

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

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

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

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

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

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

include/omath/engines/frostbite_engine/formulas.hpp

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

include/omath/engines/frostbite_engine/primitives.hpp

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

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

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

include/omath/engines/iw_engine/formulas.hpp

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

include/omath/engines/iw_engine/primitives.hpp

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

include/omath/engines/opengl_engine/camera.hpp

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

include/omath/engines/opengl_engine/formulas.hpp

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

include/omath/engines/opengl_engine/primitives.hpp

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

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

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

include/omath/engines/source_engine/formulas.hpp

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

include/omath/engines/source_engine/primitives.hpp

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

include/omath/engines/unity_engine/camera.hpp

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

include/omath/engines/unity_engine/formulas.hpp

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

include/omath/engines/unity_engine/primitives.hpp

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

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

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

include/omath/engines/unreal_engine/formulas.hpp

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

include/omath/engines/unreal_engine/primitives.hpp

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

include/omath/linear_algebra/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/lua/lua.hpp

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

include/omath/omath.hpp

@@ -17,6 +17,9 @@
 // Matrix classes
 #include "omath/linear_algebra/mat.hpp"
 
+// Quaternion
+#include "omath/linear_algebra/quaternion.hpp"
+
 // Color functionality
 #include "omath/utility/color.hpp"
 

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

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

include/omath/utility/macho_pattern_scan.hpp

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

include/omath/utility/pe_pattern_scan.hpp

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

include/omath/utility/section_scan_result.hpp

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

pixi.toml

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

pixi/fmt.cmake

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

pixi/run.benchmark.cmake

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

pixi/run.examples.cmake

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

pixi/run.unit.tests.cmake

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

scripts/cmake-format.sh

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

scripts/valgrind.sh

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

source/3d_primitives/box.cpp

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

source/3d_primitives/plane.cpp

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

source/collision/line_tracer.cpp

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

source/engines/cry_engine/formulas.cpp

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

source/engines/cry_engine/traits/camera_trait.cpp

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

source/lua/lua.cpp

@@ -0,0 +1,27 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "lua.hpp"
+#include <sol/sol.hpp>
+#include "omath/lua/lua.hpp"
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_lib(lua_State* lua_state)
+    {
+        sol::state_view lua(lua_state);
+
+        auto omath_table = lua["omath"].get_or_create<sol::table>();
+
+        register_vec2(omath_table);
+        register_vec3(omath_table);
+        register_vec4(omath_table);
+        register_color(omath_table);
+        register_triangle(omath_table);
+        register_shared_types(omath_table);
+        register_engines(omath_table);
+        register_pattern_scan(omath_table);
+    }
+} // namespace omath::lua
+#endif

source/lua/lua_color.cpp

@@ -0,0 +1,46 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <sol/sol.hpp>
+#include <omath/utility/color.hpp>
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_color(sol::table& omath_table)
+    {
+        omath_table.new_usertype<omath::Color>(
+                "Color",
+                sol::factories([](float r, float g, float b, float a) { return omath::Color(r, g, b, a); },
+                               []() { return omath::Color(); }),
+
+                "from_rgba", [](uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+                { return omath::Color::from_rgba(r, g, b, a); }, "from_hsv",
+                sol::overload([](float h, float s, float v) { return omath::Color::from_hsv(h, s, v); },
+                              [](const omath::Hsv& hsv) { return omath::Color::from_hsv(hsv); }),
+                "red", []() { return omath::Color::red(); }, "green", []() { return omath::Color::green(); }, "blue",
+                []() { return omath::Color::blue(); },
+
+                "r", sol::property([](const omath::Color& c) { return c.value().x; }), "g",
+                sol::property([](const omath::Color& c) { return c.value().y; }), "b",
+                sol::property([](const omath::Color& c) { return c.value().z; }), "a",
+                sol::property([](const omath::Color& c) { return c.value().w; }),
+
+                "to_hsv", &omath::Color::to_hsv, "set_hue", &omath::Color::set_hue, "set_saturation",
+                &omath::Color::set_saturation, "set_value", &omath::Color::set_value, "blend", &omath::Color::blend,
+
+                sol::meta_function::to_string, &omath::Color::to_string);
+
+        omath_table.new_usertype<omath::Hsv>(
+                "Hsv", sol::constructors<omath::Hsv()>(), "hue",
+                sol::property([](const omath::Hsv& h) { return h.hue; }, [](omath::Hsv& h, float val) { h.hue = val; }),
+                "saturation",
+                sol::property([](const omath::Hsv& h) { return h.saturation; },
+                              [](omath::Hsv& h, float val) { h.saturation = val; }),
+                "value",
+                sol::property([](const omath::Hsv& h) { return h.value; },
+                              [](omath::Hsv& h, float val) { h.value = val; }));
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engines.cpp

@@ -0,0 +1,227 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <omath/engines/cry_engine/camera.hpp>
+#include <omath/engines/frostbite_engine/camera.hpp>
+#include <omath/engines/iw_engine/camera.hpp>
+#include <omath/engines/opengl_engine/camera.hpp>
+#include <omath/engines/source_engine/camera.hpp>
+#include <omath/engines/unity_engine/camera.hpp>
+#include <omath/engines/unreal_engine/camera.hpp>
+#include <sol/sol.hpp>
+#include <string_view>
+
+namespace
+{
+    // ---- Canonical shared C++ type aliases ----------------------------------
+    // Each unique template instantiation must be registered exactly once.
+
+    using PitchAngle90 = omath::Angle<float, -90.f, 90.f, omath::AngleFlags::Clamped>;
+    using PitchAngle89 = omath::Angle<float, -89.f, 89.f, omath::AngleFlags::Clamped>;
+    using SharedYawRoll = omath::Angle<float, -180.f, 180.f, omath::AngleFlags::Normalized>;
+    using SharedFoV = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>;
+    using ViewAngles90 = omath::ViewAngles<PitchAngle90, SharedYawRoll, SharedYawRoll>;
+    using ViewAngles89 = omath::ViewAngles<PitchAngle89, SharedYawRoll, SharedYawRoll>;
+
+    std::string projection_error_to_string(omath::projection::Error e)
+    {
+        switch (e)
+        {
+        case omath::projection::Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS:
+            return "world position is out of screen bounds";
+        case omath::projection::Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO:
+            return "inverse view-projection matrix determinant is zero";
+        }
+        return "unknown error";
+    }
+
+    template<class AngleType>
+    void register_angle(sol::table& table, const char* name)
+    {
+        table.new_usertype<AngleType>(
+                name, sol::no_constructor, "from_degrees", &AngleType::from_degrees, "from_radians",
+                &AngleType::from_radians, "as_degrees", &AngleType::as_degrees, "as_radians", &AngleType::as_radians,
+                "sin", &AngleType::sin, "cos", &AngleType::cos, "tan", &AngleType::tan, "cot", &AngleType::cot,
+                sol::meta_function::addition, [](const AngleType& a, const AngleType& b)
+                { return AngleType::from_degrees(a.as_degrees() + b.as_degrees()); }, sol::meta_function::subtraction,
+                [](const AngleType& a, const AngleType& b)
+                { return AngleType::from_degrees(a.as_degrees() - b.as_degrees()); }, sol::meta_function::unary_minus,
+                [](const AngleType& a) { return AngleType::from_degrees(-a.as_degrees()); },
+                sol::meta_function::equal_to, [](const AngleType& a, const AngleType& b) { return a == b; },
+                sol::meta_function::to_string, [](const AngleType& a) { return std::format("{}deg", a.as_degrees()); });
+    }
+
+    // Set aliases in an engine subtable pointing to the already-registered shared types
+    template<class PitchAngleType, class ViewAnglesType>
+    void set_engine_aliases(sol::table& engine_table, sol::table& types)
+    {
+        if constexpr (std::is_same_v<PitchAngleType, PitchAngle90>)
+            engine_table["PitchAngle"] = types["PitchAngle90"];
+        else
+            engine_table["PitchAngle"] = types["PitchAngle89"];
+
+        engine_table["YawAngle"] = types["YawRoll"];
+        engine_table["RollAngle"] = types["YawRoll"];
+        engine_table["FieldOfView"] = types["FieldOfView"];
+        engine_table["ViewPort"] = types["ViewPort"];
+
+        if constexpr (std::is_same_v<ViewAnglesType, ViewAngles90>)
+            engine_table["ViewAngles"] = types["ViewAngles90"];
+        else
+            engine_table["ViewAngles"] = types["ViewAngles89"];
+    }
+
+    // Register an engine: alias shared types, register unique Camera
+    template<class EngineTraits>
+    void register_engine(sol::table& omath_table, const char* subtable_name)
+    {
+        using PitchAngle = typename EngineTraits::PitchAngle;
+        using ViewAngles = typename EngineTraits::ViewAngles;
+        using Camera = typename EngineTraits::Camera;
+
+        auto engine_table = omath_table[subtable_name].get_or_create<sol::table>();
+        auto types = omath_table["_types"].get<sol::table>();
+
+        set_engine_aliases<PitchAngle, ViewAngles>(engine_table, types);
+
+        engine_table.new_usertype<Camera>(
+                "Camera",
+                sol::constructors<Camera(const omath::Vector3<float>&, const ViewAngles&,
+                                         const omath::projection::ViewPort&, const omath::projection::FieldOfView&,
+                                         float, float)>(),
+                "look_at", &Camera::look_at, "get_forward", &Camera::get_forward, "get_right", &Camera::get_right,
+                "get_up", &Camera::get_up, "get_origin", &Camera::get_origin, "get_view_angles",
+                &Camera::get_view_angles, "get_near_plane", &Camera::get_near_plane, "get_far_plane",
+                &Camera::get_far_plane, "get_field_of_view", &Camera::get_field_of_view, "set_origin",
+                &Camera::set_origin, "set_view_angles", &Camera::set_view_angles, "set_view_port",
+                &Camera::set_view_port, "set_field_of_view", &Camera::set_field_of_view, "set_near_plane",
+                &Camera::set_near_plane, "set_far_plane", &Camera::set_far_plane,
+
+                "world_to_screen",
+                [](const Camera& cam, const omath::Vector3<float>& pos)
+                        -> std::tuple<sol::optional<omath::Vector3<float>>, sol::optional<std::string>>
+                {
+                    auto result = cam.world_to_screen(pos);
+                    if (result)
+                        return {*result, sol::nullopt};
+                    return {sol::nullopt, projection_error_to_string(result.error())};
+                },
+
+                "screen_to_world",
+                [](const Camera& cam, const omath::Vector3<float>& pos)
+                        -> std::tuple<sol::optional<omath::Vector3<float>>, sol::optional<std::string>>
+                {
+                    auto result = cam.screen_to_world(pos);
+                    if (result)
+                        return {*result, sol::nullopt};
+                    return {sol::nullopt, projection_error_to_string(result.error())};
+                });
+    }
+
+    // ---- Engine trait structs -----------------------------------------------
+
+    struct OpenGLEngineTraits
+    {
+        using PitchAngle = omath::opengl_engine::PitchAngle;
+        using ViewAngles = omath::opengl_engine::ViewAngles;
+        using Camera = omath::opengl_engine::Camera;
+    };
+    struct FrostbiteEngineTraits
+    {
+        using PitchAngle = omath::frostbite_engine::PitchAngle;
+        using ViewAngles = omath::frostbite_engine::ViewAngles;
+        using Camera = omath::frostbite_engine::Camera;
+    };
+    struct IWEngineTraits
+    {
+        using PitchAngle = omath::iw_engine::PitchAngle;
+        using ViewAngles = omath::iw_engine::ViewAngles;
+        using Camera = omath::iw_engine::Camera;
+    };
+    struct SourceEngineTraits
+    {
+        using PitchAngle = omath::source_engine::PitchAngle;
+        using ViewAngles = omath::source_engine::ViewAngles;
+        using Camera = omath::source_engine::Camera;
+    };
+    struct UnityEngineTraits
+    {
+        using PitchAngle = omath::unity_engine::PitchAngle;
+        using ViewAngles = omath::unity_engine::ViewAngles;
+        using Camera = omath::unity_engine::Camera;
+    };
+    struct UnrealEngineTraits
+    {
+        using PitchAngle = omath::unreal_engine::PitchAngle;
+        using ViewAngles = omath::unreal_engine::ViewAngles;
+        using Camera = omath::unreal_engine::Camera;
+    };
+    struct CryEngineTraits
+    {
+        using PitchAngle = omath::cry_engine::PitchAngle;
+        using ViewAngles = omath::cry_engine::ViewAngles;
+        using Camera = omath::cry_engine::Camera;
+    };
+} // namespace
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_shared_types(sol::table& omath_table)
+    {
+        auto t = omath_table["_types"].get_or_create<sol::table>();
+
+        register_angle<PitchAngle90>(t, "PitchAngle90");
+        register_angle<PitchAngle89>(t, "PitchAngle89");
+        register_angle<SharedYawRoll>(t, "YawRoll");
+        register_angle<SharedFoV>(t, "FieldOfView");
+
+        t.new_usertype<omath::projection::ViewPort>(
+                "ViewPort", sol::factories([](float w, float h) { return omath::projection::ViewPort{w, h}; }), "width",
+                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_width; },
+                              [](omath::projection::ViewPort& vp, float val) { vp.m_width = val; }),
+                "height",
+                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_height; },
+                              [](omath::projection::ViewPort& vp, float val) { vp.m_height = val; }),
+                "aspect_ratio", &omath::projection::ViewPort::aspect_ratio);
+
+        t.new_usertype<ViewAngles90>(
+                "ViewAngles90",
+                sol::factories([](PitchAngle90 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles90{p, y, r}; }),
+                "pitch",
+                sol::property([](const ViewAngles90& va) { return va.pitch; },
+                              [](ViewAngles90& va, const PitchAngle90& val) { va.pitch = val; }),
+                "yaw",
+                sol::property([](const ViewAngles90& va) { return va.yaw; },
+                              [](ViewAngles90& va, const SharedYawRoll& val) { va.yaw = val; }),
+                "roll",
+                sol::property([](const ViewAngles90& va) { return va.roll; },
+                              [](ViewAngles90& va, const SharedYawRoll& val) { va.roll = val; }));
+
+        t.new_usertype<ViewAngles89>(
+                "ViewAngles89",
+                sol::factories([](PitchAngle89 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles89{p, y, r}; }),
+                "pitch",
+                sol::property([](const ViewAngles89& va) { return va.pitch; },
+                              [](ViewAngles89& va, const PitchAngle89& val) { va.pitch = val; }),
+                "yaw",
+                sol::property([](const ViewAngles89& va) { return va.yaw; },
+                              [](ViewAngles89& va, const SharedYawRoll& val) { va.yaw = val; }),
+                "roll",
+                sol::property([](const ViewAngles89& va) { return va.roll; },
+                              [](ViewAngles89& va, const SharedYawRoll& val) { va.roll = val; }));
+    }
+
+    void LuaInterpreter::register_engines(sol::table& omath_table)
+    {
+        register_engine<OpenGLEngineTraits>(omath_table, "opengl");
+        register_engine<FrostbiteEngineTraits>(omath_table, "frostbite");
+        register_engine<IWEngineTraits>(omath_table, "iw");
+        register_engine<SourceEngineTraits>(omath_table, "source");
+        register_engine<UnityEngineTraits>(omath_table, "unity");
+        register_engine<UnrealEngineTraits>(omath_table, "unreal");
+        register_engine<CryEngineTraits>(omath_table, "cry");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_pattern_scan.cpp

@@ -0,0 +1,104 @@
+//
+// Created by orange on 10.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <format>
+#include <omath/utility/elf_pattern_scan.hpp>
+#include <omath/utility/macho_pattern_scan.hpp>
+#include <omath/utility/pattern_scan.hpp>
+#include <omath/utility/pe_pattern_scan.hpp>
+#include <omath/utility/section_scan_result.hpp>
+#include <sol/sol.hpp>
+#endif
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_pattern_scan(sol::table& omath_table)
+    {
+        omath_table.new_usertype<SectionScanResult>(
+                "SectionScanResult", sol::no_constructor,
+                "virtual_base_addr",
+                sol::property([](const SectionScanResult& r) { return r.virtual_base_addr; }),
+                "raw_base_addr",
+                sol::property([](const SectionScanResult& r) { return r.raw_base_addr; }),
+                "target_offset",
+                sol::property([](const SectionScanResult& r) { return r.target_offset; }),
+                sol::meta_function::to_string,
+                [](const SectionScanResult& r)
+                {
+                    return std::format("SectionScanResult(vbase=0x{:X}, raw_base=0x{:X}, offset={})",
+                                       r.virtual_base_addr, r.raw_base_addr, r.target_offset);
+                });
+
+        // Generic scanner: accepts a Lua string as a byte buffer
+        auto ps_table = omath_table["PatternScanner"].get_or_create<sol::table>();
+        ps_table["scan"] = [](const std::string& data, const std::string& pattern) -> sol::optional<std::ptrdiff_t>
+        {
+            const auto* begin = reinterpret_cast<const std::byte*>(data.data());
+            const auto* end = begin + data.size();
+            const auto* result = PatternScanner::scan_for_pattern(begin, end, pattern);
+            if (result == end)
+                return sol::nullopt;
+            return std::distance(begin, result);
+        };
+
+        auto pe_table = omath_table["PePatternScanner"].get_or_create<sol::table>();
+        pe_table["scan_in_module"] = [](std::uintptr_t base_addr, const std::string& pattern,
+                                        sol::optional<std::string> section) -> sol::optional<std::uintptr_t>
+        {
+            auto result = PePatternScanner::scan_for_pattern_in_loaded_module(reinterpret_cast<const void*>(base_addr),
+                                                                              pattern, section.value_or(".text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+        pe_table["scan_in_file"] = [](const std::string& path, const std::string& pattern,
+                                      sol::optional<std::string> section) -> sol::optional<SectionScanResult>
+        {
+            auto result = PePatternScanner::scan_for_pattern_in_file(std::filesystem::path(path), pattern,
+                                                                     section.value_or(".text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+        auto elf_table = omath_table["ElfPatternScanner"].get_or_create<sol::table>();
+        elf_table["scan_in_module"] = [](std::uintptr_t base_addr, const std::string& pattern,
+                                         sol::optional<std::string> section) -> sol::optional<std::uintptr_t>
+        {
+            auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(reinterpret_cast<const void*>(base_addr),
+                                                                               pattern, section.value_or(".text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+        elf_table["scan_in_file"] = [](const std::string& path, const std::string& pattern,
+                                       sol::optional<std::string> section) -> sol::optional<SectionScanResult>
+        {
+            auto result = ElfPatternScanner::scan_for_pattern_in_file(std::filesystem::path(path), pattern,
+                                                                      section.value_or(".text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+        auto macho_table = omath_table["MachOPatternScanner"].get_or_create<sol::table>();
+        macho_table["scan_in_module"] = [](std::uintptr_t base_addr, const std::string& pattern,
+                                           sol::optional<std::string> section) -> sol::optional<std::uintptr_t>
+        {
+            auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(
+                    reinterpret_cast<const void*>(base_addr), pattern, section.value_or("__text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+        macho_table["scan_in_file"] = [](const std::string& path, const std::string& pattern,
+                                         sol::optional<std::string> section) -> sol::optional<SectionScanResult>
+        {
+            auto result = MachOPatternScanner::scan_for_pattern_in_file(std::filesystem::path(path), pattern,
+                                                                        section.value_or("__text"));
+            if (!result)
+                return sol::nullopt;
+            return *result;
+        };
+    }
+} // namespace omath::lua

source/lua/lua_triangle.cpp

@@ -0,0 +1,48 @@
+//
+// Created by orange on 10.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <sol/sol.hpp>
+#include <omath/linear_algebra/triangle.hpp>
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_triangle(sol::table& omath_table)
+    {
+        using Vec3f = omath::Vector3<float>;
+        using Tri3f = omath::Triangle<Vec3f>;
+
+        omath_table.new_usertype<Tri3f>(
+                "Triangle", sol::constructors<Tri3f(), Tri3f(const Vec3f&, const Vec3f&, const Vec3f&)>(),
+
+                "vertex1",
+                sol::property([](const Tri3f& t) { return t.m_vertex1; },
+                              [](Tri3f& t, const Vec3f& v) { t.m_vertex1 = v; }),
+                "vertex2",
+                sol::property([](const Tri3f& t) { return t.m_vertex2; },
+                              [](Tri3f& t, const Vec3f& v) { t.m_vertex2 = v; }),
+                "vertex3",
+                sol::property([](const Tri3f& t) { return t.m_vertex3; },
+                              [](Tri3f& t, const Vec3f& v) { t.m_vertex3 = v; }),
+
+                "calculate_normal", &Tri3f::calculate_normal,
+                "side_a_length", &Tri3f::side_a_length,
+                "side_b_length", &Tri3f::side_b_length,
+                "side_a_vector", &Tri3f::side_a_vector,
+                "side_b_vector", &Tri3f::side_b_vector,
+                "hypot", &Tri3f::hypot,
+                "is_rectangular", &Tri3f::is_rectangular,
+                "mid_point", &Tri3f::mid_point,
+
+                sol::meta_function::to_string,
+                [](const Tri3f& t)
+                {
+                    return std::format("Triangle(({}, {}, {}), ({}, {}, {}), ({}, {}, {}))",
+                                       t.m_vertex1.x, t.m_vertex1.y, t.m_vertex1.z,
+                                       t.m_vertex2.x, t.m_vertex2.y, t.m_vertex2.z,
+                                       t.m_vertex3.x, t.m_vertex3.y, t.m_vertex3.z);
+                });
+    }
+} // namespace omath::lua
+#endif

source/lua/lua_vec2.cpp

@@ -0,0 +1,54 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <omath/linear_algebra/vector2.hpp>
+#include <sol/sol.hpp>
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_vec2(sol::table& omath_table)
+    {
+        using Vec2f = omath::Vector2<float>;
+
+        omath_table.new_usertype<Vec2f>(
+                "Vec2", sol::constructors<Vec2f(), Vec2f(float, float)>(),
+
+                "x", sol::property([](const Vec2f& v) { return v.x; }, [](Vec2f& v, const float val) { v.x = val; }),
+                "y", sol::property([](const Vec2f& v) { return v.y; }, [](Vec2f& v, const float val) { v.y = val; }),
+
+                sol::meta_function::addition, sol::resolve<Vec2f(const Vec2f&) const>(&Vec2f::operator+),
+                sol::meta_function::subtraction, sol::resolve<Vec2f(const Vec2f&) const>(&Vec2f::operator-),
+                sol::meta_function::unary_minus, sol::resolve<Vec2f() const>(&Vec2f::operator-),
+                sol::meta_function::equal_to, &Vec2f::operator==,
+                sol::meta_function::less_than, sol::resolve<bool(const Vec2f&) const>(&Vec2f::operator<),
+                sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const Vec2f&) const>(&Vec2f::operator<=),
+                sol::meta_function::to_string,
+                [](const Vec2f& v) { return std::format("Vec2({}, {})", v.x, v.y); },
+
+                sol::meta_function::multiplication,
+                sol::overload(sol::resolve<Vec2f(const float&) const>(&Vec2f::operator*),
+                              [](const float s, const Vec2f& v) { return v * s; }),
+
+                sol::meta_function::division,
+                sol::resolve<Vec2f(const float&) const>(&Vec2f::operator/),
+
+                "length", &Vec2f::length,
+                "length_sqr", &Vec2f::length_sqr,
+                "normalized", &Vec2f::normalized,
+                "dot", &Vec2f::dot,
+                "distance_to", &Vec2f::distance_to,
+                "distance_to_sqr", &Vec2f::distance_to_sqr,
+                "sum", &Vec2f::sum,
+
+                "abs",
+                [](const Vec2f& v)
+                {
+                    Vec2f copy = v;
+                    copy.abs();
+                    return copy;
+                });
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_vec3.cpp

@@ -0,0 +1,81 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <sol/sol.hpp>
+#include <omath/linear_algebra/vector3.hpp>
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_vec3(sol::table& omath_table)
+    {
+        using Vec3f = omath::Vector3<float>;
+
+        omath_table.new_usertype<Vec3f>(
+                "Vec3", sol::constructors<Vec3f(), Vec3f(float, float, float)>(),
+
+                "x", sol::property([](const Vec3f& v) { return v.x; }, [](Vec3f& v, float val) { v.x = val; }),
+                "y", sol::property([](const Vec3f& v) { return v.y; }, [](Vec3f& v, float val) { v.y = val; }),
+                "z", sol::property([](const Vec3f& v) { return v.z; }, [](Vec3f& v, float val) { v.z = val; }),
+
+                sol::meta_function::addition, sol::resolve<Vec3f(const Vec3f&) const>(&Vec3f::operator+),
+                sol::meta_function::subtraction, sol::resolve<Vec3f(const Vec3f&) const>(&Vec3f::operator-),
+                sol::meta_function::unary_minus, sol::resolve<Vec3f() const>(&Vec3f::operator-),
+                sol::meta_function::equal_to, &Vec3f::operator==, sol::meta_function::less_than,
+                sol::resolve<bool(const Vec3f&) const>(&Vec3f::operator<), sol::meta_function::less_than_or_equal_to,
+                sol::resolve<bool(const Vec3f&) const>(&Vec3f::operator<=), sol::meta_function::to_string,
+                [](const Vec3f& v) { return std::format("Vec3({}, {}, {})", v.x, v.y, v.z); },
+
+                sol::meta_function::multiplication,
+                sol::overload(sol::resolve<Vec3f(const float&) const>(&Vec3f::operator*),
+                              sol::resolve<Vec3f(const Vec3f&) const>(&Vec3f::operator*),
+                              [](const float s, const Vec3f& v) { return v * s; }),
+
+                sol::meta_function::division,
+                sol::overload(sol::resolve<Vec3f(const float&) const>(&Vec3f::operator/),
+                              sol::resolve<Vec3f(const Vec3f&) const>(&Vec3f::operator/)),
+
+                "length", &Vec3f::length, "length_2d", &Vec3f::length_2d, "length_sqr", &Vec3f::length_sqr,
+                "normalized", &Vec3f::normalized, "dot", &Vec3f::dot, "cross", &Vec3f::cross, "distance_to",
+                &Vec3f::distance_to, "distance_to_sqr", &Vec3f::distance_to_sqr, "sum",
+                sol::resolve<float() const>(&Vec3f::sum), "sum_2d", &Vec3f::sum_2d, "point_to_same_direction",
+                &Vec3f::point_to_same_direction, "as_array", &Vec3f::as_array,
+
+                "abs",
+                [](const Vec3f& v)
+                {
+                    Vec3f copy = v;
+                    copy.abs();
+                    return copy;
+                },
+
+                "angle_between",
+                [](const Vec3f& self,
+                   const Vec3f& other) -> std::tuple<sol::optional<float>, sol::optional<std::string>>
+                {
+                    auto result = self.angle_between(other);
+                    if (result)
+                        return std::make_tuple(sol::optional<float>(result->as_degrees()),
+                                               sol::optional<std::string>(sol::nullopt));
+                    return std::make_tuple(sol::optional<float>(sol::nullopt),
+                                           sol::optional<std::string>("impossible angle (zero-length vector)"));
+                },
+
+                "is_perpendicular",
+                [](const Vec3f& self, const Vec3f& other, sol::optional<float> eps)
+                { return self.is_perpendicular(other, eps.value_or(0.0001f)); },
+
+                "as_table",
+                [](const Vec3f& v, sol::this_state s) -> sol::table
+                {
+                    sol::state_view lua(s);
+                    sol::table t = lua.create_table();
+                    t["x"] = v.x;
+                    t["y"] = v.y;
+                    t["z"] = v.z;
+                    return t;
+                });
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_vec4.cpp

@@ -0,0 +1,62 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <sol/sol.hpp>
+#include <omath/linear_algebra/vector4.hpp>
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_vec4(sol::table& omath_table)
+    {
+        using Vec4f = omath::Vector4<float>;
+
+        omath_table.new_usertype<Vec4f>(
+                "Vec4", sol::constructors<Vec4f(), Vec4f(float, float, float, float)>(),
+
+                "x", sol::property([](const Vec4f& v) { return v.x; }, [](Vec4f& v, float val) { v.x = val; }),
+                "y", sol::property([](const Vec4f& v) { return v.y; }, [](Vec4f& v, float val) { v.y = val; }),
+                "z", sol::property([](const Vec4f& v) { return v.z; }, [](Vec4f& v, float val) { v.z = val; }),
+                "w", sol::property([](const Vec4f& v) { return v.w; }, [](Vec4f& v, float val) { v.w = val; }),
+
+                sol::meta_function::addition, sol::resolve<Vec4f(const Vec4f&) const>(&Vec4f::operator+),
+                sol::meta_function::subtraction, sol::resolve<Vec4f(const Vec4f&) const>(&Vec4f::operator-),
+                sol::meta_function::unary_minus, sol::resolve<Vec4f() const>(&Vec4f::operator-),
+                sol::meta_function::equal_to, &Vec4f::operator==,
+                sol::meta_function::less_than, sol::resolve<bool(const Vec4f&) const>(&Vec4f::operator<),
+                sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const Vec4f&) const>(&Vec4f::operator<=),
+                sol::meta_function::to_string,
+                [](const Vec4f& v) { return std::format("Vec4({}, {}, {}, {})", v.x, v.y, v.z, v.w); },
+
+                sol::meta_function::multiplication,
+                sol::overload(sol::resolve<Vec4f(const float&) const>(&Vec4f::operator*),
+                              sol::resolve<Vec4f(const Vec4f&) const>(&Vec4f::operator*),
+                              [](const float s, const Vec4f& v) { return v * s; }),
+
+                sol::meta_function::division,
+                sol::overload(sol::resolve<Vec4f(const float&) const>(&Vec4f::operator/),
+                              sol::resolve<Vec4f(const Vec4f&) const>(&Vec4f::operator/)),
+
+                "length", &Vec4f::length,
+                "length_sqr", &Vec4f::length_sqr,
+                "dot", &Vec4f::dot,
+                "sum", &Vec4f::sum,
+
+                "abs",
+                [](const Vec4f& v)
+                {
+                    Vec4f copy = v;
+                    copy.abs();
+                    return copy;
+                },
+
+                "clamp",
+                [](Vec4f& v, float mn, float mx)
+                {
+                    v.clamp(mn, mx);
+                    return v;
+                });
+    }
+} // namespace omath::lua::detail
+#endif

source/utility/elf_pattern_scan.cpp

@@ -0,0 +1,325 @@
+//
+// Created by Vladislav on 30.12.2025.
+//
+#include "omath/utility/pattern_scan.hpp"
+#include <array>
+#include <fstream>
+#include <omath/utility/elf_pattern_scan.hpp>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#pragma pack(push, 1)
+
+namespace
+{
+    // Common
+    constexpr uint8_t ei_nident = 16;
+    constexpr uint8_t ei_class = 4;
+
+    constexpr uint8_t elfclass32 = 1;
+    constexpr uint8_t elfclass64 = 2;
+    // ReSharper disable CppDeclaratorNeverUsed
+    struct Elf32Ehdr final
+    {
+        unsigned char e_ident[ei_nident];
+        uint16_t e_type;
+        uint16_t e_machine;
+        uint32_t e_version;
+        uint32_t e_entry;
+        uint32_t e_phoff;
+        uint32_t e_shoff;
+        uint32_t e_flags;
+        uint16_t e_ehsize;
+        uint16_t e_phentsize;
+        uint16_t e_phnum;
+        uint16_t e_shentsize;
+        uint16_t e_shnum;
+        uint16_t e_shstrndx;
+    };
+
+    struct Elf64Ehdr final
+    {
+        unsigned char e_ident[ei_nident];
+        uint16_t e_type;
+        uint16_t e_machine;
+        uint32_t e_version;
+        uint64_t e_entry;
+        uint64_t e_phoff;
+        uint64_t e_shoff;
+        uint32_t e_flags;
+        uint16_t e_ehsize;
+        uint16_t e_phentsize;
+        uint16_t e_phnum;
+        uint16_t e_shentsize;
+        uint16_t e_shnum;
+        uint16_t e_shstrndx;
+    };
+
+    struct Elf32Shdr final
+    {
+        uint32_t sh_name;
+        uint32_t sh_type;
+        uint32_t sh_flags;
+        uint32_t sh_addr;
+        uint32_t sh_offset;
+        uint32_t sh_size;
+        uint32_t sh_link;
+        uint32_t sh_info;
+        uint32_t sh_addralign;
+        uint32_t sh_entsize;
+    };
+
+    struct Elf64Shdr final
+    {
+        uint32_t sh_name;
+        uint32_t sh_type;
+        uint64_t sh_flags;
+        uint64_t sh_addr;
+        uint64_t sh_offset;
+        uint64_t sh_size;
+        uint32_t sh_link;
+        uint32_t sh_info;
+        uint64_t sh_addralign;
+        uint64_t sh_entsize;
+    };
+    // ReSharper restore CppDeclaratorNeverUsed
+#pragma pack(pop)
+} // namespace
+
+namespace
+{
+    enum class FileArch : std::int8_t
+    {
+        x32,
+        x64,
+    };
+    template<FileArch arch>
+    struct ElfHeaders
+    {
+        using FileHeader = std::conditional_t<arch == FileArch::x64, Elf64Ehdr, Elf32Ehdr>;
+        using SectionHeader = std::conditional_t<arch == FileArch::x64, Elf64Shdr, Elf32Shdr>;
+        FileHeader file_header;
+        SectionHeader section_header;
+    };
+    [[nodiscard]]
+    bool not_elf_file(std::fstream& file)
+    {
+        constexpr std::string_view valid_elf_signature = "\x7F"
+                                                         "ELF";
+        std::array<char, valid_elf_signature.size() + 1> elf_signature{};
+        const std::streampos back_up_pose = file.tellg();
+
+        file.seekg(0, std::ios_base::beg);
+        file.read(elf_signature.data(), 4);
+        file.seekg(back_up_pose, std::ios_base::beg);
+
+        return std::string_view{elf_signature.data(), 4} != valid_elf_signature;
+    }
+    [[nodiscard]]
+    std::optional<FileArch> get_file_arch(std::fstream& file)
+    {
+        std::array<char, ei_nident> e_ident{};
+        const std::streampos back_up_pose = file.tellg();
+
+        file.seekg(0, std::ios_base::beg);
+        file.read(e_ident.data(), e_ident.size());
+        file.seekg(back_up_pose, std::ios_base::beg);
+
+        if (e_ident[ei_class] == elfclass64)
+            return FileArch::x64;
+
+        if (e_ident[ei_class] == elfclass32)
+            return FileArch::x32;
+
+        return std::nullopt;
+    }
+    struct ExtractedSection final
+    {
+        std::uintptr_t virtual_base_addr{};
+        std::uintptr_t raw_base_addr{};
+        std::vector<std::byte> data;
+    };
+    [[maybe_unused]]
+    std::optional<ExtractedSection> get_elf_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 (not_elf_file(file)) [[unlikely]]
+            return std::nullopt;
+
+        const auto architecture = get_file_arch(file);
+
+        if (!architecture.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        std::variant<ElfHeaders<FileArch::x64>, ElfHeaders<FileArch::x32>> elf_headers;
+        if (architecture.value() == FileArch::x64)
+            elf_headers = ElfHeaders<FileArch::x64>{};
+        else if (architecture.value() == FileArch::x32)
+            elf_headers = ElfHeaders<FileArch::x32>{};
+
+        return std::visit(
+                [&](auto& header) -> std::optional<ExtractedSection>
+                {
+                    auto& [file_header, section_header] = header;
+                    file.seekg(0, std::ios_base::beg);
+                    if (!file.read(reinterpret_cast<char*>(&file_header), sizeof(file_header))) [[unlikely]]
+                        return std::nullopt;
+
+                    const std::streamoff shstr_off =
+                            static_cast<std::streamoff>(file_header.e_shoff)
+                            + static_cast<std::streamoff>(file_header.e_shstrndx) * sizeof(section_header);
+                    file.seekg(shstr_off, std::ios_base::beg);
+
+                    if (!file.read(reinterpret_cast<char*>(&section_header), sizeof(section_header))) [[unlikely]]
+                        return std::nullopt;
+
+                    std::vector<char> shstrtab(static_cast<std::size_t>(section_header.sh_size));
+
+                    file.seekg(section_header.sh_offset, std::ios_base::beg);
+
+                    if (!file.read(shstrtab.data(), static_cast<std::streamsize>(shstrtab.size()))) [[unlikely]]
+                        return std::nullopt;
+
+                    for (std::uint16_t i = 0; i < file_header.e_shnum; ++i)
+                    {
+                        decltype(section_header) current_section{};
+                        const std::streamoff off = static_cast<std::streamoff>(file_header.e_shoff)
+                                                   + static_cast<std::streamoff>(i) * sizeof(current_section);
+
+                        file.seekg(off, std::ios_base::beg);
+                        if (!file.read(reinterpret_cast<char*>(&current_section), sizeof(current_section))) [[unlikely]]
+                            return std::nullopt;
+
+                        if (current_section.sh_name >= shstrtab.size()) [[unlikely]]
+                            continue;
+
+                        // ReSharper disable once CppTooWideScopeInitStatement
+                        const std::string_view name = &shstrtab[current_section.sh_name];
+                        if (section_name != name)
+                            continue;
+
+                        ExtractedSection out;
+
+                        out.virtual_base_addr = static_cast<std::uintptr_t>(current_section.sh_addr);
+                        out.raw_base_addr = static_cast<std::uintptr_t>(current_section.sh_offset);
+                        out.data.resize(static_cast<std::size_t>(current_section.sh_size));
+
+                        file.seekg(static_cast<std::streamoff>(out.raw_base_addr), 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;
+                },
+                elf_headers);
+    }
+
+    template<class FileHeader, class SectionHeader>
+    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* file_header = reinterpret_cast<const FileHeader*>(base);
+
+        const auto shoff = static_cast<std::size_t>(file_header->e_shoff);
+        const auto shnum = static_cast<std::size_t>(file_header->e_shnum);
+        const auto shstrnd = static_cast<std::size_t>(file_header->e_shstrndx);
+
+        const auto shstrtab_off = shoff + shstrnd * sizeof(SectionHeader);
+        const auto* shstrtab_hdr = reinterpret_cast<const SectionHeader*>(base + shstrtab_off);
+
+        const auto shstrtab = reinterpret_cast<const char*>(base + static_cast<std::size_t>(shstrtab_hdr->sh_offset));
+
+        const auto shstrtab_size = static_cast<std::size_t>(shstrtab_hdr->sh_size);
+
+        for (std::size_t i = 0; i < shnum; ++i)
+        {
+            const auto section_off = shoff + i * sizeof(SectionHeader);
+            const auto* section = reinterpret_cast<const SectionHeader*>(base + section_off);
+
+            if (section->sh_size == 0)
+                continue;
+
+            if (std::cmp_greater_equal(section->sh_name, shstrtab_size))
+                continue;
+
+            if (std::string_view{shstrtab + section->sh_name} != target_section_name)
+                continue;
+
+            const auto* section_begin = base + static_cast<std::size_t>(section->sh_addr);
+            const auto* section_end = section_begin + static_cast<std::size_t>(section->sh_size);
+
+            const auto scan_result = omath::PatternScanner::scan_for_pattern(section_begin, section_end, pattern);
+            if (scan_result == section_end)
+                return std::nullopt;
+
+            return reinterpret_cast<std::uintptr_t>(scan_result);
+        }
+
+        return std::nullopt;
+    }
+} // namespace
+namespace omath
+{
+    std::optional<std::uintptr_t>
+    ElfPatternScanner::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);
+
+        // Validate ELF signature.
+        constexpr std::string_view valid_elf_signature = "\x7F"
+                                                         "ELF";
+        if (std::string_view{reinterpret_cast<const char*>(base), valid_elf_signature.size()} != valid_elf_signature)
+            return std::nullopt;
+
+        // Detect architecture.
+        const auto ei_class_value = static_cast<uint8_t>(base[ei_class]);
+        const auto arch = ei_class_value == elfclass64   ? FileArch::x64
+                          : ei_class_value == elfclass32 ? FileArch::x32
+                                                         : std::optional<FileArch>{};
+        if (!arch.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        if (arch == FileArch::x64)
+            return scan_in_module_impl<Elf64Ehdr, Elf64Shdr>(static_cast<const std::byte*>(module_base_address),
+                                                             pattern, target_section_name);
+        if (arch == FileArch::x32)
+            return scan_in_module_impl<Elf32Ehdr, Elf32Shdr>(static_cast<const std::byte*>(module_base_address),
+                                                             pattern, target_section_name);
+
+        std::unreachable();
+    }
+    std::optional<SectionScanResult>
+    ElfPatternScanner::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 pe_section = get_elf_section_by_name(path_to_file, target_section_name);
+
+        if (!pe_section.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        const auto scan_result =
+                PatternScanner::scan_for_pattern(pe_section->data.cbegin(), pe_section->data.cend(), pattern);
+
+        if (scan_result == pe_section->data.cend())
+            return std::nullopt;
+        const auto offset = std::distance(pe_section->data.begin(), scan_result);
+
+        return SectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
+                                 .raw_base_addr = pe_section->raw_base_addr,
+                                 .target_offset = offset};
+    }
+} // namespace omath

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,10 +237,10 @@ namespace
                           variant);
     }
 
-    struct ExtractedSection
+    struct ExtractedSection final
     {
-        std::uint64_t virtual_base_addr;
-        std::uint64_t raw_base_addr;
+        std::uintptr_t virtual_base_addr;
+        std::uintptr_t raw_base_addr;
         std::vector<std::byte> data;
     };
 
@@ -261,7 +261,7 @@ namespace
 
         const auto nt_headers = get_nt_header_from_file(file, dos_header);
 
-        if (!nt_headers)
+        if (!nt_headers) [[unlikely]]
             return std::nullopt;
 
         if (invalid_nt_header_file(nt_headers.value())) [[unlikely]]
@@ -290,10 +290,11 @@ namespace
                         file.seekg(current_section.ptr_raw_data, std::ios::beg);
                         file.read(reinterpret_cast<char*>(section_data.data()),
                                   static_cast<std::streamsize>(section_data.size()));
-                        return ExtractedSection{.virtual_base_addr = current_section.virtual_address
-                                                                     + concrete_headers.optional_header.image_base,
-                                                .raw_base_addr = current_section.ptr_raw_data,
-                                                .data = std::move(section_data)};
+                        return ExtractedSection{
+                                .virtual_base_addr = static_cast<std::uintptr_t>(
+                                        current_section.virtual_address + concrete_headers.optional_header.image_base),
+                                .raw_base_addr = static_cast<std::uintptr_t>(current_section.ptr_raw_data),
+                                .data = std::move(section_data)};
                     }
                     return std::nullopt;
                 },
@@ -304,46 +305,71 @@ namespace
 namespace omath
 {
 
-    std::optional<std::uintptr_t> PePatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
-                                                                                      const std::string_view& pattern)
+    std::optional<std::uintptr_t>
+    PePatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                                        const std::string_view& pattern,
+                                                        const std::string_view& target_section_name)
     {
         const auto base_address = reinterpret_cast<std::uintptr_t>(module_base_address);
+        const auto* base_bytes = static_cast<const std::byte*>(module_base_address);
 
         if (!base_address)
             return std::nullopt;
 
-        auto nt_header_variant = get_nt_header_from_loaded_module(module_base_address);
+        const auto* dos_header = static_cast<const DosHeader*>(module_base_address);
 
-        if (!nt_header_variant)
+        if (invalid_dos_header_file(*dos_header)) [[unlikely]]
+            return std::nullopt;
+
+        const auto nt_header_variant = get_nt_header_from_loaded_module(module_base_address);
+
+        if (!nt_header_variant) [[unlikely]]
             return std::nullopt;
 
         return std::visit(
-                [base_address, &pattern](const auto& nt_header) -> std::optional<std::uintptr_t>
+                [base_bytes, base_address, lfanew = dos_header->e_lfanew, &target_section_name,
+                 &pattern](const auto& nt_header) -> std::optional<std::uintptr_t>
                 {
-                    // Define .text segment as scan area
-                    const auto start = nt_header.optional_header.base_of_code;
-                    const auto scan_size = nt_header.optional_header.size_code;
+                    constexpr std::size_t signature_size = sizeof(nt_header.signature);
+                    const auto section_table_off = static_cast<std::size_t>(lfanew) + signature_size
+                                                   + sizeof(FileHeader) + nt_header.file_header.size_optional_header;
 
-                    const auto scan_range = std::span{reinterpret_cast<std::byte*>(base_address) + start, scan_size};
+                    const auto* section_table = reinterpret_cast<const SectionHeader*>(base_bytes + section_table_off);
 
-                    // ReSharper disable once CppTooWideScopeInitStatement
-                    const auto result = PatternScanner::scan_for_pattern(scan_range, pattern);
+                    for (std::size_t i = 0; i < nt_header.file_header.num_sections; ++i)
+                    {
+                        const auto* section = section_table + i;
 
-                    if (result != scan_range.end())
-                        return reinterpret_cast<std::uintptr_t>(&*result);
+                        if (std::string_view{section->name} != target_section_name || section->size_raw_data == 0)
+                            continue;
+
+                        const auto section_size = section->virtual_size != 0
+                                                          ? static_cast<std::size_t>(section->virtual_size)
+                                                          : static_cast<std::size_t>(section->size_raw_data);
+
+                        const auto* section_begin =
+                                reinterpret_cast<std::byte*>(base_address + section->virtual_address);
+                        const auto scan_range = std::span{section_begin, section_size};
+
+                        const auto result =
+                                PatternScanner::scan_for_pattern(scan_range.begin(), scan_range.end(), pattern);
+
+                        if (result != scan_range.end())
+                            return reinterpret_cast<std::uintptr_t>(&*result);
+                    }
 
                     return std::nullopt;
                 },
                 nt_header_variant.value());
     }
-    std::optional<PeSectionScanResult>
+    std::optional<SectionScanResult>
     PePatternScanner::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 pe_section = extract_section_from_pe_file(path_to_file, target_section_name);
 
-        if (!pe_section.has_value())
+        if (!pe_section.has_value()) [[unlikely]]
             return std::nullopt;
 
         const auto scan_result =
@@ -353,8 +379,8 @@ namespace omath
             return std::nullopt;
         const auto offset = std::distance(pe_section->data.begin(), scan_result);
 
-        return PeSectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
-                                   .raw_base_addr = pe_section->raw_base_addr,
-                                   .target_offset = offset};
+        return SectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
+                                 .raw_base_addr = pe_section->raw_base_addr,
+                                 .target_offset = offset};
     }
 } // namespace omath

tests/CMakeLists.txt

@@ -4,29 +4,46 @@ project(unit_tests)
 
 include(GoogleTest)
 
-file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
-add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES})
+file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp")
+add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp)
 
-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)
     target_link_libraries(${PROJECT_NAME} PRIVATE GTest::gtest GTest::gtest_main omath::omath)
 endif()
 
+if (OMATH_ENABLE_LUA)
+    file(GLOB_RECURSE UNIT_TESTS_SOURCES_LUA CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/lua/*.cpp")
+    target_compile_definitions(${PROJECT_NAME} PRIVATE LUA_SCRIPTS_DIR="${CMAKE_CURRENT_SOURCE_DIR}/lua")
+    target_sources(${PROJECT_NAME} PRIVATE ${UNIT_TESTS_SOURCES_LUA})
+    if (EMSCRIPTEN)
+        target_link_options(${PROJECT_NAME} PRIVATE
+            "SHELL:--embed-file ${CMAKE_CURRENT_SOURCE_DIR}/lua@${CMAKE_CURRENT_SOURCE_DIR}/lua")
+    endif()
+endif()
+
 if(OMATH_ENABLE_COVERAGE)
     include(${CMAKE_SOURCE_DIR}/cmake/Coverage.cmake)
     omath_setup_coverage(${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))
+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))
     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);
+}