Remove TOC gradient mask and add liquid glass to search results

Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>
Add dynamic mouse-tracking liquid glass effect (JS + CSS)
2026-02-13 07:03:25 +00:00 · 2026-02-07 01:35:03 +00:00 · 2026-02-07 01:26:14 +00:00 · 2026-02-07 01:18:20 +00:00 · 2026-02-07 00:55:51 +00:00 · 2026-02-07 00:48:58 +00:00
24 changed files with 1916 additions and 196 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@
 /clang-coverage/
 *.gcov
 *.bin
+/site/
 # pixi lock
 pixi.lock
 # pixi environments
--- a/docs/collision/collider_interface.md
+++ b/docs/collision/collider_interface.md
@@ -0,0 +1,93 @@
+# `omath::collision::ColliderInterface` — Abstract collider base class
+
+> Header: `omath/collision/collider_interface.hpp`
+> Namespace: `omath::collision`
+> Depends on: `omath/linear_algebra/vector3.hpp`
+
+`ColliderInterface` is the abstract base class for all colliders used by the GJK and EPA algorithms. Any shape that can report its furthest vertex along a given direction can implement this interface and be used for collision detection.
+
+---
+
+## API
+
+```cpp
+namespace omath::collision {
+
+template<class VecType = Vector3<float>>
+class ColliderInterface {
+public:
+    using VectorType = VecType;
+
+    virtual ~ColliderInterface() = default;
+
+    // Return the world-space position of the vertex furthest along `direction`.
+    [[nodiscard]]
+    virtual VectorType find_abs_furthest_vertex_position(
+        const VectorType& direction) const = 0;
+
+    // Get the collider's origin (center / position).
+    [[nodiscard]]
+    virtual const VectorType& get_origin() const = 0;
+
+    // Reposition the collider.
+    virtual void set_origin(const VectorType& new_origin) = 0;
+};
+
+} // namespace omath::collision
+```
+
+---
+
+## Implementing a custom collider
+
+To create a new collider shape, derive from `ColliderInterface` and implement the three pure-virtual methods:
+
+```cpp
+#include "omath/collision/collider_interface.hpp"
+
+class SphereCollider final
+    : public omath::collision::ColliderInterface<omath::Vector3<float>>
+{
+public:
+    SphereCollider(omath::Vector3<float> center, float radius)
+        : m_center(center), m_radius(radius) {}
+
+    [[nodiscard]]
+    omath::Vector3<float> find_abs_furthest_vertex_position(
+        const omath::Vector3<float>& direction) const override
+    {
+        return m_center + direction.normalized() * m_radius;
+    }
+
+    [[nodiscard]]
+    const omath::Vector3<float>& get_origin() const override
+    { return m_center; }
+
+    void set_origin(const omath::Vector3<float>& new_origin) override
+    { m_center = new_origin; }
+
+private:
+    omath::Vector3<float> m_center;
+    float m_radius;
+};
+```
+
+---
+
+## Notes
+
+* **Template parameter**: The default vector type is `Vector3<float>`, but any vector type with a `dot()` method can be used.
+* **GJK/EPA compatibility**: Both `GjkAlgorithm` and `EpaAlgorithm` accept any type satisfying the `ColliderInterface` contract through their template parameters.
+
+---
+
+## See also
+
+* [GJK Algorithm](gjk_algorithm.md) — collision detection using GJK.
+* [EPA Algorithm](epa_algorithm.md) — penetration depth via EPA.
+* [Mesh Collider](mesh_collider.md) — concrete collider wrapping a `Mesh`.
+* [Simplex](simplex.md) — simplex data structure used by GJK/EPA.
+
+---
+
+*Last updated: Feb 2026*
--- a/docs/containers/encrypted_variable.md
+++ b/docs/containers/encrypted_variable.md
@@ -0,0 +1,115 @@
+# `omath::EncryptedVariable` — Compile-time XOR-encrypted variable
+
+> Header: `omath/containers/encrypted_variable.hpp`
+> Namespace: `omath`
+> Depends on: `<array>`, `<cstddef>`, `<cstdint>`, `<span>`
+
+`EncryptedVariable` keeps a value XOR-encrypted in memory at rest, using a **compile-time generated random key**. It is designed to hinder static analysis and memory scanners from reading sensitive values (e.g., game constants, keys, thresholds) directly from process memory.
+
+---
+
+## Key concepts
+
+* **Compile-time key generation** — a unique random byte array is produced at compile time via SplitMix64 + FNV-1a seeded from `__FILE__`, `__DATE__`, and `__TIME__`. Each `OMATH_DEF_CRYPT_VAR` expansion receives a distinct key.
+* **XOR cipher** — `encrypt()` / `decrypt()` toggle the encrypted state by XOR-ing the raw bytes of the stored value with the key.
+* **VarAnchor (RAII guard)** — `drop_anchor()` returns a `VarAnchor` that decrypts on construction and re-encrypts on destruction, ensuring the plaintext window is as short as possible.
+
+---
+
+## API
+
+```cpp
+namespace omath {
+
+template<class T, std::size_t key_size, std::array<std::uint8_t, key_size> key>
+class EncryptedVariable final {
+public:
+    using value_type = std::remove_cvref_t<T>;
+
+    constexpr explicit EncryptedVariable(const value_type& data);
+
+    [[nodiscard]] constexpr bool is_encrypted() const;
+
+    constexpr void decrypt();
+    constexpr void encrypt();
+
+    [[nodiscard]] constexpr value_type&       value();
+    [[nodiscard]] constexpr const value_type& value() const;
+
+    [[nodiscard]] constexpr auto drop_anchor();  // returns VarAnchor
+
+    constexpr ~EncryptedVariable();  // decrypts on destruction
+};
+
+template<class EncryptedVarType>
+class VarAnchor final {
+public:
+    constexpr VarAnchor(EncryptedVarType& var);   // decrypts
+    constexpr ~VarAnchor();                        // re-encrypts
+};
+
+} // namespace omath
+```
+
+### Helper macros
+
+```cpp
+// Generate a compile-time random byte array of length N
+#define OMATH_CT_RAND_ARRAY_BYTE(N)  /* ... */
+
+// Declare a type alias for EncryptedVariable<TYPE> with KEY_SIZE random bytes
+#define OMATH_DEF_CRYPT_VAR(TYPE, KEY_SIZE)  /* ... */
+```
+
+---
+
+## Usage examples
+
+### Basic encrypt / decrypt
+
+```cpp
+#include "omath/containers/encrypted_variable.hpp"
+
+// Define an encrypted float with a 16-byte key
+using EncFloat = OMATH_DEF_CRYPT_VAR(float, 16);
+
+EncFloat secret(3.14f);         // encrypted immediately
+// secret.value() is XOR-scrambled in memory
+
+secret.decrypt();
+float v = secret.value();       // v == 3.14f
+secret.encrypt();               // scrambled again
+```
+
+### RAII guard with `drop_anchor()`
+
+```cpp
+EncFloat secret(42.0f);
+
+{
+    auto anchor = secret.drop_anchor();   // decrypts
+    float val = secret.value();           // safe to read
+    // ... use val ...
+}   // anchor destroyed → re-encrypts automatically
+```
+
+---
+
+## Notes & edge cases
+
+* **Force-inline**: When `OMATH_ENABLE_FORCE_INLINE` is defined, encrypt/decrypt operations use compiler-specific force-inline attributes to reduce the call-site footprint visible in disassembly.
+* **Not cryptographically secure**: XOR with a static key is an obfuscation technique, not encryption. It raises the bar for casual memory scanning but does not resist a determined attacker who can read the binary.
+* **Destructor decrypts**: The destructor calls `decrypt()` so the value is in plaintext at the end of its lifetime (e.g., for logging or cleanup).
+* **Thread safety**: No internal synchronization. Protect concurrent access with external locks.
+* **`constexpr` support**: All operations are `constexpr`-friendly (C++20).
+
+---
+
+## See also
+
+* [Pattern Scan](../utility/pattern_scan.md) — scan memory for byte patterns.
+* [Getting Started](../getting_started.md) — quick start with OMath.
+
+---
+
+*Last updated: Feb 2026*
--- a/docs/javascripts/liquid-glass.js
+++ b/docs/javascripts/liquid-glass.js
@@ -0,0 +1,76 @@
+/**
+ * Dynamic Liquid Glass — mouse-tracking specular highlight
+ *
+ * Creates a radial-gradient light spot that follows the cursor across
+ * glass-styled elements, giving them an interactive "liquid glass"
+ * refraction/reflection feel inspired by Apple's Liquid Glass design.
+ */
+(function () {
+  "use strict";
+
+  var SELECTORS = [
+    ".md-header",
+    ".md-content",
+    ".md-sidebar__scrollwrap",
+    ".highlight",
+    ".md-search__form",
+    ".md-footer"
+  ];
+
+  /** Apply the radial highlight via CSS custom properties. */
+  function applyHighlight(el, x, y) {
+    var rect = el.getBoundingClientRect();
+    var px = x - rect.left;
+    var py = y - rect.top;
+    el.style.setProperty("--glass-x", px + "px");
+    el.style.setProperty("--glass-y", py + "px");
+    el.classList.add("glass-active");
+  }
+
+  function clearHighlight(el) {
+    el.classList.remove("glass-active");
+  }
+
+  /** Bind events once the DOM is ready. */
+  function init() {
+    var elements = [];
+    SELECTORS.forEach(function (sel) {
+      var nodes = document.querySelectorAll(sel);
+      for (var i = 0; i < nodes.length; i++) {
+        elements.push(nodes[i]);
+      }
+    });
+
+    var ticking = false;
+    document.addEventListener("mousemove", function (e) {
+      if (ticking) return;
+      ticking = true;
+      requestAnimationFrame(function () {
+        elements.forEach(function (el) {
+          var rect = el.getBoundingClientRect();
+          if (
+            e.clientX >= rect.left &&
+            e.clientX <= rect.right &&
+            e.clientY >= rect.top &&
+            e.clientY <= rect.bottom
+          ) {
+            applyHighlight(el, e.clientX, e.clientY);
+          } else {
+            clearHighlight(el);
+          }
+        });
+        ticking = false;
+      });
+    });
+
+    document.addEventListener("mouseleave", function () {
+      elements.forEach(clearHighlight);
+    });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();
--- a/docs/styles/custom-header.css
+++ b/docs/styles/custom-header.css
@@ -1,11 +0,0 @@
-/* Widen the navbar container */
-.navbar .container {
-    max-width: 100%;   /* adjust to your target width */
-    width: 95%;
-}
-
-/* Tighter spacing between navbar items */
-.navbar-nav > li > a {
-    padding-left: 8px;
-    padding-right: 8px;
-}
--- a/docs/styles/fonts.css
+++ b/docs/styles/fonts.css
@@ -0,0 +1,172 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19-7DRs5.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19a7DRs5.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1967DRs5.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19G7DRs5.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1927DRs5.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19y7DRs5.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 300;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19K7DQ.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19-7DRs5.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19a7DRs5.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1967DRs5.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19G7DRs5.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1927DRs5.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19y7DRs5.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 400;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19K7DQ.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19-7DRs5.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19a7DRs5.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1967DRs5.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19G7DRs5.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-1927DRs5.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19y7DRs5.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto Condensed';
+  font-style: normal;
+  font-weight: 700;
+  src: url(https://fonts.gstatic.com/s/robotocondensed/v31/ieVl2ZhZI2eCN5jzbjEETS9weq8-19K7DQ.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+body {
+  font-family: 'Roboto Condensed', sans-serif;
+}
--- a/docs/styles/links.css
+++ b/docs/styles/links.css
@@ -1,65 +0,0 @@
-/* Normal links */
-a {
-    color: orange;
-}
-
-
-/* On hover/focus */
-a:hover,
-a:focus {
-    color: #ff9900; /* a slightly different orange, optional */
-}
-/* Navbar background */
-.navbar,
-.navbar-default,
-.navbar-inverse {
-    background-color: #a26228   !important;  /* your orange */
-    border-color: #ff6600 !important;
-}
-
-/* Navbar brand + links */
-.navbar .navbar-brand,
-.navbar .navbar-nav > li > a {
-    color: #ffffff !important;
-}
-
-/* Active and hover states */
-.navbar .navbar-nav > .active > a,
-.navbar .navbar-nav > .active > a:focus,
-.navbar .navbar-nav > .active > a:hover,
-.navbar .navbar-nav > li > a:hover,
-.navbar .navbar-nav > li > a:focus {
-    color: #ffffff !important;
-}
-/* === DROPDOWN MENU BACKGROUND === */
-.navbar .dropdown-menu {
-    border-color: #ff6600 !important;
-}
-
-/* Caret icon (the little triangle) */
-.navbar .dropdown-toggle .caret {
-    border-top-color: #ffffff !important;
-    border-bottom-color: #ffffff !important;
-}
-
-/* === BOOTSTRAP 3 STYLE ITEMS (mkdocs + bootswatch darkly often use this) === */
-.navbar .dropdown-menu > li > a {
-    color: #ffffff !important;
-}
-
-.navbar .dropdown-menu > li > a:hover,
-.navbar .dropdown-menu > li > a:focus {
-    background-color: #e65c00 !important; /* darker orange on hover */
-    color: #ffffff !important;
-}
-
-/* === BOOTSTRAP 4+ STYLE ITEMS (if your theme uses .dropdown-item) === */
-.navbar .dropdown-item {
-    color: #ffffff !important;
-}
-
-.navbar .dropdown-item:hover,
-.navbar .dropdown-item:focus {
-    background-color: #e65c00 !important;
-    color: #ffffff !important;
-}
--- a/docs/styles/liquid-glass.css
+++ b/docs/styles/liquid-glass.css
@@ -0,0 +1,271 @@
+/* ============================================================
+   Apple Liquid Glass Design — glassmorphism overrides
+   for Material for MkDocs (slate / dark mode)
+   ============================================================ */
+
+/* ---------- shared glass mixin values ---------- */
+:root {
+  --glass-bg: rgba(255, 255, 255, 0.04);
+  --glass-bg-hover: rgba(255, 255, 255, 0.07);
+  --glass-border: rgba(255, 255, 255, 0.08);
+  --glass-border-strong: rgba(255, 255, 255, 0.12);
+  --glass-blur: 16px;
+  --glass-radius: 14px;
+  --glass-shadow: 0 4px 24px rgba(0, 0, 0, 0.25);
+  --glass-shadow-sm: 0 2px 12px rgba(0, 0, 0, 0.18);
+  --glass-accent: rgba(255, 152, 0, 0.12);
+}
+
+/* ---------- header / top-bar ---------- */
+.md-header {
+  background: rgba(30, 30, 30, 0.55) !important;
+  -webkit-backdrop-filter: saturate(180%) blur(var(--glass-blur));
+  backdrop-filter: saturate(180%) blur(var(--glass-blur));
+  border-bottom: 1px solid var(--glass-border);
+  box-shadow: var(--glass-shadow-sm);
+}
+
+/* ---------- navigation sidebar ---------- */
+.md-sidebar {
+  background: transparent !important;
+}
+
+.md-sidebar__scrollwrap {
+  background: var(--glass-bg);
+  -webkit-backdrop-filter: saturate(160%) blur(var(--glass-blur));
+  backdrop-filter: saturate(160%) blur(var(--glass-blur));
+  border-right: 1px solid var(--glass-border);
+  border-radius: 0 var(--glass-radius) var(--glass-radius) 0;
+}
+
+/* Remove the gradient mask at the top of the table of contents */
+.md-sidebar__scrollwrap {
+  mask-image: none !important;
+  -webkit-mask-image: none !important;
+}
+
+/* active nav item — subtle glass highlight */
+.md-nav__item--active > .md-nav__link {
+  background: var(--glass-accent) !important;
+  border-radius: 8px;
+}
+
+/* ---------- content area ---------- */
+.md-main__inner {
+  background: transparent;
+}
+
+.md-content {
+  background: var(--glass-bg);
+  -webkit-backdrop-filter: saturate(140%) blur(12px);
+  backdrop-filter: saturate(140%) blur(12px);
+  border: 1px solid var(--glass-border);
+  border-radius: var(--glass-radius);
+  box-shadow: var(--glass-shadow);
+  margin: 12px 0;
+  padding: 4px;
+}
+
+/* ---------- code blocks ---------- */
+.highlight {
+  background: rgba(0, 0, 0, 0.25) !important;
+  -webkit-backdrop-filter: blur(10px);
+  backdrop-filter: blur(10px);
+  border: 1px solid var(--glass-border-strong);
+  border-radius: 12px !important;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04),
+              var(--glass-shadow-sm);
+  overflow: hidden;
+}
+
+.highlight code {
+  background: transparent !important;
+}
+
+/* inline code */
+:not(pre) > code {
+  background: rgba(255, 255, 255, 0.06) !important;
+  border: 1px solid var(--glass-border);
+  border-radius: 6px;
+  padding: 2px 6px;
+}
+
+/* ---------- tables ---------- */
+.md-typeset table:not([class]) {
+  background: var(--glass-bg);
+  -webkit-backdrop-filter: blur(10px);
+  backdrop-filter: blur(10px);
+  border: 1px solid var(--glass-border);
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: var(--glass-shadow-sm);
+}
+
+.md-typeset table:not([class]) th {
+  background: rgba(255, 152, 0, 0.08);
+}
+
+/* ---------- admonitions / call-outs ---------- */
+.md-typeset .admonition,
+.md-typeset details {
+  background: var(--glass-bg) !important;
+  -webkit-backdrop-filter: blur(10px);
+  backdrop-filter: blur(10px);
+  border: 1px solid var(--glass-border-strong) !important;
+  border-radius: 12px !important;
+  box-shadow: var(--glass-shadow-sm);
+}
+
+/* ---------- tabs ---------- */
+.md-typeset .tabbed-set {
+  background: var(--glass-bg);
+  border: 1px solid var(--glass-border);
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+/* ---------- search bar ---------- */
+.md-search__form {
+  background: rgba(255, 255, 255, 0.06) !important;
+  -webkit-backdrop-filter: blur(12px);
+  backdrop-filter: blur(12px);
+  border: 1px solid var(--glass-border);
+  border-radius: 10px !important;
+}
+
+/* search results / output — liquid glass */
+.md-search__output {
+  background: rgba(30, 30, 30, 0.70) !important;
+  -webkit-backdrop-filter: saturate(160%) blur(var(--glass-blur));
+  backdrop-filter: saturate(160%) blur(var(--glass-blur));
+  border: 1px solid var(--glass-border);
+  border-radius: 0 0 var(--glass-radius) var(--glass-radius);
+  box-shadow: var(--glass-shadow);
+}
+
+.md-search-result__link {
+  border-radius: 8px;
+  transition: background 0.2s ease;
+}
+
+.md-search-result__link:hover {
+  background: var(--glass-bg-hover) !important;
+}
+
+/* ---------- footer ---------- */
+.md-footer {
+  background: rgba(30, 30, 30, 0.50) !important;
+  -webkit-backdrop-filter: saturate(180%) blur(var(--glass-blur));
+  backdrop-filter: saturate(180%) blur(var(--glass-blur));
+  border-top: 1px solid var(--glass-border);
+}
+
+/* ---------- horizontal rules — subtle glow ---------- */
+.md-typeset hr {
+  border-image: linear-gradient(
+    to right,
+    transparent,
+    rgba(255, 152, 0, 0.25),
+    transparent
+  ) 1;
+}
+
+/* ---------- scrollbar ---------- */
+* {
+  scrollbar-width: thin;
+  scrollbar-color: rgba(255, 255, 255, 0.10) transparent;
+}
+
+::-webkit-scrollbar {
+  width: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.10);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.18);
+}
+
+/* ---------- links — subtle glass-glow on hover ---------- */
+.md-typeset a:hover {
+  text-shadow: 0 0 8px rgba(255, 152, 0, 0.3);
+}
+
+/* ---------- images — soft glass frame ---------- */
+.md-typeset img {
+  border-radius: 10px;
+}
+
+/* ============================================================
+   Dynamic Liquid Glass — mouse-tracking specular highlight
+   ============================================================ */
+
+/* Shared: every glass surface gets a hidden radial-light overlay
+   that becomes visible when JS adds the .glass-active class and
+   sets --glass-x / --glass-y custom properties. */
+.md-header,
+.md-content,
+.md-sidebar__scrollwrap,
+.highlight,
+.md-search__form,
+.md-footer {
+  position: relative;
+  overflow: hidden;
+}
+
+.md-header::after,
+.md-content::after,
+.md-sidebar__scrollwrap::after,
+.highlight::after,
+.md-search__form::after,
+.md-footer::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  opacity: 0;
+  transition: opacity 0.3s ease;
+  background: radial-gradient(
+    circle 220px at var(--glass-x, 50%) var(--glass-y, 50%),
+    rgba(255, 200, 120, 0.10) 0%,
+    rgba(255, 152, 0, 0.04) 40%,
+    transparent 70%
+  );
+  z-index: 1;
+}
+
+.md-header.glass-active::after,
+.md-content.glass-active::after,
+.md-sidebar__scrollwrap.glass-active::after,
+.highlight.glass-active::after,
+.md-search__form.glass-active::after,
+.md-footer.glass-active::after {
+  opacity: 1;
+}
+
+/* Keep header text / nav icons above the overlay */
+.md-header > *,
+.md-content > *,
+.md-sidebar__scrollwrap > *,
+.md-search__form > *,
+.md-footer > * {
+  position: relative;
+  z-index: 2;
+}
+
+/* Highlight code blocks get a slightly brighter spot */
+.highlight.glass-active::after {
+  background: radial-gradient(
+    circle 180px at var(--glass-x, 50%) var(--glass-y, 50%),
+    rgba(255, 200, 120, 0.12) 0%,
+    rgba(255, 152, 0, 0.05) 35%,
+    transparent 65%
+  );
+}
--- a/docs/utility/elf_pattern_scan.md
+++ b/docs/utility/elf_pattern_scan.md
@@ -0,0 +1,142 @@
+# `omath::ElfPatternScanner` — Scan ELF binaries for byte patterns
+
+> Header: `omath/utility/elf_pattern_scan.hpp`
+> Namespace: `omath`
+> Platform: **Linux / ELF (Executable and Linkable Format) binaries**
+> Depends on: `<cstdint>`, `<filesystem>`, `<optional>`, `<string_view>`, `omath/utility/section_scan_result.hpp`
+> Companion: works well with `omath::PatternScanner` (same pattern grammar)
+
+`ElfPatternScanner` searches **ELF** binaries for a hex pattern (with wildcards). You can scan:
+
+* a **loaded module** in the current process, or
+* an **ELF file on disk** (by section name; defaults to **`.text`**).
+
+---
+
+## Pattern string grammar (same as `PatternScanner`)
+
+* **Hex byte**: two hex digits → one byte (`90`, `4F`, `00`, `ff`).
+* **Wildcard byte**: `?` or `??` matches **any byte**.
+* **Whitespace**: ignored (use to group tokens).
+
+✔️ `"48 8B ?? ?? 89"`, `"55 48 89 E5"`, `"??"`
+❌ odd digit counts, non-hex characters (besides `?` and whitespace)
+
+---
+
+## API
+
+```cpp
+namespace omath {
+
+class ElfPatternScanner final {
+public:
+    // Scan a module already loaded in *this* process.
+    // module_base_address: base address of the loaded ELF (e.g., from dlopen / /proc/self/maps)
+    // Returns absolute address (process VA) of the first match, or nullopt.
+    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");
+
+    // Scan an ELF file on disk, by section name (default ".text").
+    // Returns section bases (virtual + raw) and match offset within the section, or nullopt.
+    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
+```
+
+---
+
+## Return values
+
+* **Loaded module**: `std::optional<std::uintptr_t>`
+
+    * `value()` = **process virtual address** of the first match.
+    * `nullopt` = no match or parse/ELF error.
+
+* **File scan**: `std::optional<SectionScanResult>`
+
+    * `virtual_base_addr` = virtual address base of the scanned section.
+    * `raw_base_addr` = file offset of section start.
+    * `target_offset` = offset from section base to the first matched byte.
+    * To get addresses:
+
+        * **Virtual address** of hit = `virtual_base_addr + target_offset`
+        * **Raw file offset** of hit = `raw_base_addr + target_offset`
+
+---
+
+## Usage examples
+
+### Scan a loaded module (current process)
+
+```cpp
+#include <dlfcn.h>
+#include "omath/utility/elf_pattern_scan.hpp"
+
+using omath::ElfPatternScanner;
+
+void* handle = dlopen("libexample.so", RTLD_LAZY);
+if (handle) {
+    auto addr = ElfPatternScanner::scan_for_pattern_in_loaded_module(
+        handle, "55 48 89 E5 ?? ?? 48"
+    );
+    if (addr) {
+        std::uintptr_t hit_va = *addr;
+        // ...
+    }
+    dlclose(handle);
+}
+```
+
+### Scan an ELF file on disk
+
+```cpp
+#include "omath/utility/elf_pattern_scan.hpp"
+using omath::ElfPatternScanner;
+
+auto res = ElfPatternScanner::scan_for_pattern_in_file(
+    "/usr/lib/libexample.so", "55 48 89 E5"
+);
+if (res) {
+    auto va_hit  = res->virtual_base_addr + res->target_offset;
+    auto raw_hit = res->raw_base_addr     + res->target_offset;
+}
+```
+
+### Scan another section (e.g., ".rodata")
+
+```cpp
+auto res = ElfPatternScanner::scan_for_pattern_in_file(
+    "myapp", "48 8D 0D ?? ?? ?? ??", ".rodata"
+);
+```
+
+---
+
+## Notes & edge cases
+
+* **ELF only**: these functions assume a valid ELF layout. Non-ELF files or corrupted headers yield `nullopt`.
+* **Section name**: defaults to **`.text`**; pass a different name to target other sections.
+* **Performance**: Pattern matching is **O(N × M)** (sliding window with wildcards). For large binaries, prefer scanning only necessary sections.
+* **Architecture**: works for 32-bit and 64-bit ELF binaries.
+
+---
+
+## See also
+
+* [`omath::PatternScanner`](pattern_scan.md) — raw buffer/iterator scanning with the same pattern grammar.
+* [`omath::PePatternScanner`](pe_pattern_scan.md) — PE (Windows) binary scanner.
+* [`omath::MachOPatternScanner`](macho_pattern_scan.md) — Mach-O (macOS) binary scanner.
+* [`omath::SectionScanResult`](section_scan_result.md) — return type for file-based scans.
+
+---
+
+*Last updated: Feb 2026*
--- a/docs/utility/macho_pattern_scan.md
+++ b/docs/utility/macho_pattern_scan.md
@@ -0,0 +1,142 @@
+# `omath::MachOPatternScanner` — Scan Mach-O binaries for byte patterns
+
+> Header: `omath/utility/macho_pattern_scan.hpp`
+> Namespace: `omath`
+> Platform: **macOS / Mach-O binaries**
+> Depends on: `<cstdint>`, `<filesystem>`, `<optional>`, `<string_view>`, `omath/utility/section_scan_result.hpp`
+> Companion: works well with `omath::PatternScanner` (same pattern grammar)
+
+`MachOPatternScanner` searches **Mach-O** binaries for a hex pattern (with wildcards). You can scan:
+
+* a **loaded module** in the current process, or
+* a **Mach-O file on disk** (by section name; defaults to **`__text`**).
+
+---
+
+## Pattern string grammar (same as `PatternScanner`)
+
+* **Hex byte**: two hex digits → one byte (`90`, `4F`, `00`, `ff`).
+* **Wildcard byte**: `?` or `??` matches **any byte**.
+* **Whitespace**: ignored (use to group tokens).
+
+✔️ `"48 8B ?? ?? 89"`, `"55 48 89 E5"`, `"??"`
+❌ odd digit counts, non-hex characters (besides `?` and whitespace)
+
+---
+
+## API
+
+```cpp
+namespace omath {
+
+class MachOPatternScanner final {
+public:
+    // Scan a module already loaded in *this* process.
+    // module_base_address: base address of the loaded Mach-O image
+    // Returns absolute address (process VA) of the first match, or nullopt.
+    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");
+
+    // Scan a Mach-O file on disk, by section name (default "__text").
+    // Returns section bases (virtual + raw) and match offset within the section, or nullopt.
+    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
+```
+
+---
+
+## Return values
+
+* **Loaded module**: `std::optional<std::uintptr_t>`
+
+    * `value()` = **process virtual address** of the first match.
+    * `nullopt` = no match or parse/Mach-O error.
+
+* **File scan**: `std::optional<SectionScanResult>`
+
+    * `virtual_base_addr` = virtual address base of the scanned section.
+    * `raw_base_addr` = file offset of section start.
+    * `target_offset` = offset from section base to the first matched byte.
+    * To get addresses:
+
+        * **Virtual address** of hit = `virtual_base_addr + target_offset`
+        * **Raw file offset** of hit = `raw_base_addr + target_offset`
+
+---
+
+## Usage examples
+
+### Scan a loaded module (current process)
+
+```cpp
+#include <dlfcn.h>
+#include "omath/utility/macho_pattern_scan.hpp"
+
+using omath::MachOPatternScanner;
+
+void* handle = dlopen("libexample.dylib", RTLD_LAZY);
+if (handle) {
+    auto addr = MachOPatternScanner::scan_for_pattern_in_loaded_module(
+        handle, "55 48 89 E5 ?? ?? 48"
+    );
+    if (addr) {
+        std::uintptr_t hit_va = *addr;
+        // ...
+    }
+    dlclose(handle);
+}
+```
+
+### Scan a Mach-O file on disk
+
+```cpp
+#include "omath/utility/macho_pattern_scan.hpp"
+using omath::MachOPatternScanner;
+
+auto res = MachOPatternScanner::scan_for_pattern_in_file(
+    "/usr/local/lib/libexample.dylib", "55 48 89 E5"
+);
+if (res) {
+    auto va_hit  = res->virtual_base_addr + res->target_offset;
+    auto raw_hit = res->raw_base_addr     + res->target_offset;
+}
+```
+
+### Scan another section (e.g., "__cstring")
+
+```cpp
+auto res = MachOPatternScanner::scan_for_pattern_in_file(
+    "myapp", "48 8D 0D ?? ?? ?? ??", "__cstring"
+);
+```
+
+---
+
+## Notes & edge cases
+
+* **Mach-O only**: these functions assume a valid Mach-O layout. Non-Mach-O files or corrupted headers yield `nullopt`.
+* **Section name**: defaults to **`__text`** (note the double underscore, per Mach-O convention); pass a different name to target other sections.
+* **Performance**: Pattern matching is **O(N × M)** (sliding window with wildcards). For large binaries, prefer scanning only necessary sections.
+* **Architecture**: works for 64-bit Mach-O binaries (x86_64 and arm64).
+
+---
+
+## See also
+
+* [`omath::PatternScanner`](pattern_scan.md) — raw buffer/iterator scanning with the same pattern grammar.
+* [`omath::PePatternScanner`](pe_pattern_scan.md) — PE (Windows) binary scanner.
+* [`omath::ElfPatternScanner`](elf_pattern_scan.md) — ELF (Linux) binary scanner.
+* [`omath::SectionScanResult`](section_scan_result.md) — return type for file-based scans.
+
+---
+
+*Last updated: Feb 2026*
--- a/docs/utility/section_scan_result.md
+++ b/docs/utility/section_scan_result.md
@@ -0,0 +1,58 @@
+# `omath::SectionScanResult` — File-based pattern scan result
+
+> Header: `omath/utility/section_scan_result.hpp`
+> Namespace: `omath`
+> Depends on: `<cstddef>`, `<cstdint>`
+
+`SectionScanResult` is the return type for file-based pattern scans across all binary formats (PE, ELF, Mach-O). It carries the section's virtual and raw base addresses together with the offset to the matched pattern.
+
+---
+
+## API
+
+```cpp
+namespace omath {
+
+struct SectionScanResult final {
+    std::uintptr_t virtual_base_addr;  // virtual address base of the scanned section
+    std::uintptr_t raw_base_addr;      // file offset of the section start
+    std::ptrdiff_t target_offset;      // offset from section base to the first matched byte
+};
+
+} // namespace omath
+```
+
+---
+
+## Computing addresses from a result
+
+```cpp
+omath::SectionScanResult res = /* ... */;
+
+// Virtual address of the match (as if the binary were loaded at its preferred base)
+auto va_hit  = res.virtual_base_addr + res.target_offset;
+
+// Raw file offset of the match
+auto raw_hit = res.raw_base_addr + res.target_offset;
+```
+
+---
+
+## Notes
+
+* `virtual_base_addr` is computed from the section header (RVA for PE, `sh_addr` for ELF, `addr` for Mach-O).
+* `raw_base_addr` is the file offset where the section data begins on disk.
+* `target_offset` is always relative to the section base — add it to either address to locate the match.
+
+---
+
+## See also
+
+* [`omath::PePatternScanner`](pe_pattern_scan.md) — PE (Windows) binary scanner.
+* [`omath::ElfPatternScanner`](elf_pattern_scan.md) — ELF (Linux) binary scanner.
+* [`omath::MachOPatternScanner`](macho_pattern_scan.md) — Mach-O (macOS) binary scanner.
+* [`omath::PatternScanner`](pattern_scan.md) — raw buffer/iterator scanning.
+
+---
+
+*Last updated: Feb 2026*
--- a/include/omath/collision/line_tracer.hpp
+++ b/include/omath/collision/line_tracer.hpp
@@ -8,43 +8,96 @@

 namespace omath::collision
 {
-    class Ray
+    template<class T = Vector3<float>>
+    class Ray final
    {
    public:
-        Vector3<float> start;
-        Vector3<float> end;
+        using VectorType = T;
+        VectorType start;
+        VectorType end;
        bool infinite_length = false;

        [[nodiscard]]
-        Vector3<float> direction_vector() const noexcept;
+        constexpr VectorType direction_vector() const noexcept
+        {
+            return end - start;
+        }

        [[nodiscard]]
-        Vector3<float> direction_vector_normalized() const noexcept;
+        constexpr VectorType direction_vector_normalized() const noexcept
+        {
+            return direction_vector().normalized();
+        }
    };
-    class LineTracer
+
+    template<class RayType = Ray<>>
+    class LineTracer final
    {
+        using TriangleType = Triangle<typename RayType::VectorType>;
+
    public:
        LineTracer() = delete;

        [[nodiscard]]
-        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+        constexpr static bool can_trace_line(const RayType& ray, const TriangleType& triangle) noexcept
+        {
+            return get_ray_hit_point(ray, triangle) == ray.end;
+        }

        // Realization of Möller–Trumbore intersection algorithm
        // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
        [[nodiscard]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
+        constexpr static auto get_ray_hit_point(const RayType& ray, const TriangleType& triangle) noexcept
+        {
+            constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
+
+            const auto side_a = triangle.side_a_vector();
+            const auto side_b = triangle.side_b_vector();
+
+            const auto ray_dir = ray.direction_vector();
+
+            const auto p = ray_dir.cross(side_b);
+            const auto det = side_a.dot(p);
+
+            if (std::abs(det) < k_epsilon)
+                return ray.end;
+
+            const auto inv_det = 1 / det;
+            const auto t = ray.start - triangle.m_vertex2;
+            const auto u = t.dot(p) * inv_det;
+
+            if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
+                return ray.end;
+
+            const auto q = t.cross(side_a);
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const auto v = ray_dir.dot(q) * inv_det;
+
+            if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
+                return ray.end;
+
+            const auto t_hit = side_b.dot(q) * inv_det;
+
+            if (ray.infinite_length && t_hit <= k_epsilon)
+                return ray.end;
+
+            if (t_hit <= k_epsilon || t_hit > 1 - k_epsilon)
+                return ray.end;
+
+            return ray.start + ray_dir * t_hit;
+        }

        template<class MeshType>
        [[nodiscard]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const MeshType& mesh) noexcept
+        constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept
        {
-            Vector3<float> mesh_hit = ray.end;
+            auto mesh_hit = ray.end;

-            auto begin = mesh.m_element_buffer_object.cbegin();
-            auto end = mesh.m_element_buffer_object.cend();
+            const auto begin = mesh.m_element_buffer_object.cbegin();
+            const auto end = mesh.m_element_buffer_object.cend();
            for (auto current = begin; current < end; current = std::next(current))
            {
-                auto face = mesh.make_face_in_world_space(current);
+                const auto face = mesh.make_face_in_world_space(current);

                auto ray_stop_point = get_ray_hit_point(ray, face);
                if (ray_stop_point.distance_to(ray.start) < mesh_hit.distance_to(ray.start))
--- a/include/omath/collision/simplex.hpp
+++ b/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;
        }

--- a/include/omath/utility/macho_pattern_scan.hpp
+++ b/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
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -1,7 +1,19 @@
 site_name: OMATH Docs
 theme:
-  name: darkly
+  name: material
+  palette:
+    scheme: slate
+    primary: deep orange
+    accent: orange
+  font:
+    text: Roboto Condensed
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.superfences
 extra_css:
+  - styles/fonts.css
  - styles/center.css
-  - styles/custom-header.css
-  - styles/links.css
+  - styles/liquid-glass.css
+extra_javascript:
+  - javascripts/liquid-glass.js
--- a/source/collision/line_tracer.cpp
+++ b/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
--- a/source/utility/macho_pattern_scan.cpp
+++ b/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
--- a/tests/general/unit_test_line_trace.cpp
+++ b/tests/general/unit_test_line_trace.cpp
@@ -47,7 +47,7 @@ namespace
    // -----------------------------------------------------------------------------
    struct TraceCase
    {
-        Ray ray;
+        Ray<> ray;
        bool expected_clear; // true => segment does NOT hit the triangle
        friend std::ostream& operator<<(std::ostream& os, const TraceCase& tc)
        {
@@ -66,7 +66,7 @@ namespace
    TEST_P(CanTraceLineParam, VariousRays)
    {
        const auto& [ray, expected_clear] = GetParam();
-        EXPECT_EQ(LineTracer::can_trace_line(ray, triangle), expected_clear);
+        EXPECT_EQ(LineTracer<>::can_trace_line(ray, triangle), expected_clear);
    }

    INSTANTIATE_TEST_SUITE_P(
@@ -91,7 +91,7 @@ namespace
        constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
        constexpr Vec3 expected{0.3f, 0.3f, 0.f};

-        const Vec3 hit = LineTracer::get_ray_hit_point(ray, triangle);
+        const Vec3 hit = LineTracer<>::get_ray_hit_point(ray, triangle);
        ASSERT_FALSE(vec_equal(hit, ray.end));
        EXPECT_TRUE(vec_equal(hit, expected));
    }
@@ -106,7 +106,7 @@ namespace
                                         {1001.f, 1000.f, 1000.f},
                                         {1000.f, 1001.f, 1000.f}};

-        EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
+        EXPECT_TRUE(LineTracer<>::can_trace_line(short_ray, distant));
    }

    TEST(unit_test_unity_engine, CantHit)
@@ -115,13 +115,13 @@ namespace

        constexpr Ray ray{{}, {1.0, 0, 0}, false};

-        EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
+        EXPECT_TRUE(omath::collision::LineTracer<>::can_trace_line(ray, triangle));
    }
    TEST(unit_test_unity_engine, CanHit)
    {
        constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};

        constexpr Ray ray{{}, {2.1, 0, 0}, false};
-        EXPECT_FALSE(omath::collision::LineTracer::can_trace_line(ray, triangle));
+        EXPECT_FALSE(omath::collision::LineTracer<>::can_trace_line(ray, triangle));
    }
 } // namespace
--- a/tests/general/unit_test_line_tracer.cpp
+++ b/tests/general/unit_test_line_tracer.cpp
@@ -15,9 +15,9 @@ TEST(LineTracerTests, ParallelRayReturnsEnd)
    ray.end = Vector3<float>{1.f,1.f,1.f};

    // For a ray parallel to the triangle plane the algorithm should return ray.end
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_TRUE(hit == ray.end);
-    EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, tri));
+    EXPECT_TRUE(omath::collision::LineTracer<>::can_trace_line(ray, tri));
 }

 TEST(LineTracerTests, MissesTriangleReturnsEnd)
@@ -27,7 +27,7 @@ TEST(LineTracerTests, MissesTriangleReturnsEnd)
    ray.start = Vector3<float>{2.f,2.f,-1.f};
    ray.end = Vector3<float>{2.f,2.f,1.f}; // passes above the triangle area

-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_TRUE(hit == ray.end);
 }

@@ -38,7 +38,7 @@ TEST(LineTracerTests, HitTriangleReturnsPointInsideSegment)
    ray.start = Vector3<float>{0.25f,0.25f,-1.f};
    ray.end = Vector3<float>{0.25f,0.25f,1.f};

-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
    // Should return a point between start and end (z approximately 0)
    EXPECT_NE(hit, ray.end);
    EXPECT_NEAR(hit.z, 0.f, 1e-4f);
@@ -60,6 +60,6 @@ TEST(LineTracerTests, InfiniteLengthEarlyOut)

    // If t_hit <= epsilon the algorithm should return ray.end when infinite_length is true.
    // Using start on the triangle plane should produce t_hit <= epsilon.
-    const auto hit = omath::collision::LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = omath::collision::LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_TRUE(hit == ray.end);
 }
--- a/tests/general/unit_test_line_tracer_extra.cpp
+++ b/tests/general/unit_test_line_tracer_extra.cpp
@@ -10,7 +10,7 @@ TEST(LineTracerExtra, MissParallel)
 {
    constexpr Triangle<Vector3<float>> tri({0,0,0},{1,0,0},{0,1,0});
    constexpr Ray ray{ {0.3f,0.3f,1.f}, {0.3f,0.3f,2.f}, false }; // parallel above triangle
-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

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

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -24,7 +24,7 @@ TEST(LineTracerMore, UOutOfRangeReturnsEnd)
    constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
    Ray ray; ray.start = {-1.f,-1.f,-1.f}; ray.end = {-0.5f,-1.f,1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -34,7 +34,7 @@ TEST(LineTracerMore, VOutOfRangeReturnsEnd)
    constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
    Ray ray; ray.start = {2.f,2.f,-1.f}; ray.end = {2.f,2.f,1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -43,7 +43,7 @@ TEST(LineTracerMore, THitTooSmallReturnsEnd)
    constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
    Ray ray; ray.start = {0.f,0.f,0.0000000001f}; ray.end = {0.f,0.f,1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -53,7 +53,7 @@ TEST(LineTracerMore, THitGreaterThanOneReturnsEnd)
    // Choose a ray and compute t_hit locally to assert consistency
    Ray ray; ray.start = {0.f,0.f,-1.f}; ray.end = {0.f,0.f,-0.5f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);

    constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
    constexpr auto side_a = tri.side_a_vector();
@@ -87,7 +87,7 @@ TEST(LineTracerMore, InfiniteLengthWithSmallTHitReturnsEnd)
    // Create triangle slightly behind so t_hit <= eps
    tri = tri2;

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -96,7 +96,7 @@ TEST(LineTracerMore, SuccessfulHitReturnsPoint)
    constexpr Triangle3 tri(Vector3<float>{0.f,0.f,0.f}, Vector3<float>{1.f,0.f,0.f}, Vector3<float>{0.f,1.f,0.f});
    Ray ray; ray.start = {0.1f,0.1f,-1.f}; ray.end = {0.1f,0.1f,1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_NE(hit, ray.end);
    // Hit should be on plane z=0 and near x=0.1,y=0.1
    EXPECT_NEAR(hit.z, 0.f, 1e-6f);
--- a/tests/general/unit_test_line_tracer_more2.cpp
+++ b/tests/general/unit_test_line_tracer_more2.cpp
@@ -14,7 +14,7 @@ TEST(LineTracerMore2, UGreaterThanOneReturnsEnd)
    // choose ray so barycentric u > 1
    Ray ray; ray.start = {2.f, -1.f, -1.f}; ray.end = {2.f, -1.f, 1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -24,7 +24,7 @@ TEST(LineTracerMore2, VGreaterThanOneReturnsEnd)
    // choose ray so barycentric v > 1
    Ray ray; ray.start = {-1.f, 2.f, -1.f}; ray.end = {-1.f, 2.f, 1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -34,7 +34,7 @@ TEST(LineTracerMore2, UPlusVGreaterThanOneReturnsEnd)
    // Ray aimed so u+v > 1 (outside triangle region)
    Ray ray; ray.start = {1.f, 1.f, -1.f}; ray.end = {1.f, 1.f, 1.f};

-    const auto hit = LineTracer::get_ray_hit_point(ray, tri);
+    const auto hit = LineTracer<>::get_ray_hit_point(ray, tri);
    EXPECT_EQ(hit, ray.end);
 }

@@ -52,6 +52,6 @@ TEST(LineTracerMore2, ZeroLengthRayHandled)
    Ray ray; ray.start = {0.f,0.f,0.f}; ray.end = {0.f,0.f,0.f};

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

    omath::collision::Ray ray{.start = {0, 0, 0}, .end = {-100, 0, 0}};
-    std::ignore = omath::collision::LineTracer::get_ray_hit_point(ray, result);
+    std::ignore = omath::collision::LineTracer<>::get_ray_hit_point(ray, result);
 }
Author	SHA1	Message	Date
copilot-swe-agent[bot]	a5fcb884f4	Remove TOC gradient mask and add liquid glass to search results Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 01:35:03 +00:00
copilot-swe-agent[bot]	4ba5355837	Add dynamic mouse-tracking liquid glass effect (JS + CSS) Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 01:26:14 +00:00
copilot-swe-agent[bot]	e9c2ea7e47	Add Apple Liquid Glass glassmorphism design for mkdocs site Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 01:18:20 +00:00
copilot-swe-agent[bot]	0120c193a5	Enable C++ syntax highlighting via pymdownx.highlight and pymdownx.superfences Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 00:55:51 +00:00
copilot-swe-agent[bot]	b9d83f2bba	Switch to Material theme with dark mode and orange accent colors Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 00:48:58 +00:00
copilot-swe-agent[bot]	66c47d87c1	Add Roboto Condensed font and documentation for new features Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-07 00:30:39 +00:00
copilot-swe-agent[bot]	6dd48f7a0c	Initial plan	2026-02-07 00:25:23 +00:00
Orange++	9c4e2a3319	Merge pull request #146 from orange-cpp/feature/line_tracer_template improvement	2026-02-06 00:14:15 +03:00
Orange	7597d95778	fixed warnings	2026-02-06 00:02:00 +03:00
Orange	5aa0e2e949	added noexcept	2026-02-05 23:45:41 +03:00
Orange	b7b1154f29	simplified shit	2026-02-05 23:43:17 +03:00
Orange	b10e26e6ba	added constexpr	2026-02-05 23:38:51 +03:00
Orange	ba23fee243	removed uselss c++ file	2026-02-05 23:31:14 +03:00
Orange	32e0f9e636	improvement	2026-02-05 23:27:31 +03:00
Orange++	63b4327c91	Merge pull request #145 from orange-cpp/feature/macho_improvement Feature/macho improvement	2026-02-04 19:27:44 +03:00
Orange	dbad87de0f	fixed bug	2026-02-04 19:10:06 +03:00
Orange	8dd044fa1e	removed nesting	2026-02-04 18:35:04 +03:00
Orange	c25a3da196	removed nesting	2026-02-04 18:33:05 +03:00
Orange	d64d60cfcd	fixed codestyle	2026-02-04 18:30:45 +03:00
Orange	2ef25b0ce8	added resharper ignore segment	2026-02-04 18:29:55 +03:00
Copilot	775949887a	Add Mach-O pattern scanner (#144 ) * Initial plan * Add Mach-O pattern scanner implementation and unit tests Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> * Add Mach-O pattern scanner Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> * Remove CodeQL build artifacts from PR Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: orange-cpp <59374393+orange-cpp@users.noreply.github.com>	2026-02-04 17:30:20 +03:00