Merge pull request #12546 from lioncash/event

VideoCommon/Statistics: Remove global system accessor from s_after_frame_event

Source/Core/Common/HookableEvent.h

@@ -97,7 +97,7 @@ public:
     std::lock_guard lock(storage.m_mutex);
 
     DEBUG_LOG_FMT(COMMON, "Registering {} handler at {} event hook", name, EventName.value);
-    auto handle = std::make_unique<HookImpl>(callback, std::move(name));
+    auto handle = std::make_unique<HookImpl>(std::move(callback), std::move(name));
     storage.m_listeners.push_back(handle.get());
     return handle;
   }

Source/Core/Core/FifoPlayer/FifoRecorder.cpp

@@ -256,7 +256,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
   m_FinishedCb = finishedCb;
 
   m_end_of_frame_event = AfterFrameEvent::Register(
-      [this] {
+      [this](const Core::System& system) {
         const bool was_recording = OpcodeDecoder::g_record_fifo_data;
         OpcodeDecoder::g_record_fifo_data = IsRecording();
 
@@ -272,7 +272,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
           RecordInitialVideoMemory();
         }
 
-        const auto& fifo = m_system.GetCommandProcessor().GetFifo();
+        const auto& fifo = system.GetCommandProcessor().GetFifo();
         EndFrame(fifo.CPBase.load(std::memory_order_relaxed),
                  fifo.CPEnd.load(std::memory_order_relaxed));
       },

Source/Core/VideoCommon/BPStructs.cpp

@@ -346,7 +346,7 @@ static void BPWritten(PixelShaderManager& pixel_shader_manager, XFStateManager&
       // render multiple sub-frames and arrange the XFB copies in next to each-other in main memory
       // so they form a single completed XFB.
       // See https://dolphin-emu.org/blog/2017/11/19/hybridxfb/ for examples and more detail.
-      AfterFrameEvent::Trigger();
+      AfterFrameEvent::Trigger(Core::System::GetInstance());
 
       // Note: Theoretically, in the future we could track the VI configuration and try to detect
       //       when an XFB is the last XFB copy of a frame. Not only would we get a clean "end of

Source/Core/VideoCommon/FrameDumper.cpp

@@ -27,7 +27,8 @@ static bool DumpFrameToPNG(const FrameData& frame, const std::string& file_name)
 
 FrameDumper::FrameDumper()
 {
-  m_frame_end_handle = AfterFrameEvent::Register([this] { FlushFrameDump(); }, "FrameDumper");
+  m_frame_end_handle =
+      AfterFrameEvent::Register([this](Core::System&) { FlushFrameDump(); }, "FrameDumper");
 }
 
 FrameDumper::~FrameDumper()

Source/Core/VideoCommon/FramebufferManager.cpp

@@ -84,7 +84,8 @@ bool FramebufferManager::Initialize()
     return false;
   }
 
-  m_end_of_frame_event = AfterFrameEvent::Register([this] { EndOfFrame(); }, "FramebufferManager");
+  m_end_of_frame_event =
+      AfterFrameEvent::Register([this](Core::System&) { EndOfFrame(); }, "FramebufferManager");
 
   return true;
 }

Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp

@@ -16,8 +16,8 @@ CustomShaderCache::CustomShaderCache()
   m_async_uber_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
   m_async_uber_shader_compiler->StartWorkerThreads(1);  // TODO
 
-  m_frame_end_handler =
+  m_frame_end_handler = AfterFrameEvent::Register([this](Core::System&) { RetrieveAsyncShaders(); },
-      AfterFrameEvent::Register([this] { RetrieveAsyncShaders(); }, "RetreiveAsyncShaders");
+                                                  "RetrieveAsyncShaders");
 }
 
 CustomShaderCache::~CustomShaderCache()

Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp

@@ -95,7 +95,8 @@ bool GraphicsModManager::Initialize()
     g_ActiveConfig.graphics_mod_config->SetChangeCount(old_game_mod_changes);
     g_graphics_mod_manager->Load(*g_ActiveConfig.graphics_mod_config);
 
-    m_end_of_frame_event = AfterFrameEvent::Register([this] { EndOfFrame(); }, "ModManager");
+    m_end_of_frame_event =
+        AfterFrameEvent::Register([this](Core::System&) { EndOfFrame(); }, "ModManager");
   }
 
   return true;

Source/Core/VideoCommon/Present.cpp

@@ -784,7 +784,7 @@ void Presenter::DoState(PointerWrap& p)
   if (p.IsReadMode() && m_last_xfb_stride != 0)
   {
     // This technically counts as the end of the frame
-    AfterFrameEvent::Trigger();
+    AfterFrameEvent::Trigger(Core::System::GetInstance());
 
     ImmediateSwap(m_last_xfb_addr, m_last_xfb_width, m_last_xfb_stride, m_last_xfb_height,
                   m_last_xfb_ticks);

Source/Core/VideoCommon/ShaderCache.cpp

@@ -46,8 +46,8 @@ bool ShaderCache::Initialize()
     return false;
 
   m_async_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
-  m_frame_end_handler =
+  m_frame_end_handler = AfterFrameEvent::Register([this](Core::System&) { RetrieveAsyncShaders(); },
-      AfterFrameEvent::Register([this] { RetrieveAsyncShaders(); }, "RetreiveAsyncShaders");
+                                                  "RetrieveAsyncShaders");
   return true;
 }
 

Source/Core/VideoCommon/Statistics.cpp

@@ -23,13 +23,12 @@ static Common::EventHook s_before_frame_event =
     BeforeFrameEvent::Register([] { g_stats.ResetFrame(); }, "Statistics::ResetFrame");
 
 static Common::EventHook s_after_frame_event = AfterFrameEvent::Register(
-    [] {
+    [](const Core::System& system) {
-      DolphinAnalytics::PerformanceSample perf_sample;
+      DolphinAnalytics::Instance().ReportPerformanceInfo({
-      perf_sample.speed_ratio =
+          .speed_ratio = system.GetSystemTimers().GetEstimatedEmulationPerformance(),
-          Core::System::GetInstance().GetSystemTimers().GetEstimatedEmulationPerformance();
+          .num_prims = g_stats.this_frame.num_prims + g_stats.this_frame.num_dl_prims,
-      perf_sample.num_prims = g_stats.this_frame.num_prims + g_stats.this_frame.num_dl_prims;
+          .num_draw_calls = g_stats.this_frame.num_draw_calls,
-      perf_sample.num_draw_calls = g_stats.this_frame.num_draw_calls;
+      });
-      DolphinAnalytics::Instance().ReportPerformanceInfo(std::move(perf_sample));
     },
     "Statistics::PerformanceSample");
 

Source/Core/VideoCommon/TextureCacheBase.h

@@ -459,7 +459,7 @@ private:
   void OnFrameEnd();
 
   Common::EventHook m_frame_event =
-      AfterFrameEvent::Register([this] { OnFrameEnd(); }, "TextureCache");
+      AfterFrameEvent::Register([this](Core::System&) { OnFrameEnd(); }, "TextureCache");
 };
 
 extern std::unique_ptr<TextureCacheBase> g_texture_cache;

Source/Core/VideoCommon/VertexManagerBase.cpp

@@ -117,9 +117,11 @@ VertexManagerBase::~VertexManagerBase() = default;
 
 bool VertexManagerBase::Initialize()
 {
-  m_frame_end_event = AfterFrameEvent::Register([this] { OnEndFrame(); }, "VertexManagerBase");
+  m_frame_end_event =
+      AfterFrameEvent::Register([this](Core::System&) { OnEndFrame(); }, "VertexManagerBase");
   m_after_present_event = AfterPresentEvent::Register(
-      [this](PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; }, "VertexManagerBase");
+      [this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; },
+      "VertexManagerBase");
   m_index_generator.Init();
   m_custom_shader_cache = std::make_unique<CustomShaderCache>();
   m_cpu_cull.Init();

Source/Core/VideoCommon/VideoConfig.cpp

@@ -395,5 +395,5 @@ void CheckForConfigChanges()
   // TODO: Move everything else to the ConfigChanged event
 }
 
-static Common::EventHook s_check_config_event =
+static Common::EventHook s_check_config_event = AfterFrameEvent::Register(
-    AfterFrameEvent::Register([] { CheckForConfigChanges(); }, "CheckForConfigChanges");
+    [](Core::System&) { CheckForConfigChanges(); }, "CheckForConfigChanges");

Source/Core/VideoCommon/VideoEvents.h

@@ -6,6 +6,11 @@
 #include "Common/CommonTypes.h"
 #include "Common/HookableEvent.h"
 
+namespace Core
+{
+class System;
+}
+
 // Called when certain video config setting are changed
 using ConfigChangedEvent = Common::HookableEvent<"ConfigChanged", u32>;
 
@@ -16,7 +21,7 @@ using BeforeFrameEvent = Common::HookableEvent<"BeforeFrame">;
 // Useful for "once per frame" usecases.
 // Note: In a few rare cases, games do multiple XFB copies per frame and join them while presenting.
 //       If this matters to your usecase, you should use BeforePresent instead.
-using AfterFrameEvent = Common::HookableEvent<"AfterFrame">;
+using AfterFrameEvent = Common::HookableEvent<"AfterFrame", Core::System&>;
 
 struct PresentInfo
 {

Source/Core/VideoCommon/Widescreen.cpp

@@ -26,8 +26,8 @@ WidescreenManager::WidescreenManager()
   auto& system = Core::System::GetInstance();
   if (!system.IsWii())
   {
-    m_update_widescreen =
+    m_update_widescreen = AfterFrameEvent::Register(
-        AfterFrameEvent::Register([this] { UpdateWidescreenHeuristic(); }, "WideScreen Heuristic");
+        [this](Core::System&) { UpdateWidescreenHeuristic(); }, "WideScreen Heuristic");
   }
 }