gbe_fork/overlay_experimental/Renderer_Detector.cpp

/*
 * Copyright (C) Nemirtingas
 * This file is part of the ingame overlay project
 *
 * The ingame overlay project is free software; you can redistribute it
 * and/or modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * The ingame overlay project is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the ingame overlay project; if not, see
 * <http://www.gnu.org/licenses/>.
 */

#include <cassert>

#include "Renderer_Detector.h"

#include "System/Encoding.hpp"
#include "System/String.hpp"
#include "System/System.h"
#include "System/Library.h"
#include "System/ScopedLock.hpp"
#define GLAD_GL_IMPLEMENTATION
#include <glad/gl.h>

#if defined(WIN64) || defined(_WIN64) || defined(__MINGW64__) \
 || defined(WIN32) || defined(_WIN32) || defined(__MINGW32__)
    #define RENDERERDETECTOR_OS_WINDOWS
  
    #include "windows/DX12_Hook.h"
    #include "windows/DX11_Hook.h"
    #include "windows/DX10_Hook.h"
    #include "windows/DX9_Hook.h"
    #include "windows/OpenGL_Hook.h"
    #include "windows/Vulkan_Hook.h"
  
    #include "windows/DirectX_VTables.h"
  
    #include <random>
  
    #ifdef GetModuleHandle
        #undef GetModuleHandle
    #endif

#elif defined(__linux__) || defined(linux)
    #define RENDERERDETECTOR_OS_LINUX

    #include "linux/OpenGLX_Hook.h"

#elif defined(__APPLE__)
    #define RENDERERDETECTOR_OS_APPLE

    #include "macosx/OpenGL_Hook.h"

#endif

class Renderer_Detector
{
    static Renderer_Detector* instance;
public:
    static Renderer_Detector* Inst()
    {
        if (instance == nullptr)
        {
            instance = new Renderer_Detector;
        }
        return instance;
    }

#if defined(RENDERERDETECTOR_OS_WINDOWS)
#define RENDERER_HOOKS { OpenGL_Hook::DLL_NAME, &Renderer_Detector::hook_opengl },\
                       { Vulkan_Hook::DLL_NAME, &Renderer_Detector::hook_vulkan },\
                       {   DX12_Hook::DLL_NAME, &Renderer_Detector::hook_dx12   },\
                       {   DX11_Hook::DLL_NAME, &Renderer_Detector::hook_dx11   },\
                       {   DX10_Hook::DLL_NAME, &Renderer_Detector::hook_dx10   },\
                       {    DX9_Hook::DLL_NAME, &Renderer_Detector::hook_dx9    },

    ~Renderer_Detector()
    {
        stop_detection();

        delete dx9_hook;
        delete dx10_hook;
        delete dx11_hook;
        delete dx12_hook;
        delete opengl_hook;
        delete vulkan_hook;

        instance = nullptr;
    }

private:

    decltype(&IDXGISwapChain::Present)       IDXGISwapChainPresent;
    decltype(&IDXGISwapChain1::Present1)     IDXGISwapChainPresent1;
    decltype(&IDirect3DDevice9::Present)     IDirect3DDevice9Present;
    decltype(&IDirect3DDevice9Ex::PresentEx) IDirect3DDevice9ExPresentEx;
    decltype(&IDirect3DSwapChain9::Present)  IDirect3DSwapChain9Present;
    decltype(::SwapBuffers)* wglSwapBuffers;
    decltype(::vkQueuePresentKHR)* vkQueuePresentKHR;

    bool dxgi_hooked;
    bool dxgi1_2_hooked;
    bool dx12_hooked;
    bool dx11_hooked;
    bool dx10_hooked;
    bool dx9_hooked;
    bool opengl_hooked;
    bool vulkan_hooked;

    DX12_Hook* dx12_hook;
    DX11_Hook* dx11_hook;
    DX10_Hook* dx10_hook;
    DX9_Hook* dx9_hook;
    OpenGL_Hook* opengl_hook;
    Vulkan_Hook* vulkan_hook;

    HWND dummyWindow = nullptr;
    std::wstring _WindowClassName;
    std::string _SystemDir;
    ATOM atom = 0;

    Renderer_Detector() :
        dxgi_hooked(false),
        dxgi1_2_hooked(false),
        dx12_hooked(false),
        dx11_hooked(false),
        dx10_hooked(false),
        dx9_hooked(false),
        opengl_hooked(false),
        vulkan_hooked(false),
        renderer_hook(nullptr),
        dx9_hook(nullptr),
        dx10_hook(nullptr),
        dx11_hook(nullptr),
        dx12_hook(nullptr),
        opengl_hook(nullptr),
        vulkan_hook(nullptr),
        detection_done(false),
        detection_count(0),
        detection_cancelled(false)
    {
        std::wstring tmp(4096, L'\0');
        tmp.resize(GetSystemDirectoryW(&tmp[0], tmp.size()));
        _SystemDir = System::Encoding::WCharToUtf8(tmp);

        System::String::ToLower(_SystemDir);

        wchar_t random_str[] = L"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        std::random_device rd;
        std::mt19937_64 gen(rd());

        std::uniform_int_distribution<uint64_t> dis(0, 61);
        _WindowClassName.resize(64);
        for (int i = 0; i < 64; ++i)
            _WindowClassName[i] = random_str[dis(gen)];
    }

    std::string FindPreferedModulePath(std::string const& name)
    {
        std::string res;
        std::string tmp;
        auto modules = System::GetModules();
        for (auto& item : modules)
        {
            tmp = System::String::CopyLower(item);
            if (tmp.length() >= name.length() && strcmp(tmp.c_str() + tmp.length() - name.length(), name.c_str()) == 0)
            {
                if (strncmp(tmp.c_str(), _SystemDir.c_str(), _SystemDir.length()) == 0)
                    return item;

                // I don't care which one is picked if we can't find a library in the system32 folder...
                res = std::move(item);
            }
        }

        return res;
    }

    HWND CreateHWND()
    {
        if (dummyWindow == nullptr)
        {
            HINSTANCE hInst = GetModuleHandleW(nullptr);
            if (atom == 0)
            {
                // Register a window class for creating our render window with.
                WNDCLASSEXW windowClass = {};

                windowClass.cbSize = sizeof(WNDCLASSEX);
                windowClass.style = CS_HREDRAW | CS_VREDRAW;
                windowClass.lpfnWndProc = DefWindowProc;
                windowClass.cbClsExtra = 0;
                windowClass.cbWndExtra = 0;
                windowClass.hInstance = hInst;
                windowClass.hIcon = NULL;
                windowClass.hCursor = ::LoadCursor(NULL, IDC_ARROW);
                windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
                windowClass.lpszMenuName = NULL;
                windowClass.lpszClassName = _WindowClassName.c_str();
                windowClass.hIconSm = NULL;

                atom = ::RegisterClassExW(&windowClass);
            }

            if (atom > 0)
            {
                dummyWindow = ::CreateWindowExW(
                    NULL,
                    _WindowClassName.c_str(),
                    L"",
                    WS_OVERLAPPEDWINDOW,
                    0,
                    0,
                    1,
                    1,
                    NULL,
                    NULL,
                    hInst,
                    nullptr
                );

                assert(dummyWindow && "Failed to create window");
            }
        }

        return dummyWindow;
    }

    void DestroyHWND()
    {
        if (dummyWindow != nullptr)
        {
            DestroyWindow(dummyWindow);
            UnregisterClassW(_WindowClassName.c_str(), GetModuleHandleW(nullptr));

            dummyWindow = nullptr;
            atom = 0;
        }
    }

    template<typename T>
    void HookDetected(T*& detected_renderer)
    {
        detection_hooks.UnhookAll();
        renderer_hook = static_cast<ingame_overlay::Renderer_Hook*>(detected_renderer);
        detected_renderer = nullptr;
        detection_done = true;
        DestroyHWND();
    }

    void DeduceDXVersionFromSwapChain(IDXGISwapChain* pSwapChain)
    {
        IUnknown* pDevice = nullptr;
        if (Inst()->dx12_hooked)
        {
            pSwapChain->GetDevice(IID_PPV_ARGS(reinterpret_cast<ID3D12Device**>(&pDevice)));
        }
        if (pDevice != nullptr)
        {
            HookDetected(dx12_hook);
        }
        else
        {
            if (dx11_hooked)
            {
                pSwapChain->GetDevice(IID_PPV_ARGS(reinterpret_cast<ID3D11Device**>(&pDevice)));
            }
            if (pDevice != nullptr)
            {
                HookDetected(dx11_hook);
            }
            else
            {
                if (dx10_hooked)
                {
                    pSwapChain->GetDevice(IID_PPV_ARGS(reinterpret_cast<ID3D10Device**>(&pDevice)));
                }
                if (pDevice != nullptr)
                {
                    HookDetected(dx10_hook);
                }
            }
        }
        if (pDevice != nullptr)
        {
            pDevice->Release();
        }
    }

    static HRESULT STDMETHODCALLTYPE MyIDXGISwapChain_Present(IDXGISwapChain* _this, UINT SyncInterval, UINT Flags)
    {
        auto inst = Inst();
        HRESULT res;
        bool locked;
        std::unique_lock<std::mutex> lk(inst->renderer_mutex, std::defer_lock);

        // It appears that (NVidia at least) calls IDXGISwapChain when calling OpenGL or Vulkan SwapBuffers.
        // So only lock when OpenGL or Vulkan hasn't already locked the mutex.
        locked = lk.try_lock();
        res = (_this->*inst->IDXGISwapChainPresent)(SyncInterval, Flags);
        if (!locked || inst->detection_done)
            return res;

        inst->DeduceDXVersionFromSwapChain(_this);

        return res;
    }

    static HRESULT STDMETHODCALLTYPE MyIDXGISwapChain_Present1(IDXGISwapChain1* _this, UINT SyncInterval, UINT Flags, const DXGI_PRESENT_PARAMETERS* pPresentParameters)
    {
        auto inst = Inst();
        HRESULT res;
        bool locked;
        std::unique_lock<std::mutex> lk(inst->renderer_mutex, std::defer_lock);

        // It appears that (NVidia at least) calls IDXGISwapChain when calling OpenGL or Vulkan SwapBuffers.
        // So only lock when OpenGL or Vulkan hasn't already locked the mutex.
        locked = lk.try_lock();
        res = (_this->*inst->IDXGISwapChainPresent1)(SyncInterval, Flags, pPresentParameters);
        if (!locked || inst->detection_done)
            return res;

        inst->DeduceDXVersionFromSwapChain(_this);

        return res;
    }

    static HRESULT STDMETHODCALLTYPE MyDX9Present(IDirect3DDevice9* _this, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);

        auto res = (_this->*inst->IDirect3DDevice9Present)(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
        if (inst->detection_done)
            return res;

        inst->HookDetected(inst->dx9_hook);

        return res;
    }

    static HRESULT STDMETHODCALLTYPE MyDX9PresentEx(IDirect3DDevice9Ex* _this, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);

        auto res = (_this->*inst->IDirect3DDevice9ExPresentEx)(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
        if (inst->detection_done)
            return res;

        inst->HookDetected(inst->dx9_hook);

        return res;
    }

    static HRESULT STDMETHODCALLTYPE MyDX9SwapChainPresent(IDirect3DSwapChain9* _this, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);

        auto res = (_this->*inst->IDirect3DSwapChain9Present)(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
        if (inst->detection_done)
            return res;

        inst->HookDetected(inst->dx9_hook);

        return res;
    }

    static BOOL WINAPI MywglSwapBuffers(HDC hDC)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);

        auto res = inst->wglSwapBuffers(hDC);
        if (inst->detection_done)
            return res;

        if (gladLoaderLoadGL() >= GLAD_MAKE_VERSION(3, 1))
        {
            inst->HookDetected(inst->opengl_hook);
        }

        return res;
    }

    static VkResult VKAPI_CALL MyvkQueuePresentKHR(VkQueue Queue, const VkPresentInfoKHR* pPresentInfo)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);

        auto res = inst->vkQueuePresentKHR(Queue, pPresentInfo);
        if (inst->detection_done)
            return res;

        inst->HookDetected(inst->vulkan_hook);

        return res;
    }

    void HookDXGIPresent(IDXGISwapChain* pSwapChain, decltype(&IDXGISwapChain::Present)& pfnPresent, decltype(&IDXGISwapChain::ResizeBuffers)& pfnResizeBuffers, decltype(&IDXGISwapChain::ResizeTarget)& pfnResizeTarget)
    {
        void** vTable = *reinterpret_cast<void***>(pSwapChain);
        (void*&)pfnPresent = vTable[(int)IDXGISwapChainVTable::Present];
        (void*&)pfnResizeBuffers = vTable[(int)IDXGISwapChainVTable::ResizeBuffers];
        (void*&)pfnResizeTarget = vTable[(int)IDXGISwapChainVTable::ResizeTarget];

        if (!dxgi_hooked)
        {
            dxgi_hooked = true;

            (void*&)IDXGISwapChainPresent = vTable[(int)IDXGISwapChainVTable::Present];
            detection_hooks.BeginHook();
            detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&IDXGISwapChainPresent, (void*)&MyIDXGISwapChain_Present});
            detection_hooks.EndHook();
        }
    }

    void HookDXGIPresent1(IDXGISwapChain1* pSwapChain1, decltype(&IDXGISwapChain1::Present1)& pfnPresent1)
    {
        void** vTable = *reinterpret_cast<void***>(pSwapChain1);
        (void*&)pfnPresent1 = vTable[(int)IDXGISwapChainVTable::Present1];

        if (!dxgi1_2_hooked)
        {
            dxgi1_2_hooked = true;

            (void*&)IDXGISwapChainPresent1 = vTable[(int)IDXGISwapChainVTable::Present1];
            detection_hooks.BeginHook();
            detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&IDXGISwapChainPresent1, (void*)&MyIDXGISwapChain_Present1});
            detection_hooks.EndHook();
        }
    }

    void HookDX9Present(IDirect3DDevice9* pDevice, bool ex, IDirect3DSwapChain9* pSwapChain,
        void*& pfnPresent,
        void*& pfnReset,
        void*& pfnPresentEx,
        void*& pfnSwapChainPresent)
    {
        void** vTable = *reinterpret_cast<void***>(pDevice);
        pfnPresent = vTable[(int)IDirect3DDevice9VTable::Present];
        pfnReset = vTable[(int)IDirect3DDevice9VTable::Reset];

        (void*&)IDirect3DDevice9Present = vTable[(int)IDirect3DDevice9VTable::Present];

        detection_hooks.BeginHook();
        detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&IDirect3DDevice9Present, (void*)&MyDX9Present });
        detection_hooks.EndHook();

        if (ex)
        {
            pfnPresentEx = vTable[(int)IDirect3DDevice9VTable::PresentEx];
            (void*&)IDirect3DDevice9ExPresentEx = vTable[(int)IDirect3DDevice9VTable::PresentEx];

            detection_hooks.BeginHook();
            detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&IDirect3DDevice9ExPresentEx, (void*)&MyDX9PresentEx });
            detection_hooks.EndHook();
        }
        else
        {
            pfnPresentEx = nullptr;
            IDirect3DDevice9ExPresentEx = nullptr;
        }

        if (pSwapChain != nullptr)
        {
            vTable = *reinterpret_cast<void***>(pSwapChain);
            pfnSwapChainPresent = vTable[(int)IDirect3DSwapChain9VTable::Present];
            (void*&)IDirect3DSwapChain9Present = vTable[(int)IDirect3DSwapChain9VTable::Present];

            detection_hooks.BeginHook();
            detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&IDirect3DSwapChain9Present, (void*)&MyDX9SwapChainPresent });
            detection_hooks.EndHook();
        }
        else
        {
            pfnSwapChainPresent = nullptr;
        }
    }

    void HookwglSwapBuffers(decltype(::SwapBuffers)* _wglSwapBuffers)
    {
        wglSwapBuffers = _wglSwapBuffers;

        detection_hooks.BeginHook();
        detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&wglSwapBuffers, (void*)&MywglSwapBuffers });
        detection_hooks.EndHook();
    }

    void HookvkQueuePresentKHR(decltype(::vkQueuePresentKHR)* _vkQueuePresentKHR)
    {
        vkQueuePresentKHR = _vkQueuePresentKHR;

        detection_hooks.BeginHook();
        detection_hooks.HookFuncs(
            std::pair<void**, void*>{ (void**)&vkQueuePresentKHR, (void*)&MyvkQueuePresentKHR }
        );
        detection_hooks.EndHook();
    }

    void hook_dx9(std::string const& library_path)
    {
        if (!dx9_hooked)
        {
            System::Library::Library libD3d9;
            if (!libD3d9.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect DX9", library_path);
                return;
            }

            IDirect3D9Ex* pD3D = nullptr;
            IDirect3DDevice9* pDevice = nullptr;
            IDirect3DSwapChain9* pSwapChain = nullptr;

            auto Direct3DCreate9Ex = libD3d9.GetSymbol<decltype(::Direct3DCreate9Ex)>("Direct3DCreate9Ex");

            D3DPRESENT_PARAMETERS params = {};
            params.BackBufferWidth = 1;
            params.BackBufferHeight = 1;
            params.hDeviceWindow = dummyWindow;
            params.BackBufferCount = 1;
            params.Windowed = TRUE;
            params.SwapEffect = D3DSWAPEFFECT_DISCARD;

            if (Direct3DCreate9Ex != nullptr)
            {
                Direct3DCreate9Ex(D3D_SDK_VERSION, &pD3D);
                pD3D->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &params, NULL, reinterpret_cast<IDirect3DDevice9Ex**>(&pDevice));
            }

            if (pDevice == nullptr)
            {
                Direct3DCreate9Ex = nullptr;
                auto Direct3DCreate9 = libD3d9.GetSymbol<decltype(::Direct3DCreate9)>("Direct3DCreate9");
                if (Direct3DCreate9 != nullptr)
                {
                    // D3DDEVTYPE_HAL
                    pD3D = reinterpret_cast<IDirect3D9Ex*>(Direct3DCreate9(D3D_SDK_VERSION));
                    pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &params, &pDevice);
                }
            }

            if (pDevice != nullptr)
            {
                SPDLOG_INFO("Hooked D3D9::Present to detect DX Version");

                dx9_hooked = true;

                pDevice->GetSwapChain(0, &pSwapChain);

                decltype(&IDirect3DDevice9::Present) pfnPresent;
                decltype(&IDirect3DDevice9::Reset) pfnReset;
                decltype(&IDirect3DDevice9Ex::PresentEx) pfnPresentEx;
                decltype(&IDirect3DSwapChain9::Present) pfnSwapChainPresent;

                HookDX9Present(pDevice, Direct3DCreate9Ex != nullptr, pSwapChain, (void*&)pfnPresent, (void*&)pfnReset, (void*&)pfnPresentEx, (void*&)pfnSwapChainPresent);

                dx9_hook = DX9_Hook::Inst();
                dx9_hook->LibraryName = library_path;
                dx9_hook->LoadFunctions(pfnPresent, pfnReset, pfnPresentEx, pfnSwapChainPresent);
            }
            else
            {
                SPDLOG_WARN("Failed to hook D3D9::Present to detect DX Version");
            }

            if (pSwapChain) pSwapChain->Release();
            if (pDevice) pDevice->Release();
            if (pD3D) pD3D->Release();
        }
    }

    void hook_dx10(std::string const& library_path)
    {
        if (!dx10_hooked)
        {
            System::Library::Library libD3d10;
            if (!libD3d10.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect DX10", library_path);
                return;
            }
            std::string dxgi_path = FindPreferedModulePath("dxgi.dll");

            IDXGISwapChain* pSwapChain = nullptr;
            ID3D10Device* pDevice = nullptr;
            int version = 0;

            if (!dxgi_path.empty())
            {
                HMODULE dxgi = GetModuleHandleA(dxgi_path.c_str());
                if (dxgi != nullptr)
                {
                    IDXGIFactory2* pDXGIFactory = nullptr;

                    auto D3D10CreateDevice = libD3d10.GetSymbol<decltype(::D3D10CreateDevice)>("D3D10CreateDevice");
                    decltype(CreateDXGIFactory1)* CreateDXGIFactory1 = (decltype(CreateDXGIFactory1))GetProcAddress(dxgi, "CreateDXGIFactory1");

                    if (D3D10CreateDevice != nullptr && CreateDXGIFactory1 != nullptr)
                    {
                        D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_NULL, NULL, 0, D3D10_SDK_VERSION, &pDevice);
                        if (pDevice != nullptr)
                        {
                            CreateDXGIFactory1(IID_PPV_ARGS(&pDXGIFactory));
                            if (pDXGIFactory != nullptr)
                            {
                                DXGI_SWAP_CHAIN_DESC1 SwapChainDesc = {};
                                SwapChainDesc.BufferCount = 2;
                                SwapChainDesc.Width = 1;
                                SwapChainDesc.Height = 1;
                                SwapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                                SwapChainDesc.Stereo = FALSE;
                                SwapChainDesc.SampleDesc = { 1, 0 };
                                SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                                SwapChainDesc.Scaling = DXGI_SCALING_NONE;
                                SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
                                SwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;

                                pDXGIFactory->CreateSwapChainForHwnd(pDevice, dummyWindow, &SwapChainDesc, NULL, NULL, reinterpret_cast<IDXGISwapChain1**>(&pSwapChain));
                            }
                        }
                    }

                    if (pDXGIFactory) pDXGIFactory->Release();
                }
            }

            if (pDevice != nullptr && pSwapChain != nullptr)
            {
                version = 1;
            }
            else
            {
                SPDLOG_WARN("Failed to instanciate IDXGISwapChain1, fallback to pure DX10 detection");

                auto D3D10CreateDeviceAndSwapChain = libD3d10.GetSymbol<decltype(::D3D10CreateDeviceAndSwapChain)>("D3D10CreateDeviceAndSwapChain");

                if (D3D10CreateDeviceAndSwapChain != nullptr)
                {
                    DXGI_SWAP_CHAIN_DESC SwapChainDesc = {};

                    SwapChainDesc.BufferCount = 1;
                    SwapChainDesc.BufferDesc.Width = 1;
                    SwapChainDesc.BufferDesc.Height = 1;
                    SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                    SwapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
                    SwapChainDesc.BufferDesc.RefreshRate.Denominator = 0;
                    SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                    SwapChainDesc.OutputWindow = dummyWindow;
                    SwapChainDesc.SampleDesc.Count = 1;
                    SwapChainDesc.SampleDesc.Quality = 0;
                    SwapChainDesc.Windowed = TRUE;

                    D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_NULL, NULL, 0, D3D10_SDK_VERSION, &SwapChainDesc, &pSwapChain, &pDevice);
                }
            }

            if (pSwapChain != nullptr)
            {
                SPDLOG_INFO("Hooked IDXGISwapChain::Present to detect DX Version");

                dx10_hooked = true;

                decltype(&IDXGISwapChain::Present) pfnPresent;
                decltype(&IDXGISwapChain::ResizeBuffers) pfnResizeBuffers;
                decltype(&IDXGISwapChain::ResizeTarget) pfnResizeTarget;
                decltype(&IDXGISwapChain1::Present1) pfnPresent1 = nullptr;

                HookDXGIPresent(pSwapChain, pfnPresent, pfnResizeBuffers, pfnResizeTarget);
                if (version > 0)
                {
                    HookDXGIPresent1(reinterpret_cast<IDXGISwapChain1*>(pSwapChain), pfnPresent1);
                }

                dx10_hook = DX10_Hook::Inst();
                dx10_hook->LibraryName = library_path;
                dx10_hook->LoadFunctions(pfnPresent, pfnResizeBuffers, pfnResizeTarget, pfnPresent1);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook IDXGISwapChain::Present to detect DX Version");
            }
            if (pDevice)pDevice->Release();
            if (pSwapChain)pSwapChain->Release();
        }
    }

    void hook_dx11(std::string const& library_path)
    {
        if (!dx11_hooked)
        {
            System::Library::Library libD3d11;
            if (!libD3d11.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect DX11", library_path);
                return;
            }
            std::string dxgi_path = FindPreferedModulePath("dxgi.dll");

            IDXGISwapChain* pSwapChain = nullptr;
            ID3D11Device* pDevice = nullptr;
            int version = 0;

            if (!dxgi_path.empty())
            {
                HMODULE dxgi = GetModuleHandleA(dxgi_path.c_str());
                if (dxgi != nullptr)
                {
                    IDXGIFactory2* pDXGIFactory = nullptr;

                    auto D3D11CreateDevice = libD3d11.GetSymbol<decltype(::D3D11CreateDevice)>("D3D11CreateDevice");
                    decltype(CreateDXGIFactory1)* CreateDXGIFactory1 = (decltype(CreateDXGIFactory1))GetProcAddress(dxgi, "CreateDXGIFactory1");

                    if (D3D11CreateDevice != nullptr && CreateDXGIFactory1 != nullptr)
                    {
                        D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_NULL, NULL, 0, NULL, 0, D3D11_SDK_VERSION, &pDevice, NULL, NULL);
                        if (pDevice != nullptr)
                        {
                            CreateDXGIFactory1(IID_PPV_ARGS(&pDXGIFactory));
                            if (pDXGIFactory != nullptr)
                            {
                                DXGI_SWAP_CHAIN_DESC1 SwapChainDesc = {};
                                SwapChainDesc.BufferCount = 2;
                                SwapChainDesc.Width = 1;
                                SwapChainDesc.Height = 1;
                                SwapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                                SwapChainDesc.Stereo = FALSE;
                                SwapChainDesc.SampleDesc = { 1, 0 };
                                SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                                SwapChainDesc.Scaling = DXGI_SCALING_NONE;
                                SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
                                SwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;

                                pDXGIFactory->CreateSwapChainForHwnd(pDevice, dummyWindow, &SwapChainDesc, NULL, NULL, reinterpret_cast<IDXGISwapChain1**>(&pSwapChain));
                            }
                        }
                    }

                    if (pDXGIFactory) pDXGIFactory->Release();
                }
            }

            if (pDevice != nullptr && pSwapChain != nullptr)
            {
                version = 1;
            }
            else
            {
                SPDLOG_WARN("Failed to instanciate IDXGISwapChain1, fallback to pure DX11 detection");

                auto D3D11CreateDeviceAndSwapChain = libD3d11.GetSymbol<decltype(::D3D11CreateDeviceAndSwapChain)>("D3D11CreateDeviceAndSwapChain");

                if (D3D11CreateDeviceAndSwapChain != nullptr)
                {
                    DXGI_SWAP_CHAIN_DESC SwapChainDesc = {};

                    SwapChainDesc.BufferCount = 1;
                    SwapChainDesc.BufferDesc.Width = 1;
                    SwapChainDesc.BufferDesc.Height = 1;
                    SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                    SwapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
                    SwapChainDesc.BufferDesc.RefreshRate.Denominator = 0;
                    SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                    SwapChainDesc.OutputWindow = dummyWindow;
                    SwapChainDesc.SampleDesc.Count = 1;
                    SwapChainDesc.SampleDesc.Quality = 0;
                    SwapChainDesc.Windowed = TRUE;

                    D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_NULL, NULL, 0, NULL, NULL, D3D11_SDK_VERSION, &SwapChainDesc, &pSwapChain, &pDevice, NULL, NULL);
                }
            }

            if (pSwapChain != nullptr)
            {
                SPDLOG_INFO("Hooked IDXGISwapChain::Present to detect DX Version");

                dx11_hooked = true;

                decltype(&IDXGISwapChain::Present) pfnPresent = nullptr;
                decltype(&IDXGISwapChain::ResizeBuffers) pfnResizeBuffers = nullptr;
                decltype(&IDXGISwapChain::ResizeTarget) pfnResizeTarget = nullptr;
                decltype(&IDXGISwapChain1::Present1) pfnPresent1 = nullptr;

                HookDXGIPresent(pSwapChain, pfnPresent, pfnResizeBuffers, pfnResizeTarget);
                if (version > 0)
                {
                    HookDXGIPresent1(reinterpret_cast<IDXGISwapChain1*>(pSwapChain), pfnPresent1);
                }

                dx11_hook = DX11_Hook::Inst();
                dx11_hook->LibraryName = library_path;
                dx11_hook->LoadFunctions(pfnPresent, pfnResizeBuffers, pfnResizeTarget, pfnPresent1);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook IDXGISwapChain::Present to detect DX Version");
            }

            if (pDevice) pDevice->Release();
            if (pSwapChain) pSwapChain->Release();
        }
    }

    void hook_dx12(std::string const& library_path)
    {
        if (!dx12_hooked)
        {
            System::Library::Library libD3d12;
            if (!libD3d12.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect DX12", library_path);
                return;
            }
            std::string dxgi_path = FindPreferedModulePath("dxgi.dll");
            if (dxgi_path.empty())
            {
                SPDLOG_WARN("Failed to load dxgi.dll to detect DX12");
                return;
            }

            IDXGIFactory4* pDXGIFactory = nullptr;
            IDXGISwapChain1* pSwapChain = nullptr;
            ID3D12CommandQueue* pCommandQueue = nullptr;
            ID3D12Device* pDevice = nullptr;

            auto D3D12CreateDevice = libD3d12.GetSymbol<decltype(::D3D12CreateDevice)>("D3D12CreateDevice");

            if (D3D12CreateDevice != nullptr)
            {
                D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&pDevice));

                if (pDevice != nullptr)
                {
                    DXGI_SWAP_CHAIN_DESC1 SwapChainDesc = {};
                    SwapChainDesc.BufferCount = 2;
                    SwapChainDesc.Width = 1;
                    SwapChainDesc.Height = 1;
                    SwapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                    SwapChainDesc.Stereo = FALSE;
                    SwapChainDesc.SampleDesc = { 1, 0 };
                    SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                    SwapChainDesc.Scaling = DXGI_SCALING_NONE;
                    SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
                    SwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;

                    D3D12_COMMAND_QUEUE_DESC queueDesc = {};
                    queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
                    queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
                    pDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&pCommandQueue));

                    if (pCommandQueue != nullptr)
                    {
                        HMODULE dxgi = GetModuleHandleA(dxgi_path.c_str());
                        if (dxgi != nullptr)
                        {
                            decltype(CreateDXGIFactory1)* CreateDXGIFactory1 = (decltype(CreateDXGIFactory1))GetProcAddress(dxgi, "CreateDXGIFactory1");
                            if (CreateDXGIFactory1 != nullptr)
                            {
                                CreateDXGIFactory1(IID_PPV_ARGS(&pDXGIFactory));
                                if (pDXGIFactory != nullptr)
                                {
                                    pDXGIFactory->CreateSwapChainForHwnd(pCommandQueue, dummyWindow, &SwapChainDesc, NULL, NULL, &pSwapChain);
                                }
                            }
                        }
                    }
                }//if (pDevice != nullptr)
            }//if (D3D12CreateDevice != nullptr)

            if (pCommandQueue != nullptr && pSwapChain != nullptr)
            {
                SPDLOG_INFO("Hooked IDXGISwapChain::Present to detect DX Version");

                dx12_hooked = true;

                decltype(&IDXGISwapChain::Present) pfnPresent = nullptr;
                decltype(&IDXGISwapChain::ResizeBuffers) pfnResizeBuffers = nullptr;
                decltype(&IDXGISwapChain::ResizeTarget) pfnResizeTarget = nullptr;
                decltype(&IDXGISwapChain1::Present1) pfnPresent1 = nullptr;

                HookDXGIPresent(pSwapChain, pfnPresent, pfnResizeBuffers, pfnResizeTarget);
                HookDXGIPresent1(reinterpret_cast<IDXGISwapChain1*>(pSwapChain), pfnPresent1);

                void** vTable = *reinterpret_cast<void***>(pCommandQueue);
                decltype(&ID3D12CommandQueue::ExecuteCommandLists) pfnExecuteCommandLists;
                (void*&)pfnExecuteCommandLists = vTable[(int)ID3D12CommandQueueVTable::ExecuteCommandLists];

                dx12_hook = DX12_Hook::Inst();
                dx12_hook->LibraryName = library_path;
                dx12_hook->LoadFunctions(pfnPresent, pfnResizeBuffers, pfnResizeTarget, pfnExecuteCommandLists, pfnPresent1);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook IDXGISwapChain::Present to detect DX Version");
            }

            if (pSwapChain) pSwapChain->Release();
            if (pDXGIFactory) pDXGIFactory->Release();
            if (pCommandQueue) pCommandQueue->Release();
            if (pDevice) pDevice->Release();
        }
    }

    void hook_opengl(std::string const& library_path)
    {
        if (!opengl_hooked)
        {
            System::Library::Library libOpenGL;
            if (!libOpenGL.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect OpenGL", library_path);
                return;
            }

            auto wglSwapBuffers = libOpenGL.GetSymbol<decltype(::SwapBuffers)>("wglSwapBuffers");
            if (wglSwapBuffers != nullptr)
            {
                SPDLOG_INFO("Hooked wglSwapBuffers to detect OpenGL");

                opengl_hooked = true;

                opengl_hook = OpenGL_Hook::Inst();
                opengl_hook->LibraryName = library_path;
                opengl_hook->LoadFunctions(wglSwapBuffers);

                HookwglSwapBuffers(wglSwapBuffers);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook wglSwapBuffers to detect OpenGL");
            }
        }
    }

    void hook_vulkan(std::string const& library_path)
    {
        // Vulkan hook disabled until proper implementation.
        return;
        if (!vulkan_hooked)
        {
            System::Library::Library libVulkan;
            if (!libVulkan.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect Vulkan", library_path);
                return;
            }

            auto vkCreateInstance = libVulkan.GetSymbol<decltype(::vkCreateInstance)>("vkCreateInstance");
            auto vkDestroyInstance = libVulkan.GetSymbol<decltype(::vkDestroyInstance)>("vkDestroyInstance");
            auto vkGetInstanceProcAddr = libVulkan.GetSymbol<decltype(::vkGetInstanceProcAddr)>("vkGetInstanceProcAddr");

            decltype(::vkQueuePresentKHR)* vkQueuePresentKHR = nullptr;
            decltype(::vkAcquireNextImageKHR)* vkAcquireNextImageKHR = nullptr;
            decltype(::vkAcquireNextImage2KHR)* vkAcquireNextImage2KHR = nullptr;

            VkInstanceCreateInfo instance_infos{};
            VkInstance instance{};
            std::vector<VkPhysicalDevice> phyDevices;
            VkDeviceCreateInfo create_info{};
            VkDevice pDevice{};
            uint32_t count = 0;

            instance_infos.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
            vkCreateInstance(&instance_infos, nullptr, &instance);

            auto vkCreateDevice = (decltype(::vkCreateDevice)*)vkGetInstanceProcAddr(instance, "vkCreateDevice");
            auto vkDestroyDevice = (decltype(::vkDestroyDevice)*)vkGetInstanceProcAddr(instance, "vkDestroyDevice");
            auto vkGetDeviceProcAddr = (decltype(::vkGetDeviceProcAddr)*)vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr");
            auto vkEnumeratePhysicalDevices = (decltype(::vkEnumeratePhysicalDevices)*)vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices");
            auto vkEnumerateDeviceExtensionProperties = (decltype(::vkEnumerateDeviceExtensionProperties)*)vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties");
            auto vkGetPhysicalDeviceProperties = (decltype(::vkGetPhysicalDeviceProperties)*)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties");

            vkEnumeratePhysicalDevices(instance, &count, nullptr);
            phyDevices.resize(count);
            vkEnumeratePhysicalDevices(instance, &count, phyDevices.data());

            [&]()
            {// Lambda for nested for break.
                VkPhysicalDeviceProperties props{};
                std::vector<VkExtensionProperties> ext_props;

                for (auto& device : phyDevices)
                {
                    vkGetPhysicalDeviceProperties(device, &props);
                    if (props.deviceType == VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU || props.deviceType == VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU)
                    {
                        count = 0;
                        vkEnumerateDeviceExtensionProperties(device, nullptr, &count, nullptr);
                        ext_props.resize(count);
                        vkEnumerateDeviceExtensionProperties(device, nullptr, &count, ext_props.data());

                        for (auto& ext : ext_props)
                        {
                            if (strcmp(ext.extensionName, "VK_KHR_swapchain") == 0)
                            {
                                create_info.sType = VkStructureType::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
                                create_info.enabledExtensionCount = 1;
                                const char* str = "VK_KHR_swapchain";
                                create_info.ppEnabledExtensionNames = &str;
                                vkCreateDevice(device, &create_info, nullptr, &pDevice);
                                if (pDevice != nullptr)
                                    return;
                            }
                        }
                    }
                }
            }();

            if (pDevice != nullptr)
            {
                vkQueuePresentKHR = (decltype(::vkQueuePresentKHR)*)vkGetDeviceProcAddr(pDevice, "vkQueuePresentKHR");
                vkAcquireNextImageKHR = (decltype(::vkAcquireNextImageKHR)*)vkGetDeviceProcAddr(pDevice, "vkAcquireNextImageKHR");
                vkAcquireNextImage2KHR = (decltype(::vkAcquireNextImage2KHR)*)vkGetDeviceProcAddr(pDevice, "vkAcquireNextImage2KHR");
                vkDestroyDevice(pDevice, nullptr);
            }
            vkDestroyInstance(instance, nullptr);

            if (vkQueuePresentKHR != nullptr /* && (vkAcquireNextImageKHR != nullptr || vkAcquireNextImage2KHR != nullptr)*/)
            {
                SPDLOG_INFO("Hooked vkQueuePresentKHR to detect Vulkan");

                vulkan_hooked = true;

                vulkan_hook = Vulkan_Hook::Inst();
                vulkan_hook->LibraryName = library_path;
                vulkan_hook->LoadFunctions(vkQueuePresentKHR);

                HookvkQueuePresentKHR(vkQueuePresentKHR);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook vkQueuePresentKHR to detect Vulkan");
            }
        }
    }

    bool EnterDetection()
    {
        return CreateHWND() != nullptr;
    }

    void ExitDetection()
    {
        DestroyHWND();

        detection_done = true;
        detection_hooks.UnhookAll();

        dxgi_hooked    = false;
        dxgi1_2_hooked = false;
        dx12_hooked    = false;
        dx11_hooked    = false;
        dx10_hooked    = false;
        dx9_hooked     = false;
        opengl_hooked  = false;
        vulkan_hooked  = false;

        delete dx9_hook   ; dx9_hook    = nullptr;
        delete dx10_hook  ; dx10_hook   = nullptr;
        delete dx11_hook  ; dx11_hook   = nullptr;
        delete dx12_hook  ; dx12_hook   = nullptr;
        delete opengl_hook; opengl_hook = nullptr;
        delete vulkan_hook; vulkan_hook = nullptr;
    }

#elif defined(RENDERERDETECTOR_OS_LINUX)
#define RENDERER_HOOKS { OpenGLX_Hook::DLL_NAME, &Renderer_Detector::hook_openglx },

    ~Renderer_Detector()
    {
        stop_detection();

        delete openglx_hook;
        //delete vulkan_hook;

        instance = nullptr;
    }

private:
    decltype(::glXSwapBuffers)* glXSwapBuffers;

    bool openglx_hooked;
    //bool vulkan_hooked;

    OpenGLX_Hook* openglx_hook;
    //Vulkan_Hook* vulkan_hook;

    Renderer_Detector() :
        openglx_hooked(false),
        renderer_hook(nullptr),
        openglx_hook(nullptr),
        //vulkan_hook(nullptr),
        detection_done(false),
        detection_count(0),
        detection_cancelled(false)
    {}

    std::string FindPreferedModulePath(std::string const& name)
    {
        return name;
    }

    static void MyglXSwapBuffers(Display* dpy, GLXDrawable drawable)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);
        inst->glXSwapBuffers(dpy, drawable);
        if (inst->detection_done)
            return;

        if (gladLoaderLoadGL() >= GLAD_MAKE_VERSION(3, 1))
        {
            inst->detection_hooks.UnhookAll();
            inst->renderer_hook = static_cast<ingame_overlay::Renderer_Hook*>(Inst()->openglx_hook);
            inst->openglx_hook = nullptr;
            inst->detection_done = true;
        }
    }

    void HookglXSwapBuffers(decltype(::glXSwapBuffers)* _glXSwapBuffers)
    {
        glXSwapBuffers = _glXSwapBuffers;

        detection_hooks.BeginHook();
        detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&glXSwapBuffers, (void*)&MyglXSwapBuffers });
        detection_hooks.EndHook();
    }

    void hook_openglx(std::string const& library_path)
    {
        if (!openglx_hooked)
        {
            System::Library::Library libGLX;
            if (!libGLX.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect OpenGLX", library_path);
                return;
            }

            auto glXSwapBuffers = libGLX.GetSymbol<decltype(::glXSwapBuffers)>("glXSwapBuffers");
            if (glXSwapBuffers != nullptr)
            {
                SPDLOG_INFO("Hooked glXSwapBuffers to detect OpenGLX");

                openglx_hooked = true;

                openglx_hook = OpenGLX_Hook::Inst();
                openglx_hook->LibraryName = library_path;
                openglx_hook->LoadFunctions(glXSwapBuffers);

                HookglXSwapBuffers(glXSwapBuffers);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook glXSwapBuffers to detect OpenGLX");
            }
        }
    }

    bool EnterDetection()
    {
        return true;
    }

    void ExitDetection()
    {
        detection_done = true;
        detection_hooks.UnhookAll();

        openglx_hooked = false;
        //vulkan_hooked = false;

        delete openglx_hook; openglx_hook = nullptr;
        //delete vulkan_hook; vulkan_hook = nullptr;
    }

#elif defined(RENDERERDETECTOR_OS_APPLE)
#define RENDERER_HOOKS { OpenGL_Hook::DLL_NAME, & Renderer_Detector::hook_opengl },

    ~Renderer_Detector()
    {
        stop_detection();

        delete opengl_hook;

        instance = nullptr;
    }

private:
    decltype(::CGLFlushDrawable)* CGLFlushDrawable;

    bool opengl_hooked;
    //bool metal_hooked;

    OpenGL_Hook* opengl_hook;
    //Metal_Hook* metal_hook;

    Renderer_Detector() :
        opengl_hooked(false),
        renderer_hook(nullptr),
        opengl_hook(nullptr),
        detection_done(false),
        detection_count(0),
        detection_cancelled(false)
    {}

    std::string FindPreferedModulePath(std::string const& name)
    {
        return name;
    }

    static int64_t MyCGLFlushDrawable(CGLDrawable_t* glDrawable)
    {
        auto inst = Inst();
        std::lock_guard<std::mutex> lk(inst->renderer_mutex);
        int64_t res = inst->CGLFlushDrawable(glDrawable);

        if (gladLoaderLoadGL() >= GLAD_MAKE_VERSION(2, 0))
        {
            inst->detection_hooks.UnhookAll();
            inst->renderer_hook = static_cast<ingame_overlay::Renderer_Hook*>(Inst()->opengl_hook);
            inst->opengl_hook = nullptr;
            inst->detection_done = true;
        }

        return res;
    }

    void HookglFlushDrawable(decltype(::CGLFlushDrawable)* _CGLFlushDrawable)
    {
        CGLFlushDrawable = _CGLFlushDrawable;

        detection_hooks.BeginHook();
        detection_hooks.HookFunc(std::pair<void**, void*>{ (void**)&CGLFlushDrawable, (void*)&MyCGLFlushDrawable });
        detection_hooks.EndHook();
    }

    void hook_opengl(std::string const& library_path)
    {
        if (!opengl_hooked)
        {
            System::Library::Library libOpenGL;
            if (!libOpenGL.OpenLibrary(library_path, false))
            {
                SPDLOG_WARN("Failed to load {} to detect OpenGL", library_path);
                return;
            }

            auto CGLFlushDrawable = libOpenGL.GetSymbol<decltype(::CGLFlushDrawable)>("CGLFlushDrawable");
            if (CGLFlushDrawable != nullptr)
            {
                SPDLOG_INFO("Hooked CGLFlushDrawable to detect OpenGL");

                opengl_hooked = true;

                opengl_hook = OpenGL_Hook::Inst();
                opengl_hook->LibraryName = library_path;
                opengl_hook->LoadFunctions(CGLFlushDrawable);

                HookglFlushDrawable(CGLFlushDrawable);
            }
            else
            {
                SPDLOG_WARN("Failed to Hook CGLFlushDrawable to detect OpenGL");
            }
        }
    }

    bool EnterDetection()
    {
        return true;
    }

    void ExitDetection()
    {
        detection_done = true;
        detection_hooks.UnhookAll();

        opengl_hooked = false;
        //metal_hooked = false;

        delete opengl_hook; opengl_hook = nullptr;
        //delete metal_hook; metal_hook = nullptr;
    }

#endif

private:
    std::timed_mutex detector_mutex;
    std::mutex renderer_mutex;

    Base_Hook detection_hooks;
    ingame_overlay::Renderer_Hook* renderer_hook;
    
    bool detection_done;
    uint32_t detection_count;
    bool detection_cancelled;
    std::condition_variable stop_detection_cv;
    std::mutex stop_detection_mutex;

public:
    std::future<ingame_overlay::Renderer_Hook*> detect_renderer(std::chrono::milliseconds timeout)
    {
        std::lock_guard<std::mutex> lk(stop_detection_mutex);

        if (detection_count == 0)
        {// If we have no detections in progress, restart detection.
            detection_cancelled = false;
        }

        ++detection_count;

        return std::async(std::launch::async, [this, timeout]() -> ingame_overlay::Renderer_Hook*
        {
            std::unique_lock<std::timed_mutex> detection_lock(detector_mutex, std::defer_lock);
            constexpr std::chrono::milliseconds infinite_timeout{ -1 };
        
            if (!detection_lock.try_lock_for(timeout))
                return nullptr;

            bool cancel = false;
            {
                System::scoped_lock lk(renderer_mutex, stop_detection_mutex);

                if (!detection_cancelled)
                {
                    if (detection_done)
                    {
                        if (renderer_hook == nullptr)
                        {// Renderer detection was run but we didn't find it, restart the detection
                            detection_done = false;
                        }
                        else
                        {// Renderer already detected, cancel detection and return the renderer.
                            cancel = true;
                        }
                    }

                    if (!EnterDetection())
                        cancel = true;
                }
                else
                {// Detection was cancelled, cancel this detection
                    cancel = true;
                }
            }

            if (cancel)
            {
                --detection_count;
                stop_detection_cv.notify_all();
                return renderer_hook;
            }

            SPDLOG_TRACE("Started renderer detection.");

            std::pair<std::string, void(Renderer_Detector::*)(std::string const&)> libraries[]{
                RENDERER_HOOKS
            };
            std::string name;

            auto start_time = std::chrono::steady_clock::now();
            do
            {
                std::unique_lock<std::mutex> lck(stop_detection_mutex);
                if (detection_cancelled || detection_done)
                    break;

                for (auto const& library : libraries)
                {
                    std::string lib_path = FindPreferedModulePath(library.first);
                    if (!lib_path.empty())
                    {
                        void* lib_handle = System::Library::GetLibraryHandle(lib_path.c_str());
                        if (lib_handle != nullptr)
                        {
                            std::lock_guard<std::mutex> lk(renderer_mutex);
                            (this->*library.second)(System::Library::GetLibraryPath(lib_handle));
                        }
                    }
                }

                stop_detection_cv.wait_for(lck, std::chrono::milliseconds{ 100 });
            } while (timeout == infinite_timeout || (std::chrono::steady_clock::now() - start_time) <= timeout);

            {
                System::scoped_lock lk(renderer_mutex, stop_detection_mutex);
                
                ExitDetection();

                --detection_count;
            }
            stop_detection_cv.notify_all();

            SPDLOG_TRACE("Renderer detection done {}.", (void*)renderer_hook);

            return renderer_hook;
        });
    }

    void stop_detection()
    {
        {
            std::lock_guard<std::mutex> lk(stop_detection_mutex);
            if (detection_count == 0)
                return;
        }
        {
            System::scoped_lock lk(renderer_mutex, stop_detection_mutex);
            detection_cancelled = true;
        }
        stop_detection_cv.notify_all();
        {
            std::unique_lock<std::mutex> lk(stop_detection_mutex);
            stop_detection_cv.wait(lk, [&]() { return detection_count == 0; });
        }
    }
};

Renderer_Detector* Renderer_Detector::instance = nullptr;

namespace ingame_overlay {

std::future<ingame_overlay::Renderer_Hook*> DetectRenderer(std::chrono::milliseconds timeout)
{
    return Renderer_Detector::Inst()->detect_renderer(timeout);
}

void StopRendererDetection()
{
    Renderer_Detector::Inst()->stop_detection();
}

void FreeDetector()
{
    delete Renderer_Detector::Inst();
}

}