Common: Make HookableEvent use non-static data.

Co-authored-by: Dentomologist <[email protected]>

Source/Core/Core/AchievementManager.cpp

@@ -344,7 +344,7 @@ void AchievementManager::DoFrame()
   {
     m_last_rp_time = current_time;
     rc_client_get_rich_presence_message(m_client, m_rich_presence.data(), RP_SIZE);
-    UpdateEvent::Trigger(UpdatedItems{.rich_presence = true});
+    update_event.Trigger(UpdatedItems{.rich_presence = true});
     if (Config::Get(Config::RA_DISCORD_PRESENCE_ENABLED))
       Discord::UpdateDiscordPresence();
   }
@@ -769,7 +769,7 @@ void AchievementManager::CloseGame()
     INFO_LOG_FMT(ACHIEVEMENTS, "Game closed.");
   }
 
-  UpdateEvent::Trigger(UpdatedItems{.all = true});
+  update_event.Trigger(UpdatedItems{.all = true});
 }
 
 void AchievementManager::Logout()
@@ -783,7 +783,7 @@ void AchievementManager::Logout()
     Config::SetBaseOrCurrent(Config::RA_API_TOKEN, "");
   }
 
-  UpdateEvent::Trigger(UpdatedItems{.all = true});
+  update_event.Trigger(UpdatedItems{.all = true});
   INFO_LOG_FMT(ACHIEVEMENTS, "Logged out from server.");
 }
 
@@ -922,23 +922,24 @@ void AchievementManager::LoadDefaultBadges()
 void AchievementManager::LoginCallback(int result, const char* error_message, rc_client_t* client,
                                        void* userdata)
 {
+  auto& instance = AchievementManager::GetInstance();
   if (result != RC_OK)
   {
     WARN_LOG_FMT(ACHIEVEMENTS, "Failed to login {} to RetroAchievements server.",
                  Config::Get(Config::RA_USERNAME));
-    UpdateEvent::Trigger({.failed_login_code = result});
+    instance.update_event.Trigger({.failed_login_code = result});
     return;
   }
 
   const rc_client_user_t* user;
   {
-    std::lock_guard lg{AchievementManager::GetInstance().GetLock()};
+    std::lock_guard lg{instance.GetLock()};
     user = rc_client_get_user_info(client);
   }
   if (!user)
   {
     WARN_LOG_FMT(ACHIEVEMENTS, "Failed to retrieve user information from client.");
-    UpdateEvent::Trigger({.failed_login_code = RC_INVALID_STATE});
+    instance.update_event.Trigger({.failed_login_code = RC_INVALID_STATE});
     return;
   }
 
@@ -957,15 +958,15 @@ void AchievementManager::LoginCallback(int result, const char* error_message, rc
       INFO_LOG_FMT(ACHIEVEMENTS, "Attempted to login prior user {}; current user is {}.",
                    user->username, Config::Get(Config::RA_USERNAME));
       rc_client_logout(client);
-      UpdateEvent::Trigger({.failed_login_code = RC_INVALID_STATE});
+      instance.update_event.Trigger({.failed_login_code = RC_INVALID_STATE});
       return;
     }
   }
   INFO_LOG_FMT(ACHIEVEMENTS, "Successfully logged in {} to RetroAchievements server.",
                user->username);
-  std::lock_guard lg{AchievementManager::GetInstance().GetLock()};
+  std::lock_guard lg{instance.GetLock()};
   Config::SetBaseOrCurrent(Config::RA_API_TOKEN, user->token);
-  AchievementManager::GetInstance().FetchPlayerBadge();
+  instance.FetchPlayerBadge();
 }
 
 void AchievementManager::FetchBoardInfo(AchievementId leaderboard_id)
@@ -982,6 +983,7 @@ void AchievementManager::LeaderboardEntriesCallback(int result, const char* erro
                                                     rc_client_leaderboard_entry_list_t* list,
                                                     rc_client_t* client, void* userdata)
 {
+  auto& instance = AchievementManager::GetInstance();
   u32* leaderboard_id = static_cast<u32*>(userdata);
   Common::ScopeGuard on_end_scope([&] { delete leaderboard_id; });
 
@@ -991,10 +993,10 @@ void AchievementManager::LeaderboardEntriesCallback(int result, const char* erro
     return;
   }
 
-  auto& leaderboard = AchievementManager::GetInstance().m_leaderboard_map[*leaderboard_id];
+  auto& leaderboard = instance.m_leaderboard_map[*leaderboard_id];
   for (size_t ix = 0; ix < list->num_entries; ix++)
   {
-    std::lock_guard lg{AchievementManager::GetInstance().GetLock()};
+    std::lock_guard lg{instance.GetLock()};
     const auto& response_entry = list->entries[ix];
     auto& map_entry = leaderboard.entries[response_entry.index];
     map_entry.username.assign(response_entry.user);
@@ -1003,7 +1005,7 @@ void AchievementManager::LeaderboardEntriesCallback(int result, const char* erro
     if (static_cast<int32_t>(ix) == list->user_index)
       leaderboard.player_index = response_entry.rank;
   }
-  UpdateEvent::Trigger({.leaderboards = {*leaderboard_id}});
+  instance.update_event.Trigger({.leaderboards = {*leaderboard_id}});
 }
 
 void AchievementManager::LoadGameCallback(int result, const char* error_message,
@@ -1049,7 +1051,7 @@ void AchievementManager::LoadGameCallback(int result, const char* error_message,
   rc_client_set_read_memory_function(instance.m_client, MemoryPeeker);
   instance.FetchGameBadges();
   instance.m_system.store(&Core::System::GetInstance(), std::memory_order_release);
-  UpdateEvent::Trigger({.all = true});
+  instance.update_event.Trigger({.all = true});
   // Set this to a value that will immediately trigger RP
   instance.m_last_rp_time = std::chrono::steady_clock::now() - std::chrono::minutes{2};
 
@@ -1129,7 +1131,7 @@ void AchievementManager::DisplayWelcomeMessage()
 
 void AchievementManager::HandleAchievementTriggeredEvent(const rc_client_event_t* client_event)
 {
-  const auto& instance = AchievementManager::GetInstance();
+  auto& instance = AchievementManager::GetInstance();
 
   OSD::AddMessage(fmt::format("Unlocked: {} ({})", client_event->achievement->title,
                               client_event->achievement->points),
@@ -1137,7 +1139,7 @@ void AchievementManager::HandleAchievementTriggeredEvent(const rc_client_event_t
                   (rc_client_get_hardcore_enabled(instance.m_client)) ? OSD::Color::YELLOW :
                                                                         OSD::Color::CYAN,
                   &instance.GetAchievementBadge(client_event->achievement->id, false));
-  UpdateEvent::Trigger(UpdatedItems{.achievements = {client_event->achievement->id}});
+  instance.update_event.Trigger(UpdatedItems{.achievements = {client_event->achievement->id}});
 #ifdef RC_CLIENT_SUPPORTS_RAINTEGRATION
   switch (rc_client_raintegration_get_achievement_state(instance.m_client,
                                                         client_event->achievement->id))
@@ -1181,12 +1183,13 @@ void AchievementManager::HandleLeaderboardFailedEvent(const rc_client_event_t* c
 
 void AchievementManager::HandleLeaderboardSubmittedEvent(const rc_client_event_t* client_event)
 {
+  auto& instance = AchievementManager::GetInstance();
   OSD::AddMessage(fmt::format("Scored {} on leaderboard: {}",
                               client_event->leaderboard->tracker_value,
                               client_event->leaderboard->title),
                   OSD::Duration::VERY_LONG, OSD::Color::YELLOW);
-  AchievementManager::GetInstance().FetchBoardInfo(client_event->leaderboard->id);
-  UpdateEvent::Trigger(UpdatedItems{.leaderboards = {client_event->leaderboard->id}});
+  instance.FetchBoardInfo(client_event->leaderboard->id);
+  instance.update_event.Trigger(UpdatedItems{.leaderboards = {client_event->leaderboard->id}});
 }
 
 void AchievementManager::HandleLeaderboardTrackerUpdateEvent(const rc_client_event_t* client_event)
@@ -1223,7 +1226,7 @@ void AchievementManager::HandleAchievementChallengeIndicatorShowEvent(
   const auto [iter, inserted] = instance.m_active_challenges.insert(client_event->achievement->id);
   if (inserted)
     instance.m_challenges_updated = true;
-  UpdateEvent::Trigger(UpdatedItems{.rich_presence = true});
+  instance.update_event.Trigger(UpdatedItems{.rich_presence = true});
 }
 
 void AchievementManager::HandleAchievementChallengeIndicatorHideEvent(
@@ -1233,7 +1236,7 @@ void AchievementManager::HandleAchievementChallengeIndicatorHideEvent(
   const auto removed = instance.m_active_challenges.erase(client_event->achievement->id);
   if (removed > 0)
     instance.m_challenges_updated = true;
-  UpdateEvent::Trigger(UpdatedItems{.rich_presence = true});
+  instance.update_event.Trigger(UpdatedItems{.rich_presence = true});
 }
 
 void AchievementManager::HandleAchievementProgressIndicatorShowEvent(
@@ -1249,7 +1252,7 @@ void AchievementManager::HandleAchievementProgressIndicatorShowEvent(
                   OSD::Duration::SHORT, OSD::Color::GREEN,
                   &instance.GetAchievementBadge(client_event->achievement->id, false));
   instance.m_last_progress_message = current_time;
-  UpdateEvent::Trigger(UpdatedItems{.achievements = {client_event->achievement->id}});
+  instance.update_event.Trigger(UpdatedItems{.achievements = {client_event->achievement->id}});
 }
 
 void AchievementManager::HandleGameCompletedEvent(const rc_client_event_t* client_event,
@@ -1388,7 +1391,7 @@ void AchievementManager::FetchBadge(AchievementManager::Badge* badge, u32 badge_
 {
   if (!m_client || !HasAPIToken())
   {
-    UpdateEvent::Trigger(callback_data);
+    update_event.Trigger(callback_data);
     if (m_display_welcome_message && badge_type == RC_IMAGE_TYPE_GAME)
       DisplayWelcomeMessage();
     return;
@@ -1434,7 +1437,7 @@ void AchievementManager::FetchBadge(AchievementManager::Badge* badge, u32 badge_
                      "RetroAchievements connection failed on image request.\n URL: {}",
                      api_request.url);
         rc_api_destroy_request(&api_request);
-        UpdateEvent::Trigger(callback_data);
+        update_event.Trigger(callback_data);
         return;
       }
 
@@ -1467,7 +1470,7 @@ void AchievementManager::FetchBadge(AchievementManager::Badge* badge, u32 badge_
     }
 
     *badge = std::move(tmp_badge);
-    UpdateEvent::Trigger(callback_data);
+    update_event.Trigger(callback_data);
     if (badge_type == RC_IMAGE_TYPE_ACHIEVEMENT &&
         m_active_challenges.contains(*callback_data.achievements.begin()))
     {
@@ -1543,7 +1546,7 @@ void AchievementManager::LoadIntegrationCallback(int result, const char* error_m
     rc_client_raintegration_set_event_handler(instance.m_client, RAIntegrationEventHandler);
     rc_client_raintegration_set_write_memory_function(instance.m_client, MemoryPoker);
     rc_client_raintegration_set_get_game_name_function(instance.m_client, GameTitleEstimateHandler);
-    DevMenuUpdateEvent::Trigger();
+    instance.dev_menu_update_event.Trigger();
     // TODO: hook up menu and dll event handlers
     break;
 
@@ -1565,11 +1568,12 @@ void AchievementManager::LoadIntegrationCallback(int result, const char* error_m
 void AchievementManager::RAIntegrationEventHandler(const rc_client_raintegration_event_t* event,
                                                    rc_client_t* client)
 {
+  auto& instance = AchievementManager::GetInstance();
   switch (event->type)
   {
   case RC_CLIENT_RAINTEGRATION_EVENT_MENU_CHANGED:
   case RC_CLIENT_RAINTEGRATION_EVENT_MENUITEM_CHECKED_CHANGED:
-    DevMenuUpdateEvent::Trigger();
+    instance.dev_menu_update_event.Trigger();
     break;
   case RC_CLIENT_RAINTEGRATION_EVENT_PAUSE:
   {

Source/Core/Core/AchievementManager.h

@@ -120,7 +120,7 @@ public:
     bool rich_presence = false;
     int failed_login_code = 0;
   };
-  using UpdateEvent = Common::HookableEvent<"AchievementManagerUpdate", const UpdatedItems&>;
+  Common::HookableEvent<const UpdatedItems&> update_event{"AchievementManagerUpdate"};
 
   static AchievementManager& GetInstance();
   void Init(void* hwnd);
@@ -174,7 +174,7 @@ public:
   std::vector<std::string> GetActiveLeaderboards() const;
 
 #ifdef RC_CLIENT_SUPPORTS_RAINTEGRATION
-  using DevMenuUpdateEvent = Common::HookableEvent<"AchievementManagerDevMenuUpdate">;
+  Common::HookableEvent<> dev_menu_update_event{"AchievementManagerDevMenuUpdate"};
   const rc_client_raintegration_menu_t* GetDevelopmentMenu();
   u32 ActivateDevMenuItem(u32 menu_item_id);
   bool CheckForModifications() { return rc_client_raintegration_has_modifications(m_client); }

Source/Core/Core/Core.cpp

@@ -113,7 +113,7 @@ static std::atomic<State> s_state = State::Uninitialized;
 static std::unique_ptr<MemoryWatcher> s_memory_watcher;
 #endif
 
-void Callback_FramePresented(const PresentInfo& present_info);
+static void Callback_FramePresented(const PresentInfo& present_info);
 
 struct HostJob
 {
@@ -131,9 +131,6 @@ static thread_local bool tls_is_host_thread = false;
 static void EmuThread(Core::System& system, std::unique_ptr<BootParameters> boot,
                       WindowSystemInfo wsi);
 
-static Common::EventHook s_frame_presented =
-    AfterPresentEvent::Register(&Core::Callback_FramePresented, "Core Frame Presented");
-
 bool GetIsThrottlerTempDisabled()
 {
   return s_is_throttler_temp_disabled;
@@ -661,6 +658,9 @@ static void EmuThread(Core::System& system, std::unique_ptr<BootParameters> boot
   // This adds the SyncGPU handler to CoreTiming, so now CoreTiming::Advance might block.
   system.GetFifo().Prepare();
 
+  const Common::EventHook frame_presented = GetVideoEvents().after_present_event.Register(
+      &Core::Callback_FramePresented, "Core Frame Presented");
+
   // Setup our core
   if (Config::Get(Config::MAIN_CPU_CORE) != PowerPC::CPUCore::Interpreter)
   {

Source/Core/Core/FifoPlayer/FifoRecorder.cpp

@@ -250,7 +250,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
   m_RequestedRecordingEnd = false;
   m_FinishedCb = finishedCb;
 
-  m_end_of_frame_event = AfterFrameEvent::Register(
+  m_end_of_frame_event = m_system.GetVideoEvents().after_frame_event.Register(
       [this](const Core::System& system) {
         const bool was_recording = OpcodeDecoder::g_record_fifo_data;
         OpcodeDecoder::g_record_fifo_data = IsRecording();

Source/Core/Core/HW/VideoInterface.cpp

@@ -894,7 +894,7 @@ void VideoInterfaceManager::EndField(FieldType field, u64 ticks)
     m_system.GetCoreTiming().Throttle(ticks);
 
   g_perf_metrics.CountVBlank();
-  VIEndFieldEvent::Trigger();
+  m_system.GetVideoEvents().vi_end_field_event.Trigger();
   Core::OnFrameEnd(m_system);
 }
 

Source/Core/Core/System.cpp

@@ -59,6 +59,9 @@ struct System::Impl
   {
   }
 
+  // Built first since other constructors may register hooks right away.
+  VideoEvents m_video_events;
+
   std::unique_ptr<SoundStream> m_sound_stream;
   bool m_sound_stream_running = false;
   bool m_audio_dump_started = false;
@@ -339,4 +342,14 @@ VideoCommon::CustomResourceManager& System::GetCustomResourceManager() const
 {
   return m_impl->m_custom_resource_manager;
 }
+
+VideoEvents& System::GetVideoEvents() const
+{
+  return m_impl->m_video_events;
+}
 }  // namespace Core
+
+VideoEvents& GetVideoEvents()
+{
+  return Core::System::GetInstance().GetVideoEvents();
+}

Source/Core/Core/System.h

@@ -5,6 +5,8 @@
 
 #include <memory>
 
+#include "VideoCommon/VideoEvents.h"
+
 class GeometryShaderManager;
 class Interpreter;
 class JitInterface;
@@ -198,6 +200,7 @@ public:
   XFStateManager& GetXFStateManager() const;
   VideoInterface::VideoInterfaceManager& GetVideoInterface() const;
   VideoCommon::CustomResourceManager& GetCustomResourceManager() const;
+  VideoEvents& GetVideoEvents() const;
 
 private:
   System();