reshade.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Patrick Mours
 * SPDX-License-Identifier: BSD-3-Clause OR MIT
 */
 
#pragma once
 
#include "reshade_events.hpp"
#include "reshade_overlay.hpp"
#include <charconv>
 
// Current version of the ReShade API
#define RESHADE_API_VERSION 20
 
// Optionally import ReShade API functions when 'RESHADE_API_LIBRARY' is defined instead of using header-only mode
#if defined(RESHADE_API_LIBRARY) || defined(RESHADE_API_LIBRARY_EXPORT)
 
#if defined(RESHADE_API_LIBRARY_EXPORT)
    #define RESHADE_API_LIBRARY 1
    #define RESHADE_API_LIBRARY_DECL extern "C" __declspec(dllexport)
#else
    #define RESHADE_API_LIBRARY_DECL extern "C" __declspec(dllimport)
#endif
 
RESHADE_API_LIBRARY_DECL void ReShadeLogMessage(void *module, int level, const char *message);
 
RESHADE_API_LIBRARY_DECL void ReShadeGetBasePath(char *path, size_t *path_size);
 
RESHADE_API_LIBRARY_DECL bool ReShadeGetConfigValue(void *module, reshade::api::effect_runtime *runtime, const char *section, const char *key, char *value, size_t *value_size);
RESHADE_API_LIBRARY_DECL void ReShadeSetConfigValue(void *module, reshade::api::effect_runtime *runtime, const char *section, const char *key, const char *value);
RESHADE_API_LIBRARY_DECL void ReShadeSetConfigArray(void *module, reshade::api::effect_runtime *runtime, const char *section, const char *key, const char *value, size_t value_size);
 
RESHADE_API_LIBRARY_DECL bool ReShadeRegisterAddon(void *module, uint32_t api_version);
RESHADE_API_LIBRARY_DECL void ReShadeUnregisterAddon(void *module);
 
RESHADE_API_LIBRARY_DECL void ReShadeRegisterEvent(reshade::addon_event ev, void *callback);
RESHADE_API_LIBRARY_DECL void ReShadeRegisterEventForAddon(void *module, reshade::addon_event ev, void *callback);
RESHADE_API_LIBRARY_DECL void ReShadeUnregisterEvent(reshade::addon_event ev, void *callback);
RESHADE_API_LIBRARY_DECL void ReShadeUnregisterEventForAddon(void *module, reshade::addon_event ev, void *callback);
 
RESHADE_API_LIBRARY_DECL void ReShadeRegisterOverlay(const char *title, void(*callback)(reshade::api::effect_runtime *runtime));
RESHADE_API_LIBRARY_DECL void ReShadeRegisterOverlayForAddon(void *module, const char *title, void(*callback)(reshade::api::effect_runtime *runtime));
RESHADE_API_LIBRARY_DECL void ReShadeUnregisterOverlay(const char *title, void(*callback)(reshade::api::effect_runtime *runtime));
RESHADE_API_LIBRARY_DECL void ReShadeUnregisterOverlayForAddon(void *module, const char *title, void(*callback)(reshade::api::effect_runtime *runtime));
 
RESHADE_API_LIBRARY_DECL bool ReShadeCreateEffectRuntime(reshade::api::device_api api, void *opaque_device, void *opaque_command_queue, void *opaque_swapchain, const char *config_path, reshade::api::effect_runtime **out_runtime);
RESHADE_API_LIBRARY_DECL void ReShadeDestroyEffectRuntime(reshade::api::effect_runtime *runtime);
RESHADE_API_LIBRARY_DECL void ReShadeUpdateAndPresentEffectRuntime(reshade::api::effect_runtime *runtime);
 
#else
 
#include <Windows.h>
 
// Use the kernel32 variant of module enumeration functions so it can be safely called from 'DllMain'
extern "C" BOOL WINAPI K32EnumProcessModules(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
 
namespace reshade::internal
{
    inline HMODULE get_reshade_module_handle(HMODULE initial_handle = nullptr)
    {
        static HMODULE handle = initial_handle;
        if (handle == nullptr)
        {
            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;
    }
 
    inline HMODULE get_current_module_handle(HMODULE initial_handle = nullptr)
    {
        static HMODULE handle = initial_handle;
        return handle;
    }
}
 
#endif
 
namespace reshade
{
#if !defined(RESHADE_API_LIBRARY_EXPORT) || defined(BUILTIN_ADDON)
    namespace log
    {
        enum class level
        {
            error = 1,
            warning = 2,
            info = 3,
            debug = 4,
        };
 
        inline void message(level level, const char *message)
        {
#if defined(RESHADE_API_LIBRARY)
            ReShadeLogMessage(nullptr, static_cast<int>(level), message);
#else
            static const auto func = reinterpret_cast<void(*)(void *, int, const char *)>(
                GetProcAddress(internal::get_reshade_module_handle(), "ReShadeLogMessage"));
            func(internal::get_current_module_handle(), static_cast<int>(level), message);
#endif
        }
    }
#endif
 
    inline void get_reshade_base_path(char *path, size_t *path_size)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeGetBasePath(path, path_size);
#else
        static const auto func = reinterpret_cast<bool(*)(char *, size_t *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeGetBasePath"));
        func(path, path_size);
#endif
    }
 
    inline bool get_config_value(api::effect_runtime *runtime, const char *section, const char *key, char *value, size_t *value_size)
    {
#if defined(RESHADE_API_LIBRARY)
        return ReShadeGetConfigValue(nullptr, runtime, section, key, value, value_size);
#else
        static const auto func = reinterpret_cast<bool(*)(void *, api::effect_runtime *, const char *, const char *, char *, size_t *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeGetConfigValue"));
        return func(internal::get_current_module_handle(), runtime, section, key, value, value_size);
#endif
    }
#if _HAS_CXX17 || __cplusplus >= 201703L
    template <typename T>
    inline bool get_config_value(api::effect_runtime *runtime, const char *section, const char *key, T &value)
    {
        char value_string[32]; size_t value_length = sizeof(value_string) - 1;
        if (!get_config_value(runtime, section, key, value_string, &value_length))
            return false;
        return std::from_chars(value_string, value_string + value_length, value).ec == std::errc {};
    }
    template <>
    inline bool get_config_value<bool>(api::effect_runtime *runtime, const char *section, const char *key, bool &value)
    {
        int value_int = 0;
        if (!get_config_value<int>(runtime, section, key, value_int))
            return false;
        value = (value_int != 0);
        return true;
    }
#endif
 
    inline void set_config_value(api::effect_runtime *runtime, const char *section, const char *key, const char *value)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeSetConfigValue(nullptr, runtime, section, key, value);
#else
        static const auto func = reinterpret_cast<void(*)(void *, api::effect_runtime *, const char *, const char *, const char *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeSetConfigValue"));
        func(internal::get_current_module_handle(), runtime, section, key, value);
#endif
    }
#if _HAS_CXX17 || __cplusplus >= 201703L
    template <typename T>
    inline void set_config_value(api::effect_runtime *runtime, const char *section, const char *key, const T &value)
    {
        char value_string[32] = "";
        std::to_chars(value_string, value_string + sizeof(value_string) - 1, value);
        set_config_value(runtime, section, key, static_cast<const char *>(value_string));
    }
    template <>
    inline void set_config_value<bool>(api::effect_runtime *runtime, const char *section, const char *key, const bool &value)
    {
        set_config_value<int>(runtime, section, key, value ? 1 : 0);
    }
#endif
    inline void set_config_value(api::effect_runtime *runtime, const char *section, const char *key, const char *value, size_t value_size)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeSetConfigArray(nullptr, runtime, section, key, value, value_size);
#else
        static const auto func = reinterpret_cast<void(*)(void *, api::effect_runtime *, const char *, const char *, const char *, size_t)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeSetConfigArray"));
        func(internal::get_current_module_handle(), runtime, section, key, value, value_size);
#endif
    }
 
    inline bool register_addon(void *addon_module, [[maybe_unused]] void *reshade_module = nullptr)
    {
#if defined(RESHADE_API_LIBRARY)
        return ReShadeRegisterAddon(addon_module, RESHADE_API_VERSION);
#else
        addon_module = internal::get_current_module_handle(static_cast<HMODULE>(addon_module));
        reshade_module = internal::get_reshade_module_handle(static_cast<HMODULE>(reshade_module));
 
        if (reshade_module == nullptr)
            return false;
 
        const auto func = reinterpret_cast<bool(*)(void *, uint32_t)>(
            GetProcAddress(static_cast<HMODULE>(reshade_module), "ReShadeRegisterAddon"));
        // Check that the ReShade module supports the used API
        if (func == nullptr || !func(addon_module, RESHADE_API_VERSION))
            return false;
 
#if defined(IMGUI_VERSION_NUM)
        const auto imgui_func = reinterpret_cast<const imgui_function_table *(*)(uint32_t)>(
            GetProcAddress(static_cast<HMODULE>(reshade_module), "ReShadeGetImGuiFunctionTable"));
        // Check that the ReShade module was built with Dear ImGui support and supports the used version
        if (imgui_func == nullptr || !(imgui_function_table_instance() = imgui_func(IMGUI_VERSION_NUM)))
            return false;
#endif
 
        return true;
#endif
    }
    inline void unregister_addon(void *addon_module, [[maybe_unused]] void *reshade_module = nullptr)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeUnregisterAddon(addon_module);
#else
        addon_module = internal::get_current_module_handle(static_cast<HMODULE>(addon_module));
        reshade_module = internal::get_reshade_module_handle(static_cast<HMODULE>(reshade_module));
 
        if (reshade_module == nullptr)
            return;
 
        const auto func = reinterpret_cast<bool(*)(void *)>(
            GetProcAddress(static_cast<HMODULE>(reshade_module), "ReShadeUnregisterAddon"));
        if (func != nullptr)
            func(addon_module);
#endif
    }
 
    template <addon_event ev>
    inline void register_event(typename addon_event_traits<ev>::decl callback)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeRegisterEvent(ev, reinterpret_cast<void *>(callback));
#else
        static const auto func = reinterpret_cast<void(*)(addon_event, void *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeRegisterEvent"));
        if (func != nullptr)
            func(ev, reinterpret_cast<void *>(callback));
#endif
    }
    template <addon_event ev>
    inline void unregister_event(typename addon_event_traits<ev>::decl callback)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeUnregisterEvent(ev, reinterpret_cast<void *>(callback));
#else
        static const auto func = reinterpret_cast<void(*)(addon_event, void *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeUnregisterEvent"));
        if (func != nullptr)
            func(ev, reinterpret_cast<void *>(callback));
#endif
    }
 
    inline void register_overlay(const char *title, void(*callback)(api::effect_runtime *runtime))
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeRegisterOverlay(title, callback);
#else
        static const auto func = reinterpret_cast<void(*)(const char *, void(*)(api::effect_runtime *))>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeRegisterOverlay"));
        if (func != nullptr)
            func(title, callback);
#endif
    }
    inline void unregister_overlay(const char *title, void(*callback)(api::effect_runtime *runtime))
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeUnregisterOverlay(title, callback);
#else
        static const auto func = reinterpret_cast<void(*)(const char *, void(*)(api::effect_runtime *))>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeUnregisterOverlay"));
        if (func != nullptr)
            func(title, callback);
#endif
    }
 
    inline bool create_effect_runtime(reshade::api::device_api api, void *device, void *command_queue, void *swapchain, const char *config_path, reshade::api::effect_runtime **out_runtime)
    {
#if defined(RESHADE_API_LIBRARY)
        return ReShadeCreateEffectRuntime(api, device, command_queue, swapchain, config_path, out_runtime);
#else
        static const auto func = reinterpret_cast<bool(*)(reshade::api::device_api, void *, void *, void *, const char *, reshade::api::effect_runtime **)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeCreateEffectRuntime"));
        if (func == nullptr)
        {
            *out_runtime = nullptr;
            return false;
        }
        return func(api, device, command_queue, swapchain, config_path, out_runtime);
#endif
    }
    inline void destroy_effect_runtime(api::effect_runtime *runtime)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeDestroyEffectRuntime(runtime);
#else
        static const auto func = reinterpret_cast<void(*)(reshade::api::effect_runtime *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeDestroyEffectRuntime"));
        if (func != nullptr)
            func(runtime);
#endif
    }
    inline void update_and_present_effect_runtime(api::effect_runtime *runtime)
    {
#if defined(RESHADE_API_LIBRARY)
        ReShadeUpdateAndPresentEffectRuntime(runtime);
#else
        static const auto func = reinterpret_cast<void(*)(reshade::api::effect_runtime *)>(
            GetProcAddress(internal::get_reshade_module_handle(), "ReShadeUpdateAndPresentEffectRuntime"));
        if (func != nullptr)
            func(runtime);
#endif
    }
}