Improve ImGui hooked methods in Object Explorer (#1667)

* List all arguments when "Hook all method"

* Add unhook all methods

* Add auto unhook when exceed call count

Author: hcdd0304

src/mods/tools/ObjectExplorer.cpp

@@ -317,6 +317,24 @@ genny::Enum* enum_from_name(genny::Namespace* g, const std::string& enum_name) {
     return new_ns->enum_(namespaces.back());
 }
 
+std::string get_method_prototype_context_name(sdk::REMethodDefinition& m) {
+    auto method_name = m.get_name();
+    auto method_param_types = m.get_param_types();
+
+    std::stringstream ss_context{};
+    ss_context << method_name << "(";
+
+    for (auto i = 0; i < method_param_types.size(); i++) {
+        if (i > 0) {
+            ss_context << ", ";
+        }
+        ss_context << method_param_types[i]->get_full_name();
+    }
+
+    ss_context << ")";
+    return ss_context.str();
+}
+
 std::shared_ptr<ObjectExplorer>& ObjectExplorer::get() {
     static auto instance = std::make_shared<ObjectExplorer>();
 
@@ -863,6 +881,30 @@ void ObjectExplorer::display_hooks() {
             ImGui::EndCombo();
         }
 
+        // Auto-unhook options
+        ImGui::Checkbox("Enable Auto Unhook", &m_hooks_context.enable_auto_unhook);
+
+        if (m_hooks_context.enable_auto_unhook) {
+            if (ImGui::BeginCombo("Auto Unhook When", HooksContext::s_auto_unhook_method_names[(uint8_t)m_hooks_context.auto_unhook_method])) {
+                for (int i = 0; i < HooksContext::s_auto_unhook_method_names.size(); i++) {
+                    const bool is_selected = (m_hooks_context.auto_unhook_method == (HooksContext::AutoUnhookMethod)i);
+
+                    if (ImGui::Selectable(HooksContext::s_auto_unhook_method_names[i], is_selected)) {
+                        m_hooks_context.auto_unhook_method = (HooksContext::AutoUnhookMethod)i;
+                    }
+
+                    if (is_selected) {
+                        ImGui::SetItemDefaultFocus();
+                    }
+                }
+
+                ImGui::EndCombo();
+            }
+
+            // Always make it editable regardless of the auto unhook method, this is intentional
+            ImGui::InputScalar("Max Call Count", ImGuiDataType_U32, &m_hooks_context.auto_unhook_call_count_threshold);
+        }
+
         ImGui::TreePop();
     }
 
@@ -4269,7 +4311,7 @@ void ObjectExplorer::hook_method(sdk::REMethodDefinition* method, std::optional<
     if (name) {
         hooked.name = method->get_declaring_type()->get_full_name() + "." + *name;
     } else {
-        hooked.name = method->get_declaring_type()->get_full_name() + "." + method->get_name();
+        hooked.name = method->get_declaring_type()->get_full_name() + "." +  get_method_prototype_context_name(*method);
     }
 
     using namespace asmjit;
@@ -4342,6 +4384,23 @@ void ObjectExplorer::hook_all_methods(sdk::RETypeDefinition* t) {
     }
 }
 
+void ObjectExplorer::unhook_all_methods(sdk::RETypeDefinition* t) {
+    if (t == nullptr) {
+        return;
+    }
+
+    const auto methods = t->get_methods();
+
+    for (auto& m : methods) {
+        auto it = std::find_if(m_hooked_methods.begin(), m_hooked_methods.end(), [&m](auto& hook) { return hook.method == &m; });
+
+        if (it != m_hooked_methods.end()) {
+            g_hookman.remove(it->method, it->hook_id);
+            m_hooked_methods.erase(it);
+        }
+    }
+}
+
 void ObjectExplorer::method_context_menu(sdk::REMethodDefinition* method, std::optional<std::string> name, ::REManagedObject* obj) {
     auto additional_ctx = [&]() {
         auto it = std::find_if(m_hooked_methods.begin(), m_hooked_methods.end(), [method](auto& hook) { return hook.method == method; });
@@ -4377,6 +4436,18 @@ void ObjectExplorer::method_context_menu(sdk::REMethodDefinition* method, std::o
             }
         }
 
+        if (ImGui::Selectable("Unhook All Methods")) {
+            const auto declaring_type = method->get_declaring_type();
+
+            if (declaring_type != nullptr) {
+                std::scoped_lock _{m_job_mutex};
+
+                m_frame_jobs.push_back([this, declaring_type]() {
+                    unhook_all_methods(declaring_type);
+                });
+            }
+        }
+
         // Allow us to call really simple methods with no params
         if (method->get_param_types().size() == 0) {
             if (obj != nullptr || method->is_static()) {
@@ -5385,6 +5456,20 @@ void ObjectExplorer::post_hooked_method_internal(uintptr_t& ret_val, sdk::REType
     const auto delta = now - hooked_method.stats.last_call_times[tid];
     hooked_method.stats.last_call_delta = delta;
     hooked_method.stats.total_call_time += delta;
+    
+    // Auto-unhook check
+    if (m_hooks_context.enable_auto_unhook && m_hooks_context.auto_unhook_method == HooksContext::AutoUnhookMethod::EXCEED_CALL_COUNT) {
+        if (hooked_method.stats.call_count >= m_hooks_context.auto_unhook_call_count_threshold) {
+            std::scoped_lock job_lock{m_job_mutex};
+            m_frame_jobs.push_back([this, method]() {
+                auto it2 = std::find_if(m_hooked_methods.begin(), m_hooked_methods.end(), [method](auto& a) { return a.method == method; });
+                if (it2 != m_hooked_methods.end()) {
+                    g_hookman.remove(it2->method, it2->hook_id);
+                    m_hooked_methods.erase(it2);
+                }
+            });
+        }
+    }
 }
 
 void ObjectExplorer::post_hooked_method(uintptr_t& ret_val, sdk::RETypeDefinition*& ret_ty, uintptr_t ret_addr, sdk::REMethodDefinition* method) {

src/mods/tools/ObjectExplorer.hpp

@@ -172,6 +172,7 @@ class ObjectExplorer : public Tool {
     void context_menu(void* address, std::optional<std::string> name = std::nullopt, std::optional<std::function<void()>> additional_context = std::nullopt);
     void hook_method(sdk::REMethodDefinition* method, std::optional<std::string> name);
     void hook_all_methods(sdk::RETypeDefinition* type);
+    void unhook_all_methods(sdk::RETypeDefinition* type);
     void method_context_menu(sdk::REMethodDefinition* method, std::optional<std::string> name, ::REManagedObject* obj = nullptr);
     void make_same_line_text(std::string_view text, const ImVec4& color);
 
@@ -255,9 +256,23 @@ class ObjectExplorer : public Tool {
             "Number of Threads Called From"
         };
 
+        enum class AutoUnhookMethod : uint8_t {
+            NONE,
+            EXCEED_CALL_COUNT
+        };
+
+        static inline constexpr std::array<const char*, 2> s_auto_unhook_method_names {
+            "None",
+            "Exceed Call Count"
+        };
+
         std::recursive_mutex mtx{};
         bool hide_uncalled_methods{false};
         SortMethod sort_method{SortMethod::NONE};
+
+        bool enable_auto_unhook{false};
+        AutoUnhookMethod auto_unhook_method{AutoUnhookMethod::NONE};
+        uint32_t auto_unhook_call_count_threshold{10000};
     } m_hooks_context{};
 
     std::recursive_mutex m_job_mutex{};