feat: EventViewerMod

UE4SS/include/UE4SSProgram.hpp

@@ -361,6 +361,6 @@ namespace RC
         friend void* HookedLoadLibraryExA(const char* dll_name, void* file, int32_t flags);
         friend void* HookedLoadLibraryW(const wchar_t* dll_name);
         friend void* HookedLoadLibraryExW(const wchar_t* dll_name, void* file, int32_t flags);
-        friend auto gui_render_thread_tick(Unreal::UObject*, float) -> void;
+        friend auto gui_render_thread_tick() -> void;
     };
 } // namespace RC

UE4SS/src/GUI/UFunctionCallerWidget.cpp

@@ -136,7 +136,7 @@ namespace RC::GUI
     static FOutputDevice s_ar{};
     static UFunction* s_function{};
     static UObject* s_executor{};
-    auto call_process_console_exec(UObject*, UFunction*, void*) -> void
+    auto call_process_console_exec(Hook::TCallbackIterationData<void>&, UObject*, UFunction*, void*) -> void
     {
         if (s_do_call)
         {
@@ -173,7 +173,7 @@ namespace RC::GUI
         if (!s_is_hooked)
         {
             s_is_hooked = true;
-            Hook::RegisterProcessEventPostCallback(call_process_console_exec);
+            Hook::RegisterProcessEventPostCallback(call_process_console_exec, {false, false, STR("UE4SS"), STR("FunctionCallerWidgetHook")});
         }
         s_do_call = true;
     }

UE4SS/src/Mod/LuaMod.cpp

@@ -3773,7 +3773,8 @@ No overload found for function 'IsInGameThread'.
         });
     }
 
-    auto static process_event_hook([[maybe_unused]] Unreal::UObject* Context,
+    auto static process_event_hook([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData,
+                                   [[maybe_unused]] Unreal::UObject* Context,
                                    [[maybe_unused]] Unreal::UFunction* Function,
                                    [[maybe_unused]] void* Parms) -> void
     {
@@ -3783,7 +3784,10 @@ No overload found for function 'IsInGameThread'.
         process_delayed_actions<GameThreadExecutionMethod::ProcessEvent>(LuaMod::m_delayed_game_thread_actions);
     }
 
-    auto static engine_tick_hook([[maybe_unused]] Unreal::UEngine* Context, [[maybe_unused]] float DeltaSeconds) -> void
+    auto static engine_tick_hook([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData,
+                                 [[maybe_unused]] Unreal::UEngine* Context,
+                                 [[maybe_unused]] float DeltaSeconds,
+                                 [[maybe_unused]] bool bIdle) -> void
     {
         std::lock_guard<std::recursive_mutex> guard{LuaMod::m_thread_actions_mutex};
 
@@ -3807,7 +3811,7 @@ No overload found for function 'IsInGameThread'.
     {
         if (!m_is_engine_tick_hooked)
         {
-            Unreal::Hook::RegisterEngineTickPreCallback(&engine_tick_hook);
+            Unreal::Hook::RegisterEngineTickPreCallback(engine_tick_hook, {false, false, STR("UE4SS"), STR("LuaModImpl")});
             m_is_engine_tick_hooked = true;
         }
     }
@@ -3817,7 +3821,7 @@ No overload found for function 'IsInGameThread'.
     {
         if (!mod->m_is_process_event_hooked)
         {
-            Unreal::Hook::RegisterProcessEventPreCallback(&process_event_hook);
+            Unreal::Hook::RegisterProcessEventPreCallback(process_event_hook, {false, false, STR("UE4SS"), STR("LuaModImpl")});
             mod->m_is_process_event_hooked = true;
         }
     }
@@ -5562,7 +5566,7 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
         LuaStatics::console_executor_enabled = false;
     }
 
-    static auto script_hook([[maybe_unused]] Unreal::UObject* Context, Unreal::FFrame& Stack, [[maybe_unused]] void* RESULT_DECL) -> void
+    static auto script_hook([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::UObject* Context, Unreal::FFrame& Stack, [[maybe_unused]] void* RESULT_DECL) -> void
     {
         std::lock_guard<std::recursive_mutex> guard{LuaMod::m_thread_actions_mutex};
 
@@ -5699,7 +5703,7 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
     auto LuaMod::on_program_start() -> void
     {
         Unreal::UObjectArray::AddUObjectDeleteListener(&LuaType::FLuaObjectDeleteListener::s_lua_object_delete_listener);
-
+        const Unreal::Hook::FCallbackOptions common_opts {false, false, STR("UE4SS"), STR("LuaModImpl")};
         Unreal::Hook::RegisterLoadMapPreCallback(
                 [](Unreal::UEngine* Engine, Unreal::FWorldContext& WorldContext, Unreal::FURL URL, Unreal::UPendingNetGame* PendingGame, Unreal::FString& Error)
                         -> std::pair<bool, bool> {
@@ -5780,7 +5784,7 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     });
                 });
 
-        Unreal::Hook::RegisterInitGameStatePreCallback([]([[maybe_unused]] Unreal::AGameModeBase* Context) {
+        Unreal::Hook::RegisterInitGameStatePreCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AGameModeBase* Context) {
             TRY([&] {
                 for (const auto& callback_data : m_init_game_state_pre_callbacks)
                 {
@@ -5795,9 +5799,9 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
-        Unreal::Hook::RegisterInitGameStatePostCallback([]([[maybe_unused]] Unreal::AGameModeBase* Context) {
+        Unreal::Hook::RegisterInitGameStatePostCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AGameModeBase* Context) {
             TRY([&] {
                 for (const auto& callback_data : m_init_game_state_post_callbacks)
                 {
@@ -5812,9 +5816,9 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
-        Unreal::Hook::RegisterBeginPlayPreCallback([]([[maybe_unused]] Unreal::AActor* Context) {
+        Unreal::Hook::RegisterBeginPlayPreCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AActor* Context) {
             TRY([&] {
                 for (const auto& callback_data : m_begin_play_pre_callbacks)
                 {
@@ -5829,9 +5833,9 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
-        Unreal::Hook::RegisterBeginPlayPostCallback([]([[maybe_unused]] Unreal::AActor* Context) {
+        Unreal::Hook::RegisterBeginPlayPostCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AActor* Context) {
             TRY([&] {
                 for (const auto& callback_data : m_begin_play_post_callbacks)
                 {
@@ -5846,9 +5850,9 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
-        Unreal::Hook::RegisterEndPlayPreCallback([]([[maybe_unused]] Unreal::AActor* Context, Unreal::EEndPlayReason EndPlayReason) {
+        Unreal::Hook::RegisterEndPlayPreCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AActor* Context, Unreal::EEndPlayReason EndPlayReason) {
             TRY([&] {
                 for (const auto& callback_data : m_end_play_pre_callbacks)
                 {
@@ -5865,9 +5869,9 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
-        Unreal::Hook::RegisterEndPlayPostCallback([]([[maybe_unused]] Unreal::AActor* Context, Unreal::EEndPlayReason EndPlayReason) {
+        Unreal::Hook::RegisterEndPlayPostCallback([]([[maybe_unused]] Unreal::Hook::TCallbackIterationData<void>& CallbackIterationData, [[maybe_unused]] Unreal::AActor* Context, Unreal::EEndPlayReason EndPlayReason) {
             TRY([&] {
                 for (const auto& callback_data : m_end_play_post_callbacks)
                 {
@@ -5884,7 +5888,7 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
                     }
                 }
             });
-        });
+        }, common_opts);
 
         Unreal::Hook::RegisterStaticConstructObjectPostCallback([](const Unreal::FStaticConstructObjectParameters&, Unreal::UObject* constructed_object) {
             return TRY([&] {
@@ -6412,12 +6416,12 @@ No overload found for function 'FPackageName:IsValidLongPackageName'.
         if (Unreal::UObject::ProcessLocalScriptFunctionInternal.is_ready() && Unreal::Version::IsAtLeast(4, 22))
         {
             Output::send(STR("Enabling custom events\n"));
-            Unreal::Hook::RegisterProcessLocalScriptFunctionPostCallback(script_hook);
+            Unreal::Hook::RegisterProcessLocalScriptFunctionPostCallback(script_hook, {false, false, STR("UE4SS"), STR("LuaModImplScriptHook")});
         }
         else if (Unreal::UObject::ProcessInternalInternal.is_ready() && Unreal::Version::IsBelow(4, 22))
         {
             Output::send(STR("Enabling custom events\n"));
-            Unreal::Hook::RegisterProcessInternalPostCallback(script_hook);
+            Unreal::Hook::RegisterProcessInternalPostCallback(script_hook, {false, false, STR("UE4SS"), STR("LuaModImplScriptHook")});
         }
     }
 

UE4SS/src/UE4SSProgram.cpp

@@ -900,7 +900,7 @@ namespace RC
 
     static bool s_gui_initialized_for_game_thread{};
     static bool s_gui_initializing_for_game_thread{};
-    auto gui_render_thread_tick(Unreal::UObject*, float) -> void
+    auto gui_render_thread_tick() -> void
     {
         if (UE4SSProgram::settings_manager.Debug.RenderMode == GUI::RenderMode::ExternalThread)
         {
@@ -941,11 +941,11 @@ namespace RC
 
         if (settings_manager.Debug.RenderMode == GUI::RenderMode::EngineTick)
         {
-            Hook::RegisterEngineTickPostCallback(gui_render_thread_tick);
+            Hook::RegisterEngineTickPostCallback([](auto&,...){gui_render_thread_tick(); }, {false, false, STR("UE4SS"), STR("ImGuiRenderHook")});
         }
         else if (settings_manager.Debug.RenderMode == GUI::RenderMode::GameViewportClientTick)
         {
-            Hook::RegisterGameViewportClientTickPostCallback(gui_render_thread_tick);
+            Hook::RegisterGameViewportClientTickPostCallback([](auto&,...){gui_render_thread_tick(); }, {false, false, STR("UE4SS"), STR("ImGuiRenderHook")});
         }
 
         if (settings_manager.Debug.DebugConsoleEnabled)

cppmods/CMakeLists.txt

@@ -3,6 +3,7 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 # Add C++ mods
 add_subdirectory("KismetDebuggerMod")
+add_subdirectory("EventViewerMod")
 
 # Organize targets in the "mods" folder
 get_property(TARGETS DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY BUILDSYSTEM_TARGETS)

cppmods/EventViewerMod/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.22)
+set(TARGET EventViewerMod)
+project(${TARGET})
+
+include(FetchContent)
+
+FetchContent_Declare(
+        concurrentqueue
+        GIT_REPOSITORY [email protected]:cameron314/concurrentqueue.git
+        GIT_TAG c68072129c8a5b4025122ca5a0c82ab14b30cb03
+)
+FetchContent_MakeAvailable(concurrentqueue)
+
+add_library(${TARGET} SHARED
+        src/dllmain.cpp
+        src/EventViewer.cpp
+        src/Middleware.cpp
+        src/Client.cpp
+        src/Structs.cpp
+        src/StringPool.cpp
+        src/EntryCallStackRenderer.cpp
+        src/FilterCountRenderer.cpp
+)
+
+target_include_directories(${TARGET} PRIVATE "include")
+target_link_libraries(${TARGET} PRIVATE ImGui)
+target_link_libraries(${TARGET} PRIVATE concurrentqueue)
+target_link_libraries(${TARGET} PUBLIC UE4SS)

cppmods/EventViewerMod/README.md

@@ -0,0 +1,128 @@
+# EventViewerMod
+
+A UE4SS C++ mod that captures Unreal Engine call flow and renders it live in ImGui.
+
+It hooks **ProcessEvent**, **ProcessInternal**, and **ProcessLocalScriptFunction** concurrently and uses a **single
+unified depth counter** so nested and recursive call chains keep a consistent indentation story (PE → PI → PLSF → …).
+
+## What you can do
+
+- Watch a **live call stack** with depth-indented entries.
+- Switch between **Stack** and **Frequency** modes.
+- Filter captures with **case-insensitive** whitelist/blacklist substring rules.
+- Pause the stream and use right-click context menus to copy names, add filters, or open a focused call-stack modal.
+- Save the current view (or everything) to a timestamped text file.
+
+## UI overview
+
+### Enable / Start / Pause
+
+- **Enable** toggles the mod on/off (and persists that setting).
+- **Start/Stop** controls whether the middleware is actively capturing and dequeuing.
+- **Pause** keeps capturing logic installed but stops dequeuing and UI growth.
+
+### Target filter
+
+The **Target** combo is a *view filter*, not a capture filter:
+
+- **All** shows the call stack exactly as the middleware reports it.
+- **ProcessEvent / ProcessInternal / ProcessLocalScriptFunction** show only entries that originated from that hook.
+
+Important: depth is **not** recomputed when you filter. If you hide callers, the remaining entries keep their original
+depth so you can still read the true nesting structure.
+
+### Modes
+
+- **Stack**: live call stack history (ordered by time, per thread).
+- **Frequency**: aggregates by function and tracks how often it appears.
+
+### Thread picker
+
+Captures are grouped by the originating `std::thread::id`. The combo lets you switch which thread you’re viewing. The
+game thread is labeled with `(Game)` when detected.
+
+### Performance knobs
+
+- **Max MS Read Time** and **Max Count Per Iteration** bound how much work `dequeue()` is allowed to do per ImGui frame.
+
+### Saving captures
+
+- **Save** writes the current thread + current mode to a timestamped file.
+- **Save All** dumps both modes for all threads.
+
+## Filtering (case-insensitive)
+
+Whitelist and blacklist entries are **comma-separated tokens**.
+
+- Tokens are trimmed and converted to lowercase (ASCII-only lowercasing).
+- Filtering is done against the entry’s cached **lower-cased** strings.
+- The UI always displays the original (non-lowercased) names.
+
+Rules:
+
+- **Whitelist**: if empty, everything passes. If non-empty, an entry passes if **any** whitelist token is a substring
+  match.
+- **Blacklist**: if any blacklist token is a substring match, the entry fails.
+- **Show Tick Functions** is an additional filter gate applied on top.
+
+## Right-click menus
+
+Both stack entries and frequency entries have a right-click menu (when enabled by the current render flags) with helpers
+such as:
+
+- Copy function/caller names to clipboard
+- Add function/caller to whitelist/blacklist
+- Open the call stack modal (when the stream is paused)
+
+## Call stack modal
+
+When the stream is paused, the context menu can open a modal window that shows an entry’s root call chain.
+
+Definitions:
+
+- The **root caller** of an entry is the depth `0` entry that began the call chain that ultimately led to the selected
+  entry.
+
+The modal provides:
+
+- **Show full context**
+    - Enabled: shows all calls produced by the root caller (the entire subtree under that root).
+    - Disabled: shows the path from the root → selected entry, plus the calls triggered by the selected entry.
+- **Disable Indent Colors**
+    - Mirrors the main window’s behavior.
+
+## Architecture (high-level)
+
+- **Middleware** (`include/Middleware.hpp`, `src/Middleware.cpp`)
+    - Owns the UE hooks and pushes lightweight capture entries into a `moodycamel::ConcurrentQueue`.
+    - Uses thread-local producer tokens for low overhead under high call volume.
+    - Uses a one-time barrier/flag to prevent enqueuing until all hooks are installed (to keep depth sane).
+
+- **Client** (`include/Client.hpp`, `src/Client.cpp`)
+    - ImGui renderer + persistent UI state.
+    - Dequeues entries, groups by thread, maintains stack/frequency views, and applies filters.
+
+- **StringPool** (`include/StringPool.hpp`, `src/StringPool.cpp`)
+    - Interns function and caller strings and returns stable `std::string_view` pairs.
+    - Caches both original and lowercased variants.
+    - Produces a function hash (from Unreal’s `ComparisonIndex`) to avoid expensive string comparisons in hot paths.
+
+- **EntryCallStackRenderer** (`include/EntryCallStackRenderer.hpp`, `src/EntryCallStackRenderer.cpp`)
+    - Manages the call-stack modal’s state and rendering.
+
+## Files and persistence
+
+- UI state is stored as JSON at:
+    - `Mods/EventViewerMod/config/settings.json`
+- Capture dumps are written to:
+    - `Mods/EventViewerMod/captures/`
+
+## Building
+
+This mod is intended to be compiled as a UE4SS C++ mod (MSVC, `/std:c++latest`).
+
+## Notes and gotchas
+
+- String views returned from `StringPool` are stable until the pool is cleared. The current implementation is designed
+  for “grow-only” usage during a session and never clears, but if later implementation does want to support clearing it,
+  they should also clear all threads.