updated credits

Feature/hud declarative

CREDITS.md

@@ -5,6 +5,7 @@ Thanks to everyone who made this possible, including:
 - Saikari aka luadebug for VCPKG port and awesome new initial logo design.
 - AmbushedRaccoon for telegram post about omath to boost repository activity.
 - Billy O'Neal aka BillyONeal for fixing compilation issues due to C math library compatibility.
+- Alex2772 for reference of AUI declarative interface design for omath::hud
 
 And a big hand to everyone else who has contributed over the past!
 

README.md

@@ -14,7 +14,7 @@
 [![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)
 
-OMath is a 100% independent, constexpr template blazingly fast math library that doesn't have legacy C++ code.
+OMath is a 100% independent, constexpr template blazingly fast math/physics/games/mods/cheats development framework that doesn't have legacy C++ code.
 
 It provides the latest features, is highly customizable, has all for cheat development, DirectX/OpenGL/Vulkan support, premade support for different game engines, much more constexpr stuff than in other libraries and more...
 <br>
@@ -84,7 +84,8 @@ if (auto screen = camera.world_to_screen(world_position)) {
 - **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
+- **Scripting**: Supports to make scripts in Lua out of box.
+- **Handy**: Allow to design wall hacks in modern jetpack compose like way.
 - **Battle tested**: It's already used by some big players on the market like wraith.su and bluedream.ltd
 <div align = center>
  

examples/CMakeLists.txt

@@ -2,6 +2,7 @@ add_subdirectory(example_barycentric)
 add_subdirectory(example_glfw3)
 add_subdirectory(example_proj_mat_builder)
 add_subdirectory(example_signature_scan)
+add_subdirectory(example_hud)
 
 if(OMATH_ENABLE_VALGRIND)
     omath_setup_valgrind(example_projection_matrix_builder)

examples/example_hud/CMakeLists.txt

@@ -0,0 +1,16 @@
+project(example_hud)
+
+
+add_executable(${PROJECT_NAME} main.cpp gui/main_window.cpp gui/main_window.hpp)
+
+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 glfw imgui::imgui omath::omath OpenGL::GL)

examples/example_hud/gui/main_window.cpp

@@ -0,0 +1,224 @@
+//
+// Created by Orange on 11/11/2024.
+//
+#include "main_window.hpp"
+#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <omath/hud/entity_overlay.hpp>
+
+namespace imgui_desktop::gui
+{
+    bool MainWindow::m_canMoveWindow = false;
+
+    MainWindow::MainWindow(const std::string_view& caption, int width, int height)
+    {
+        if (!glfwInit())
+            std::exit(EXIT_FAILURE);
+
+        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+        glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, true);
+        m_window = glfwCreateWindow(width, height, caption.data(), nullptr, nullptr);
+
+        glfwMakeContextCurrent(m_window);
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetStyle().Colors[ImGuiCol_WindowBg] = {0.05f, 0.05f, 0.05f, 0.92f};
+        ImGui::GetStyle().AntiAliasedLines = false;
+        ImGui::GetStyle().AntiAliasedFill = false;
+        ImGui_ImplGlfw_InitForOpenGL(m_window, true);
+        ImGui_ImplOpenGL3_Init("#version 150");
+    }
+
+    void MainWindow::Run()
+    {
+        while (!glfwWindowShouldClose(m_window) && m_opened)
+        {
+            glfwPollEvents();
+            ImGui_ImplOpenGL3_NewFrame();
+            ImGui_ImplGlfw_NewFrame();
+            ImGui::NewFrame();
+
+            const auto* vp = ImGui::GetMainViewport();
+            ImGui::GetBackgroundDrawList()->AddRectFilled({}, vp->Size, ImColor(30, 30, 30, 220));
+
+            draw_controls();
+            draw_overlay();
+
+            ImGui::Render();
+            present();
+        }
+        glfwDestroyWindow(m_window);
+    }
+
+    void MainWindow::draw_controls()
+    {
+        const auto* vp = ImGui::GetMainViewport();
+        ImGui::SetNextWindowPos({0.f, 0.f});
+        ImGui::SetNextWindowSize({280.f, vp->Size.y});
+        ImGui::Begin("Controls", &m_opened,
+                     ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
+        ImGui::PushItemWidth(160.f);
+
+        if (ImGui::CollapsingHeader("Entity", ImGuiTreeNodeFlags_DefaultOpen))
+        {
+            ImGui::SliderFloat("X##ent", &m_entity_x, 100.f, vp->Size.x - 100.f);
+            ImGui::SliderFloat("Top Y", &m_entity_top_y, 20.f, m_entity_bottom_y - 20.f);
+            ImGui::SliderFloat("Bottom Y", &m_entity_bottom_y, m_entity_top_y + 20.f, vp->Size.y - 20.f);
+        }
+
+        if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
+        {
+            ImGui::Checkbox("Box##chk", &m_show_box);
+            ImGui::SameLine();
+            ImGui::Checkbox("Cornered", &m_show_cornered_box);
+            ImGui::SameLine();
+            ImGui::Checkbox("Dashed", &m_show_dashed_box);
+            ImGui::ColorEdit4("Color##box", reinterpret_cast<float*>(&m_box_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("Fill##box", reinterpret_cast<float*>(&m_box_fill), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
+            ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
+            ImGui::Separator();
+            ImGui::ColorEdit4("Dash color", reinterpret_cast<float*>(&m_dash_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Dash length", &m_dash_len, 2.f, 30.f);
+            ImGui::SliderFloat("Dash gap", &m_dash_gap, 1.f, 20.f);
+            ImGui::SliderFloat("Dash thick", &m_dash_thickness, 0.5f, 5.f);
+        }
+
+        if (ImGui::CollapsingHeader("Bars", ImGuiTreeNodeFlags_DefaultOpen))
+        {
+            ImGui::ColorEdit4("Color##bar", reinterpret_cast<float*>(&m_bar_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("BG##bar", reinterpret_cast<float*>(&m_bar_bg_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("Outline##bar", reinterpret_cast<float*>(&m_bar_outline_color),
+                              ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Width##bar", &m_bar_width, 1.f, 20.f);
+            ImGui::SliderFloat("Value##bar", &m_bar_value, 0.f, 1.f);
+            ImGui::SliderFloat("Offset##bar", &m_bar_offset, 1.f, 20.f);
+            ImGui::Checkbox("Right##bar", &m_show_right_bar);
+            ImGui::SameLine();
+            ImGui::Checkbox("Left##bar", &m_show_left_bar);
+            ImGui::Checkbox("Top##bar", &m_show_top_bar);
+            ImGui::SameLine();
+            ImGui::Checkbox("Bottom##bar", &m_show_bottom_bar);
+            ImGui::Checkbox("Right dashed##bar", &m_show_right_dashed_bar);
+            ImGui::SameLine();
+            ImGui::Checkbox("Left dashed##bar", &m_show_left_dashed_bar);
+            ImGui::Checkbox("Top dashed##bar", &m_show_top_dashed_bar);
+            ImGui::SameLine();
+            ImGui::Checkbox("Bot dashed##bar", &m_show_bottom_dashed_bar);
+            ImGui::SliderFloat("Dash len##bar", &m_bar_dash_len, 2.f, 20.f);
+            ImGui::SliderFloat("Dash gap##bar", &m_bar_dash_gap, 1.f, 15.f);
+        }
+
+        if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen))
+        {
+            ImGui::Checkbox("Outlined", &m_outlined);
+            ImGui::SliderFloat("Offset##lbl", &m_label_offset, 0.f, 15.f);
+            ImGui::Checkbox("Right##lbl", &m_show_right_labels);
+            ImGui::SameLine();
+            ImGui::Checkbox("Left##lbl", &m_show_left_labels);
+            ImGui::Checkbox("Top##lbl", &m_show_top_labels);
+            ImGui::SameLine();
+            ImGui::Checkbox("Bottom##lbl", &m_show_bottom_labels);
+            ImGui::Checkbox("Ctr top##lbl", &m_show_centered_top);
+            ImGui::SameLine();
+            ImGui::Checkbox("Ctr bot##lbl", &m_show_centered_bottom);
+        }
+
+        if (ImGui::CollapsingHeader("Skeleton"))
+        {
+            ImGui::Checkbox("Show##skel", &m_show_skeleton);
+            ImGui::ColorEdit4("Color##skel", reinterpret_cast<float*>(&m_skel_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Thick##skel", &m_skel_thickness, 0.5f, 5.f);
+        }
+
+        if (ImGui::CollapsingHeader("Snap Line"))
+        {
+            ImGui::Checkbox("Show##snap", &m_show_snap);
+            ImGui::ColorEdit4("Color##snap", reinterpret_cast<float*>(&m_snap_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Width##snap", &m_snap_width, 0.5f, 5.f);
+        }
+
+        ImGui::PopItemWidth();
+        ImGui::End();
+    }
+
+    void MainWindow::draw_overlay()
+    {
+        using namespace omath::hud::widget;
+        using omath::hud::when;
+        const auto* vp = ImGui::GetMainViewport();
+        const Bar bar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset};
+        const DashedBar dbar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width,
+                             m_bar_value, m_bar_dash_len,      m_bar_dash_gap, m_bar_offset};
+
+        omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y},
+                                  std::make_shared<omath::hud::ImguiHudRenderer>())
+                .contents(
+                        // ── Boxes ────────────────────────────────────────────────────
+                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_thickness}),
+                        when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
+                                                              m_corner_ratio, m_box_thickness}),
+                        when(m_show_dashed_box, DashedBox{m_dash_color, m_dash_len, m_dash_gap, m_dash_thickness}),
+
+                        RightSide
+                        {
+                                when(m_show_right_bar, bar),
+                                when(m_show_right_dashed_bar, dbar),
+                                when(m_show_right_labels,
+                                     Label{{0.f, 1.f, 0.f, 1.f}, m_label_offset, m_outlined, "Health: 100/100"}),
+                                when(m_show_right_labels,
+                                     Label{{1.f, 0.f, 0.f, 1.f}, m_label_offset, m_outlined, "Shield: 125/125"}),
+                                when(m_show_right_labels,
+                                     Label{{1.f, 0.f, 1.f, 1.f}, m_label_offset, m_outlined, "*LOCKED*"}),
+                        },
+                        LeftSide
+                        {
+                                when(m_show_left_bar, bar),
+                                when(m_show_left_dashed_bar, dbar),
+                                when(m_show_left_labels, Label{omath::Color::from_rgba(255, 128, 0, 255),
+                                                               m_label_offset, m_outlined, "Armor: 75"}),
+                                when(m_show_left_labels, Label{omath::Color::from_rgba(0, 200, 255, 255),
+                                                               m_label_offset, m_outlined, "Level: 42"}),
+                        },
+                        TopSide
+                        {
+                                when(m_show_top_bar, bar),
+                                when(m_show_top_dashed_bar, dbar),
+                                when(m_show_centered_top, Centered{Label{omath::Color::from_rgba(0, 255, 255, 255),
+                                                                         m_label_offset, m_outlined, "*VISIBLE*"}}),
+                                when(m_show_top_labels, Label{omath::Color::from_rgba(255, 255, 0, 255), m_label_offset,
+                                                              m_outlined, "*SCOPED*"}),
+                                when(m_show_top_labels, Label{omath::Color::from_rgba(255, 0, 0, 255), m_label_offset,
+                                                              m_outlined, "*BLEEDING*"}),
+                        },
+                        BottomSide
+                        {
+                                when(m_show_bottom_bar, bar),
+                                when(m_show_bottom_dashed_bar, dbar),
+                                when(m_show_centered_bottom, Centered{Label{omath::Color::from_rgba(255, 255, 255, 255),
+                                                                            m_label_offset, m_outlined, "PlayerName"}}),
+                                when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
+                                                                 m_label_offset, m_outlined, "42m"}),
+                        },
+                        when(m_show_skeleton, Skeleton{m_skel_color, m_skel_thickness}),
+                        when(m_show_snap, SnapLine{{vp->Size.x / 2.f, vp->Size.y}, m_snap_color, m_snap_width}));
+    }
+
+    void MainWindow::present()
+    {
+        int w, h;
+        glfwGetFramebufferSize(m_window, &w, &h);
+        glViewport(0, 0, w, h);
+        glClearColor(0.f, 0.f, 0.f, 0.f);
+        glClear(GL_COLOR_BUFFER_BIT);
+        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+        glfwSwapBuffers(m_window);
+    }
+} // namespace imgui_desktop::gui

examples/example_hud/gui/main_window.hpp

@@ -0,0 +1,69 @@
+//
+// Created by Orange on 11/11/2024.
+//
+#pragma once
+#include <omath/hud/entity_overlay.hpp>
+#include <omath/utility/color.hpp>
+#include <string_view>
+
+struct GLFWwindow;
+
+namespace imgui_desktop::gui
+{
+    class MainWindow
+    {
+    public:
+        MainWindow(const std::string_view& caption, int width, int height);
+        void Run();
+
+    private:
+        void draw_controls();
+        void draw_overlay();
+        void present();
+
+        GLFWwindow* m_window = nullptr;
+        static bool m_canMoveWindow;
+        bool m_opened = true;
+
+        // Entity
+        float m_entity_x = 550.f, m_entity_top_y = 150.f, m_entity_bottom_y = 450.f;
+
+        // Box
+        omath::Color m_box_color{1.f, 1.f, 1.f, 1.f};
+        omath::Color m_box_fill{0.f, 0.f, 0.f, 0.f};
+        float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
+        bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
+
+        // Dashed box
+        omath::Color m_dash_color = omath::Color::from_rgba(255, 200, 0, 255);
+        float m_dash_len = 8.f, m_dash_gap = 5.f, m_dash_thickness = 1.f;
+
+        // Bars
+        omath::Color m_bar_color{0.f, 1.f, 0.f, 1.f};
+        omath::Color m_bar_bg_color{0.f, 0.f, 0.f, 0.5f};
+        omath::Color m_bar_outline_color{0.f, 0.f, 0.f, 1.f};
+        float m_bar_width = 4.f, m_bar_value = 0.75f, m_bar_offset = 5.f;
+        bool m_show_right_bar = true,         m_show_left_bar = true;
+        bool m_show_top_bar = true,           m_show_bottom_bar = true;
+        bool m_show_right_dashed_bar = false, m_show_left_dashed_bar = false;
+        bool m_show_top_dashed_bar = false,   m_show_bottom_dashed_bar = false;
+        float m_bar_dash_len = 6.f, m_bar_dash_gap = 4.f;
+
+        // Labels
+        float m_label_offset = 3.f;
+        bool m_outlined = true;
+        bool m_show_right_labels = true, m_show_left_labels = true;
+        bool m_show_top_labels = true,   m_show_bottom_labels = true;
+        bool m_show_centered_top = true, m_show_centered_bottom = true;
+
+        // Skeleton
+        omath::Color m_skel_color = omath::Color::from_rgba(255, 255, 255, 200);
+        float m_skel_thickness = 1.f;
+        bool m_show_skeleton = false;
+
+        // Snap line
+        omath::Color m_snap_color = omath::Color::from_rgba(255, 50, 50, 255);
+        float m_snap_width = 1.5f;
+        bool m_show_snap = true;
+    };
+} // namespace imgui_desktop::gui

examples/example_hud/main.cpp

@@ -0,0 +1,8 @@
+//
+// Created by orange on 13.03.2026.
+//
+#include "gui/main_window.hpp"
+int main()
+{
+    imgui_desktop::gui::MainWindow("omath::hud", 800, 600).Run();
+}

include/omath/hud/canvas_box.hpp

@@ -0,0 +1,23 @@
+//
+// Created by orange on 13.03.2026.
+//
+#pragma once
+#include "omath/linear_algebra/vector2.hpp"
+#include <array>
+namespace omath::hud
+{
+    class CanvasBox final
+    {
+    public:
+        CanvasBox(Vector2<float> top, Vector2<float> bottom, float ratio = 4.f);
+
+        [[nodiscard]]
+        std::array<Vector2<float>, 4> as_array() const;
+
+        Vector2<float> top_left_corner;
+        Vector2<float> top_right_corner;
+
+        Vector2<float> bottom_left_corner;
+        Vector2<float> bottom_right_corner;
+    };
+} // namespace omath::hud

include/omath/hud/entity_overlay.hpp

@@ -0,0 +1,168 @@
+//
+// Created by orange on 13.03.2026.
+//
+#pragma once
+#include "canvas_box.hpp"
+#include "entity_overlay_widgets.hpp"
+#include "hud_renderer_interface.hpp"
+#include "omath/linear_algebra/vector2.hpp"
+#include "omath/utility/color.hpp"
+#include <memory>
+#include <string_view>
+
+namespace omath::hud
+{
+    class EntityOverlay final
+    {
+    public:
+        EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom,
+                      const std::shared_ptr<HudRendererInterface>& renderer);
+
+        // ── Boxes ────────────────────────────────────────────────────────
+        EntityOverlay& add_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
+                                  float thickness = 1.f);
+
+        EntityOverlay& add_cornered_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
+                                           float corner_ratio_len = 0.2f, float thickness = 1.f);
+
+        EntityOverlay& add_dashed_box(const Color& color, float dash_len = 8.f, float gap_len = 5.f,
+                                      float thickness = 1.f);
+
+        // ── Bars ─────────────────────────────────────────────────────────
+        EntityOverlay& add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
+                                     float ratio, float offset = 5.f);
+
+        EntityOverlay& add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
+                                    float ratio, float offset = 5.f);
+
+        EntityOverlay& add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color, float height,
+                                   float ratio, float offset = 5.f);
+
+        EntityOverlay& add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                      float height, float ratio, float offset = 5.f);
+
+        EntityOverlay& add_right_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                            float width, float ratio, float dash_len, float gap_len,
+                                            float offset = 5.f);
+
+        EntityOverlay& add_left_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                           float width, float ratio, float dash_len, float gap_len, float offset = 5.f);
+
+        EntityOverlay& add_top_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                          float height, float ratio, float dash_len, float gap_len, float offset = 5.f);
+
+        EntityOverlay& add_bottom_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                             float height, float ratio, float dash_len, float gap_len,
+                                             float offset = 5.f);
+
+        // ── Labels ───────────────────────────────────────────────────────
+        EntityOverlay& add_right_label(const Color& color, float offset, bool outlined, const std::string_view& text);
+
+        EntityOverlay& add_left_label(const Color& color, float offset, bool outlined, const std::string_view& text);
+
+        EntityOverlay& add_top_label(const Color& color, float offset, bool outlined, std::string_view text);
+
+        EntityOverlay& add_bottom_label(const Color& color, float offset, bool outlined, std::string_view text);
+
+        EntityOverlay& add_centered_top_label(const Color& color, float offset, bool outlined,
+                                              const std::string_view& text);
+
+        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, bool outlined,
+                                                 const std::string_view& text);
+
+        template<typename... Args>
+        EntityOverlay& add_right_label(const Color& color, float offset, bool outlined, std::format_string<Args...> fmt,
+                                       Args&&... args)
+        {
+            return add_right_label(color, offset, outlined,
+                                   std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        template<typename... Args>
+        EntityOverlay& add_left_label(const Color& color, float offset, bool outlined, std::format_string<Args...> fmt,
+                                      Args&&... args)
+        {
+            return add_left_label(color, offset, outlined,
+                                  std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        template<typename... Args>
+        EntityOverlay& add_top_label(const Color& color, float offset, bool outlined, std::format_string<Args...> fmt,
+                                     Args&&... args)
+        {
+            return add_top_label(color, offset, outlined,
+                                 std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        template<typename... Args>
+        EntityOverlay& add_bottom_label(const Color& color, float offset, bool outlined,
+                                        std::format_string<Args...> fmt, Args&&... args)
+        {
+            return add_bottom_label(color, offset, outlined,
+                                    std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        template<typename... Args>
+        EntityOverlay& add_centered_top_label(const Color& color, float offset, bool outlined,
+                                              std::format_string<Args...> fmt, Args&&... args)
+        {
+            return add_centered_top_label(color, offset, outlined,
+                                          std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        template<typename... Args>
+        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, bool outlined,
+                                                 std::format_string<Args...> fmt, Args&&... args)
+        {
+            return add_centered_bottom_label(color, offset, outlined,
+                                             std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
+        }
+
+        // ── Misc ─────────────────────────────────────────────────────────
+        EntityOverlay& add_snap_line(const Vector2<float>& start_pos, const Color& color, float width);
+
+        EntityOverlay& add_skeleton(const Color& color, float thickness = 1.f);
+
+        // ── Declarative interface ─────────────────────────────────────────
+        /// Pass any combination of widget:: descriptor structs (and std::optional<W>
+        /// from when()) to render them all in declaration order.
+        template<typename... Widgets>
+        EntityOverlay& contents(Widgets&&... widgets)
+        {
+            (dispatch(std::forward<Widgets>(widgets)), ...);
+            return *this;
+        }
+
+    private:
+        // optional<W> dispatch — enables when() conditional widgets
+        template<typename W>
+        void dispatch(const std::optional<W>& w)
+        {
+            if (w)
+                dispatch(*w);
+        }
+
+        void dispatch(const widget::Box& w);
+        void dispatch(const widget::CorneredBox& w);
+        void dispatch(const widget::DashedBox& w);
+        void dispatch(const widget::RightSide& w);
+        void dispatch(const widget::LeftSide& w);
+        void dispatch(const widget::TopSide& w);
+        void dispatch(const widget::BottomSide& w);
+        void dispatch(const widget::Skeleton& w);
+        void dispatch(const widget::SnapLine& w);
+        void draw_outlined_text(const Vector2<float>& position, const Color& color, const std::string_view& text);
+        void draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color, float dash_len,
+                              float gap_len, float thickness) const;
+        void draw_dashed_fill(const Vector2<float>& origin, const Vector2<float>& step_dir,
+                              const Vector2<float>& perp_dir, float full_len, float filled_len, const Color& fill_color,
+                              const Color& split_color, float dash_len, float gap_len) const;
+
+        CanvasBox m_canvas;
+        Vector2<float> m_text_cursor_right;
+        Vector2<float> m_text_cursor_top;
+        Vector2<float> m_text_cursor_bottom;
+        Vector2<float> m_text_cursor_left;
+        std::shared_ptr<HudRendererInterface> m_renderer;
+    };
+} // namespace omath::hud

include/omath/hud/entity_overlay_widgets.hpp

@@ -0,0 +1,142 @@
+//
+// Created by orange on 15.03.2026.
+//
+#pragma once
+#include "omath/linear_algebra/vector2.hpp"
+#include "omath/utility/color.hpp"
+#include <initializer_list>
+#include <optional>
+#include <string_view>
+#include <variant>
+
+namespace omath::hud::widget
+{
+    // ── Overloaded helper for std::visit ──────────────────────────────────────
+    template<typename... Ts>
+    struct Overloaded : Ts...
+    {
+        using Ts::operator()...;
+    };
+    template<typename... Ts>
+    Overloaded(Ts...) -> Overloaded<Ts...>;
+
+    // ── Standalone widgets ────────────────────────────────────────────────────
+    struct Box
+    {
+        Color color;
+        Color fill{0.f, 0.f, 0.f, 0.f};
+        float thickness = 1.f;
+    };
+
+    struct CorneredBox
+    {
+        Color color;
+        Color fill{0.f, 0.f, 0.f, 0.f};
+        float corner_ratio = 0.2f;
+        float thickness = 1.f;
+    };
+
+    struct DashedBox
+    {
+        Color color;
+        float dash_len = 8.f;
+        float gap_len = 5.f;
+        float thickness = 1.f;
+    };
+
+    struct Skeleton
+    {
+        Color color;
+        float thickness = 1.f;
+    };
+    struct SnapLine
+    {
+        Vector2<float> start;
+        Color color;
+        float width;
+    };
+
+    // ── Side-agnostic widgets (used inside XxxSide containers) ────────────────
+
+    /// A filled bar. `size` is width for left/right sides, height for top/bottom.
+    struct Bar
+    {
+        Color color;
+        Color outline;
+        Color bg;
+        float size;
+        float ratio;
+        float offset = 5.f;
+    };
+
+    /// A dashed bar. Same field semantics as Bar plus dash parameters.
+    struct DashedBar
+    {
+        Color color;
+        Color outline;
+        Color bg;
+        float size;
+        float ratio;
+        float dash_len;
+        float gap_len;
+        float offset = 5.f;
+    };
+
+    struct Label
+    {
+        Color            color;
+        float            offset;
+        bool             outlined;
+        std::string_view text;
+    };
+
+    /// Wraps a Label to request horizontal centering (only applied in TopSide / BottomSide).
+    template<typename W>
+    struct Centered
+    {
+        W child;
+    };
+    template<typename W>
+    Centered(W) -> Centered<W>;
+
+    // ── Side widget variant ───────────────────────────────────────────────────
+    struct None {};  ///< No-op placeholder — used by widget::when for disabled elements.
+    using SideWidget = std::variant<None, Bar, DashedBar, Label, Centered<Label>>;
+
+    // ── Side containers ───────────────────────────────────────────────────────
+    // Storing std::initializer_list<SideWidget> is safe here: the backing array
+    // is a const SideWidget[] on the caller's stack whose lifetime matches the
+    // temporary side-container object, which is consumed within the same
+    // full-expression by EntityOverlay::dispatch. No heap allocation occurs.
+
+    struct RightSide  { std::initializer_list<SideWidget> children; RightSide(std::initializer_list<SideWidget> c) : children(c) {} };
+    struct LeftSide   { std::initializer_list<SideWidget> children; LeftSide(std::initializer_list<SideWidget> c) : children(c) {} };
+    struct TopSide    { std::initializer_list<SideWidget> children; TopSide(std::initializer_list<SideWidget> c) : children(c) {} };
+    struct BottomSide { std::initializer_list<SideWidget> children; BottomSide(std::initializer_list<SideWidget> c) : children(c) {} };
+
+} // namespace omath::hud::widget
+
+namespace omath::hud::widget
+{
+    /// Inside XxxSide containers: returns the widget as a SideWidget when condition is true,
+    /// or None{} otherwise. Preferred over hud::when for types inside the SideWidget variant.
+    template<typename W>
+        requires std::constructible_from<SideWidget, W>
+    SideWidget when(const bool condition, W widget)
+    {
+        if (condition) return SideWidget{std::move(widget)};
+        return None{};
+    }
+} // namespace omath::hud::widget
+
+namespace omath::hud
+{
+    /// Top-level: returns an engaged optional<W> when condition is true, std::nullopt otherwise.
+    /// Designed for use with EntityOverlay::contents() for top-level widget types.
+    template<typename W>
+    std::optional<W> when(const bool condition, W widget)
+    {
+        if (condition) return std::move(widget);
+        return std::nullopt;
+    }
+} // namespace omath::hud

include/omath/hud/hud_renderer_interface.hpp

@@ -0,0 +1,32 @@
+//
+// Created by orange on 13.03.2026.
+//
+#pragma once
+#include "omath/linear_algebra/vector2.hpp"
+#include "omath/utility/color.hpp"
+#include <span>
+
+namespace omath::hud
+{
+    class HudRendererInterface
+    {
+    public:
+        virtual ~HudRendererInterface() = default;
+        virtual void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
+                              float thickness) = 0;
+
+        virtual void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
+                                  float thickness) = 0;
+
+        virtual void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) = 0;
+
+        virtual void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
+
+        virtual void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
+
+        virtual void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) = 0;
+
+        [[nodiscard]]
+        virtual Vector2<float> calc_text_size(const std::string_view& text) = 0;
+    };
+} // namespace omath::hud

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -0,0 +1,25 @@
+//
+// Created by orange on 13.03.2026.
+//
+#pragma once
+#include <omath/hud/hud_renderer_interface.hpp>
+
+#ifdef OMATH_IMGUI_INTEGRATION
+namespace omath::hud
+{
+    class ImguiHudRenderer final : public HudRendererInterface
+    {
+    public:
+        ~ImguiHudRenderer() override;
+        void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
+                      float thickness) override;
+        void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color, float thickness) override;
+        void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) override;
+        void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
+        void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
+        void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) override;
+        [[nodiscard]]
+        virtual Vector2<float> calc_text_size(const std::string_view& text) override;
+    };
+} // namespace omath::hud
+#endif // OMATH_IMGUI_INTEGRATION

include/omath/pathfinding/navigation_mesh.hpp

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

include/omath/utility/elf_pattern_scan.hpp

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -21,5 +22,10 @@ namespace omath
         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");
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
+                                        const std::string_view& target_section_name = ".text");
     };
 } // namespace omath

include/omath/utility/macho_pattern_scan.hpp

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -21,5 +22,10 @@ namespace omath
         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");
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
+                                        const std::string_view& target_section_name = "__text");
     };
 } // namespace omath

include/omath/utility/pe_pattern_scan.hpp

@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -23,5 +24,10 @@ namespace omath
         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");
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
+                                        const std::string_view& target_section_name = ".text");
     };
 } // namespace omath

source/hud/canvas_box.cpp

@@ -0,0 +1,27 @@
+//
+// Created by orange on 13.03.2026.
+//
+//
+// Created by Vlad on 6/17/2025.
+//
+#include "omath/hud/canvas_box.hpp"
+
+namespace omath::hud
+{
+
+    CanvasBox::CanvasBox(const Vector2<float> top, Vector2<float> bottom, const float ratio)
+    {
+        bottom.x = top.x;
+        const auto height = std::abs(top.y - bottom.y);
+
+        top_left_corner = top - Vector2<float>{height / ratio, 0};
+        top_right_corner = top + Vector2<float>{height / ratio, 0};
+
+        bottom_left_corner = bottom - Vector2<float>{height / ratio, 0};
+        bottom_right_corner = bottom + Vector2<float>{height / ratio, 0};
+    }
+    std::array<Vector2<float>, 4> CanvasBox::as_array() const
+    {
+        return {top_left_corner, top_right_corner, bottom_right_corner, bottom_left_corner};
+    }
+} // namespace ohud

source/hud/entity_overlay.cpp

@@ -0,0 +1,541 @@
+//
+// Created by orange on 13.03.2026.
+//
+#include "omath/hud/entity_overlay.hpp"
+
+namespace omath::hud
+{
+    EntityOverlay& EntityOverlay::add_2d_box(const Color& box_color, const Color& fill_color, const float thickness)
+    {
+        const auto points = m_canvas.as_array();
+
+        m_renderer->add_polyline({points.data(), points.size()}, box_color, thickness);
+
+        if (fill_color.value().w > 0.f)
+            m_renderer->add_filled_polyline({points.data(), points.size()}, fill_color);
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_cornered_2d_box(const Color& box_color, const Color& fill_color,
+                                                      const float corner_ratio_len, const float thickness)
+    {
+        const auto corner_line_length =
+                std::abs((m_canvas.top_left_corner - m_canvas.top_right_corner).x * corner_ratio_len);
+
+        if (fill_color.value().w > 0.f)
+            add_2d_box(fill_color, fill_color);
+        // Left Side
+        m_renderer->add_line(m_canvas.top_left_corner,
+                             m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f}, box_color, thickness);
+
+        m_renderer->add_line(m_canvas.top_left_corner,
+                             m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length}, box_color, thickness);
+
+        m_renderer->add_line(m_canvas.bottom_left_corner,
+                             m_canvas.bottom_left_corner - Vector2<float>{0.f, corner_line_length}, box_color,
+                             thickness);
+
+        m_renderer->add_line(m_canvas.bottom_left_corner,
+                             m_canvas.bottom_left_corner + Vector2<float>{corner_line_length, 0.f}, box_color,
+                             thickness);
+        // Right Side
+        m_renderer->add_line(m_canvas.top_right_corner,
+                             m_canvas.top_right_corner - Vector2<float>{corner_line_length, 0.f}, box_color, thickness);
+
+        m_renderer->add_line(m_canvas.top_right_corner,
+                             m_canvas.top_right_corner + Vector2<float>{0.f, corner_line_length}, box_color, thickness);
+
+        m_renderer->add_line(m_canvas.bottom_right_corner,
+                             m_canvas.bottom_right_corner - Vector2<float>{0.f, corner_line_length}, box_color,
+                             thickness);
+
+        m_renderer->add_line(m_canvas.bottom_right_corner,
+                             m_canvas.bottom_right_corner - Vector2<float>{corner_line_length, 0.f}, box_color,
+                             thickness);
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                                const float width, float ratio, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const auto max_bar_height = std::abs(m_canvas.top_right_corner.y - m_canvas.bottom_right_corner.y);
+
+        const auto bar_start = Vector2<float>{m_text_cursor_right.x + offset, m_canvas.bottom_right_corner.y};
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
+        m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
+                                  bar_start + Vector2<float>(width, -max_bar_height), outline_color);
+
+        m_text_cursor_right.x += offset + width;
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                               const float width, float ratio, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const auto max_bar_height = std::abs(m_canvas.top_left_corner.y - m_canvas.bottom_right_corner.y);
+
+        const auto bar_start = Vector2<float>{m_text_cursor_left.x - (offset + width), m_canvas.bottom_left_corner.y};
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
+        m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
+                                  bar_start + Vector2<float>(width, -max_bar_height), outline_color);
+
+        m_text_cursor_left.x -= offset + width;
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_right_label(const Color& color, const float offset, const bool outlined,
+                                                  const std::string_view& text)
+    {
+        if (outlined)
+            draw_outlined_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text);
+        else
+            m_renderer->add_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text.data());
+
+        m_text_cursor_right.y += m_renderer->calc_text_size(text.data()).y;
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_top_label(const Color& color, const float offset, const bool outlined,
+                                                const std::string_view text)
+    {
+        m_text_cursor_top.y -= m_renderer->calc_text_size(text.data()).y;
+
+        if (outlined)
+            draw_outlined_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text);
+        else
+            m_renderer->add_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text.data());
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                              const float height, float ratio, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const auto max_bar_width = std::abs(m_canvas.top_left_corner.x - m_canvas.bottom_right_corner.x);
+
+        const auto bar_start = Vector2<float>{m_canvas.top_left_corner.x, m_text_cursor_top.y - offset};
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), bg_color);
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, -height), color);
+        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), outline_color);
+
+        m_text_cursor_top.y -= offset + height;
+
+        return *this;
+    }
+    EntityOverlay& EntityOverlay::add_snap_line(const Vector2<float>& start_pos, const Color& color, const float width)
+    {
+        const Vector2<float> line_end =
+                m_canvas.bottom_left_corner
+                + Vector2<float>{m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x, 0.f} / 2;
+        m_renderer->add_line(start_pos, line_end, color, width);
+
+        return *this;
+    }
+    void EntityOverlay::draw_dashed_fill(const Vector2<float>& origin, const Vector2<float>& step_dir,
+                                         const Vector2<float>& perp_dir, const float full_len, const float filled_len,
+                                         const Color& fill_color, const Color& split_color, const float dash_len,
+                                         const float gap_len) const
+    {
+        if (full_len <= 0.f)
+            return;
+
+        const float step = dash_len + gap_len;
+        const float n = std::floor((full_len + gap_len) / step);
+        if (n < 1.f)
+            return;
+
+        const float used = n * dash_len + (n - 1.f) * gap_len;
+        const float offset = (full_len - used) / 2.f;
+
+        const auto fill_rect = [&](const Vector2<float>& a, const Vector2<float>& b, const Color& c)
+        {
+            m_renderer->add_filled_rectangle({std::min(a.x, b.x), std::min(a.y, b.y)},
+                                             {std::max(a.x, b.x), std::max(a.y, b.y)}, c);
+        };
+
+        // Draw split lines (gaps) across the full bar first
+        // Leading gap
+        if (offset > 0.f)
+            fill_rect(origin, origin + step_dir * offset + perp_dir, split_color);
+
+        for (float i = 0.f; i < n; ++i)
+        {
+            const float dash_start = offset + i * step;
+            const float dash_end = dash_start + dash_len;
+            const float gap_start = dash_end;
+            const float gap_end = dash_start + step;
+
+            // Fill dash only up to filled_len
+            if (dash_start < filled_len)
+            {
+                const auto a = origin + step_dir * dash_start;
+                const auto b = a + step_dir * std::min(dash_len, filled_len - dash_start) + perp_dir;
+                fill_rect(a, b, fill_color);
+            }
+
+            // Split line (gap) — always drawn across full bar
+            if (i < n - 1.f && gap_start < full_len)
+            {
+                const auto a = origin + step_dir * gap_start;
+                const auto b = origin + step_dir * std::min(gap_end, full_len) + perp_dir;
+                fill_rect(a, b, split_color);
+            }
+        }
+
+        // Trailing gap
+        const float trail_start = offset + n * dash_len + (n - 1.f) * gap_len;
+        if (trail_start < full_len)
+            fill_rect(origin + step_dir * trail_start, origin + step_dir * full_len + perp_dir, split_color);
+    }
+
+    EntityOverlay& EntityOverlay::add_right_dashed_bar(const Color& color, const Color& outline_color,
+                                                       const Color& bg_color, const float width, float ratio,
+                                                       const float dash_len, const float gap_len, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const float height = std::abs(m_canvas.top_right_corner.y - m_canvas.bottom_right_corner.y);
+        const auto bar_start = Vector2<float>{m_text_cursor_right.x + offset, m_canvas.bottom_right_corner.y};
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{width, -height}, bg_color);
+        draw_dashed_fill(bar_start, {0.f, -1.f}, {width, 0.f}, height, height * ratio, color, outline_color, dash_len,
+                         gap_len);
+        m_renderer->add_rectangle(bar_start - Vector2<float>{1.f, 0.f}, bar_start + Vector2<float>{width, -height},
+                                  outline_color);
+        m_text_cursor_right.x += offset + width;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_dashed_bar(const Color& color, const Color& outline_color,
+                                                      const Color& bg_color, const float width, float ratio,
+                                                      const float dash_len, const float gap_len, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const float height = std::abs(m_canvas.top_left_corner.y - m_canvas.bottom_left_corner.y);
+        const auto bar_start = Vector2<float>{m_text_cursor_left.x - (offset + width), m_canvas.bottom_left_corner.y};
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{width, -height}, bg_color);
+        draw_dashed_fill(bar_start, {0.f, -1.f}, {width, 0.f}, height, height * ratio, color, outline_color, dash_len,
+                         gap_len);
+        m_renderer->add_rectangle(bar_start - Vector2<float>{1.f, 0.f}, bar_start + Vector2<float>{width, -height},
+                                  outline_color);
+        m_text_cursor_left.x -= offset + width;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_top_dashed_bar(const Color& color, const Color& outline_color,
+                                                     const Color& bg_color, const float height, float ratio,
+                                                     const float dash_len, const float gap_len, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const float bar_w = std::abs(m_canvas.top_left_corner.x - m_canvas.top_right_corner.x);
+        const auto bar_start = Vector2<float>{m_canvas.top_left_corner.x, m_text_cursor_top.y - offset};
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{bar_w, -height}, bg_color);
+        draw_dashed_fill(bar_start, {1.f, 0.f}, {0.f, -height}, bar_w, bar_w * ratio, color, outline_color, dash_len,
+                         gap_len);
+        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>{bar_w, -height}, outline_color);
+        m_text_cursor_top.y -= offset + height;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_dashed_bar(const Color& color, const Color& outline_color,
+                                                        const Color& bg_color, const float height, float ratio,
+                                                        const float dash_len, const float gap_len, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const float bar_w = std::abs(m_canvas.bottom_left_corner.x - m_canvas.bottom_right_corner.x);
+        const auto bar_start = Vector2<float>{m_canvas.bottom_left_corner.x, m_text_cursor_bottom.y + offset};
+
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{bar_w, height}, bg_color);
+        draw_dashed_fill(bar_start, {1.f, 0.f}, {0.f, height}, bar_w, bar_w * ratio, color, outline_color, dash_len,
+                         gap_len);
+        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>{bar_w, height}, outline_color);
+        m_text_cursor_bottom.y += offset + height;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_skeleton(const Color& color, const float thickness)
+    {
+        // Maps normalized (rx in [0,1], ry in [0,1]) to canvas screen position
+        const auto joint = [&](const float rx, const float ry) -> Vector2<float>
+        {
+            const auto top = m_canvas.top_left_corner + (m_canvas.top_right_corner - m_canvas.top_left_corner) * rx;
+            const auto bot =
+                    m_canvas.bottom_left_corner + (m_canvas.bottom_right_corner - m_canvas.bottom_left_corner) * rx;
+            return top + (bot - top) * ry;
+        };
+
+        using B = std::pair<std::pair<float, float>, std::pair<float, float>>;
+        static constexpr std::array<B, 15> k_bones{{
+                // Spine
+                {{0.50f, 0.13f}, {0.50f, 0.22f}}, // head       → neck
+                {{0.50f, 0.22f}, {0.50f, 0.38f}}, // neck       → chest
+                {{0.50f, 0.38f}, {0.50f, 0.55f}}, // chest      → pelvis
+                // Left arm
+                {{0.50f, 0.22f}, {0.25f, 0.25f}}, // neck       → L shoulder
+                {{0.25f, 0.25f}, {0.13f, 0.42f}}, // L shoulder → L elbow
+                {{0.13f, 0.42f}, {0.08f, 0.56f}}, // L elbow    → L hand
+                // Right arm
+                {{0.50f, 0.22f}, {0.75f, 0.25f}}, // neck       → R shoulder
+                {{0.75f, 0.25f}, {0.87f, 0.42f}}, // R shoulder → R elbow
+                {{0.87f, 0.42f}, {0.92f, 0.56f}}, // R elbow    → R hand
+                // Left leg
+                {{0.50f, 0.55f}, {0.36f, 0.58f}}, // pelvis     → L hip
+                {{0.36f, 0.58f}, {0.32f, 0.77f}}, // L hip      → L knee
+                {{0.32f, 0.77f}, {0.27f, 0.97f}}, // L knee     → L foot
+                // Right leg
+                {{0.50f, 0.55f}, {0.64f, 0.58f}}, // pelvis     → R hip
+                {{0.64f, 0.58f}, {0.68f, 0.77f}}, // R hip      → R knee
+                {{0.68f, 0.77f}, {0.73f, 0.97f}}, // R knee     → R foot
+        }};
+
+        for (const auto& [a, b] : k_bones)
+            m_renderer->add_line(joint(a.first, a.second), joint(b.first, b.second), color, thickness);
+
+        return *this;
+    }
+
+    void EntityOverlay::draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color,
+                                         const float dash_len, const float gap_len, const float thickness) const
+    {
+        const auto total = (to - from).length();
+        if (total <= 0.f)
+            return;
+
+        const auto dir = (to - from).normalized();
+        const float step = dash_len + gap_len;
+
+        const float n_dashes = std::floor((total + gap_len) / step);
+        if (n_dashes < 1.f)
+            return;
+
+        const float used = n_dashes * dash_len + (n_dashes - 1.f) * gap_len;
+        const float offset = (total - used) / 2.f;
+
+        for (float i = 0.f; i < n_dashes; ++i)
+        {
+            const float pos = offset + i * step;
+            const auto dash_start = from + dir * pos;
+            const auto dash_end = from + dir * std::min(pos + dash_len, total);
+            m_renderer->add_line(dash_start, dash_end, color, thickness);
+        }
+    }
+
+    EntityOverlay& EntityOverlay::add_dashed_box(const Color& color, const float dash_len, const float gap_len,
+                                                 const float thickness)
+    {
+        const float min_edge = std::min((m_canvas.top_right_corner - m_canvas.top_left_corner).length(),
+                                        (m_canvas.bottom_right_corner - m_canvas.top_right_corner).length());
+        const float corner_len = std::min(dash_len, min_edge / 2.f);
+
+        const auto draw_edge = [&](const Vector2<float>& from, const Vector2<float>& to)
+        {
+            const auto dir = (to - from).normalized();
+
+            m_renderer->add_line(from, from + dir * corner_len, color, thickness);
+            draw_dashed_line(from + dir * corner_len, to - dir * corner_len, color, dash_len, gap_len, thickness);
+            m_renderer->add_line(to - dir * corner_len, to, color, thickness);
+        };
+
+        draw_edge(m_canvas.top_left_corner, m_canvas.top_right_corner);
+        draw_edge(m_canvas.top_right_corner, m_canvas.bottom_right_corner);
+        draw_edge(m_canvas.bottom_right_corner, m_canvas.bottom_left_corner);
+        draw_edge(m_canvas.bottom_left_corner, m_canvas.top_left_corner);
+
+        return *this;
+    }
+
+    void EntityOverlay::draw_outlined_text(const Vector2<float>& position, const Color& color,
+                                           const std::string_view& text)
+    {
+        static constexpr std::array outline_offsets = {
+                Vector2<float>{-1, -1}, Vector2<float>{-1, 0}, Vector2<float>{-1, 1}, Vector2<float>{0, -1},
+                Vector2<float>{0, 1},   Vector2<float>{1, -1}, Vector2<float>{1, 0},  Vector2<float>{1, 1}};
+
+        for (const auto& outline_offset : outline_offsets)
+            m_renderer->add_text(position + outline_offset, Color{0.f, 0.f, 0.f, 1.f}, text.data());
+        m_renderer->add_text(position, color, text.data());
+    }
+    EntityOverlay& EntityOverlay::add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
+                                                 const float height, float ratio, const float offset)
+    {
+        ratio = std::clamp(ratio, 0.f, 1.f);
+        const auto max_bar_width = std::abs(m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x);
+
+        const auto bar_start = Vector2<float>{m_canvas.bottom_left_corner.x, m_text_cursor_bottom.y + offset};
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), bg_color);
+        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, height), color);
+        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), outline_color);
+
+        m_text_cursor_bottom.y += offset + height;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_label(const Color& color, const float offset, const bool outlined,
+                                                   const std::string_view text)
+    {
+        const auto text_size = m_renderer->calc_text_size(text);
+
+        if (outlined)
+            draw_outlined_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
+        else
+            m_renderer->add_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
+
+        m_text_cursor_bottom.y += text_size.y;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_label(const Color& color, const float offset, const bool outlined,
+                                                 const std::string_view& text)
+    {
+        const auto text_size = m_renderer->calc_text_size(text);
+        const auto pos = m_text_cursor_left + Vector2<float>{-(offset + text_size.x), 0.f};
+
+        if (outlined)
+            draw_outlined_text(pos, color, text);
+        else
+            m_renderer->add_text(pos, color, text);
+
+        m_text_cursor_left.y += text_size.y;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_centered_bottom_label(const Color& color, const float offset, const bool outlined,
+                                                            const std::string_view& text)
+    {
+        const auto text_size = m_renderer->calc_text_size(text);
+        const auto box_center_x =
+                m_canvas.bottom_left_corner.x + (m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x) / 2.f;
+        const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_bottom.y + offset};
+
+        if (outlined)
+            draw_outlined_text(pos, color, text);
+        else
+            m_renderer->add_text(pos, color, text);
+
+        m_text_cursor_bottom.y += text_size.y;
+
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_centered_top_label(const Color& color, const float offset, const bool outlined,
+                                                         const std::string_view& text)
+    {
+        const auto text_size = m_renderer->calc_text_size(text);
+        const auto box_center_x =
+                m_canvas.top_left_corner.x + (m_canvas.top_right_corner.x - m_canvas.top_left_corner.x) / 2.f;
+
+        m_text_cursor_top.y -= text_size.y;
+        const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_top.y - offset};
+
+        if (outlined)
+            draw_outlined_text(pos, color, text);
+        else
+            m_renderer->add_text(pos, color, text);
+
+        return *this;
+    }
+
+    EntityOverlay::EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom,
+                                 const std::shared_ptr<HudRendererInterface>& renderer)
+        : m_canvas(top, bottom), m_text_cursor_right(m_canvas.top_right_corner),
+          m_text_cursor_top(m_canvas.top_left_corner), m_text_cursor_bottom(m_canvas.bottom_left_corner),
+          m_text_cursor_left(m_canvas.top_left_corner), m_renderer(renderer)
+    {
+    }
+    // ── widget dispatch ───────────────────────────────────────────────────────
+    void EntityOverlay::dispatch(const widget::Box& w)
+        { add_2d_box(w.color, w.fill, w.thickness); }
+
+    void EntityOverlay::dispatch(const widget::CorneredBox& w)
+        { add_cornered_2d_box(w.color, w.fill, w.corner_ratio, w.thickness); }
+
+    void EntityOverlay::dispatch(const widget::DashedBox& w)
+        { add_dashed_box(w.color, w.dash_len, w.gap_len, w.thickness); }
+
+    void EntityOverlay::dispatch(const widget::Skeleton& w)
+        { add_skeleton(w.color, w.thickness); }
+
+    void EntityOverlay::dispatch(const widget::SnapLine& w)
+        { add_snap_line(w.start, w.color, w.width); }
+
+    // ── Side container dispatch ───────────────────────────────────────────────
+    void EntityOverlay::dispatch(const widget::RightSide& s)
+    {
+        for (const auto& child : s.children)
+            std::visit(widget::Overloaded{
+                [](const widget::None&) {},
+                [this](const widget::Bar& w)
+                    { add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset); },
+                [this](const widget::DashedBar& w)
+                    { add_right_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len, w.offset); },
+                [this](const widget::Label& w)
+                    { add_right_label(w.color, w.offset, w.outlined, w.text); },
+                [this](const widget::Centered<widget::Label>& w)
+                    { add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text); },
+            }, child);
+    }
+
+    void EntityOverlay::dispatch(const widget::LeftSide& s)
+    {
+        for (const auto& child : s.children)
+            std::visit(widget::Overloaded{
+                [](const widget::None&) {},
+                [this](const widget::Bar& w)
+                    { add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset); },
+                [this](const widget::DashedBar& w)
+                    { add_left_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len, w.offset); },
+                [this](const widget::Label& w)
+                    { add_left_label(w.color, w.offset, w.outlined, w.text); },
+                [this](const widget::Centered<widget::Label>& w)
+                    { add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text); },
+            }, child);
+    }
+
+    void EntityOverlay::dispatch(const widget::TopSide& s)
+    {
+        for (const auto& child : s.children)
+            std::visit(widget::Overloaded{
+                [](const widget::None&) {},
+                [this](const widget::Bar& w)
+                    { add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset); },
+                [this](const widget::DashedBar& w)
+                    { add_top_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len, w.offset); },
+                [this](const widget::Label& w)
+                    { add_top_label(w.color, w.offset, w.outlined, w.text); },
+                [this](const widget::Centered<widget::Label>& w)
+                    { add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text); },
+            }, child);
+    }
+
+    void EntityOverlay::dispatch(const widget::BottomSide& s)
+    {
+        for (const auto& child : s.children)
+            std::visit(widget::Overloaded{
+                [](const widget::None&) {},
+                [this](const widget::Bar& w)
+                    { add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset); },
+                [this](const widget::DashedBar& w)
+                    { add_bottom_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len, w.offset); },
+                [this](const widget::Label& w)
+                    { add_bottom_label(w.color, w.offset, w.outlined, w.text); },
+                [this](const widget::Centered<widget::Label>& w)
+                    { add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined, w.child.text); },
+            }, child);
+    }
+
+} // namespace omath::hud

source/hud/renderer_realizations/imgui_renderer.cpp

@@ -0,0 +1,56 @@
+//
+// Created by orange on 13.03.2026.
+//
+#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
+
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+
+namespace omath::hud
+{
+    ImguiHudRenderer::~ImguiHudRenderer() = default;
+
+    void ImguiHudRenderer::add_line(const Vector2<float>& line_start, const Vector2<float>& line_end,
+                                    const Color& color, const float thickness)
+    {
+        ImGui::GetBackgroundDrawList()->AddLine(line_start.to_im_vec2(), line_end.to_im_vec2(), color.to_im_color(),
+                                                thickness);
+    }
+
+    void ImguiHudRenderer::add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
+                                        const float thickness)
+    {
+        ImGui::GetBackgroundDrawList()->AddPolyline(reinterpret_cast<const ImVec2*>(vertexes.data()),
+                                                    static_cast<int>(vertexes.size()), color.to_im_color(),
+                                                    ImDrawFlags_Closed, thickness);
+    }
+
+    void ImguiHudRenderer::add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color)
+    {
+        ImGui::GetBackgroundDrawList()->AddConvexPolyFilled(reinterpret_cast<const ImVec2*>(vertexes.data()),
+                                                    static_cast<int>(vertexes.size()), color.to_im_color());
+    }
+
+    void ImguiHudRenderer::add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color)
+    {
+        ImGui::GetBackgroundDrawList()->AddRect(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
+    }
+
+    void ImguiHudRenderer::add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                                const Color& color)
+    {
+        ImGui::GetBackgroundDrawList()->AddRectFilled(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
+    }
+
+    void ImguiHudRenderer::add_text(const Vector2<float>& position, const Color& color, const std::string_view& text)
+    {
+        ImGui::GetBackgroundDrawList()->AddText(position.to_im_vec2(), color.to_im_color(), text.data(),
+                                                text.data() + text.size());
+    }
+    [[nodiscard]]
+    Vector2<float> ImguiHudRenderer::calc_text_size(const std::string_view& text)
+    {
+        return Vector2<float>::from_im_vec2(ImGui::CalcTextSize(text.data()));
+    }
+} // namespace omath::hud
+#endif // OMATH_IMGUI_INTEGRATION

source/lua/lua_pattern_scan.cpp

@@ -10,7 +10,6 @@
 #include <omath/utility/pe_pattern_scan.hpp>
 #include <omath/utility/section_scan_result.hpp>
 #include <sol/sol.hpp>
-#endif
 
 namespace omath::lua
 {
@@ -102,3 +101,4 @@ namespace omath::lua
         };
     }
 } // namespace omath::lua
+#endif

source/pathfinding/navigation_mesh.cpp

@@ -3,9 +3,9 @@
 //
 #include "omath/pathfinding/navigation_mesh.hpp"
 #include <algorithm>
-#include <cstring>
+#include <sstream>
-#include <limits>
 #include <stdexcept>
+
 namespace omath::pathfinding
 {
     std::expected<Vector3<float>, std::string>
@@ -30,77 +30,72 @@ namespace omath::pathfinding
         return m_vertex_map.empty();
     }
 
-    std::vector<uint8_t> NavigationMesh::serialize() const noexcept
+    void NavigationMesh::set_event(const Vector3<float>& vertex, const std::string_view&  event_id)
     {
-        std::vector<std::uint8_t> raw;
+        if (!m_vertex_map.contains(vertex))
+            throw std::invalid_argument(std::format("Vertex '{}' not found", vertex));
 
-        // Pre-calculate total size for better performance
+        m_vertex_events[vertex] = event_id;
-        std::size_t total_size = 0;
-        for (const auto& [vertex, neighbors] : m_vertex_map)
-        {
-            total_size += sizeof(vertex) + sizeof(std::uint16_t) + sizeof(Vector3<float>) * neighbors.size();
-        }
-        raw.reserve(total_size);
-
-        auto dump_to_vector = [&raw]<typename T>(const T& t)
-        {
-            const auto* byte_ptr = reinterpret_cast<const std::uint8_t*>(&t);
-            raw.insert(raw.end(), byte_ptr, byte_ptr + sizeof(T));
-        };
-
-        for (const auto& [vertex, neighbors] : m_vertex_map)
-        {
-            // Clamp neighbors count to fit in uint16_t (prevents silent data corruption)
-            // NOTE: If neighbors.size() > 65535, only the first 65535 neighbors will be serialized.
-            // This is a limitation of the current serialization format using uint16_t for count.
-            const auto clamped_count =
-                    std::min<std::size_t>(neighbors.size(), std::numeric_limits<std::uint16_t>::max());
-            const auto neighbors_count = static_cast<std::uint16_t>(clamped_count);
-
-            dump_to_vector(vertex);
-            dump_to_vector(neighbors_count);
-
-            // Only serialize up to the clamped count
-            for (std::size_t i = 0; i < clamped_count; ++i)
-                dump_to_vector(neighbors[i]);
-        }
-        return raw;
     }
 
-    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
+    void NavigationMesh::clear_event(const Vector3<float>& vertex)
     {
-        auto load_from_vector = [](const std::vector<uint8_t>& vec, std::size_t& offset, auto& value)
+        m_vertex_events.erase(vertex);
+    }
+
+    std::optional<std::string> NavigationMesh::get_event(const Vector3<float>& vertex) const noexcept
+    {
+        const auto it = m_vertex_events.find(vertex);
+        if (it == m_vertex_events.end())
+            return std::nullopt;
+        return it->second;
+    }
+
+    // Serialization format per vertex line:
+    //   x y z neighbor_count event_id
+    // where event_id is "-" when no event is set.
+    // Neighbor lines follow: nx ny nz
+
+    std::string NavigationMesh::serialize() const noexcept
+    {
+        std::ostringstream oss;
+        for (const auto& [vertex, neighbors] : m_vertex_map)
         {
-            if (offset + sizeof(value) > vec.size())
+            const auto event_it = m_vertex_events.find(vertex);
-                throw std::runtime_error("Deserialize: Invalid input data size.");
+            const std::string& event = (event_it != m_vertex_events.end()) ? event_it->second : "-";
 
-            std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
+            oss << vertex.x << ' ' << vertex.y << ' ' << vertex.z << ' ' << neighbors.size() << ' ' << event << '\n';
-            offset += sizeof(value);
-        };
 
+            for (const auto& n : neighbors)
+                oss << n.x << ' ' << n.y << ' ' << n.z << '\n';
+        }
+        return oss.str();
+    }
+
+    void NavigationMesh::deserialize(const std::string& raw)
+    {
         m_vertex_map.clear();
+        m_vertex_events.clear();
+        std::istringstream iss(raw);
 
-        std::size_t offset = 0;
+        Vector3<float> vertex;
-
+        std::size_t neighbors_count;
-        while (offset < raw.size())
+        std::string event;
+        while (iss >> vertex.x >> vertex.y >> vertex.z >> neighbors_count >> event)
         {
-            Vector3<float> vertex;
-            load_from_vector(raw, offset, vertex);
-
-            std::uint16_t neighbors_count;
-            load_from_vector(raw, offset, neighbors_count);
-
             std::vector<Vector3<float>> neighbors;
             neighbors.reserve(neighbors_count);
-
             for (std::size_t i = 0; i < neighbors_count; ++i)
             {
-                Vector3<float> neighbor;
+                Vector3<float> n;
-                load_from_vector(raw, offset, neighbor);
+                if (!(iss >> n.x >> n.y >> n.z))
-                neighbors.push_back(neighbor);
+                    throw std::runtime_error("Deserialize: Unexpected end of data.");
+                neighbors.push_back(n);
             }
-
             m_vertex_map.emplace(vertex, std::move(neighbors));
+
+            if (event != "-")
+                m_vertex_events.emplace(vertex, std::move(event));
         }
     }
 } // namespace omath::pathfinding

source/utility/elf_pattern_scan.cpp

@@ -5,6 +5,7 @@
 #include <array>
 #include <fstream>
 #include <omath/utility/elf_pattern_scan.hpp>
+#include <span>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -140,6 +141,87 @@ namespace
         std::uintptr_t raw_base_addr{};
         std::vector<std::byte> data;
     };
+    template<FileArch arch>
+    std::optional<ExtractedSection> get_elf_section_from_memory_impl(const std::span<const std::byte> data,
+                                                                     const std::string_view& section_name)
+    {
+        using FH = typename ElfHeaders<arch>::FileHeader;
+        using SH = typename ElfHeaders<arch>::SectionHeader;
+
+        if (data.size() < sizeof(FH))
+            return std::nullopt;
+
+        const auto* file_header = reinterpret_cast<const FH*>(data.data());
+
+        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 shstrndx = static_cast<std::size_t>(file_header->e_shstrndx);
+
+        const auto shstrtab_hdr_off = shoff + shstrndx * sizeof(SH);
+        if (shstrtab_hdr_off + sizeof(SH) > data.size())
+            return std::nullopt;
+
+        const auto* shstrtab_hdr = reinterpret_cast<const SH*>(data.data() + shstrtab_hdr_off);
+        const auto shstrtab_off = static_cast<std::size_t>(shstrtab_hdr->sh_offset);
+        const auto shstrtab_size = static_cast<std::size_t>(shstrtab_hdr->sh_size);
+
+        if (shstrtab_off + shstrtab_size > data.size())
+            return std::nullopt;
+
+        const auto* shstrtab = reinterpret_cast<const char*>(data.data() + shstrtab_off);
+
+        for (std::size_t i = 0; i < shnum; ++i)
+        {
+            const auto sect_hdr_off = shoff + i * sizeof(SH);
+            if (sect_hdr_off + sizeof(SH) > data.size())
+                continue;
+
+            const auto* section = reinterpret_cast<const SH*>(data.data() + sect_hdr_off);
+
+            if (std::cmp_greater_equal(section->sh_name, shstrtab_size))
+                continue;
+
+            if (std::string_view{shstrtab + section->sh_name} != section_name)
+                continue;
+
+            const auto raw_off = static_cast<std::size_t>(section->sh_offset);
+            const auto sec_size = static_cast<std::size_t>(section->sh_size);
+
+            if (raw_off + sec_size > data.size())
+                return std::nullopt;
+
+            ExtractedSection out;
+            out.virtual_base_addr = static_cast<std::uintptr_t>(section->sh_addr);
+            out.raw_base_addr = raw_off;
+            out.data.assign(data.data() + raw_off, data.data() + raw_off + sec_size);
+            return out;
+        }
+        return std::nullopt;
+    }
+
+    std::optional<ExtractedSection> get_elf_section_by_name_from_memory(const std::span<const std::byte> data,
+                                                                        const std::string_view& section_name)
+    {
+        constexpr std::string_view valid_elf_signature = "\x7F"
+                                                         "ELF";
+        if (data.size() < ei_nident)
+            return std::nullopt;
+
+        if (std::string_view{reinterpret_cast<const char*>(data.data()), valid_elf_signature.size()}
+            != valid_elf_signature)
+            return std::nullopt;
+
+        const auto class_byte = static_cast<uint8_t>(data[ei_class]);
+
+        if (class_byte == elfclass64)
+            return get_elf_section_from_memory_impl<FileArch::x64>(data, section_name);
+
+        if (class_byte == elfclass32)
+            return get_elf_section_from_memory_impl<FileArch::x32>(data, section_name);
+
+        return std::nullopt;
+    }
+
     [[maybe_unused]]
     std::optional<ExtractedSection> get_elf_section_by_name(const std::filesystem::path& path,
                                                             const std::string_view& section_name)
@@ -322,4 +404,27 @@ namespace omath
                                  .raw_base_addr = pe_section->raw_base_addr,
                                  .target_offset = offset};
     }
+
+    std::optional<SectionScanResult>
+    ElfPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
+                                                       const std::string_view& pattern,
+                                                       const std::string_view& target_section_name)
+    {
+        const auto section = get_elf_section_by_name_from_memory(file_data, target_section_name);
+
+        if (!section.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        const auto scan_result =
+                PatternScanner::scan_for_pattern(section->data.cbegin(), section->data.cend(), pattern);
+
+        if (scan_result == section->data.cend())
+            return std::nullopt;
+
+        const auto offset = std::distance(section->data.begin(), scan_result);
+
+        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
+                                 .raw_base_addr = section->raw_base_addr,
+                                 .target_offset = offset};
+    }
 } // namespace omath

source/utility/macho_pattern_scan.cpp

@@ -5,6 +5,7 @@
 #include "omath/utility/pattern_scan.hpp"
 #include <cstring>
 #include <fstream>
+#include <span>
 #include <variant>
 #include <vector>
 
@@ -231,6 +232,96 @@ namespace
         return std::nullopt;
     }
 
+    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd>
+    std::optional<ExtractedSection> extract_section_from_memory_impl(const std::span<const std::byte> data,
+                                                                     const std::string_view& section_name)
+    {
+        if (data.size() < sizeof(HeaderType))
+            return std::nullopt;
+
+        const auto* header = reinterpret_cast<const HeaderType*>(data.data());
+
+        std::size_t cmd_offset = sizeof(HeaderType);
+
+        for (std::uint32_t i = 0; i < header->ncmds; ++i)
+        {
+            if (cmd_offset + sizeof(LoadCommand) > data.size())
+                return std::nullopt;
+
+            const auto* lc = reinterpret_cast<const LoadCommand*>(data.data() + cmd_offset);
+
+            if (lc->cmd != segment_cmd)
+            {
+                cmd_offset += lc->cmdsize;
+                continue;
+            }
+
+            if (cmd_offset + sizeof(SegmentType) > data.size())
+                return std::nullopt;
+
+            const auto* segment = reinterpret_cast<const SegmentType*>(data.data() + cmd_offset);
+
+            if (!segment->nsects)
+            {
+                cmd_offset += lc->cmdsize;
+                continue;
+            }
+
+            std::size_t sect_offset = cmd_offset + sizeof(SegmentType);
+
+            for (std::uint32_t j = 0; j < segment->nsects; ++j)
+            {
+                if (sect_offset + sizeof(SectionType) > data.size())
+                    return std::nullopt;
+
+                const auto* section = reinterpret_cast<const SectionType*>(data.data() + sect_offset);
+
+                if (get_section_name(section->sectname) != section_name)
+                {
+                    sect_offset += sizeof(SectionType);
+                    continue;
+                }
+
+                const auto raw_off = static_cast<std::size_t>(section->offset);
+                const auto sec_size = static_cast<std::size_t>(section->size);
+
+                if (raw_off + sec_size > data.size())
+                    return std::nullopt;
+
+                ExtractedSection out;
+                out.virtual_base_addr = static_cast<std::uintptr_t>(section->addr);
+                out.raw_base_addr = raw_off;
+                out.data.assign(data.data() + raw_off, data.data() + raw_off + sec_size);
+                return out;
+            }
+
+            cmd_offset += lc->cmdsize;
+        }
+
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    std::optional<ExtractedSection> get_macho_section_by_name_from_memory(const std::span<const std::byte> data,
+                                                                          const std::string_view& section_name)
+    {
+        if (data.size() < sizeof(std::uint32_t))
+            return std::nullopt;
+
+        std::uint32_t magic{};
+        std::memcpy(&magic, data.data(), sizeof(magic));
+
+        if (magic == mh_magic_64 || magic == mh_cigam_64)
+            return extract_section_from_memory_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(
+                    data, section_name);
+
+        if (magic == mh_magic_32 || magic == mh_cigam_32)
+            return extract_section_from_memory_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(data,
+                                                                                                           section_name);
+
+        return std::nullopt;
+    }
+
     [[nodiscard]]
     std::optional<ExtractedSection> get_macho_section_by_name(const std::filesystem::path& path,
                                                               const std::string_view& section_name)
@@ -346,4 +437,27 @@ namespace omath
                                  .raw_base_addr = macho_section->raw_base_addr,
                                  .target_offset = offset};
     }
+
+    std::optional<SectionScanResult>
+    MachOPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
+                                                         const std::string_view& pattern,
+                                                         const std::string_view& target_section_name)
+    {
+        const auto section = get_macho_section_by_name_from_memory(file_data, target_section_name);
+
+        if (!section.has_value()) [[unlikely]]
+            return std::nullopt;
+
+        const auto scan_result =
+                PatternScanner::scan_for_pattern(section->data.cbegin(), section->data.cend(), pattern);
+
+        if (scan_result == section->data.cend())
+            return std::nullopt;
+
+        const auto offset = std::distance(section->data.begin(), scan_result);
+
+        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
+                                 .raw_base_addr = section->raw_base_addr,
+                                 .target_offset = offset};
+    }
 } // namespace omath

source/utility/pe_pattern_scan.cpp

@@ -7,6 +7,7 @@
 #include <span>
 #include <stdexcept>
 #include <variant>
+#include <vector>
 
 // Internal PE shit defines
 // Big thx for linuxpe sources as ref
@@ -244,6 +245,78 @@ namespace
         std::vector<std::byte> data;
     };
 
+    [[nodiscard]]
+    std::optional<ExtractedSection> extract_section_from_pe_memory(const std::span<const std::byte> data,
+                                                                   const std::string_view& section_name)
+    {
+        if (data.size() < sizeof(DosHeader))
+            return std::nullopt;
+
+        const auto* dos_header = reinterpret_cast<const DosHeader*>(data.data());
+
+        if (invalid_dos_header_file(*dos_header))
+            return std::nullopt;
+
+        const auto nt_off = static_cast<std::size_t>(dos_header->e_lfanew);
+
+        if (nt_off + sizeof(ImageNtHeaders<NtArchitecture::x32_bit>) > data.size())
+            return std::nullopt;
+
+        const auto* x86_hdrs =
+                reinterpret_cast<const ImageNtHeaders<NtArchitecture::x32_bit>*>(data.data() + nt_off);
+
+        NtHeaderVariant nt_headers;
+        if (x86_hdrs->optional_header.magic == opt_hdr32_magic)
+            nt_headers = *x86_hdrs;
+        else if (x86_hdrs->optional_header.magic == opt_hdr64_magic)
+        {
+            if (nt_off + sizeof(ImageNtHeaders<NtArchitecture::x64_bit>) > data.size())
+                return std::nullopt;
+            nt_headers = *reinterpret_cast<const ImageNtHeaders<NtArchitecture::x64_bit>*>(data.data() + nt_off);
+        }
+        else
+            return std::nullopt;
+
+        if (invalid_nt_header_file(nt_headers))
+            return std::nullopt;
+
+        return std::visit(
+                [&data, &section_name, nt_off](const auto& concrete_headers) -> std::optional<ExtractedSection>
+                {
+                    constexpr std::size_t sig_size = sizeof(concrete_headers.signature);
+                    const auto section_table_off = nt_off + sig_size + sizeof(FileHeader)
+                                                   + concrete_headers.file_header.size_optional_header;
+
+                    for (std::size_t i = 0; i < concrete_headers.file_header.num_sections; ++i)
+                    {
+                        const auto sh_off = section_table_off + i * sizeof(SectionHeader);
+                        if (sh_off + sizeof(SectionHeader) > data.size())
+                            return std::nullopt;
+
+                        const auto* section = reinterpret_cast<const SectionHeader*>(data.data() + sh_off);
+
+                        if (std::string_view(section->name) != section_name)
+                            continue;
+
+                        const auto raw_off = static_cast<std::size_t>(section->ptr_raw_data);
+                        const auto raw_size = static_cast<std::size_t>(section->size_raw_data);
+
+                        if (raw_off + raw_size > data.size())
+                            return std::nullopt;
+
+                        std::vector<std::byte> section_data(data.data() + raw_off, data.data() + raw_off + raw_size);
+
+                        return ExtractedSection{
+                                .virtual_base_addr = static_cast<std::uintptr_t>(
+                                        section->virtual_address + concrete_headers.optional_header.image_base),
+                                .raw_base_addr = raw_off,
+                                .data = std::move(section_data)};
+                    }
+                    return std::nullopt;
+                },
+                nt_headers);
+    }
+
     [[nodiscard]]
     std::optional<ExtractedSection> extract_section_from_pe_file(const std::filesystem::path& path_to_file,
                                                                  const std::string_view& section_name)
@@ -383,4 +456,27 @@ namespace omath
                                  .raw_base_addr = pe_section->raw_base_addr,
                                  .target_offset = offset};
     }
+
+    std::optional<SectionScanResult>
+    PePatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
+                                                      const std::string_view& pattern,
+                                                      const std::string_view& target_section_name)
+    {
+        const auto pe_section = extract_section_from_pe_memory(file_data, 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

tests/CMakeLists.txt

@@ -4,7 +4,7 @@ project(unit_tests)
 
 include(GoogleTest)
 
-file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp")
+file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
 add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp)
 
 set_target_properties(

tests/general/mem_fd_helper.hpp

@@ -0,0 +1,192 @@
+#pragma once
+// Cross-platform helper for creating binary test "files" without writing to disk where possible.
+//
+// Strategy:
+//   - Linux (non-Android, or Android API >= 30): memfd_create → /proc/self/fd/<N>  (no disk I/O)
+//   - All other platforms: anonymous temp file via std::tmpfile(), accessed via /proc/self/fd/<N>
+//     on Linux, or a named temp file (cleaned up on destruction) elsewhere.
+//
+// Usage:
+//   auto f = MemFdFile::create(myVector);
+//   ASSERT_TRUE(f.valid());
+//   scanner.scan_for_pattern_in_file(f.path(), ...);
+
+#include <cstdint>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <random>
+#include <string>
+#include <vector>
+
+#if defined(__linux__)
+#  include <unistd.h>
+#  include <fcntl.h>
+#  if defined(__ANDROID__)
+#    if __ANDROID_API__ >= 30
+#      include <sys/mman.h>
+#      define OMATH_TEST_USE_MEMFD 1
+#    endif
+// Android < 30: fall through to tmpfile() path below
+#  else
+// Desktop Linux: memfd_create available since glibc 2.27 / kernel 3.17
+#    include <sys/mman.h>
+#    define OMATH_TEST_USE_MEMFD 1
+#  endif
+#endif
+
+class MemFdFile
+{
+public:
+    MemFdFile() = default;
+
+    ~MemFdFile()
+    {
+#if defined(OMATH_TEST_USE_MEMFD)
+        if (m_fd >= 0)
+            ::close(m_fd);
+#else
+        if (!m_temp_path.empty())
+            std::filesystem::remove(m_temp_path);
+#endif
+    }
+
+    MemFdFile(const MemFdFile&) = delete;
+    MemFdFile& operator=(const MemFdFile&) = delete;
+
+    MemFdFile(MemFdFile&& o) noexcept
+        : m_path(std::move(o.m_path))
+#if defined(OMATH_TEST_USE_MEMFD)
+        , m_fd(o.m_fd)
+#else
+        , m_temp_path(std::move(o.m_temp_path))
+#endif
+    {
+#if defined(OMATH_TEST_USE_MEMFD)
+        o.m_fd = -1;
+#else
+        o.m_temp_path.clear();
+#endif
+    }
+
+    [[nodiscard]] bool valid() const { return !m_path.empty(); }
+
+    [[nodiscard]] const std::filesystem::path& path() const { return m_path; }
+
+    static MemFdFile create(const std::vector<std::uint8_t>& data)
+    {
+        return create(data.data(), data.size());
+    }
+
+    static MemFdFile create(const std::uint8_t* data, std::size_t size)
+    {
+        MemFdFile f;
+
+#if defined(OMATH_TEST_USE_MEMFD)
+        f.m_fd = static_cast<int>(::memfd_create("test_bin", 0));
+        if (f.m_fd < 0)
+            return f;
+
+        if (!write_all(f.m_fd, data, size))
+        {
+            ::close(f.m_fd);
+            f.m_fd = -1;
+            return f;
+        }
+        f.m_path = "/proc/self/fd/" + std::to_string(f.m_fd);
+
+#else
+        // Portable fallback: write to a uniquely-named temp file and delete on destruction
+        const auto tmp_dir = std::filesystem::temp_directory_path();
+        std::mt19937_64 rng(std::random_device{}());
+        const auto unique_name = "omath_test_" + std::to_string(rng()) + ".bin";
+        f.m_temp_path = (tmp_dir / unique_name).string();
+        f.m_path      = f.m_temp_path;
+
+        std::ofstream out(f.m_temp_path, std::ios::binary | std::ios::trunc);
+        if (!out.is_open())
+        {
+            f.m_temp_path.clear();
+            f.m_path.clear();
+            return f;
+        }
+        out.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
+        if (!out)
+        {
+            out.close();
+            std::filesystem::remove(f.m_temp_path);
+            f.m_temp_path.clear();
+            f.m_path.clear();
+        }
+#endif
+        return f;
+    }
+
+private:
+    std::filesystem::path m_path;
+
+#if defined(OMATH_TEST_USE_MEMFD)
+    int m_fd = -1;
+
+    static bool write_all(int fd, const std::uint8_t* data, std::size_t size)
+    {
+        std::size_t written = 0;
+        while (written < size)
+        {
+            const auto n = ::write(fd, data + written, size - written);
+            if (n <= 0)
+                return false;
+            written += static_cast<std::size_t>(n);
+        }
+        return true;
+    }
+#else
+    std::string m_temp_path;
+#endif
+};
+
+// ---------------------------------------------------------------------------
+// Build a minimal PE binary in-memory with a single .text section.
+// Layout (all offsets compile-time):
+//   0x00: DOS header (64 B)   0x40: pad   0x80: NT sig   0x84: FileHeader (20 B)
+//   0x98: OptionalHeader (0xF0 B)   0x188: SectionHeader (44 B)   0x1B4: section data
+// ---------------------------------------------------------------------------
+inline std::vector<std::uint8_t> build_minimal_pe(const std::vector<std::uint8_t>& section_bytes)
+{
+    constexpr std::uint32_t e_lfanew  = 0x80u;
+    constexpr std::uint16_t size_opt  = 0xF0u;
+    constexpr std::size_t   nt_off    = e_lfanew;
+    constexpr std::size_t   fh_off    = nt_off + 4;
+    constexpr std::size_t   oh_off    = fh_off + 20;
+    constexpr std::size_t   sh_off    = oh_off + size_opt;
+    constexpr std::size_t   data_off  = sh_off + 44;
+
+    std::vector<std::uint8_t> buf(data_off + section_bytes.size(), 0u);
+
+    buf[0] = 'M'; buf[1] = 'Z';
+    std::memcpy(buf.data() + 0x3Cu, &e_lfanew, 4);
+
+    buf[nt_off] = 'P'; buf[nt_off + 1] = 'E';
+
+    const std::uint16_t machine = 0x8664u, num_sections = 1u;
+    std::memcpy(buf.data() + fh_off,      &machine,      2);
+    std::memcpy(buf.data() + fh_off + 2,  &num_sections, 2);
+    std::memcpy(buf.data() + fh_off + 16, &size_opt,     2);
+
+    const std::uint16_t magic = 0x20Bu;
+    std::memcpy(buf.data() + oh_off, &magic, 2);
+
+    const char name[8] = {'.','t','e','x','t',0,0,0};
+    std::memcpy(buf.data() + sh_off, name, 8);
+
+    const auto vsize   = static_cast<std::uint32_t>(section_bytes.size());
+    const std::uint32_t vaddr   = 0x1000u;
+    const auto ptr_raw = static_cast<std::uint32_t>(data_off);
+    std::memcpy(buf.data() + sh_off + 8,  &vsize,   4);
+    std::memcpy(buf.data() + sh_off + 12, &vaddr,   4);
+    std::memcpy(buf.data() + sh_off + 16, &vsize,   4);
+    std::memcpy(buf.data() + sh_off + 20, &ptr_raw, 4);
+
+    std::memcpy(buf.data() + data_off, section_bytes.data(), section_bytes.size());
+    return buf;
+}

tests/general/unit_test_a_star.cpp

@@ -8,6 +8,29 @@
 using namespace omath;
 using namespace omath::pathfinding;
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+static NavigationMesh make_linear_chain(int length)
+{
+    // 0 -> 1 -> 2 -> ... -> length-1  (directed)
+    NavigationMesh nav;
+    for (int i = 0; i < length; ++i)
+    {
+        const Vector3<float> v{static_cast<float>(i), 0.f, 0.f};
+        if (i + 1 < length)
+            nav.m_vertex_map[v] = {Vector3<float>{static_cast<float>(i + 1), 0.f, 0.f}};
+        else
+            nav.m_vertex_map[v] = {};
+    }
+    return nav;
+}
+
+// ---------------------------------------------------------------------------
+// Basic reachability
+// ---------------------------------------------------------------------------
+
 TEST(AStarExtra, TrivialNeighbor)
 {
     NavigationMesh nav;
@@ -78,7 +101,7 @@ TEST(AStarExtra, LongerPathAvoidsBlock)
     constexpr Vector3<float> goal = idx(2, 1);
     const auto path = Astar::find_path(start, goal, nav);
     ASSERT_FALSE(path.empty());
-    EXPECT_EQ(path.front(), goal); // Astar convention: single-element or endpoint present
+    EXPECT_EQ(path.front(), goal);
 }
 
 TEST(AstarTests, TrivialDirectNeighborPath)
@@ -91,9 +114,6 @@ TEST(AstarTests, TrivialDirectNeighborPath)
     nav.m_vertex_map.emplace(v2, std::vector<Vector3<float>>{v1});
 
     const auto path = Astar::find_path(v1, v2, nav);
-    // Current A* implementation returns the end vertex as the reconstructed
-    // path (single-element) in the simple neighbor scenario. Assert that the
-    // endpoint is present and reachable.
     ASSERT_EQ(path.size(), 1u);
     EXPECT_EQ(path.front(), v2);
 }
@@ -134,3 +154,154 @@ TEST(unit_test_a_star, finding_right_path)
     mesh.m_vertex_map[{0.f, 3.f, 0.f}] = {};
     std::ignore = omath::pathfinding::Astar::find_path({}, {0.f, 3.f, 0.f}, mesh);
 }
+
+// ---------------------------------------------------------------------------
+// Directed edges
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, DirectedEdge_ForwardPathExists)
+{
+    // A -> B only; path from A to B should succeed
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {}; // no edge back
+
+    const auto path = Astar::find_path(a, b, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), b);
+}
+
+TEST(AstarTests, DirectedEdge_ReversePathMissing)
+{
+    // A -> B only; path from B to A should fail
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {};
+
+    const auto path = Astar::find_path(b, a, nav);
+    EXPECT_TRUE(path.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Vertex snapping
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, OffMeshStart_SnapsToNearestVertex)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> v1{0.f, 0.f, 0.f};
+    constexpr Vector3<float> v2{10.f, 0.f, 0.f};
+    nav.m_vertex_map[v1] = {v2};
+    nav.m_vertex_map[v2] = {v1};
+
+    // Start is slightly off v1 but closer to it than to v2
+    constexpr Vector3<float> off_start{0.1f, 0.f, 0.f};
+    const auto path = Astar::find_path(off_start, v2, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), v2);
+}
+
+TEST(AstarTests, OffMeshEnd_SnapsToNearestVertex)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> v1{0.f, 0.f, 0.f};
+    constexpr Vector3<float> v2{10.f, 0.f, 0.f};
+    nav.m_vertex_map[v1] = {v2};
+    nav.m_vertex_map[v2] = {v1};
+
+    // Goal is slightly off v2 but closer to it than to v1
+    constexpr Vector3<float> off_goal{9.9f, 0.f, 0.f};
+    const auto path = Astar::find_path(v1, off_goal, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), v2);
+}
+
+// ---------------------------------------------------------------------------
+// Cycle handling
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, CyclicGraph_FindsPathWithoutLooping)
+{
+    // Triangle: A <-> B <-> C <-> A
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    constexpr Vector3<float> c{0.5f, 1.f, 0.f};
+    nav.m_vertex_map[a] = {b, c};
+    nav.m_vertex_map[b] = {a, c};
+    nav.m_vertex_map[c] = {a, b};
+
+    const auto path = Astar::find_path(a, c, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), c);
+}
+
+TEST(AstarTests, SelfLoopVertex_DoesNotBreakSearch)
+{
+    // Vertex with itself as a neighbor
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {a, b}; // self-loop on a
+    nav.m_vertex_map[b] = {a};
+
+    const auto path = Astar::find_path(a, b, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), b);
+}
+
+// ---------------------------------------------------------------------------
+// Longer chains
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, LinearChain_ReachesEnd)
+{
+    constexpr int kLength = 10;
+    const NavigationMesh nav = make_linear_chain(kLength);
+
+    const Vector3<float> start{0.f, 0.f, 0.f};
+    const Vector3<float> goal{static_cast<float>(kLength - 1), 0.f, 0.f};
+
+    const auto path = Astar::find_path(start, goal, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), goal);
+}
+
+TEST(AstarTests, LinearChain_MidpointReachable)
+{
+    constexpr int kLength = 6;
+    const NavigationMesh nav = make_linear_chain(kLength);
+
+    const Vector3<float> start{0.f, 0.f, 0.f};
+    const Vector3<float> mid{3.f, 0.f, 0.f};
+
+    const auto path = Astar::find_path(start, mid, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), mid);
+}
+
+// ---------------------------------------------------------------------------
+// Serialize -> pathfind integration
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, PathfindAfterSerializeDeserialize)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    constexpr Vector3<float> c{2.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {a, c};
+    nav.m_vertex_map[c] = {b};
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    const auto path = Astar::find_path(a, c, nav2);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), c);
+}

tests/general/unit_test_elf_scanner.cpp

@@ -1,17 +1,214 @@
 //
 // Created by Vladislav on 30.12.2025.
 //
-// /Users/vladislav/Downloads/valencia
+#include <algorithm>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
 #include <gtest/gtest.h>
 #include <omath/utility/elf_pattern_scan.hpp>
-#include <print>
+#include <span>
-TEST(unit_test_elf_pattern_scan_file, ScanMissingPattern)
+#include <vector>
+
+using namespace omath;
+
+// ---- helpers ---------------------------------------------------------------
+
+// Minimal ELF64 file with a single .text section containing known bytes.
+// Layout:
+//   0x000 : ELF64 file header  (64 bytes)
+//   0x040 : section data       (padded to 0x20 bytes)
+//   0x060 : section name table ".text\0" + "\0" (empty name for SHN_UNDEF)
+//   0x080 : section header table  (3 entries × 64 bytes = 0xC0)
+static std::vector<std::byte> make_elf64_with_text_section(const std::vector<std::uint8_t>& code_bytes)
 {
-    //FIXME: Implement normal tests :)
+    // Fixed layout constants
-    //constexpr std::string_view path = "/Users/vladislav/Downloads/crackme";
+    constexpr std::size_t text_off = 0x40;
+    constexpr std::size_t text_size = 0x20; // always 32 bytes (code padded with zeros)
+    constexpr std::size_t shstrtab_off = text_off + text_size;
+    // ".text\0" = 6 chars, prepend \0 for SHN_UNDEF → "\0.text\0"
+    constexpr std::size_t shstrtab_size = 8; // "\0.text\0\0"
+    constexpr std::size_t shdr_table_off = shstrtab_off + shstrtab_size;
+    constexpr std::size_t shdr_size = 64; // sizeof(Elf64_Shdr)
+    constexpr std::size_t num_sections = 3; // null + .text + .shstrtab
+    constexpr std::size_t total_size = shdr_table_off + num_sections * shdr_size;
 
-    //const auto res = omath::ElfPatternScanner::scan_for_pattern_in_file(path, "F3 0F 1E FA 55 48 89 E5 B8 00 00 00 00", ".text");
+    std::vector<std::byte> buf(total_size, std::byte{0});
-    //EXPECT_TRUE(res.has_value());
 
-    //std::println("In virtual mem: 0x{:x}", res->virtual_base_addr+res->target_offset);
+    auto w8 = [&](std::size_t off, std::uint8_t v) { buf[off] = std::byte{v}; };
+    auto w16 = [&](std::size_t off, std::uint16_t v)
+    { std::memcpy(buf.data() + off, &v, 2); };
+    auto w32 = [&](std::size_t off, std::uint32_t v)
+    { std::memcpy(buf.data() + off, &v, 4); };
+    auto w64 = [&](std::size_t off, std::uint64_t v)
+    { std::memcpy(buf.data() + off, &v, 8); };
+
+    // --- ELF64 file header ---
+    // e_ident
+    buf[0] = std::byte{0x7F};
+    buf[1] = std::byte{'E'};
+    buf[2] = std::byte{'L'};
+    buf[3] = std::byte{'F'};
+    w8(4, 2); // ELFCLASS64
+    w8(5, 1); // ELFDATA2LSB
+    w8(6, 1); // EV_CURRENT
+    // rest of e_ident is 0
+    w16(16, 2);  // e_type = ET_EXEC
+    w16(18, 62); // e_machine = EM_X86_64
+    w32(20, 1);  // e_version
+    w64(24, 0);  // e_entry
+    w64(32, 0);  // e_phoff
+    w64(40, static_cast<std::uint64_t>(shdr_table_off)); // e_shoff
+    w32(48, 0);  // e_flags
+    w16(52, 64); // e_ehsize
+    w16(54, 56); // e_phentsize
+    w16(56, 0);  // e_phnum
+    w16(58, static_cast<std::uint16_t>(shdr_size)); // e_shentsize
+    w16(60, static_cast<std::uint16_t>(num_sections)); // e_shnum
+    w16(62, 2);  // e_shstrndx = 2 (.shstrtab is section index 2)
+
+    // --- section data (.text) ---
+    const std::size_t copy_len = std::min(code_bytes.size(), text_size);
+    for (std::size_t i = 0; i < copy_len; ++i)
+        buf[text_off + i] = std::byte{code_bytes[i]};
+
+    // --- .shstrtab data: "\0.text\0\0" ---
+    //  index 0 → "" (SHN_UNDEF name)
+    //  index 1 → ".text"
+    //  index 7 → ".shstrtab" (we cheat and use index 1 for .shstrtab too, fine for test)
+    buf[shstrtab_off + 0] = std::byte{0};
+    buf[shstrtab_off + 1] = std::byte{'.'};
+    buf[shstrtab_off + 2] = std::byte{'t'};
+    buf[shstrtab_off + 3] = std::byte{'e'};
+    buf[shstrtab_off + 4] = std::byte{'x'};
+    buf[shstrtab_off + 5] = std::byte{'t'};
+    buf[shstrtab_off + 6] = std::byte{0};
+    buf[shstrtab_off + 7] = std::byte{0};
+
+    // --- section headers ---
+    // Elf64_Shdr fields (all offsets relative to start of a section header):
+    //  0  sh_name     (4)
+    //  4  sh_type     (4)
+    //  8  sh_flags    (8)
+    //  16 sh_addr     (8)
+    //  24 sh_offset   (8)
+    //  32 sh_size     (8)
+    //  40 sh_link     (4)
+    //  44 sh_info     (4)
+    //  48 sh_addralign(8)
+    //  56 sh_entsize  (8)
+
+    // Section 0: null
+    // (all zeros – already zeroed)
+
+    // Section 1: .text
+    {
+        const std::size_t base = shdr_table_off + 1 * shdr_size;
+        w32(base + 0, 1);  // sh_name → index 1 in shstrtab → ".text"
+        w32(base + 4, 1);  // sh_type = SHT_PROGBITS
+        w64(base + 8, 6);  // sh_flags = SHF_ALLOC|SHF_EXECINSTR
+        w64(base + 16, static_cast<std::uint64_t>(text_off)); // sh_addr (same as offset in test)
+        w64(base + 24, static_cast<std::uint64_t>(text_off)); // sh_offset
+        w64(base + 32, static_cast<std::uint64_t>(text_size)); // sh_size
+        w64(base + 48, 16); // sh_addralign
+    }
+
+    // Section 2: .shstrtab
+    {
+        const std::size_t base = shdr_table_off + 2 * shdr_size;
+        w32(base + 0, 0);  // sh_name → index 0 → "" (good enough for scanner)
+        w32(base + 4, 3);  // sh_type = SHT_STRTAB
+        w64(base + 24, static_cast<std::uint64_t>(shstrtab_off)); // sh_offset
+        w64(base + 32, static_cast<std::uint64_t>(shstrtab_size)); // sh_size
+    }
+
+    return buf;
+}
+
+// ---- tests -----------------------------------------------------------------
+
+TEST(unit_test_elf_pattern_scan_memory, finds_pattern)
+{
+    const std::vector<std::uint8_t> code = {0x55, 0x48, 0x89, 0xE5, 0xC3};
+    const auto buf = make_elf64_with_text_section(code);
+    const auto span = std::span<const std::byte>{buf};
+
+    const auto result = ElfPatternScanner::scan_for_pattern_in_memory_file(span, "55 48 89 E5", ".text");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+}
+
+TEST(unit_test_elf_pattern_scan_memory, finds_pattern_with_wildcard)
+{
+    const std::vector<std::uint8_t> code = {0xDE, 0xAD, 0xBE, 0xEF, 0x00};
+    const auto buf = make_elf64_with_text_section(code);
+
+    const auto result =
+            ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "DE ?? BE EF", ".text");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+}
+
+TEST(unit_test_elf_pattern_scan_memory, pattern_not_found_returns_nullopt)
+{
+    const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03, 0x04};
+    const auto buf = make_elf64_with_text_section(code);
+
+    const auto result =
+            ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "AA BB CC", ".text");
+
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_elf_pattern_scan_memory, invalid_data_returns_nullopt)
+{
+    const std::vector<std::byte> garbage(64, std::byte{0xFF});
+    const auto result =
+            ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{garbage}, "FF FF", ".text");
+
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_elf_pattern_scan_memory, empty_data_returns_nullopt)
+{
+    const auto result = ElfPatternScanner::scan_for_pattern_in_memory_file({}, "FF", ".text");
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_elf_pattern_scan_memory, missing_section_returns_nullopt)
+{
+    const std::vector<std::uint8_t> code = {0x90, 0x90};
+    const auto buf = make_elf64_with_text_section(code);
+
+    const auto result = ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf},
+                                                                            "90 90", ".nonexistent");
+
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_elf_pattern_scan_memory, matches_file_scan)
+{
+    // Write our synthetic ELF to a temp file and verify memory scan == file scan
+    const std::vector<std::uint8_t> code = {0x48, 0x89, 0xE5, 0xDE, 0xAD, 0xBE, 0xEF, 0x00};
+    const auto buf = make_elf64_with_text_section(code);
+
+    const auto tmp_path = std::filesystem::temp_directory_path() / "omath_elf_test.elf";
+    {
+        std::ofstream out(tmp_path, std::ios::binary);
+        out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
+    }
+
+    const auto file_result = ElfPatternScanner::scan_for_pattern_in_file(tmp_path, "48 89 E5 DE AD", ".text");
+    const auto mem_result =
+            ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "48 89 E5 DE AD", ".text");
+
+    std::filesystem::remove(tmp_path);
+
+    ASSERT_TRUE(file_result.has_value());
+    ASSERT_TRUE(mem_result.has_value());
+    EXPECT_EQ(file_result->virtual_base_addr, mem_result->virtual_base_addr);
+    EXPECT_EQ(file_result->raw_base_addr, mem_result->raw_base_addr);
+    EXPECT_EQ(file_result->target_offset, mem_result->target_offset);
 }

tests/general/unit_test_macho_memory_file_scan.cpp

@@ -0,0 +1,145 @@
+// Tests for MachOPatternScanner::scan_for_pattern_in_memory_file
+#include <cstring>
+#include <gtest/gtest.h>
+#include <omath/utility/macho_pattern_scan.hpp>
+#include <span>
+#include <vector>
+
+using namespace omath;
+
+// Build a minimal Mach-O 64-bit file in memory with a single __text section.
+// Layout:
+//   0x000 : MachHeader64        (32 bytes)
+//   0x020 : SegmentCommand64    (72 bytes)
+//   0x068 : Section64           (80 bytes)  ← follows segment command inline
+//   0x0B8 : section raw data    (padded to 0x20 bytes)
+static std::vector<std::byte> make_macho64_with_text_section(const std::vector<std::uint8_t>& code_bytes)
+{
+    constexpr std::uint32_t mh_magic_64 = 0xFEEDFACF;
+    constexpr std::uint32_t lc_segment_64 = 0x19;
+
+    // MachHeader64 layout (32 bytes):
+    //  0 magic, 4 cputype, 8 cpusubtype, 12 filetype, 16 ncmds, 20 sizeofcmds, 24 flags, 28 reserved
+    constexpr std::size_t hdr_size = 32;
+
+    // SegmentCommand64 layout (72 bytes):
+    //  0 cmd, 4 cmdsize, 8 segname[16], 24 vmaddr, 32 vmsize, 40 fileoff, 48 filesize,
+    //  56 maxprot, 60 initprot, 64 nsects, 68 flags
+    constexpr std::size_t seg_size = 72;
+
+    // Section64 layout (80 bytes):
+    //  0 sectname[16], 16 segname[16], 32 addr, 40 size, 48 offset, 52 align,
+    //  56 reloff, 60 nreloc, 64 flags, 68 reserved1, 72 reserved2, 76 reserved3
+    constexpr std::size_t sect_hdr_size = 80;
+
+    constexpr std::size_t text_raw_off = hdr_size + seg_size + sect_hdr_size; // 0xB8
+    constexpr std::size_t text_raw_size = 0x20;
+    constexpr std::size_t total_size = text_raw_off + text_raw_size;
+    constexpr std::uint64_t text_vmaddr = 0x1000ULL;
+
+    constexpr std::uint32_t cmd_size =
+            static_cast<std::uint32_t>(seg_size + sect_hdr_size); // segment + 1 section
+
+    std::vector<std::byte> buf(total_size, std::byte{0});
+
+    auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+    auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
+
+    // MachHeader64
+    w32(0, mh_magic_64);
+    w32(4, 0x0100000C);  // cputype = CPU_TYPE_ARM64 (doesn't matter for scan)
+    w32(12, 2);           // filetype = MH_EXECUTE
+    w32(16, 1);           // ncmds = 1
+    w32(20, cmd_size);    // sizeofcmds
+
+    // SegmentCommand64 at 0x20
+    constexpr std::size_t seg_off = hdr_size;
+    w32(seg_off + 0, lc_segment_64);
+    w32(seg_off + 4, cmd_size);
+    std::memcpy(buf.data() + seg_off + 8, "__TEXT", 6); // segname
+    w64(seg_off + 24, text_vmaddr);                      // vmaddr
+    w64(seg_off + 32, text_raw_size);                    // vmsize
+    w64(seg_off + 40, text_raw_off);                     // fileoff
+    w64(seg_off + 48, text_raw_size);                    // filesize
+    w32(seg_off + 64, 1);                                // nsects
+
+    // Section64 at 0x68
+    constexpr std::size_t sect_off = seg_off + seg_size;
+    std::memcpy(buf.data() + sect_off + 0, "__text", 6);  // sectname
+    std::memcpy(buf.data() + sect_off + 16, "__TEXT", 6); // segname
+    w64(sect_off + 32, text_vmaddr);                       // addr
+    w64(sect_off + 40, text_raw_size);                     // size
+    w32(sect_off + 48, static_cast<std::uint32_t>(text_raw_off)); // offset (file offset)
+
+    // Section data
+    const std::size_t copy_len = std::min(code_bytes.size(), text_raw_size);
+    for (std::size_t i = 0; i < copy_len; ++i)
+        buf[text_raw_off + i] = std::byte{code_bytes[i]};
+
+    return buf;
+}
+
+// ---- tests -----------------------------------------------------------------
+
+TEST(unit_test_macho_memory_file_scan, finds_pattern)
+{
+    const std::vector<std::uint8_t> code = {0x55, 0x48, 0x89, 0xE5, 0xC3};
+    const auto buf = make_macho64_with_text_section(code);
+
+    const auto result =
+            MachOPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "55 48 89 E5");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+}
+
+TEST(unit_test_macho_memory_file_scan, finds_pattern_with_wildcard)
+{
+    const std::vector<std::uint8_t> code = {0xDE, 0xAD, 0xBE, 0xEF};
+    const auto buf = make_macho64_with_text_section(code);
+
+    const auto result =
+            MachOPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "DE ?? BE EF");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+}
+
+TEST(unit_test_macho_memory_file_scan, pattern_not_found_returns_nullopt)
+{
+    const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03};
+    const auto buf = make_macho64_with_text_section(code);
+
+    const auto result =
+            MachOPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "AA BB CC");
+
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_macho_memory_file_scan, invalid_data_returns_nullopt)
+{
+    const std::vector<std::byte> garbage(64, std::byte{0xFF});
+    const auto result =
+            MachOPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{garbage}, "FF FF");
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_macho_memory_file_scan, empty_data_returns_nullopt)
+{
+    const auto result = MachOPatternScanner::scan_for_pattern_in_memory_file({}, "FF");
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_macho_memory_file_scan, raw_addr_and_virtual_addr_correct)
+{
+    const std::vector<std::uint8_t> code = {0xCA, 0xFE, 0xBA, 0xBE};
+    const auto buf = make_macho64_with_text_section(code);
+
+    constexpr std::size_t expected_raw_off = 32 + 72 + 80; // hdr + seg + sect_hdr
+    const auto result =
+            MachOPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "CA FE BA BE");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->raw_base_addr, expected_raw_off);
+    EXPECT_EQ(result->virtual_base_addr, 0x1000u);
+}

tests/general/unit_test_macho_scanner.cpp

@@ -6,8 +6,8 @@
 #include <omath/utility/macho_pattern_scan.hpp>
 #include <cstdint>
 #include <cstring>
-#include <fstream>
 #include <vector>
+#include "mem_fd_helper.hpp"
 
 using namespace omath;
 
@@ -16,11 +16,12 @@ 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  = 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
     {
@@ -107,249 +108,174 @@ namespace
     };
 #pragma pack(pop)
 
-    // Helper function to create a minimal 64-bit Mach-O file with a __text section
+    // Build a minimal 64-bit Mach-O binary in-memory with a __text section
-    bool write_minimal_macho64_file(const std::string& path, const std::vector<std::uint8_t>& section_bytes)
+    std::vector<std::uint8_t> build_minimal_macho64(const std::vector<std::uint8_t>& section_bytes)
     {
-        std::ofstream f(path, std::ios::binary);
+        constexpr std::size_t load_cmd_size = sizeof(SegmentCommand64) + sizeof(Section64);
-        if (!f.is_open())
+        const std::size_t section_offset    = sizeof(MachHeader64) + load_cmd_size;
-            return false;
 
-        // Calculate sizes
+        std::vector<std::uint8_t> buf(section_offset + section_bytes.size(), 0u);
-        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
+        auto* header = reinterpret_cast<MachHeader64*>(buf.data());
-        MachHeader64 header{};
+        header->magic      = mh_magic_64;
-        header.magic = mh_magic_64;
+        header->cputype    = 0x01000007;  // CPU_TYPE_X86_64
-        header.cputype = 0x01000007;  // CPU_TYPE_X86_64
+        header->cpusubtype = 0x3;
-        header.cpusubtype = 0x3;       // CPU_SUBTYPE_X86_64_ALL
+        header->filetype   = 0x2;         // MH_EXECUTE
-        header.filetype = 0x2;         // MH_EXECUTE
+        header->ncmds      = 1;
-        header.ncmds = 1;
+        header->sizeofcmds = static_cast<std::uint32_t>(load_cmd_size);
-        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));
+        auto* segment = reinterpret_cast<SegmentCommand64*>(buf.data() + sizeof(MachHeader64));
+        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;
+        segment->initprot = 5;
+        segment->nsects   = 1;
 
-        // Create segment command
+        auto* section = reinterpret_cast<Section64*>(buf.data() + sizeof(MachHeader64) + sizeof(SegmentCommand64));
-        SegmentCommand64 segment{};
+        std::ranges::copy(section_name, section->sectname);
-        segment.cmd = lc_segment_64;
+        std::ranges::copy(segment_name, section->segname);
-        segment.cmdsize = static_cast<std::uint32_t>(load_cmd_size);
+        section->addr   = 0x100000000;
-        std::ranges::copy(segment_name, segment.segname);
+        section->size   = section_bytes.size();
-        segment.vmaddr = 0x100000000;
+        section->offset = static_cast<std::uint32_t>(section_offset);
-        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));
+        std::memcpy(buf.data() + section_offset, section_bytes.data(), section_bytes.size());
-
+        return buf;
-        // 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
+    // Build a minimal 32-bit Mach-O binary in-memory with a __text section
-    bool write_minimal_macho32_file(const std::string& path, const std::vector<std::uint8_t>& section_bytes)
+    std::vector<std::uint8_t> build_minimal_macho32(const std::vector<std::uint8_t>& section_bytes)
     {
-        std::ofstream f(path, std::ios::binary);
+        constexpr std::size_t load_cmd_size = sizeof(SegmentCommand32) + sizeof(Section32);
-        if (!f.is_open())
+        constexpr std::size_t section_offset = sizeof(MachHeader32) + load_cmd_size;
-            return false;
 
-        // Calculate sizes
+        std::vector<std::uint8_t> buf(section_offset + section_bytes.size(), 0u);
-        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
+        auto* header = reinterpret_cast<MachHeader32*>(buf.data());
-        constexpr std::size_t section_offset = header_size + load_cmd_size;
+        header->magic      = mh_magic_32;
+        header->cputype    = 0x7;
+        header->cpusubtype = 0x3;
+        header->filetype   = 0x2;
+        header->ncmds      = 1;
+        header->sizeofcmds = static_cast<std::uint32_t>(load_cmd_size);
 
-        // Create Mach-O header
+        auto* segment = reinterpret_cast<SegmentCommand32*>(buf.data() + sizeof(MachHeader32));
-        MachHeader32 header{};
+        segment->cmd      = lc_segment;
-        header.magic = mh_magic_32;
+        segment->cmdsize  = static_cast<std::uint32_t>(load_cmd_size);
-        header.cputype = 0x7;          // CPU_TYPE_X86
+        std::ranges::copy(segment_name, segment->segname);
-        header.cpusubtype = 0x3;       // CPU_SUBTYPE_X86_ALL
+        segment->vmaddr   = 0x1000;
-        header.filetype = 0x2;         // MH_EXECUTE
+        segment->vmsize   = static_cast<std::uint32_t>(section_bytes.size());
-        header.ncmds = 1;
+        segment->fileoff  = static_cast<std::uint32_t>(section_offset);
-        header.sizeofcmds = static_cast<std::uint32_t>(load_cmd_size);
+        segment->filesize = static_cast<std::uint32_t>(section_bytes.size());
-        header.flags = 0;
+        segment->maxprot  = 7;
+        segment->initprot = 5;
+        segment->nsects   = 1;
 
-        f.write(reinterpret_cast<const char*>(&header), sizeof(header));
+        auto* section = reinterpret_cast<Section32*>(buf.data() + sizeof(MachHeader32) + sizeof(SegmentCommand32));
+        std::ranges::copy(section_name, section->sectname);
+        std::ranges::copy(segment_name, section->segname);
+        section->addr   = 0x1000;
+        section->size   = static_cast<std::uint32_t>(section_bytes.size());
+        section->offset = static_cast<std::uint32_t>(section_offset);
 
-        // Create segment command
+        std::memcpy(buf.data() + section_offset, section_bytes.data(), section_bytes.size());
-        SegmentCommand32 segment{};
+        return buf;
-        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};
-    const std::vector<std::uint8_t> bytes = {0x55, 0x48, 0x89, 0xE5, 0x90, 0x90}; // push rbp; mov rbp, rsp; nop; nop
+    const auto f = MemFdFile::create(build_minimal_macho64(bytes));
-    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48 89 E5", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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};
-    const std::vector<std::uint8_t> bytes = {0x55, 0x89, 0xE5, 0x90, 0x90}; // push ebp; mov ebp, esp; nop; nop
+    const auto f = MemFdFile::create(build_minimal_macho32(bytes));
-    ASSERT_TRUE(write_minimal_macho32_file(path.data(), bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 89 E5", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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 f = MemFdFile::create(build_minimal_macho64(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "FF EE DD", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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};
-    const std::vector<std::uint8_t> bytes = {0x90, 0x90, 0x90, 0x55, 0x48, 0x89, 0xE5}; // nops then pattern
+    const auto f = MemFdFile::create(build_minimal_macho64(bytes));
-    ASSERT_TRUE(write_minimal_macho64_file(path.data(), bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48 89 E5", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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 f = MemFdFile::create(build_minimal_macho64(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 ? 89 E5", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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()));
+    const auto f = MemFdFile::create(garbage);
-    f.close();
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48", "__text");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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 f = MemFdFile::create(build_minimal_macho64(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = MachOPatternScanner::scan_for_pattern_in_file(path, "55 48", "__nonexistent");
+    const auto res = MachOPatternScanner::scan_for_pattern_in_file(f.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);

tests/general/unit_test_navigation_mesh.cpp

@@ -7,19 +7,18 @@ using namespace omath::pathfinding;
 TEST(NavigationMeshTests, SerializeDeserializeRoundTrip)
 {
     NavigationMesh nav;
-    Vector3<float> a{0.f,0.f,0.f};
+    Vector3<float> a{0.f, 0.f, 0.f};
-    Vector3<float> b{1.f,0.f,0.f};
+    Vector3<float> b{1.f, 0.f, 0.f};
-    Vector3<float> c{0.f,1.f,0.f};
+    Vector3<float> c{0.f, 1.f, 0.f};
 
-    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b,c});
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b, c});
     nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{a});
     nav.m_vertex_map.emplace(c, std::vector<Vector3<float>>{a});
 
-    auto data = nav.serialize();
+    std::string data = nav.serialize();
     NavigationMesh nav2;
     EXPECT_NO_THROW(nav2.deserialize(data));
 
-    // verify neighbors preserved
     EXPECT_EQ(nav2.m_vertex_map.size(), nav.m_vertex_map.size());
     EXPECT_EQ(nav2.get_neighbors(a).size(), 2u);
 }
@@ -27,7 +26,223 @@ TEST(NavigationMeshTests, SerializeDeserializeRoundTrip)
 TEST(NavigationMeshTests, GetClosestVertexWhenEmpty)
 {
     const NavigationMesh nav;
-    constexpr Vector3<float> p{5.f,5.f,5.f};
+    constexpr Vector3<float> p{5.f, 5.f, 5.f};
     const auto res = nav.get_closest_vertex(p);
     EXPECT_FALSE(res.has_value());
 }
+
+TEST(NavigationMeshTests, SerializeEmptyMesh)
+{
+    const NavigationMesh nav;
+    const std::string data = nav.serialize();
+    EXPECT_TRUE(data.empty());
+}
+
+TEST(NavigationMeshTests, DeserializeEmptyString)
+{
+    NavigationMesh nav;
+    EXPECT_NO_THROW(nav.deserialize(""));
+    EXPECT_TRUE(nav.empty());
+}
+
+TEST(NavigationMeshTests, SerializeProducesHumanReadableText)
+{
+    NavigationMesh nav;
+    nav.m_vertex_map.emplace(Vector3<float>{1.f, 2.f, 3.f}, std::vector<Vector3<float>>{{4.f, 5.f, 6.f}});
+
+    const std::string data = nav.serialize();
+
+    // Must contain the vertex and neighbor coords as plain text
+    EXPECT_NE(data.find("1"), std::string::npos);
+    EXPECT_NE(data.find("2"), std::string::npos);
+    EXPECT_NE(data.find("3"), std::string::npos);
+    EXPECT_NE(data.find("4"), std::string::npos);
+    EXPECT_NE(data.find("5"), std::string::npos);
+    EXPECT_NE(data.find("6"), std::string::npos);
+}
+
+TEST(NavigationMeshTests, DeserializeRestoresNeighborValues)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 2.f, 3.f};
+    const Vector3<float> n1{4.f, 5.f, 6.f};
+    const Vector3<float> n2{7.f, 8.f, 9.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{n1, n2});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    const auto& neighbors = nav2.get_neighbors(v);
+    ASSERT_EQ(neighbors.size(), 2u);
+    EXPECT_EQ(neighbors[0], n1);
+    EXPECT_EQ(neighbors[1], n2);
+}
+
+TEST(NavigationMeshTests, DeserializeOverwritesPreviousData)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    // Load a different mesh into the same object
+    NavigationMesh other;
+    const Vector3<float> a{10.f, 20.f, 30.f};
+    other.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+
+    nav.deserialize(other.serialize());
+
+    EXPECT_EQ(nav.m_vertex_map.size(), 1u);
+    EXPECT_EQ(nav.m_vertex_map.count(v), 0u);
+    EXPECT_EQ(nav.m_vertex_map.count(a), 1u);
+}
+
+TEST(NavigationMeshTests, RoundTripNegativeAndFractionalCoords)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{-1.5f, 0.25f, -3.75f};
+    const Vector3<float> n{100.f, -200.f, 0.001f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{n});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    const auto& neighbors = nav2.get_neighbors(v);
+    ASSERT_EQ(neighbors.size(), 1u);
+    EXPECT_NEAR(neighbors[0].x, n.x, 1e-3f);
+    EXPECT_NEAR(neighbors[0].y, n.y, 1e-3f);
+    EXPECT_NEAR(neighbors[0].z, n.z, 1e-3f);
+}
+
+TEST(NavigationMeshTests, GetClosestVertexReturnsNearest)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{10.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+
+    const auto res = nav.get_closest_vertex({1.f, 0.f, 0.f});
+    ASSERT_TRUE(res.has_value());
+    EXPECT_EQ(res.value(), a);
+}
+
+TEST(NavigationMeshTests, VertexWithNoNeighborsRoundTrip)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{5.f, 5.f, 5.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    EXPECT_TRUE(nav2.get_neighbors(v).empty());
+}
+
+// ---------------------------------------------------------------------------
+// Vertex events
+// ---------------------------------------------------------------------------
+
+TEST(NavigationMeshTests, SetEventOnNonExistentVertexThrows)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{99.f, 99.f, 99.f};
+    EXPECT_THROW(nav.set_event(v, "jump"), std::invalid_argument);
+}
+
+TEST(NavigationMeshTests, EventNotSetByDefault)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{0.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}
+
+TEST(NavigationMeshTests, SetAndGetEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+
+    const auto event = nav.get_event(v);
+    ASSERT_TRUE(event.has_value());
+    EXPECT_EQ(event.value(), "jump");
+}
+
+TEST(NavigationMeshTests, OverwriteEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+    nav.set_event(v, "teleport");
+
+    EXPECT_EQ(nav.get_event(v).value(), "teleport");
+}
+
+TEST(NavigationMeshTests, ClearEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+    nav.clear_event(v);
+
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}
+
+TEST(NavigationMeshTests, EventRoundTripSerialization)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+    nav.set_event(b, "jump");
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_FALSE(nav2.get_event(a).has_value());
+    ASSERT_TRUE(nav2.get_event(b).has_value());
+    EXPECT_EQ(nav2.get_event(b).value(), "jump");
+}
+
+TEST(NavigationMeshTests, MultipleEventsRoundTrip)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{1.f, 0.f, 0.f};
+    const Vector3<float> c{2.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(c, std::vector<Vector3<float>>{});
+    nav.set_event(a, "spawn");
+    nav.set_event(c, "teleport");
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    EXPECT_EQ(nav2.get_event(a).value(), "spawn");
+    EXPECT_FALSE(nav2.get_event(b).has_value());
+    EXPECT_EQ(nav2.get_event(c).value(), "teleport");
+}
+
+TEST(NavigationMeshTests, DeserializeClearsOldEvents)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{0.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+
+    // Deserialize a mesh that has no events
+    NavigationMesh empty_events;
+    empty_events.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    nav.deserialize(empty_events.serialize());
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}

tests/general/unit_test_pe_memory_file_scan.cpp

@@ -0,0 +1,128 @@
+// Tests for PePatternScanner::scan_for_pattern_in_memory_file
+#include <cstring>
+#include <gtest/gtest.h>
+#include <omath/utility/pe_pattern_scan.hpp>
+#include <span>
+#include <vector>
+
+using namespace omath;
+
+// Reuse the fake-module builder from unit_test_pe_pattern_scan_loaded.cpp but
+// lay out the buffer as a raw PE *file* (ptr_raw_data != virtual_address).
+static std::vector<std::byte> make_fake_pe_file(std::uint32_t virtual_address, std::uint32_t ptr_raw_data,
+                                                std::uint32_t section_size,
+                                                const std::vector<std::uint8_t>& code_bytes)
+{
+    constexpr std::uint32_t e_lfanew = 0x80;
+    constexpr std::uint32_t nt_sig = 0x4550;
+    constexpr std::uint16_t opt_magic = 0x020B; // PE32+
+    constexpr std::uint16_t num_sections = 1;
+    constexpr std::uint16_t opt_hdr_size = 0xF0;
+    constexpr std::uint32_t section_table_off = e_lfanew + 4 + 20 + opt_hdr_size;
+    constexpr std::uint32_t section_header_size = 40;
+
+    const std::uint32_t total_size = ptr_raw_data + section_size + 0x100;
+    std::vector<std::byte> buf(total_size, std::byte{0});
+
+    auto w16 = [&](std::size_t off, std::uint16_t v) { std::memcpy(buf.data() + off, &v, 2); };
+    auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+    auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
+
+    // DOS header
+    w16(0x00, 0x5A4D);
+    w32(0x3C, e_lfanew);
+
+    // NT signature
+    w32(e_lfanew, nt_sig);
+
+    // FileHeader
+    const std::size_t fh_off = e_lfanew + 4;
+    w16(fh_off + 2, num_sections);
+    w16(fh_off + 16, opt_hdr_size);
+
+    // OptionalHeader PE32+
+    const std::size_t opt_off = fh_off + 20;
+    w16(opt_off + 0, opt_magic);
+    w64(opt_off + 24, 0ULL); // ImageBase = 0 to keep virtual_base_addr in 32-bit range
+
+    // Section header (.text)
+    const std::size_t sh_off = section_table_off;
+    std::memcpy(buf.data() + sh_off, ".text", 5);
+    w32(sh_off + 8, section_size);        // VirtualSize
+    w32(sh_off + 12, virtual_address);    // VirtualAddress
+    w32(sh_off + 16, section_size);       // SizeOfRawData
+    w32(sh_off + 20, ptr_raw_data);       // PointerToRawData
+
+    // Place code at raw file offset
+    const std::size_t copy_len = std::min(code_bytes.size(), static_cast<std::size_t>(section_size));
+    for (std::size_t i = 0; i < copy_len; ++i)
+        buf[ptr_raw_data + i] = std::byte{code_bytes[i]};
+
+    return buf;
+}
+
+// ---- tests -----------------------------------------------------------------
+
+TEST(unit_test_pe_memory_file_scan, finds_pattern)
+{
+    const std::vector<std::uint8_t> code = {0x90, 0x01, 0x02, 0x03, 0x04};
+    const auto buf = make_fake_pe_file(0x1000, 0x400, static_cast<std::uint32_t>(code.size()), code);
+
+    const auto result = PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "90 01 02");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+    EXPECT_EQ(result->raw_base_addr, 0x400u);
+}
+
+TEST(unit_test_pe_memory_file_scan, finds_pattern_with_wildcard)
+{
+    const std::vector<std::uint8_t> code = {0xDE, 0xAD, 0xBE, 0xEF};
+    const auto buf = make_fake_pe_file(0x2000, 0x600, static_cast<std::uint32_t>(code.size()), code);
+
+    const auto result =
+            PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "DE ?? BE EF");
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->target_offset, 0);
+}
+
+TEST(unit_test_pe_memory_file_scan, pattern_not_found_returns_nullopt)
+{
+    const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03};
+    const auto buf = make_fake_pe_file(0x1000, 0x400, static_cast<std::uint32_t>(code.size()), code);
+
+    const auto result =
+            PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "AA BB CC");
+
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_pe_memory_file_scan, invalid_data_returns_nullopt)
+{
+    const std::vector<std::byte> garbage(128, std::byte{0xFF});
+    const auto result = PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{garbage}, "FF FF");
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_pe_memory_file_scan, empty_data_returns_nullopt)
+{
+    const auto result = PePatternScanner::scan_for_pattern_in_memory_file({}, "FF");
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(unit_test_pe_memory_file_scan, raw_addr_differs_from_virtual_address)
+{
+    // ptr_raw_data = 0x600, virtual_address = 0x3000 — different intentionally
+    const std::vector<std::uint8_t> code = {0xCA, 0xFE, 0xBA, 0xBE};
+    const auto buf = make_fake_pe_file(0x3000, 0x600, static_cast<std::uint32_t>(code.size()), code);
+
+    const auto result =
+            PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "CA FE BA BE");
+
+    ASSERT_TRUE(result.has_value());
+    // raw_base_addr should be ptr_raw_data, not virtual_address
+    EXPECT_EQ(result->raw_base_addr, 0x600u);
+    // virtual_base_addr = virtual_address + image_base (image_base = 0)
+    EXPECT_EQ(result->virtual_base_addr, 0x3000u);
+}

tests/general/unit_test_pe_pattern_scan_file.cpp

@@ -1,114 +1,28 @@
 // Unit test for PePatternScanner::scan_for_pattern_in_file using a synthetic PE-like file
 #include <gtest/gtest.h>
 #include <omath/utility/pe_pattern_scan.hpp>
-#include <fstream>
-#include <vector>
 #include <cstdint>
-#include <cstring>
+#include <vector>
+#include "mem_fd_helper.hpp"
 
 using namespace omath;
 
-// Helper: write a trivial PE-like file with DOS header and a single section named .text
-static bool write_minimal_pe_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;
-
-    // Write DOS header (e_magic = 0x5A4D, e_lfanew at offset 0x3C)
-    std::vector<std::uint8_t> dos(64, 0);
-    dos[0] = 'M'; dos[1] = 'Z';
-    // e_lfanew -> place NT headers right after DOS (offset 0x80)
-    std::uint32_t e_lfanew = 0x80;
-    std::memcpy(dos.data() + 0x3C, &e_lfanew, sizeof(e_lfanew));
-    f.write(reinterpret_cast<const char*>(dos.data()), dos.size());
-
-    // Pad up to e_lfanew
-    if (f.tellp() < static_cast<std::streampos>(e_lfanew))
-    {
-        std::vector<char> pad(e_lfanew - static_cast<std::uint32_t>(f.tellp()), 0);
-        f.write(pad.data(), pad.size());
-    }
-
-    // NT headers signature 'PE\0\0'
-    f.put('P'); f.put('E'); f.put('\0'); f.put('\0');
-
-    // FileHeader: machine, num_sections
-    std::uint16_t machine = 0x8664; // x64
-    std::uint16_t num_sections = 1;
-    std::uint32_t dummy32 = 0;
-    std::uint32_t dummy32b = 0;
-    std::uint16_t size_optional = 0xF0; // reasonable
-    std::uint16_t characteristics = 0;
-    f.write(reinterpret_cast<const char*>(&machine), sizeof(machine));
-    f.write(reinterpret_cast<const char*>(&num_sections), sizeof(num_sections));
-    f.write(reinterpret_cast<const char*>(&dummy32), sizeof(dummy32));
-    f.write(reinterpret_cast<const char*>(&dummy32b), sizeof(dummy32b));
-    std::uint32_t num_symbols = 0;
-    f.write(reinterpret_cast<const char*>(&num_symbols), sizeof(num_symbols));
-    f.write(reinterpret_cast<const char*>(&size_optional), sizeof(size_optional));
-    f.write(reinterpret_cast<const char*>(&characteristics), sizeof(characteristics));
-
-    // OptionalHeader (x64) minimal: magic 0x20b, image_base, size_of_code, size_of_headers
-    std::uint16_t magic = 0x20b;
-    f.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
-    // filler for rest of optional header up to size_optional
-    std::vector<std::uint8_t> opt(size_optional - sizeof(magic), 0);
-    // set size_code near end
-    // we'll set image_base and size_code fields in reasonable positions for extractor
-    // For simplicity, leave zeros; extractor primarily uses optional_header.image_base and size_code later,
-    // but we will craft a SectionHeader that points to raw data we append below.
-    f.write(reinterpret_cast<const char*>(opt.data()), opt.size());
-
-    // Section header (name 8 bytes, then remaining 36 bytes)
-    char name[8] = {'.','t','e','x','t',0,0,0};
-    f.write(name, 8);
-
-    // Write placeholder bytes for the rest of the section header and remember its start
-    constexpr std::uint32_t section_header_rest = 36u;
-    const std::streampos header_rest_pos = f.tellp();
-    std::vector<char> placeholder(section_header_rest, 0);
-    f.write(placeholder.data(), placeholder.size());
-
-    // Now write section raw data and remember its file offset
-    const std::streampos data_pos = f.tellp();
-    f.write(reinterpret_cast<const char*>(section_bytes.data()), static_cast<std::streamsize>(section_bytes.size()));
-
-    // Patch section header fields: virtual_size, virtual_address, size_raw_data, ptr_raw_data
-    const std::uint32_t virtual_size = static_cast<std::uint32_t>(section_bytes.size());
-    constexpr std::uint32_t virtual_address = 0x1000u;
-    const std::uint32_t size_raw_data = static_cast<std::uint32_t>(section_bytes.size());
-    const std::uint32_t ptr_raw_data = static_cast<std::uint32_t>(data_pos);
-
-    // Seek back to the header_rest_pos and write fields in order
-    f.seekp(header_rest_pos, std::ios::beg);
-    f.write(reinterpret_cast<const char*>(&virtual_size), sizeof(virtual_size));
-    f.write(reinterpret_cast<const char*>(&virtual_address), sizeof(virtual_address));
-    f.write(reinterpret_cast<const char*>(&size_raw_data), sizeof(size_raw_data));
-    f.write(reinterpret_cast<const char*>(&ptr_raw_data), sizeof(ptr_raw_data));
-
-    // Seek back to end for consistency
-    f.seekp(0, std::ios::end);
-
-    f.close();
-    return true;
-}
-
 TEST(unit_test_pe_pattern_scan_file, ScanFindsPattern)
 {
-    constexpr std::string_view path = "./test_minimal_pe.bin";
+    const std::vector<std::uint8_t> bytes = {0x55, 0x8B, 0xEC, 0x90, 0x90};
-    const std::vector<std::uint8_t> bytes = {0x55, 0x8B, 0xEC, 0x90, 0x90}; // pattern at offset 0
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
-    ASSERT_TRUE(write_minimal_pe_file(path.data(), bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "55 8B EC", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "55 8B EC", ".text");
     EXPECT_TRUE(res.has_value());
 }
 
 TEST(unit_test_pe_pattern_scan_file, ScanMissingPattern)
 {
-    constexpr std::string_view path = "./test_minimal_pe_2.bin";
     const std::vector<std::uint8_t> bytes = {0x00, 0x01, 0x02, 0x03};
-    ASSERT_TRUE(write_minimal_pe_file(path.data(), bytes));
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "FF EE DD", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "FF EE DD", ".text");
     EXPECT_FALSE(res.has_value());
 }

tests/general/unit_test_pe_pattern_scan_more.cpp

@@ -1,120 +1,89 @@
 // Additional tests for PePatternScanner to exercise edge cases and loaded-module scanning
 #include <cstdint>
 #include <cstring>
-#include <fstream>
 #include <gtest/gtest.h>
 #include <omath/utility/pe_pattern_scan.hpp>
 #include <vector>
+#include "mem_fd_helper.hpp"
 
 using namespace omath;
 
-static bool write_bytes(const std::string& path, const std::vector<std::uint8_t>& data)
-{
-    std::ofstream f(path, std::ios::binary);
-    if (!f.is_open())
-        return false;
-    f.write(reinterpret_cast<const char*>(data.data()), data.size());
-    return true;
-}
-
 TEST(unit_test_pe_pattern_scan_more, InvalidDosHeader)
 {
-    constexpr std::string_view path = "./test_bad_dos.bin";
     std::vector<std::uint8_t> data(128, 0);
-    // write wrong magic
     data[0] = 'N';
     data[1] = 'Z';
-    ASSERT_TRUE(write_bytes(path.data(), data));
+    const auto f = MemFdFile::create(data);
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "55 8B EC", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "55 8B EC", ".text");
     EXPECT_FALSE(res.has_value());
 }
 
 TEST(unit_test_pe_pattern_scan_more, InvalidNtSignature)
 {
-    constexpr std::string_view path = "./test_bad_nt.bin";
     std::vector<std::uint8_t> data(256, 0);
-    // valid DOS header
     data[0] = 'M';
     data[1] = 'Z';
-    // point e_lfanew to 0x80
     constexpr std::uint32_t e_lfanew = 0x80;
     std::memcpy(data.data() + 0x3C, &e_lfanew, sizeof(e_lfanew));
-    // write garbage at e_lfanew (not 'PE\0\0')
     data[e_lfanew + 0] = 'X';
     data[e_lfanew + 1] = 'Y';
     data[e_lfanew + 2] = 'Z';
     data[e_lfanew + 3] = 'W';
-    ASSERT_TRUE(write_bytes(path.data(), data));
+    const auto f = MemFdFile::create(data);
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "55 8B EC", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "55 8B EC", ".text");
     EXPECT_FALSE(res.has_value());
 }
 
 TEST(unit_test_pe_pattern_scan_more, SectionNotFound)
 {
-    // reuse minimal writer but with section named .data and search .text
+    // Minimal PE with a .data section; scanning for .text should fail
-    constexpr std::string_view path = "./test_section_not_found.bin";
+    constexpr std::uint32_t e_lfanew  = 0x80u;
-    std::ofstream f(path.data(), std::ios::binary);
+    constexpr std::uint16_t size_opt  = 0xF0u;
-    ASSERT_TRUE(f.is_open());
+    constexpr std::size_t   nt_off    = e_lfanew;
-    // DOS
+    constexpr std::size_t   fh_off    = nt_off + 4;
-    std::vector<std::uint8_t> dos(64, 0);
+    constexpr std::size_t   oh_off    = fh_off + 20;
-    dos[0] = 'M';
+    constexpr std::size_t   sh_off    = oh_off + size_opt;
-    dos[1] = 'Z';
+    constexpr std::size_t   data_off  = sh_off + 44;
-    std::uint32_t e_lfanew = 0x80;
-    std::memcpy(dos.data() + 0x3C, &e_lfanew, sizeof(e_lfanew));
-    f.write(reinterpret_cast<char*>(dos.data()), dos.size());
-    // pad
-    std::vector<char> pad(e_lfanew - static_cast<std::uint32_t>(f.tellp()), 0);
-    f.write(pad.data(), pad.size());
-    // NT sig
-    f.put('P');
-    f.put('E');
-    f.put('\0');
-    f.put('\0');
-    // FileHeader minimal
-    std::uint16_t machine = 0x8664;
-    std::uint16_t num_sections = 1;
-    std::uint32_t z = 0;
-    std::uint32_t z2 = 0;
-    std::uint32_t numsym = 0;
-    std::uint16_t size_opt = 0xF0;
-    std::uint16_t ch = 0;
-    f.write(reinterpret_cast<char*>(&machine), sizeof(machine));
-    f.write(reinterpret_cast<char*>(&num_sections), sizeof(num_sections));
-    f.write(reinterpret_cast<char*>(&z), sizeof(z));
-    f.write(reinterpret_cast<char*>(&z2), sizeof(z2));
-    f.write(reinterpret_cast<char*>(&numsym), sizeof(numsym));
-    f.write(reinterpret_cast<char*>(&size_opt), sizeof(size_opt));
-    f.write(reinterpret_cast<char*>(&ch), sizeof(ch));
-    // Optional header magic
-    std::uint16_t magic = 0x20b;
-    f.write(reinterpret_cast<char*>(&magic), sizeof(magic));
-    std::vector<std::uint8_t> opt(size_opt - sizeof(magic), 0);
-    f.write(reinterpret_cast<char*>(opt.data()), opt.size());
-    // Section header named .data
-    char name[8] = {'.', 'd', 'a', 't', 'a', 0, 0, 0};
-    f.write(name, 8);
-    std::uint32_t vs = 4, va = 0x1000, srd = 4, prd = 0x200;
-    f.write(reinterpret_cast<char*>(&vs), 4);
-    f.write(reinterpret_cast<char*>(&va), 4);
-    f.write(reinterpret_cast<char*>(&srd), 4);
-    f.write(reinterpret_cast<char*>(&prd), 4);
-    std::vector<char> rest(16, 0);
-    f.write(rest.data(), rest.size());
-    // section bytes
-    std::vector<std::uint8_t> sec = {0x00, 0x01, 0x02, 0x03};
-    f.write(reinterpret_cast<char*>(sec.data()), sec.size());
-    f.close();
 
-    auto res = PePatternScanner::scan_for_pattern_in_file(path, "00 01", ".text");
+    const std::vector<std::uint8_t> sec_data = {0x00, 0x01, 0x02, 0x03};
+    std::vector<std::uint8_t> buf(data_off + sec_data.size(), 0u);
+
+    buf[0] = 'M'; buf[1] = 'Z';
+    std::memcpy(buf.data() + 0x3C, &e_lfanew, 4);
+    buf[nt_off] = 'P'; buf[nt_off + 1] = 'E';
+
+    const std::uint16_t machine = 0x8664u, num_sections = 1u;
+    std::memcpy(buf.data() + fh_off,      &machine,       2);
+    std::memcpy(buf.data() + fh_off + 2,  &num_sections,  2);
+    std::memcpy(buf.data() + fh_off + 16, &size_opt,      2);
+
+    const std::uint16_t magic = 0x20Bu;
+    std::memcpy(buf.data() + oh_off, &magic, 2);
+
+    const char name[8] = {'.','d','a','t','a',0,0,0};
+    std::memcpy(buf.data() + sh_off, name, 8);
+
+    const std::uint32_t vs = 4u, va = 0x1000u, srd = 4u, prd = static_cast<std::uint32_t>(data_off);
+    std::memcpy(buf.data() + sh_off + 8,  &vs,  4);
+    std::memcpy(buf.data() + sh_off + 12, &va,  4);
+    std::memcpy(buf.data() + sh_off + 16, &srd, 4);
+    std::memcpy(buf.data() + sh_off + 20, &prd, 4);
+    std::memcpy(buf.data() + data_off, sec_data.data(), sec_data.size());
+
+    const auto f = MemFdFile::create(buf);
+    ASSERT_TRUE(f.valid());
+
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "00 01", ".text");
     EXPECT_FALSE(res.has_value());
 }
 
 TEST(unit_test_pe_pattern_scan_more, LoadedModuleScanFinds)
 {
     // Create an in-memory buffer that mimics loaded module layout
-    // Define local header structs matching those in source
     struct DosHeader
     {
         std::uint16_t e_magic;
@@ -158,9 +127,9 @@ TEST(unit_test_pe_pattern_scan_more, LoadedModuleScanFinds)
         std::uint32_t base_of_code;
         std::uint64_t image_base;
         std::uint32_t section_alignment;
-        std::uint32_t file_alignment; /* rest omitted */
+        std::uint32_t file_alignment;
         std::uint32_t size_image;
-        std::uint32_t size_headers; /* keep space */
+        std::uint32_t size_headers;
         std::uint8_t pad[200];
     };
     struct SectionHeader
@@ -188,44 +157,38 @@ TEST(unit_test_pe_pattern_scan_more, LoadedModuleScanFinds)
     };
 
     const std::vector<std::uint8_t> pattern_bytes = {0xDE, 0xAD, 0xBE, 0xEF, 0x90};
-    constexpr std::uint32_t base_of_code = 0x200; // will place bytes at offset 0x200
+    constexpr std::uint32_t base_of_code = 0x200;
     const std::uint32_t size_code = static_cast<std::uint32_t>(pattern_bytes.size());
 
     const std::uint32_t bufsize = 0x400 + size_code;
     std::vector<std::uint8_t> buf(bufsize, 0);
 
-    // DOS header
     const auto dos = reinterpret_cast<DosHeader*>(buf.data());
-    dos->e_magic = 0x5A4D;
+    dos->e_magic  = 0x5A4D;
     dos->e_lfanew = 0x80;
 
-    // NT headers
     const auto nt = reinterpret_cast<ImageNtHeadersX64*>(buf.data() + dos->e_lfanew);
-    nt->signature = 0x4550; // 'PE\0\0'
+    nt->signature                         = 0x4550;
-    nt->file_header.machine = 0x8664;
+    nt->file_header.machine               = 0x8664;
-    nt->file_header.num_sections = 1;
+    nt->file_header.num_sections          = 1;
-    nt->file_header.size_optional_header = static_cast<std::uint16_t>(sizeof(OptionalHeaderX64));
+    nt->file_header.size_optional_header  = static_cast<std::uint16_t>(sizeof(OptionalHeaderX64));
+    nt->optional_header.magic             = 0x020B;
+    nt->optional_header.base_of_code      = base_of_code;
+    nt->optional_header.size_code         = size_code;
 
-    nt->optional_header.magic = 0x020B; // x64
-    nt->optional_header.base_of_code = base_of_code;
-    nt->optional_header.size_code = size_code;
-
-    // Compute section table offset: e_lfanew + 4 (sig) + FileHeader + OptionalHeader
     const std::size_t section_table_off =
         static_cast<std::size_t>(dos->e_lfanew) + 4 + sizeof(FileHeader) + sizeof(OptionalHeaderX64);
     nt->optional_header.size_headers = static_cast<std::uint32_t>(section_table_off + sizeof(SectionHeader));
 
-    // Section header (.text)
     const auto sect = reinterpret_cast<SectionHeader*>(buf.data() + section_table_off);
     std::memset(sect, 0, sizeof(SectionHeader));
     std::memcpy(sect->name, ".text", 5);
-    sect->virtual_size = size_code;
+    sect->virtual_size    = size_code;
     sect->virtual_address = base_of_code;
-    sect->size_raw_data = size_code;
+    sect->size_raw_data   = size_code;
-    sect->ptr_raw_data = base_of_code;
+    sect->ptr_raw_data    = base_of_code;
-    sect->characteristics = 0x60000020; // code | execute | read
+    sect->characteristics = 0x60000020;
 
-    // place code at base_of_code
     std::memcpy(buf.data() + base_of_code, pattern_bytes.data(), pattern_bytes.size());
 
     const auto res = PePatternScanner::scan_for_pattern_in_loaded_module(buf.data(), "DE AD BE EF", ".text");

tests/general/unit_test_pe_pattern_scan_more2.cpp

@@ -4,6 +4,7 @@
 #include <gtest/gtest.h>
 #include <omath/utility/pe_pattern_scan.hpp>
 #include <vector>
+#include "mem_fd_helper.hpp"
 
 using namespace omath;
 
@@ -19,95 +20,6 @@ struct TestFileHeader
     std::uint16_t characteristics;
 };
 
-static bool write_bytes(const std::string& path, const std::vector<std::uint8_t>& data)
-{
-    std::ofstream f(path, std::ios::binary);
-    if (!f.is_open())
-        return false;
-    f.write(reinterpret_cast<const char*>(data.data()), data.size());
-    return true;
-}
-
-// Helper: write a trivial PE-like file with DOS header and a single section named .text
-static bool write_minimal_pe_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;
-
-    // Write DOS header (e_magic = 0x5A4D, e_lfanew at offset 0x3C)
-    std::vector<std::uint8_t> dos(64, 0);
-    dos[0] = 'M';
-    dos[1] = 'Z';
-    std::uint32_t e_lfanew = 0x80;
-    std::memcpy(dos.data() + 0x3C, &e_lfanew, sizeof(e_lfanew));
-    f.write(reinterpret_cast<const char*>(dos.data()), dos.size());
-
-    // Pad up to e_lfanew
-    if (f.tellp() < static_cast<std::streampos>(e_lfanew))
-    {
-        std::vector<char> pad(e_lfanew - static_cast<std::uint32_t>(f.tellp()), 0);
-        f.write(pad.data(), pad.size());
-    }
-
-    // NT headers signature 'PE\0\0'
-    f.put('P');
-    f.put('E');
-    f.put('\0');
-    f.put('\0');
-
-    // FileHeader minimal
-    std::uint16_t machine = 0x8664; // x64
-    std::uint16_t num_sections = 1;
-    std::uint32_t dummy32 = 0;
-    std::uint32_t dummy32b = 0;
-    std::uint16_t size_optional = 0xF0;
-    std::uint16_t characteristics = 0;
-    f.write(reinterpret_cast<const char*>(&machine), sizeof(machine));
-    f.write(reinterpret_cast<const char*>(&num_sections), sizeof(num_sections));
-    f.write(reinterpret_cast<const char*>(&dummy32), sizeof(dummy32));
-    f.write(reinterpret_cast<const char*>(&dummy32b), sizeof(dummy32b));
-    std::uint32_t num_symbols = 0;
-    f.write(reinterpret_cast<const char*>(&num_symbols), sizeof(num_symbols));
-    f.write(reinterpret_cast<const char*>(&size_optional), sizeof(size_optional));
-    f.write(reinterpret_cast<const char*>(&characteristics), sizeof(characteristics));
-
-    // OptionalHeader minimal filler
-    std::uint16_t magic = 0x20b;
-    f.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
-    std::vector<std::uint8_t> opt(size_optional - sizeof(magic), 0);
-    f.write(reinterpret_cast<const char*>(opt.data()), opt.size());
-
-    // Section header (name 8 bytes, then remaining 36 bytes)
-    char name[8] = {'.', 't', 'e', 'x', 't', 0, 0, 0};
-    f.write(name, 8);
-
-    constexpr std::uint32_t section_header_rest = 36u;
-    const std::streampos header_rest_pos = f.tellp();
-    std::vector<char> placeholder(section_header_rest, 0);
-    f.write(placeholder.data(), placeholder.size());
-
-    // Now write section raw data and remember its file offset
-    const std::streampos data_pos = f.tellp();
-    f.write(reinterpret_cast<const char*>(section_bytes.data()), static_cast<std::streamsize>(section_bytes.size()));
-
-    // Patch section header fields
-    const std::uint32_t virtual_size = static_cast<std::uint32_t>(section_bytes.size());
-    constexpr std::uint32_t virtual_address = 0x1000u;
-    const std::uint32_t size_raw_data = static_cast<std::uint32_t>(section_bytes.size());
-    const std::uint32_t ptr_raw_data = static_cast<std::uint32_t>(data_pos);
-
-    f.seekp(header_rest_pos, std::ios::beg);
-    f.write(reinterpret_cast<const char*>(&virtual_size), sizeof(virtual_size));
-    f.write(reinterpret_cast<const char*>(&virtual_address), sizeof(virtual_address));
-    f.write(reinterpret_cast<const char*>(&size_raw_data), sizeof(size_raw_data));
-    f.write(reinterpret_cast<const char*>(&ptr_raw_data), sizeof(ptr_raw_data));
-    f.seekp(0, std::ios::end);
-
-    f.close();
-    return true;
-}
-
 TEST(unit_test_pe_pattern_scan_more2, LoadedModuleNullBaseReturnsNull)
 {
     const auto res = PePatternScanner::scan_for_pattern_in_loaded_module(nullptr, "DE AD");
@@ -116,7 +28,6 @@ TEST(unit_test_pe_pattern_scan_more2, LoadedModuleNullBaseReturnsNull)
 
 TEST(unit_test_pe_pattern_scan_more2, LoadedModuleInvalidOptionalHeaderReturnsNull)
 {
-    // Construct in-memory buffer with DOS header but invalid optional header magic
     std::vector<std::uint8_t> buf(0x200, 0);
     struct DosHeader
     {
@@ -128,19 +39,11 @@ TEST(unit_test_pe_pattern_scan_more2, LoadedModuleInvalidOptionalHeaderReturnsNu
     dos->e_magic = 0x5A4D;
     dos->e_lfanew = 0x80;
 
-    // Place an NT header with wrong optional magic at e_lfanew
     const auto nt_ptr = buf.data() + dos->e_lfanew;
-    // write signature
+    nt_ptr[0] = 'P'; nt_ptr[1] = 'E'; nt_ptr[2] = 0; nt_ptr[3] = 0;
-    nt_ptr[0] = 'P';
+
-    nt_ptr[1] = 'E';
-    nt_ptr[2] = 0;
-    nt_ptr[3] = 0;
-    // craft FileHeader with size_optional_header large enough
     constexpr std::uint16_t size_opt = 0xE0;
-    // file header starts at offset 4
+    std::memcpy(nt_ptr + 4 + 12, &size_opt, sizeof(size_opt));
-    std::memcpy(nt_ptr + 4 + 12, &size_opt,
-                sizeof(size_opt)); // size_optional_header located after 12 bytes into FileHeader
-    // write optional header magic to be invalid value
     constexpr std::uint16_t bad_magic = 0x9999;
     std::memcpy(nt_ptr + 4 + sizeof(std::uint32_t) + sizeof(std::uint16_t) + sizeof(std::uint16_t), &bad_magic,
                 sizeof(bad_magic));
@@ -151,13 +54,11 @@ TEST(unit_test_pe_pattern_scan_more2, LoadedModuleInvalidOptionalHeaderReturnsNu
 
 TEST(unit_test_pe_pattern_scan_more2, FileX86OptionalHeaderScanFindsPattern)
 {
-    constexpr std::string_view path = "./test_pe_x86.bin";
     const std::vector<std::uint8_t> pattern = {0xDE, 0xAD, 0xBE, 0xEF};
+    const auto f = MemFdFile::create(build_minimal_pe(pattern));
+    ASSERT_TRUE(f.valid());
 
-    // Use helper from this file to write a consistent minimal PE file with .text section
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "DE AD BE EF", ".text");
-    ASSERT_TRUE(write_minimal_pe_file(path.data(), pattern));
-
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "DE AD BE EF", ".text");
     ASSERT_TRUE(res.has_value());
     EXPECT_GE(res->virtual_base_addr, 0u);
     EXPECT_GE(res->raw_base_addr, 0u);
@@ -166,97 +67,73 @@ TEST(unit_test_pe_pattern_scan_more2, FileX86OptionalHeaderScanFindsPattern)
 
 TEST(unit_test_pe_pattern_scan_more2, FilePatternNotFoundReturnsNull)
 {
-    const std::string path = "./test_pe_no_pattern.bin";
     std::vector<std::uint8_t> data(512, 0);
-    // minimal DOS/NT headers to make extract_section fail earlier or return empty data
+    data[0] = 'M'; data[1] = 'Z';
-    data[0] = 'M';
-    data[1] = 'Z';
     constexpr std::uint32_t e_lfanew = 0x80;
     std::memcpy(data.data() + 0x3C, &e_lfanew, sizeof(e_lfanew));
-    // NT signature
+    data[e_lfanew + 0] = 'P'; data[e_lfanew + 1] = 'E';
-    data[e_lfanew + 0] = 'P';
+
-    data[e_lfanew + 1] = 'E';
-    data[e_lfanew + 2] = 0;
-    data[e_lfanew + 3] = 0;
-    // FileHeader: one section, size_optional_header set low
     constexpr std::uint16_t num_sections = 1;
     constexpr std::uint16_t size_optional_header = 0xE0;
     std::memcpy(data.data() + e_lfanew + 6, &num_sections, sizeof(num_sections));
     std::memcpy(data.data() + e_lfanew + 4 + 12, &size_optional_header, sizeof(size_optional_header));
-    // Optional header magic x64
+
     constexpr std::uint16_t magic = 0x020B;
     std::memcpy(data.data() + e_lfanew + 4 + sizeof(TestFileHeader), &magic, sizeof(magic));
-    // Section header .text with small data that does not contain the pattern
+
     constexpr std::size_t offset_to_segment_table = e_lfanew + 4 + sizeof(TestFileHeader) + size_optional_header;
     constexpr char name[8] = {'.', 't', 'e', 'x', 't', 0, 0, 0};
     std::memcpy(data.data() + offset_to_segment_table, name, 8);
     std::uint32_t vs = 4, va = 0x1000, srd = 4, prd = 0x200;
-    std::memcpy(data.data() + offset_to_segment_table + 8, &vs, 4);
+    std::memcpy(data.data() + offset_to_segment_table + 8,  &vs,  4);
-    std::memcpy(data.data() + offset_to_segment_table + 12, &va, 4);
+    std::memcpy(data.data() + offset_to_segment_table + 12, &va,  4);
     std::memcpy(data.data() + offset_to_segment_table + 16, &srd, 4);
     std::memcpy(data.data() + offset_to_segment_table + 20, &prd, 4);
-    // write file
-    ASSERT_TRUE(write_bytes(path, data));
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "AA BB CC", ".text");
+    const auto f = MemFdFile::create(data);
+    ASSERT_TRUE(f.valid());
+
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "AA BB CC", ".text");
     EXPECT_FALSE(res.has_value());
 }
-// Extra tests for pe_pattern_scan edge cases (on-disk API)
 
 TEST(PePatternScanMore2, PatternAtStartFound)
 {
-    const std::string path = "./test_pe_more_start.bin";
     const std::vector<std::uint8_t> bytes = {0x90, 0x01, 0x02, 0x03, 0x04};
-    ASSERT_TRUE(write_minimal_pe_file(path, bytes));
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "90 01 02", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "90 01 02", ".text");
     EXPECT_TRUE(res.has_value());
 }
 
 TEST(PePatternScanMore2, PatternAtEndFound)
 {
-    const std::string path = "./test_pe_more_end.bin";
+    const std::vector<std::uint8_t> bytes = {0x00, 0x11, 0x22, 0x33, 0x44};
-    std::vector<std::uint8_t> bytes = {0x00, 0x11, 0x22, 0x33, 0x44};
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
-    ASSERT_TRUE(write_minimal_pe_file(path, bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "22 33 44", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "22 33 44", ".text");
     if (!res.has_value())
     {
-        // Try to locate the section header and print the raw section bytes the scanner would read
+        // Debug: inspect section header via the memfd path
-        std::ifstream in(path, std::ios::binary);
+        std::ifstream in(f.path(), std::ios::binary);
-        ASSERT_TRUE(in.is_open());
+        if (in.is_open())
-        // search for ".text" name
-        in.seekg(0, std::ios::beg);
-        std::vector<char> filebuf((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
-        const auto it = std::search(filebuf.begin(), filebuf.end(), std::begin(".text"), std::end(".text") - 1);
-        if (it != filebuf.end())
         {
-            const size_t pos = std::distance(filebuf.begin(), it);
+            std::vector<char> filebuf((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
-            // after name, next fields: virtual_size (4), virtual_address(4), size_raw_data(4), ptr_raw_data(4)
+            const auto it = std::search(filebuf.begin(), filebuf.end(), std::begin(".text"), std::end(".text") - 1);
-            const size_t meta_off = pos + 8;
+            if (it != filebuf.end())
-            uint32_t virtual_size{};
-            uint32_t virtual_address{};
-            uint32_t size_raw_data{};
-            uint32_t ptr_raw_data{};
-            std::memcpy(&virtual_size, filebuf.data() + meta_off, sizeof(virtual_size));
-            std::memcpy(&virtual_address, filebuf.data() + meta_off + 4, sizeof(virtual_address));
-            std::memcpy(&size_raw_data, filebuf.data() + meta_off + 8, sizeof(size_raw_data));
-            std::memcpy(&ptr_raw_data, filebuf.data() + meta_off + 12, sizeof(ptr_raw_data));
-
-            std::cerr << "Parsed section header: virtual_size=" << virtual_size << " virtual_address=0x" << std::hex
-                      << virtual_address << std::dec << " size_raw_data=" << size_raw_data
-                      << " ptr_raw_data=" << ptr_raw_data << "\n";
-
-            if (ptr_raw_data + size_raw_data <= filebuf.size())
             {
-                std::cerr << "Extracted section bytes:\n";
+                const std::size_t pos = std::distance(filebuf.begin(), it);
-                for (size_t i = 0; i < size_raw_data; i += 16)
+                const std::size_t meta_off = pos + 8;
-                {
+                std::uint32_t virtual_size{}, virtual_address{}, size_raw_data{}, ptr_raw_data{};
-                    std::fprintf(stderr, "%04zx: ", i);
+                std::memcpy(&virtual_size,  filebuf.data() + meta_off,      sizeof(virtual_size));
-                    for (size_t j = 0; j < 16 && i + j < size_raw_data; ++j)
+                std::memcpy(&virtual_address, filebuf.data() + meta_off + 4, sizeof(virtual_address));
-                        std::fprintf(stderr, "%02x ", static_cast<uint8_t>(filebuf[ptr_raw_data + i + j]));
+                std::memcpy(&size_raw_data, filebuf.data() + meta_off + 8,  sizeof(size_raw_data));
-                    std::fprintf(stderr, "\n");
+                std::memcpy(&ptr_raw_data,  filebuf.data() + meta_off + 12, sizeof(ptr_raw_data));
-                }
+                std::cerr << "Parsed section header: virtual_size=" << virtual_size << " virtual_address=0x"
+                          << std::hex << virtual_address << std::dec << " size_raw_data=" << size_raw_data
+                          << " ptr_raw_data=" << ptr_raw_data << "\n";
             }
         }
     }
@@ -265,30 +142,30 @@ TEST(PePatternScanMore2, PatternAtEndFound)
 
 TEST(PePatternScanMore2, WildcardMatches)
 {
-    const std::string path = "./test_pe_more_wild.bin";
     const std::vector<std::uint8_t> bytes = {0xDE, 0xAD, 0xBE, 0xEF};
-    ASSERT_TRUE(write_minimal_pe_file(path, bytes));
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "DE ?? BE", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "DE ?? BE", ".text");
     EXPECT_TRUE(res.has_value());
 }
 
 TEST(PePatternScanMore2, PatternLongerThanBuffer)
 {
-    const std::string path = "./test_pe_more_small.bin";
     const std::vector<std::uint8_t> bytes = {0xAA, 0xBB};
-    ASSERT_TRUE(write_minimal_pe_file(path, bytes));
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "AA BB CC", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "AA BB CC", ".text");
     EXPECT_FALSE(res.has_value());
 }
 
 TEST(PePatternScanMore2, InvalidPatternParse)
 {
-    const std::string path = "./test_pe_more_invalid.bin";
     const std::vector<std::uint8_t> bytes = {0x01, 0x02, 0x03};
-    ASSERT_TRUE(write_minimal_pe_file(path, bytes));
+    const auto f = MemFdFile::create(build_minimal_pe(bytes));
+    ASSERT_TRUE(f.valid());
 
-    const auto res = PePatternScanner::scan_for_pattern_in_file(path, "01 GG 03", ".text");
+    const auto res = PePatternScanner::scan_for_pattern_in_file(f.path(), "01 GG 03", ".text");
     EXPECT_FALSE(res.has_value());
 }

tests/lua/pe_scanner_tests.lua

@@ -0,0 +1,66 @@
+-- PatternScanner tests: generic scan over a Lua string buffer
+
+function PatternScanner_FindsExactPattern()
+    local buf = "\x90\x01\x02\x03\x04"
+    local offset = omath.PatternScanner.scan(buf, "90 01 02")
+    assert(offset ~= nil, "expected pattern to be found")
+    assert(offset == 0, "expected offset 0, got " .. tostring(offset))
+end
+
+function PatternScanner_FindsPatternAtNonZeroOffset()
+    local buf = "\x00\x00\xAB\xCD\xEF"
+    local offset = omath.PatternScanner.scan(buf, "AB CD EF")
+    assert(offset ~= nil, "expected pattern to be found")
+    assert(offset == 2, "expected offset 2, got " .. tostring(offset))
+end
+
+function PatternScanner_WildcardMatches()
+    local buf = "\xDE\xAD\xBE\xEF"
+    local offset = omath.PatternScanner.scan(buf, "DE ?? BE")
+    assert(offset ~= nil, "expected wildcard match")
+    assert(offset == 0)
+end
+
+function PatternScanner_ReturnsNilWhenNotFound()
+    local buf = "\x01\x02\x03"
+    local offset = omath.PatternScanner.scan(buf, "AA BB CC")
+    assert(offset == nil, "expected nil for not-found pattern")
+end
+
+function PatternScanner_ReturnsNilForEmptyBuffer()
+    local offset = omath.PatternScanner.scan("", "90 01")
+    assert(offset == nil)
+end
+
+-- PePatternScanner tests: scan_in_module uses FAKE_MODULE_BASE injected from C++
+-- The fake module contains {0x90, 0x01, 0x02, 0x03, 0x04} placed at raw offset 0x200
+
+function PeScanner_FindsExactPattern()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 01 02")
+    assert(addr ~= nil, "expected pattern to be found in module")
+    local offset = addr - FAKE_MODULE_BASE
+    assert(offset == 0x200, string.format("expected offset 0x200, got 0x%X", offset))
+end
+
+function PeScanner_WildcardMatches()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 ?? 02")
+    assert(addr ~= nil, "expected wildcard match in module")
+    local offset = addr - FAKE_MODULE_BASE
+    assert(offset == 0x200, string.format("expected offset 0x200, got 0x%X", offset))
+end
+
+function PeScanner_ReturnsNilWhenNotFound()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "AA BB CC DD")
+    assert(addr == nil, "expected nil for not-found pattern")
+end
+
+function PeScanner_CustomSectionFallsBackToNil()
+    -- Request a section that doesn't exist in our fake module
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 01 02", ".rdata")
+    assert(addr == nil, "expected nil for wrong section name")
+end
+
+-- SectionScanResult: verify the type is registered and tostring works on a C++-returned value
+function SectionScanResult_TypeIsRegistered()
+    assert(omath.SectionScanResult ~= nil, "SectionScanResult type should be registered")
+end

tests/lua/unit_test_lua_pe_scanner.cpp

@@ -0,0 +1,113 @@
+//
+// Created by orange on 10.03.2026.
+//
+#include <gtest/gtest.h>
+#include <lua.hpp>
+#include <omath/lua/lua.hpp>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace
+{
+    std::vector<std::uint8_t> make_fake_pe_module(std::uint32_t base_of_code, std::uint32_t size_code,
+                                                  const std::vector<std::uint8_t>& code_bytes)
+    {
+        constexpr std::uint32_t e_lfanew         = 0x80;
+        constexpr std::uint32_t nt_sig           = 0x4550;
+        constexpr std::uint16_t opt_magic        = 0x020B; // PE32+
+        constexpr std::uint16_t num_sections     = 1;
+        constexpr std::uint16_t opt_hdr_size     = 0xF0;
+        constexpr std::uint32_t section_table_off = e_lfanew + 4 + 20 + opt_hdr_size;
+        constexpr std::uint32_t section_hdr_size = 40;
+        constexpr std::uint32_t text_chars       = 0x60000020;
+
+        const std::uint32_t headers_end = section_table_off + section_hdr_size;
+        const std::uint32_t code_end    = base_of_code + size_code;
+        const std::uint32_t total_size  = std::max(headers_end, code_end) + 0x100;
+        std::vector<std::uint8_t> buf(total_size, 0);
+
+        auto w16 = [&](std::size_t off, std::uint16_t v) { std::memcpy(buf.data() + off, &v, 2); };
+        auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+        auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
+
+        w16(0x00, 0x5A4D);
+        w32(0x3C, e_lfanew);
+        w32(e_lfanew, nt_sig);
+
+        const std::size_t fh  = e_lfanew + 4;
+        w16(fh + 2,  num_sections);
+        w16(fh + 16, opt_hdr_size);
+
+        const std::size_t opt = fh + 20;
+        w16(opt + 0,   opt_magic);
+        w32(opt + 4,   size_code);
+        w32(opt + 20,  base_of_code);
+        w64(opt + 24,  0);
+        w32(opt + 32,  0x1000);
+        w32(opt + 36,  0x200);
+        w32(opt + 56,  code_end);
+        w32(opt + 60,  headers_end);
+        w32(opt + 108, 0);
+
+        const std::size_t sh = section_table_off;
+        std::memcpy(buf.data() + sh, ".text", 5);
+        w32(sh + 8,  size_code);
+        w32(sh + 12, base_of_code);
+        w32(sh + 16, size_code);
+        w32(sh + 20, base_of_code);
+        w32(sh + 36, text_chars);
+
+        if (base_of_code + code_bytes.size() <= buf.size())
+            std::memcpy(buf.data() + base_of_code, code_bytes.data(), code_bytes.size());
+
+        return buf;
+    }
+} // namespace
+
+class LuaPeScanner : public ::testing::Test
+{
+protected:
+    lua_State*                  L            = nullptr;
+    std::vector<std::uint8_t>   m_fake_module;
+
+    void SetUp() override
+    {
+        const std::vector<std::uint8_t> code = {0x90, 0x01, 0x02, 0x03, 0x04};
+        m_fake_module = make_fake_pe_module(0x200, static_cast<std::uint32_t>(code.size()), code);
+
+        L = luaL_newstate();
+        luaL_openlibs(L);
+        omath::lua::LuaInterpreter::register_lib(L);
+
+        lua_pushinteger(L, static_cast<lua_Integer>(
+                reinterpret_cast<std::uintptr_t>(m_fake_module.data())));
+        lua_setglobal(L, "FAKE_MODULE_BASE");
+
+        if (luaL_dofile(L, LUA_SCRIPTS_DIR "/pe_scanner_tests.lua") != LUA_OK)
+            FAIL() << lua_tostring(L, -1);
+    }
+
+    void TearDown() override { lua_close(L); }
+
+    void check(const char* func_name)
+    {
+        lua_getglobal(L, func_name);
+        if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+        {
+            FAIL() << lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+};
+
+TEST_F(LuaPeScanner, PatternScanner_FindsExactPattern)       { check("PatternScanner_FindsExactPattern"); }
+TEST_F(LuaPeScanner, PatternScanner_FindsPatternAtOffset)    { check("PatternScanner_FindsPatternAtNonZeroOffset"); }
+TEST_F(LuaPeScanner, PatternScanner_WildcardMatches)         { check("PatternScanner_WildcardMatches"); }
+TEST_F(LuaPeScanner, PatternScanner_ReturnsNilWhenNotFound)  { check("PatternScanner_ReturnsNilWhenNotFound"); }
+TEST_F(LuaPeScanner, PatternScanner_ReturnsNilForEmptyBuffer){ check("PatternScanner_ReturnsNilForEmptyBuffer"); }
+TEST_F(LuaPeScanner, PeScanner_FindsExactPattern)            { check("PeScanner_FindsExactPattern"); }
+TEST_F(LuaPeScanner, PeScanner_WildcardMatches)              { check("PeScanner_WildcardMatches"); }
+TEST_F(LuaPeScanner, PeScanner_ReturnsNilWhenNotFound)       { check("PeScanner_ReturnsNilWhenNotFound"); }
+TEST_F(LuaPeScanner, PeScanner_CustomSectionFallsBackToNil)  { check("PeScanner_CustomSectionFallsBackToNil"); }
+TEST_F(LuaPeScanner, SectionScanResult_TypeIsRegistered)     { check("SectionScanResult_TypeIsRegistered"); }

vcpkg.json

@@ -31,7 +31,11 @@
       "dependencies": [
         "glfw3",
         "glew",
-        "opengl"
+        "opengl",
+        {
+          "name": "imgui",
+          "features": ["glfw-binding", "opengl3-binding"]
+        }
       ]
     },
     "imgui": {