H3cJP/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-12-15 16:21:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Common: Remove the string parameters from the HookableEvent interface.

Browse Source
This commit is contained in:
Jordan Woyak 2025-11-06 22:08:27 -06:00
parent 5650be6842
commit da6c65bf3b
27 changed files with 83 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
Source/Core/Common/HookableEvent.h
View File

@ -6,14 +6,9 @@
#include <functional>
#include <memory>
#include <mutex>
#include <string_view>
#include <vector>
#if defined(_DEBUG)
#include <string>
#include "Common/Logging/Log.h"
#endif
namespace Common
{
@ -33,12 +28,13 @@ using EventHook = std::unique_ptr<HookBase>;
//
// Define Events as:
//
// HookableEvent<std::string, u32> my_lovely_event{"My lovely event"};
// HookableEvent<std::string, u32> my_lovely_event;
//
// Register listeners anywhere you need them as:
// EventHook my_hook = my_lovely_event.Register([](std::string foo, u32 bar) {
//
// EventHook my_hook = my_lovely_event.Register([](std::string foo, u32 bar) {
// fmt::print("I've been triggered with {} and {}", foo, bar)
// }, "NameOfHook");
// });
//
// The hook will be automatically unregistered when the EventHook object goes out of scope.
// Trigger events by calling Trigger as:
@ -52,19 +48,12 @@ class HookableEvent
public:
using CallbackType = std::function<void(CallbackArgs...)>;
explicit HookableEvent(std::string_view event_name)
: m_storage{std::make_shared<Storage>(event_name)}
{
}
// Returns a handle that will unregister the listener when destroyed.
// Note: Attempting to add/remove hooks of the event within the callback itself will NOT work.
[[nodiscard]] EventHook Register(CallbackType callback, std::string_view name)
[[nodiscard]] EventHook Register(CallbackType callback)
{
#if defined(_DEBUG)
DEBUG_LOG_FMT(COMMON, "Registering {} handler at {} event hook", name, m_storage->event_name);
#endif
auto handle = std::make_unique<HookImpl>(m_storage, std::move(callback), name);
DEBUG_LOG_FMT(COMMON, "Registering event hook handler");
auto handle = std::make_unique<HookImpl>(m_storage, std::move(callback));
std::lock_guard lg(m_storage->listeners_mutex);
m_storage->listeners.push_back(handle.get());
@ -83,29 +72,15 @@ private:
struct Storage
{
explicit Storage(std::string_view name [[maybe_unused]])
{
#if defined(_DEBUG)
event_name = std::string(name);
#endif
}
std::mutex listeners_mutex;
std::vector<HookImpl*> listeners;
#if defined(_DEBUG)
std::string event_name;
#endif
};
struct HookImpl final : HookBase
{
HookImpl(const std::shared_ptr<Storage> storage, CallbackType func,
std::string_view name [[maybe_unused]])
HookImpl(const std::shared_ptr<Storage> storage, CallbackType func)
: weak_storage{storage}, callback{std::move(func)}
{
#if defined(_DEBUG)
hook_name = std::string(name);
#endif
}
~HookImpl() override
@ -113,28 +88,22 @@ private:
const auto storage = weak_storage.lock();
if (storage == nullptr)
{
#if defined(_DEBUG)
DEBUG_LOG_FMT(COMMON, "Handler {} outlived event hook", hook_name);
#endif
DEBUG_LOG_FMT(COMMON, "Handler outlived event hook");
return;
}
#if defined(_DEBUG)
DEBUG_LOG_FMT(COMMON, "Removing handler {} of event hook {}", hook_name, storage->event_name);
#endif
DEBUG_LOG_FMT(COMMON, "Removing event hook handler");
std::lock_guard lg(storage->listeners_mutex);
std::erase(storage->listeners, this);
}
std::weak_ptr<Storage> weak_storage;
const CallbackType callback;
#if defined(_DEBUG)
std::string hook_name;
#endif
};
// shared_ptr storage allows hooks to forget their connection if they outlive the event itself.
std::shared_ptr<Storage> m_storage;
std::shared_ptr<Storage> m_storage{std::make_shared<Storage>()};
};
} // namespace Common

4
Source/Core/Core/AchievementManager.h
View File

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

4
Source/Core/Core/Core.cpp
View File

@ -658,8 +658,8 @@ 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");
const Common::EventHook frame_presented =
GetVideoEvents().after_present_event.Register(&Core::Callback_FramePresented);
// Setup our core
if (Config::Get(Config::MAIN_CPU_CORE) != PowerPC::CPUCore::Interpreter)

7
Source/Core/Core/FifoPlayer/FifoRecorder.cpp
View File

@ -250,8 +250,8 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
m_RequestedRecordingEnd = false;
m_FinishedCb = finishedCb;
m_end_of_frame_event = m_system.GetVideoEvents().after_frame_event.Register(
[this](const Core::System& system) {
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();
@ -270,8 +270,7 @@ void FifoRecorder::StartRecording(s32 numFrames, CallbackFunc finishedCb)
const auto& fifo = system.GetCommandProcessor().GetFifo();
EndFrame(fifo.CPBase.load(std::memory_order_relaxed),
fifo.CPEnd.load(std::memory_order_relaxed));
},
"FifoRecorder::EndFrame");
});
}
void FifoRecorder::RecordInitialVideoMemory()

3
Source/Core/DolphinQt/Achievements/AchievementsWindow.cpp
View File

@ -36,8 +36,7 @@ AchievementsWindow::AchievementsWindow(QWidget* parent) : QDialog(parent)
QueueOnObject(this, [this, updated_items = std::move(updated_items)] {
AchievementsWindow::UpdateData(std::move(updated_items));
});
},
"AchievementsWindow");
});
UpdateData(AchievementManager::UpdatedItems{.all = true});
connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,

4
Source/Core/DolphinQt/CheatsManager.cpp
View File

@ -79,8 +79,8 @@ void CheatsManager::UpdateAllCheatSearchWidgetCurrentValues()
void CheatsManager::RegisterAfterFrameEventCallback()
{
m_VI_end_field_event = m_system.GetVideoEvents().vi_end_field_event.Register(
[this] { OnFrameEnd(); }, "CheatsManager");
m_VI_end_field_event =
m_system.GetVideoEvents().vi_end_field_event.Register([this] { OnFrameEnd(); });
}
void CheatsManager::RemoveAfterFrameEventCallback()

4
Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
View File

@ -429,8 +429,8 @@ void MemoryWidget::hideEvent(QHideEvent* event)
void MemoryWidget::RegisterAfterFrameEventCallback()
{
m_vi_end_field_event = m_system.GetVideoEvents().vi_end_field_event.Register(
[this] { AutoUpdateTable(); }, "MemoryWidget");
m_vi_end_field_event =
m_system.GetVideoEvents().vi_end_field_event.Register([this] { AutoUpdateTable(); });
}
void MemoryWidget::RemoveAfterFrameEventCallback()

2
Source/Core/DolphinQt/MenuBar.cpp
View File

@ -296,7 +296,7 @@ void MenuBar::AddToolsMenu()
#ifdef RC_CLIENT_SUPPORTS_RAINTEGRATION
m_achievements_dev_menu = tools_menu->addMenu(tr("RetroAchievements Development"));
m_raintegration_event_hook = AchievementManager::GetInstance().dev_menu_update_event.Register(
[this] { QueueOnObject(this, [this] { UpdateAchievementDevelopmentMenu(); }); }, "MenuBar");
[this] { QueueOnObject(this, [this] { UpdateAchievementDevelopmentMenu(); }); });
m_achievements_dev_menu->menuAction()->setVisible(false);
#endif // RC_CLIENT_SUPPORTS_RAINTEGRATION
tools_menu->addSeparator();

2
Source/Core/DolphinQt/Settings.cpp
View File

@ -75,7 +75,7 @@ Settings::Settings()
}
});
m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback("Settings", [this] {
m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback([this] {
if (Core::IsHostThread())
{
emit DevicesChanged();

2
Source/Core/InputCommon/ControllerInterface/Android/Android.cpp
View File

@ -455,7 +455,7 @@ void RegisterDevicesChangedCallbackIfNeeded(JNIEnv* env, jclass controller_inter
env->GetStaticMethodID(global_controller_interface_class, "onDevicesChanged", "()V");
static Common::EventHook event_hook = g_controller_interface.RegisterDevicesChangedCallback(
"Android", [global_controller_interface_class, controller_interface_on_devices_changed] {
[global_controller_interface_class, controller_interface_on_devices_changed] {
IDCache::GetEnvForThread()->CallStaticVoidMethod(global_controller_interface_class,
controller_interface_on_devices_changed);
});

5
Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp
View File

@ -415,10 +415,9 @@ bool ControllerInterface::IsMouseCenteringRequested() const
// Returns a handle for later removing the callback.
Common::EventHook
ControllerInterface::RegisterDevicesChangedCallback(std::string_view name,
Common::HookableEvent<>::CallbackType callback)
ControllerInterface::RegisterDevicesChangedCallback(Common::HookableEvent<>::CallbackType callback)
{
return m_devices_changed_event.Register(std::move(callback), name);
return m_devices_changed_event.Register(std::move(callback));
}
// Invoke all callbacks that were registered

5
Source/Core/InputCommon/ControllerInterface/ControllerInterface.h
View File

@ -115,8 +115,7 @@ public:
bool IsMouseCenteringRequested() const;
[[nodiscard]] Common::EventHook
RegisterDevicesChangedCallback(std::string_view name,
Common::HookableEvent<>::CallbackType callback);
RegisterDevicesChangedCallback(Common::HookableEvent<>::CallbackType callback);
static void SetCurrentInputChannel(ciface::InputChannel);
static ciface::InputChannel GetCurrentInputChannel();
@ -128,7 +127,7 @@ private:
void InvokeDevicesChangedCallbacks();
Common::HookableEvent<> m_devices_changed_event{"Devices Changed"};
Common::HookableEvent<> m_devices_changed_event;
mutable std::recursive_mutex m_devices_population_mutex;
std::atomic<bool> m_is_init;

9
Source/Core/InputCommon/InputConfig.cpp
View File

@ -172,11 +172,10 @@ void InputConfig::RegisterHotplugCallback()
{
// Update control references on all controllers
// as configured devices may have been added or removed.
m_hotplug_event_hook =
g_controller_interface.RegisterDevicesChangedCallback("InputConfig", [this] {
for (auto& controller : m_controllers)
controller->UpdateReferences(g_controller_interface);
});
m_hotplug_event_hook = g_controller_interface.RegisterDevicesChangedCallback([this] {
for (auto& controller : m_controllers)
controller->UpdateReferences(g_controller_interface);
});
}
void InputConfig::UnregisterHotplugCallback()

4
Source/Core/VideoCommon/AbstractGfx.cpp
View File

@ -18,8 +18,8 @@ std::unique_ptr<AbstractGfx> g_gfx;
AbstractGfx::AbstractGfx()
{
m_config_changed = GetVideoEvents().config_changed_event.Register(
[this](u32 bits) { OnConfigChanged(bits); }, "AbstractGfx");
m_config_changed =
GetVideoEvents().config_changed_event.Register([this](u32 bits) { OnConfigChanged(bits); });
}
bool AbstractGfx::IsHeadless() const

4
Source/Core/VideoCommon/Assets/CustomResourceManager.cpp
View File

@ -29,8 +29,8 @@ void CustomResourceManager::Initialize()
m_asset_loader.Initialize();
m_xfb_event = GetVideoEvents().after_frame_event.Register(
[this](Core::System&) { XFBTriggered(); }, "CustomResourceManager");
m_xfb_event =
GetVideoEvents().after_frame_event.Register([this](Core::System&) { XFBTriggered(); });
}
void CustomResourceManager::Shutdown()

4
Source/Core/VideoCommon/FrameDumper.cpp
View File

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

4
Source/Core/VideoCommon/FramebufferManager.cpp
View File

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

2
Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
View File

@ -18,7 +18,7 @@ CustomShaderCache::CustomShaderCache()
m_async_uber_shader_compiler->StartWorkerThreads(1); // TODO
m_frame_end_handler = GetVideoEvents().after_frame_event.Register(
[this](Core::System&) { RetrieveAsyncShaders(); }, "RetrieveAsyncShaders");
[this](Core::System&) { RetrieveAsyncShaders(); });
}
CustomShaderCache::~CustomShaderCache()

4
Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp
View File

@ -95,8 +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 = GetVideoEvents().after_frame_event.Register(
[this](Core::System&) { EndOfFrame(); }, "ModManager");
m_end_of_frame_event =
GetVideoEvents().after_frame_event.Register([this](Core::System&) { EndOfFrame(); });
}
return true;

4
Source/Core/VideoCommon/Present.cpp
View File

@ -94,8 +94,8 @@ static void TryToSnapToXFBSize(int& width, int& height, int xfb_width, int xfb_h
Presenter::Presenter()
{
m_config_changed = GetVideoEvents().config_changed_event.Register(
[this](u32 bits) { ConfigChanged(bits); }, "Presenter");
m_config_changed =
GetVideoEvents().config_changed_event.Register([this](u32 bits) { ConfigChanged(bits); });
}
Presenter::~Presenter()

2
Source/Core/VideoCommon/ShaderCache.cpp
View File

@ -47,7 +47,7 @@ bool ShaderCache::Initialize()
m_async_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
m_frame_end_handler = GetVideoEvents().after_frame_event.Register(
[this](Core::System&) { RetrieveAsyncShaders(); }, "RetrieveAsyncShaders");
[this](Core::System&) { RetrieveAsyncShaders(); });
return true;
}

19
Source/Core/VideoCommon/Statistics.cpp
View File

@ -500,18 +500,15 @@ void Statistics::DisplayScissor()
void Statistics::Init()
{
s_before_frame_event = GetVideoEvents().before_frame_event.Register([] { g_stats.ResetFrame(); },
"Statistics::ResetFrame");
s_before_frame_event = GetVideoEvents().before_frame_event.Register([] { g_stats.ResetFrame(); });
s_after_frame_event = GetVideoEvents().after_frame_event.Register(
[](const Core::System& system) {
DolphinAnalytics::Instance().ReportPerformanceInfo({
.speed_ratio = system.GetSystemTimers().GetEstimatedEmulationPerformance(),
.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,
});
},
"Statistics::PerformanceSample");
s_after_frame_event = GetVideoEvents().after_frame_event.Register([](const Core::System& system) {
DolphinAnalytics::Instance().ReportPerformanceInfo({
.speed_ratio = system.GetSystemTimers().GetEstimatedEmulationPerformance(),
.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,
});
});
}
void Statistics::Shutdown()

4
Source/Core/VideoCommon/TextureCacheBase.h
View File

@ -463,8 +463,8 @@ private:
void OnFrameEnd();
Common::EventHook m_frame_event = GetVideoEvents().after_frame_event.Register(
[this](Core::System&) { OnFrameEnd(); }, "TextureCache");
Common::EventHook m_frame_event =
GetVideoEvents().after_frame_event.Register([this](Core::System&) { OnFrameEnd(); });
VideoCommon::TextureUtils::TextureDumper m_texture_dumper;
};

7
Source/Core/VideoCommon/VertexManagerBase.cpp
View File

@ -120,11 +120,10 @@ bool VertexManagerBase::Initialize()
{
auto& video_events = GetVideoEvents();
m_frame_end_event = video_events.after_frame_event.Register(
[this](Core::System&) { OnEndFrame(); }, "VertexManagerBase");
m_frame_end_event =
video_events.after_frame_event.Register([this](Core::System&) { OnEndFrame(); });
m_after_present_event = video_events.after_present_event.Register(
[this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; },
"VertexManagerBase");
[this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; });
m_index_generator.Init();
m_custom_shader_cache = std::make_unique<CustomShaderCache>();
m_cpu_cull.Init();

4
Source/Core/VideoCommon/VideoConfig.cpp
View File

@ -221,8 +221,8 @@ void VideoConfig::VerifyValidity()
void VideoConfig::Init()
{
s_check_config_event = GetVideoEvents().after_frame_event.Register(
[](Core::System&) { CheckForConfigChanges(); }, "CheckForConfigChanges");
s_check_config_event =
GetVideoEvents().after_frame_event.Register([](Core::System&) { CheckForConfigChanges(); });
}
void VideoConfig::Shutdown()

12
Source/Core/VideoCommon/VideoEvents.h
View File

@ -69,17 +69,17 @@ struct PresentInfo
struct VideoEvents
{
// Called when certain video config setting are changed
Common::HookableEvent<u32> config_changed_event{"ConfigChanged"};
Common::HookableEvent<u32> config_changed_event;
// An event called just before the first draw call of a frame
Common::HookableEvent<> before_frame_event{"BeforeFrame"};
Common::HookableEvent<> before_frame_event;
// An event called after the frame XFB copy begins processing on the host GPU.
// 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.
Common::HookableEvent<Core::System&> after_frame_event{"AfterFrame"};
Common::HookableEvent<Core::System&> after_frame_event;
// An event called just as a frame is queued for presentation.
// The exact timing of this event depends on the "Immediately Present XFB" option.
@ -89,14 +89,14 @@ struct VideoEvents
// frame.
//
// frame_count: The number of frames
Common::HookableEvent<PresentInfo&> before_present_event{"BeforePresent"};
Common::HookableEvent<PresentInfo&> before_present_event;
// An event that is triggered after a frame is presented.
// The exact timing of this event depends on backend/driver support.
Common::HookableEvent<PresentInfo&> after_present_event{"AfterPresent"};
Common::HookableEvent<PresentInfo&> after_present_event;
// An end of frame event that runs on the CPU thread
Common::HookableEvent<> vi_end_field_event{"VIEndField"};
Common::HookableEvent<> vi_end_field_event;
};
VideoEvents& GetVideoEvents();

28
Source/Core/VideoCommon/Widescreen.cpp
View File

@ -32,26 +32,24 @@ WidescreenManager::WidescreenManager()
auto& system = Core::System::GetInstance();
auto& video_events = system.GetVideoEvents();
m_config_changed = video_events.config_changed_event.Register(
[this](u32 bits) {
if (bits & (CONFIG_CHANGE_BIT_ASPECT_RATIO))
{
// If the widescreen flag isn't being overridden by any settings,
// reset it to default if heuristic aren't running or to the last
// heuristic value if they were running.
if (std::optional<bool> is_game_widescreen = GetWidescreenOverride())
m_is_game_widescreen = *is_game_widescreen;
else
m_is_game_widescreen = (m_heuristic_state == HeuristicState::Active_Found_Anamorphic);
}
},
"Widescreen");
m_config_changed = video_events.config_changed_event.Register([this](u32 bits) {
if (bits & (CONFIG_CHANGE_BIT_ASPECT_RATIO))
{
// If the widescreen flag isn't being overridden by any settings,
// reset it to default if heuristic aren't running or to the last
// heuristic value if they were running.
if (std::optional<bool> is_game_widescreen = GetWidescreenOverride())
m_is_game_widescreen = *is_game_widescreen;
else
m_is_game_widescreen = (m_heuristic_state == HeuristicState::Active_Found_Anamorphic);
}
});
// VertexManager doesn't maintain statistics in Wii mode.
if (!system.IsWii())
{
m_update_widescreen = video_events.after_frame_event.Register(
[this](Core::System&) { UpdateWidescreenHeuristic(); }, "WideScreen Heuristic");
[this](Core::System&) { UpdateWidescreenHeuristic(); });
}
}