Rework add-on manager to track add-on modules and add version information to the add-on list overlay

Author: crosire

deps/Windows.props

@@ -7,7 +7,7 @@
       <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>Shlwapi.lib;WinInet.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>ShLwApi.lib;WinInet.lib;WS2_32.lib;Version.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
 </Project>

include/README.md

@@ -8,7 +8,6 @@ A ReShade add-on is simply a DLL that uses the header-only ReShade API to regist
 Here is a very basic code example of an add-on that registers a callback that gets executed every time a new frame is presented to the screen:
 
 ```cpp
-#define RESHADE_ADDON_IMPL // Define this before including the ReShade header in exactly one source file
 #include <reshade.hpp>
 
 static void on_present(reshade::api::command_queue *queue, reshade::api::swapchain *swapchain)
@@ -21,19 +20,19 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
     switch (fdwReason)
     {
     case DLL_PROCESS_ATTACH:
-        // Call 'reshade::register_addon' before you call any other function of the ReShade API
-        // This will look for the ReShade instance in the current process and initialize the API when found
+        // Call 'reshade::register_addon' before you call any other function of the ReShade API.
+        // This will look for the ReShade instance in the current process and initialize the API when found.
         if (!reshade::register_addon(hinstDLL))
             return FALSE;
-        // This registers a callback for the 'present' event, which occurs every time a new frame is presented to the screen
-        // The function signature has to match the type defined by 'reshade::addon_event_traits<reshade::addon_event::present>::decl'
-        // For more details check the inline documentation for each event in 'reshade_events.hpp'
+        // This registers a callback for the 'present' event, which occurs every time a new frame is presented to the screen.
+        // The function signature has to match the type defined by 'reshade::addon_event_traits<reshade::addon_event::present>::decl'.
+        // For more details check the inline documentation for each event in 'reshade_events.hpp'.
         reshade::register_event<reshade::addon_event::present>(on_present);
         break;
     case DLL_PROCESS_DETACH:
-        // Before the add-on is unloaded, be sure to unregister any event callbacks that where previously registered
+        // This unregisters the event callback that was previously registered during process attachment.
         reshade::unregister_event<reshade::addon_event::present>(on_present);
-        // And finally unregister the add-on from ReShade
+        // And finally unregister the add-on from ReShade (this will automatically clean up any events registered by this add-on as well).
         reshade::unregister_addon(hinstDLL);
         break;
     }
@@ -46,12 +45,16 @@ For more complex examples, see also the built-in add-ons in [source/addon](../so
 ## Overlays
 
 It is also supported to add an overlay, which can e.g. be used to display debug information or interact with the user in-application.
-Overlays are created with the use of [Dear ImGui](https://github.com/ocornut/imgui/). Including the [`reshade.hpp`](reshade.hpp) header after `imgui.h` will automatically overwrite all Dear ImGui functions to use the instance created and managed by ReShade. This means all you have to do is include these two headers and use Dear ImGui as usual (without actually having to build its source code files, only the header files are needed):
+Overlays are created with the use of [Dear ImGui](https://github.com/ocornut/imgui/). Including the [`reshade.hpp`](reshade.hpp) header after `imgui.h` will automatically overwrite all Dear ImGui functions to use the instance created and managed by ReShade. This means all you have to do is include these two headers, define the function table variable in one of your source code file and use Dear ImGui as usual (without actually having to build its source code files, only the header files are needed):
 
 ```cpp
 #include <imgui.h>
 #include <reshade.hpp>
 
+// Define this variable in exactly one of your source code files.
+// The function table is automatically populated in the call to 'reshade::register_addon' and overwrites all Dear ImGui functions.
+imgui_function_table g_imgui_function_table = {};
+
 bool g_popup_window_visible = false;
 
 static void draw_debug_overlay(reshade::api::effect_runtime *runtime, void *imgui_context)
@@ -69,20 +72,31 @@ static void draw_debug_overlay(reshade::api::effect_runtime *runtime, void *imgu
     }
 }
 
+static void draw_settings_overlay(reshade::api::effect_runtime *runtime, void *imgui_context)
+{
+    ImGui::Checkbox("Popup window is visible", &g_popup_window_visible);
+}
+
 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
 {
     switch (fdwReason)
     {
     case DLL_PROCESS_ATTACH:
-        if (!reshade::init_addon())
+        // This will also populate the Dear ImGui function table.
+        if (!reshade::register_addon(hinstDLL))
             return FALSE;
         // This registers a new overlay with the specified name with ReShade.
         // It will be displayed as an additional window when the ReShade overlay is opened.
         // Its contents are defined by Dear ImGui commands issued in the specified callback function.
         reshade::register_overlay("Test", draw_debug_overlay);
+        // It is also possible to register a special settings overlay by passing "nullptr" instead of a title.
+        // This is shown beneath the add-on information in the add-on list of the ReShade overlay and can be used to present settings to users.
+        reshade::register_overlay(nullptr, draw_settings_overlay);
         break;
     case DLL_PROCESS_DETACH:
         reshade::unregister_overlay("Test");
+        // And finally unregister the add-on from ReShade (this will automatically clean up any overlays registered by this add-on as well).
+        reshade::unregister_addon(hinstDLL);
         break;
     }
     return TRUE;

include/reshade.hpp

@@ -10,58 +10,80 @@
 #include <Windows.h>
 #include <Psapi.h>
 
-extern HMODULE g_module_handle;
-
 namespace reshade
 {
 	/// <summary>
-	/// Writes a message to the ReShade log.
+	/// Gets the handle to the ReShade module in the current process.
+	/// </summary>
+	inline HMODULE &get_reshade_module_handle()
+	{
+		static HMODULE handle = nullptr;
+		if (handle == nullptr)
+		{
+			// Use the kernel32 variant of module enumeration functions so it can be safely called from 'DllMain'
+			HMODULE modules[1024]; DWORD num = 0;
+			if (K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &num))
+			{
+				if (num > sizeof(modules))
+					num = sizeof(modules);
+
+				for (DWORD i = 0; i < num / sizeof(HMODULE); ++i)
+				{
+					if (GetProcAddress(modules[i], "ReShadeRegisterAddon") &&
+						GetProcAddress(modules[i], "ReShadeUnregisterAddon"))
+					{
+						handle = modules[i];
+						break;
+					}
+				}
+			}
+		}
+		return handle;
+	}
+	/// <summary>
+	/// Gets the handle to the current add-on module.
+	/// </summary>
+	inline HMODULE &get_current_module_handle()
+	{
+		static HMODULE handle = nullptr;
+		return handle;
+	}
+
+	/// <summary>
+	/// Writes a message to ReShade's log.
 	/// </summary>
 	/// <param name="level">Severity level (1 = error, 2 = warning, 3 = info, 4 = debug).</param>
 	/// <param name="message">A null-terminated message string.</param>
 	inline void log_message(int level, const char *message)
 	{
-		static const auto func = reinterpret_cast<void(*)(int, const char *)>(
-			GetProcAddress(g_module_handle, "ReShadeLogMessage"));
-		func(level, message);
+		static const auto func = reinterpret_cast<void(*)(HMODULE, int, const char *)>(
+			GetProcAddress(get_reshade_module_handle(), "ReShadeLogMessage"));
+		func(get_current_module_handle(), level, message);
 	}
 
 	/// <summary>
-	/// Registers this module as an add-on with ReShade. Call this in 'DllMain' during process attach, before any of the other API functions!
+	/// Registers this module as an add-on with ReShade.
+	/// Call this in 'DllMain' during process attach, before any of the other API functions!
 	/// </summary>
+	/// <param name="module">Handle of the current add-on module.</param>
 	inline bool register_addon(HMODULE module)
 	{
-		// Use the kernel32 variant of module enumeration functions so it can be safely called from 'DllMain'
-		HMODULE modules[1024]; DWORD num = 0;
-		if (K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &num))
-		{
-			if (num > sizeof(modules))
-				num = sizeof(modules);
+		get_current_module_handle() = module;
 
-			for (DWORD i = 0; i < num / sizeof(HMODULE); ++i)
-			{
-				if (GetProcAddress(modules[i], "ReShadeRegisterAddon") &&
-					GetProcAddress(modules[i], "ReShadeUnregisterAddon"))
-				{
-					g_module_handle = modules[i];
-					break;
-				}
-			}
-		}
-
-		if (g_module_handle == nullptr)
+		const HMODULE reshade_module = get_reshade_module_handle();
+		if (reshade_module == nullptr)
 			return false;
 
 		// Check that the ReShade module supports the used API
 		const auto func = reinterpret_cast<bool(*)(HMODULE, uint32_t)>(
-			GetProcAddress(g_module_handle, "ReShadeRegisterAddon"));
+			GetProcAddress(reshade_module, "ReShadeRegisterAddon"));
 		if (!func(module, RESHADE_API_VERSION))
 			return false;
 
 #ifdef IMGUI_VERSION
 		// Check that the ReShade module was built with imgui support
 		const auto imgui_func = reinterpret_cast<const imgui_function_table *(*)(unsigned int)>(
-			GetProcAddress(g_module_handle, "ReShadeGetImGuiFunctionTable"));
+			GetProcAddress(reshade_module, "ReShadeGetImGuiFunctionTable"));
 		if (imgui_func == nullptr)
 			return false;
 
@@ -77,65 +99,62 @@ namespace reshade
 	/// <summary>
 	/// Unregisters this module. Call this in 'DllMain' during process detach, after any of the other API functions.
 	/// </summary>
+	/// <param name="module">Handle of the current add-on module.</param>
 	inline void unregister_addon(HMODULE module)
 	{
-		if (g_module_handle == nullptr)
+		const HMODULE reshade_module = get_reshade_module_handle();
+		if (reshade_module == nullptr)
 			return;
 
 		const auto func = reinterpret_cast<bool(*)(HMODULE)>(
-			GetProcAddress(g_module_handle, "ReShadeUnregisterAddon"));
+			GetProcAddress(reshade_module, "ReShadeUnregisterAddon"));
 		func(module);
 	}
 
 	/// <summary>
 	/// Registers a callback for the specified event (via template) with ReShade.
 	/// <para>The callback function is then called whenever the application performs a task associated with this event (see also the <see cref="addon_event"/> enumeration).</para>
 	/// </summary>
+	/// <param name="callback">Pointer to the callback function.</param>
 	template <reshade::addon_event ev>
 	inline void register_event(typename reshade::addon_event_traits<ev>::decl callback)
 	{
 		static const auto func = reinterpret_cast<void(*)(reshade::addon_event, void *)>(
-			GetProcAddress(g_module_handle, "ReShadeRegisterEvent"));
+			GetProcAddress(get_reshade_module_handle(), "ReShadeRegisterEvent"));
 		func(ev, static_cast<void *>(callback));
 	}
 	/// <summary>
 	/// Unregisters a callback for the specified event (via template) that was previously registered via <see cref="register_event"/>.
 	/// </summary>
+	/// <param name="callback">Pointer to the callback function.</param>
 	template <reshade::addon_event ev>
 	inline void unregister_event(typename reshade::addon_event_traits<ev>::decl callback)
 	{
 		static const auto func = reinterpret_cast<void(*)(reshade::addon_event, void *)>(
-			GetProcAddress(g_module_handle, "ReShadeUnregisterEvent"));
+			GetProcAddress(get_reshade_module_handle(), "ReShadeUnregisterEvent"));
 		func(ev, static_cast<void *>(callback));
 	}
 
 	/// <summary>
 	/// Registers an overlay with ReShade.
 	/// <para>The callback function is then called whenever the ReShade overlay is visible and allows adding imgui widgets for user interaction.</para>
 	/// </summary>
+	/// <param name="title">A null-terminated title string, or <c>nullptr</c> to register a settings overlay for this add-on.</param>
+	/// <param name="callback">Pointer to the callback function.</param>
 	inline void register_overlay(const char *title, void(*callback)(reshade::api::effect_runtime *runtime, void *imgui_context))
 	{
-		static const auto func = reinterpret_cast<decltype(&register_overlay)>(
-			GetProcAddress(g_module_handle, "ReShadeRegisterOverlay"));
+		static const auto func = reinterpret_cast<void(*)(const char *, void(*)(reshade::api::effect_runtime *, void *))>(
+			GetProcAddress(get_reshade_module_handle(), "ReShadeRegisterOverlay"));
 		func(title, callback);
 	}
 	/// <summary>
 	/// Unregisters an overlay that was previously registered via <see cref="register_overlay"/>.
 	/// </summary>
+	/// <param name="title">A null-terminated title string.</param>
 	inline void unregister_overlay(const char *title)
 	{
-		static const auto func = reinterpret_cast<decltype(&unregister_overlay)>(
-			GetProcAddress(g_module_handle, "ReShadeUnregisterOverlay"));
+		static const auto func = reinterpret_cast<void(*)(const char *)>(
+			GetProcAddress(get_reshade_module_handle(), "ReShadeUnregisterOverlay"));
 		func(title);
 	}
 }
-
-// Define 'RESHADE_ADDON_IMPL' before including this header in exactly one source file to create the implementation
-#ifdef RESHADE_ADDON_IMPL
-
-HMODULE g_module_handle = nullptr;
-#ifdef IMGUI_VERSION
-imgui_function_table g_imgui_function_table = {};
-#endif
-
-#endif

source/addon.cpp

@@ -5,13 +5,24 @@
 
 #if RESHADE_ADDON
 
-#include <imgui.h>
 #include "addon.hpp"
 #include "dll_log.hpp"
+#include <imgui.h>
+#include <Windows.h>
 
-extern "C" __declspec(dllexport) void ReShadeLogMessage(int level, const char *message)
+extern reshade::addon::info *find_addon(HMODULE module);
+
+extern "C" __declspec(dllexport) void ReShadeLogMessage(HMODULE module, int level, const char *message)
 {
-	reshade::log::message(static_cast<reshade::log::level>(level)) << "Add-on | " << message;
+	std::string prefix;
+	if (module != nullptr)
+	{
+		reshade::addon::info *const info = find_addon(module);
+		if (info != nullptr)
+			prefix = "[" + info->name + "] ";
+	}
+
+	reshade::log::message(static_cast<reshade::log::level>(level)) << prefix << message;
 }
 
 #if RESHADE_GUI

source/addon.hpp

@@ -86,9 +86,20 @@ namespace reshade::addon
 {
 	struct info
 	{
-		void *handle;
+		void *handle = nullptr;
+
 		std::string name;
 		std::string description;
+		std::string file;
+		std::string author;
+		std::string version;
+
+		std::vector<std::pair<uint32_t, void *>> event_callbacks;
+#if RESHADE_GUI
+		float settings_height = 0.0f;
+		void(*settings_overlay_callback)(api::effect_runtime *, void *) = nullptr;
+		std::vector<std::string> overlay_titles;
+#endif
 	};
 
 	/// <summary>