Archives/goldberg_emulator
2
0
Fork 0
mirror of https://gitlab.com/Mr_Goldberg/goldberg_emulator.git synced 2024-11-09 01:10:34 +00:00
Code Issues Projects Releases Wiki Activity
cd8c5fc2ea
goldberg_emulator/overlay_experimental/Hook_Manager.cpp

496 lines
16 KiB
C++
Raw Normal View History

Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
#include "../dll/dll.h"
#include "Hook_Manager.h"
Created a define to not compile overlay.
2019-08-14 13:09:57 +00:00
#ifndef NO_OVERLAY
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
#include "../detours/detours.h"
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#ifdef STEAM_WIN32
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
#include "DX12_Hook.h"
#include "DX11_Hook.h"
#include "DX10_Hook.h"
#include "DX9_Hook.h"
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
#include "Windows_Hook.h"
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#endif
Added opengl hook
2019-07-31 20:19:44 +00:00
#include "OpenGL_Hook.h"
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
#include <algorithm>
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
constexpr int max_hook_retries = 500;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#ifdef STEAM_WIN32
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
static decltype(&IDXGISwapChain::Present) _IDXGISwapChain_Present;
static decltype(&IDirect3DDevice9::Present) _IDirect3DDevice9_Present;
static decltype(&IDirect3DDevice9Ex::PresentEx) _IDirect3DDevice9Ex_PresentEx;
static decltype(wglMakeCurrent)* _wglMakeCurrent;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
HRESULT STDMETHODCALLTYPE Hook_Manager::MyIDXGISwapChain_Present(IDXGISwapChain* _this, UINT SyncInterval, UINT Flags)
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
Hook_Manager& inst = Hook_Manager::Inst();
if (!inst.stop_retry())
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
{
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
IUnknown* pDevice = nullptr;
_this->GetDevice(__uuidof(ID3D10Device), (void**)&pDevice);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
if (pDevice)
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
DX10_Hook* hook = DX10_Hook::Inst();
if (hook->start_hook())
inst.AddHook(hook);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
else
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
_this->GetDevice(__uuidof(ID3D11Device), (void**)& pDevice);
if (pDevice)
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
DX11_Hook* hook = DX11_Hook::Inst();
if (hook->start_hook())
inst.AddHook(hook);
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
}
else
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
_this->GetDevice(__uuidof(ID3D12Device), (void**)& pDevice);
Partially working DX12 overlay DX12 hook seems ok, there are some bugs remaining. ImGui setup for DX12 doesn't work.
2019-08-19 16:56:15 +00:00
if (pDevice)
{
// DX12_Hook* hook = DX12_Hook::Inst();
// if (hook->start_hook())
// inst.AddHook(hook);
}
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
}
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
if (pDevice) pDevice->Release();
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
return (_this->*_IDXGISwapChain_Present)(SyncInterval, Flags);
}
HRESULT STDMETHODCALLTYPE Hook_Manager::MyPresent(IDirect3DDevice9* _this, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion)
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
Hook_Manager& inst = Hook_Manager::Inst();
if (!inst.stop_retry())
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
DX9_Hook* hook = DX9_Hook::Inst();
if (hook->start_hook())
inst.AddHook(hook);
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
}
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
return (_this->*_IDirect3DDevice9_Present)(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}
HRESULT STDMETHODCALLTYPE Hook_Manager::MyPresentEx(IDirect3DDevice9Ex* _this, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags)
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
Hook_Manager& inst = Hook_Manager::Inst();
if (!inst.stop_retry())
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
DX9_Hook* hook = DX9_Hook::Inst();
if (hook->start_hook())
inst.AddHook(hook);
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
}
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
return (_this->*_IDirect3DDevice9Ex_PresentEx)(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
}
BOOL WINAPI Hook_Manager::MywglMakeCurrent(HDC hDC, HGLRC hGLRC)
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
Hook_Manager& inst = Hook_Manager::Inst();
if (!inst.stop_retry())
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
{
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
OpenGL_Hook* hook = OpenGL_Hook::Inst();
if (hook->start_hook())
inst.AddHook(hook);
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
}
return _wglMakeCurrent(hDC, hGLRC);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
void Hook_Manager::HookDXGIPresent()
{
if (!_dxgi_hooked)
{
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
_dxgi_hooked = true;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
rendererdetect_hook->BeginHook();
rendererdetect_hook->HookFuncs(
std::pair<void**, void*>((PVOID*)& _IDXGISwapChain_Present, &Hook_Manager::MyIDXGISwapChain_Present)
);
rendererdetect_hook->EndHook();
}
}
void Hook_Manager::HookDX9Present()
{
if (!_dx9_hooked)
{
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
_dx9_hooked = true;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
rendererdetect_hook->BeginHook();
rendererdetect_hook->HookFuncs(
std::pair<void**, void*>((PVOID*)& _IDirect3DDevice9_Present, &Hook_Manager::MyPresent),
std::pair<void**, void*>((PVOID*)& _IDirect3DDevice9Ex_PresentEx, &Hook_Manager::MyPresentEx)
);
rendererdetect_hook->EndHook();
}
}
void Hook_Manager::HookwglMakeCurrent()
{
if (!_ogl_hooked)
{
Added error handling when hook fails
2019-08-16 17:10:12 +00:00
_ogl_hooked = true;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
rendererdetect_hook->BeginHook();
rendererdetect_hook->HookFuncs(
std::pair<void**, void*>((PVOID*)& _wglMakeCurrent, &Hook_Manager::MywglMakeCurrent)
);
rendererdetect_hook->EndHook();
}
}
void Hook_Manager::hook_dx9()
{
if (!_dx9_hooked && !_renderer_found)
{
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
HWND hWnd = GetGameWindow();
if (!hWnd)
return;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
IDirect3D9Ex* pD3D;
IDirect3DDevice9Ex* pDeviceEx;
decltype(Direct3DCreate9Ex)* Direct3DCreate9Ex = (decltype(Direct3DCreate9Ex))GetProcAddress(GetModuleHandle(DX9_Hook::DLL_NAME), "Direct3DCreate9Ex");
Direct3DCreate9Ex(D3D_SDK_VERSION, &pD3D);
D3DPRESENT_PARAMETERS params = {};
params.BackBufferWidth = 1;
params.BackBufferHeight = 1;
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
params.hDeviceWindow = hWnd;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
pD3D->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &params, NULL, &pDeviceEx);
if (pDeviceEx)
{
PRINT_DEBUG("Hooked D3D9::Present to detect DX Version\n");
(void*&)_IDirect3DDevice9_Present = (*reinterpret_cast<void***>(pDeviceEx))[(int)IDirect3DDevice9VTable::Present];
(void*&)_IDirect3DDevice9Ex_PresentEx = (*reinterpret_cast<void***>(pDeviceEx))[(int)IDirect3DDevice9VTable::PresentEx];
HookDX9Present();
}
else
{
PRINT_DEBUG("Failed to hook D3D9::Present to detect DX Version\n");
}
if (pDeviceEx)pDeviceEx->Release();
if (pD3D)pD3D->Release();
}
}
void Hook_Manager::hook_dx10()
{
if (!_dxgi_hooked && !_renderer_found)
{
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
HWND hWnd = GetGameWindow();
if (!hWnd)
return;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
IDXGISwapChain* pSwapChain;
ID3D10Device* pDevice;
DXGI_SWAP_CHAIN_DESC SwapChainDesc = {};
decltype(D3D10CreateDeviceAndSwapChain)* D3D10CreateDeviceAndSwapChain =
(decltype(D3D10CreateDeviceAndSwapChain))GetProcAddress(GetModuleHandle(DX10_Hook::DLL_NAME), "D3D10CreateDeviceAndSwapChain");
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;
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
SwapChainDesc.OutputWindow = hWnd;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
SwapChainDesc.SampleDesc.Count = 1;
SwapChainDesc.SampleDesc.Quality = 0;
SwapChainDesc.Windowed = TRUE;
Better compatibility for dx10 and 11
2019-08-20 06:27:50 +00:00
D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_NULL, NULL, 0, D3D10_SDK_VERSION, &SwapChainDesc, &pSwapChain, &pDevice);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
if (pDevice != nullptr && pSwapChain != nullptr)
{
PRINT_DEBUG("Hooked IDXGISwapChain::Present to detect DX Version\n");
(void*&)_IDXGISwapChain_Present = (*reinterpret_cast<void***>(pSwapChain))[(int)IDXGISwapChainVTable::Present];
HookDXGIPresent();
}
else
{
PRINT_DEBUG("Failed to Hook IDXGISwapChain::Present to detect DX Version\n");
}
if (pDevice)pDevice->Release();
if (pSwapChain)pSwapChain->Release();
}
}
void Hook_Manager::hook_dx11()
{
if (!_dxgi_hooked && !_renderer_found)
{
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
HWND hWnd = GetGameWindow();
if (!hWnd)
return;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
IDXGISwapChain* pSwapChain;
ID3D11Device* pDevice;
DXGI_SWAP_CHAIN_DESC SwapChainDesc = {};
decltype(D3D11CreateDeviceAndSwapChain)* D3D11CreateDeviceAndSwapChain =
(decltype(D3D11CreateDeviceAndSwapChain))GetProcAddress(GetModuleHandle(DX11_Hook::DLL_NAME), "D3D11CreateDeviceAndSwapChain");
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;
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
SwapChainDesc.OutputWindow = hWnd;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
SwapChainDesc.SampleDesc.Count = 1;
SwapChainDesc.SampleDesc.Quality = 0;
SwapChainDesc.Windowed = TRUE;
Better compatibility for dx10 and 11
2019-08-20 06:27:50 +00:00
D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_NULL, NULL, 0, NULL, NULL, D3D11_SDK_VERSION, &SwapChainDesc, &pSwapChain, &pDevice, NULL, NULL);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
if (pDevice != nullptr && pSwapChain != nullptr)
{
PRINT_DEBUG("Hooked IDXGISwapChain::Present to detect DX Version\n");
(void*&)_IDXGISwapChain_Present = (*reinterpret_cast<void***>(pSwapChain))[(int)IDXGISwapChainVTable::Present];
HookDXGIPresent();
}
else
{
PRINT_DEBUG("Failed to Hook IDXGISwapChain::Present to detect DX Version\n");
}
if (pDevice) pDevice->Release();
if (pSwapChain) pSwapChain->Release();
}
}
void Hook_Manager::hook_dx12()
{
if (!_dxgi_hooked && !_renderer_found)
{
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
HWND hWnd = GetGameWindow();
if (!hWnd)
return;
Partially working DX12 overlay DX12 hook seems ok, there are some bugs remaining. ImGui setup for DX12 doesn't work.
2019-08-19 16:56:15 +00:00
IDXGIFactory4* pDXGIFactory = nullptr;
IDXGISwapChain1* pSwapChain = nullptr;
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
ID3D12CommandQueue* pCommandQueue = nullptr;
ID3D12Device* pDevice = nullptr;
decltype(D3D12CreateDevice)* D3D12CreateDevice =
(decltype(D3D12CreateDevice))GetProcAddress(GetModuleHandle(DX12_Hook::DLL_NAME), "D3D12CreateDevice");
D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&pDevice));
if (pDevice)
{
DXGI_SWAP_CHAIN_DESC1 SwapChainDesc = {};
SwapChainDesc.Width = 0;
SwapChainDesc.Height = 0;
SwapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
SwapChainDesc.Stereo = FALSE;
SwapChainDesc.SampleDesc = { 1, 0 };
SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
SwapChainDesc.BufferCount = 3;
SwapChainDesc.Scaling = DXGI_SCALING_STRETCH;
SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
SwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
pDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&pCommandQueue));
if (pCommandQueue)
{
reinterpret_cast<decltype(CreateDXGIFactory1)*>(GetProcAddress(GetModuleHandle("dxgi.dll"), "CreateDXGIFactory1"))(IID_PPV_ARGS(&pDXGIFactory));
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
pDXGIFactory->CreateSwapChainForHwnd(pCommandQueue, hWnd, &SwapChainDesc, NULL, NULL, &pSwapChain);
Partially working DX12 overlay DX12 hook seems ok, there are some bugs remaining. ImGui setup for DX12 doesn't work.
2019-08-19 16:56:15 +00:00
if (pSwapChain != nullptr)
{
PRINT_DEBUG("Hooked IDXGISwapChain::Present to detect DX Version\n");
(void*&)_IDXGISwapChain_Present = (*reinterpret_cast<void***>(pSwapChain))[(int)IDXGISwapChainVTable::Present];
HookDXGIPresent();
}
else
{
PRINT_DEBUG("Failed to Hook IDXGISwapChain::Present to detect DX Version\n");
}
}
}
if (pSwapChain) pSwapChain->Release();
if (pDXGIFactory) pDXGIFactory->Release();
if (pCommandQueue) pCommandQueue->Release();
if (pDevice) pDevice->Release();
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
}
void Hook_Manager::hook_opengl()
{
if (!_ogl_hooked && !_renderer_found)
{
_wglMakeCurrent = (decltype(_wglMakeCurrent))GetProcAddress(GetModuleHandle(OpenGL_Hook::DLL_NAME), "wglMakeCurrent");
HookwglMakeCurrent();
}
}
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
void Hook_Manager::create_hook(const char* libname)
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
{
Added opengl hook
2019-07-31 20:19:44 +00:00
if (!_stricmp(libname, "d3d9.dll"))
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Hook_Manager::Inst().hook_dx9();
Added opengl hook
2019-07-31 20:19:44 +00:00
else if (!_stricmp(libname, "d3d10.dll"))
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Hook_Manager::Inst().hook_dx10();
Added opengl hook
2019-07-31 20:19:44 +00:00
else if (!_stricmp(libname, "d3d11.dll"))
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Hook_Manager::Inst().hook_dx11();
Added opengl hook
2019-07-31 20:19:44 +00:00
else if (!_stricmp(libname, "d3d12.dll"))
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Hook_Manager::Inst().hook_dx12();
Added opengl hook
2019-07-31 20:19:44 +00:00
else if (!_stricmp(libname, "opengl32.dll"))
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Hook_Manager::Inst().hook_opengl();
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
}
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
//void Hook_Manager::create_hookW(const wchar_t *libname)
//{
// if (!_wcsicmp(libname, L"d3d9.dll"))
// Hook_Manager::Inst().hook_dx9();
// else if (!_wcsicmp(libname, L"d3d10.dll"))
// Hook_Manager::Inst().hook_dx10();
// else if (!_wcsicmp(libname, L"d3d11.dll"))
// Hook_Manager::Inst().hook_dx11();
// else if (!_wcsicmp(libname, L"d3d12.dll"))
// Hook_Manager::Inst().hook_dx12();
// else if (!_wcsicmp(libname, L"opengl32.dll"))
// Hook_Manager::Inst().hook_opengl();
//}
//
//HMODULE WINAPI Hook_Manager::MyLoadLibraryA(LPCTSTR lpLibFileName)
//{
// auto res = _LoadLibraryA(lpLibFileName);
// Hook_Manager::Inst().create_hookA(lpLibFileName);
// return res;
//}
//
//HMODULE WINAPI Hook_Manager::MyLoadLibraryW(LPCWSTR lpLibFileName)
//{
// auto res = _LoadLibraryW(lpLibFileName);
// Hook_Manager::Inst().create_hookW(lpLibFileName);
// return res;
//}
//
//HMODULE WINAPI Hook_Manager::MyLoadLibraryExA(LPCTSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
//{
// auto res = _LoadLibraryA(lpLibFileName);
// Hook_Manager::Inst().create_hookA(lpLibFileName);
// return res;
//}
//
//HMODULE WINAPI Hook_Manager::MyLoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
//{
// auto res = _LoadLibraryExW(lpLibFileName, hFile, dwFlags);
// Hook_Manager::Inst().create_hookW(lpLibFileName);
// return res;
//}
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
bool Hook_Manager::stop_retry()
{
Fixed overlay on x64 They are not longer available with GetWindowLong. There is a new function GetWindowLongPtr. GWLP* must be used.
2019-08-21 08:46:58 +00:00
// Retry or not
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
bool stop = ++_hook_retries >= max_hook_retries;
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
if (stop)
FoundRenderer(nullptr);
return stop;
}
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
void Hook_Manager::find_renderer(Hook_Manager* _this)
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
{
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
_this->rendererdetect_hook = new Base_Hook();
_this->AddHook(_this->rendererdetect_hook);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
std::vector<std::string> const libraries = { "opengl32.dll", "d3d12.dll", "d3d11.dll", "d3d10.dll", "d3d9.dll" };
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
while (!_this->_renderer_found && !_this->stop_retry())
{
std::vector<std::string>::const_iterator it = libraries.begin();
while (it != libraries.end())
{
it = std::find_if(it, libraries.end(), [](std::string const& name) {
auto x = GetModuleHandle(name.c_str());
if (x != NULL)
return true;
return false;
});
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
if (it == libraries.end())
break;
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
_this->create_hook(it->c_str());
++it;
}
std::this_thread::sleep_for(std::chrono::milliseconds(500));
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
}
#endif
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
Hook_Manager::Hook_Manager():
Moved hooks calls and added hook retry With that change, I no longer re-hook rendering functions as Hook_Manager::FoundRenderer removes all hooks and then we hook the true functions in the renderer specialization. Added a retry count.
2019-08-18 15:12:57 +00:00
_hook_retries(0),
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#ifdef STEAM_WIN32
_loadlibrary_hooked(false),
_dxgi_hooked(false),
_dx9_hooked(false),
#endif
_renderer_found(false),
_ogl_hooked(false)
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
{}
Hook_Manager::~Hook_Manager()
{
for (auto& i : _hooks)
delete i;
}
Hook_Manager& Hook_Manager::Inst()
{
static Hook_Manager hook;
return hook;
}
Moved window hooks to its own class Every class has a job. Overlay is to show an overlay not to hook windows functions. Hook_Manager's job is to manage hooks and should not contain a reference to the overlay. (It should not contains any reference to directX or OpenGL either but I'll see that later... Maybe) This makes the overlay code much cleaner and "could" be used in Linux as well.
2019-08-18 14:22:07 +00:00
void Hook_Manager::HookRenderer()
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
{
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#ifdef STEAM_WIN32
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
_hook_thread = new std::thread(&Hook_Manager::find_renderer, this);
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
#endif
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
}
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
void Hook_Manager::FoundRenderer(Base_Hook* hook)
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
{
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
if (!_renderer_found)
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
{
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
_renderer_found = true;
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
Refactor dx device creation Find the game's window instead of using the foreground window.
2019-08-20 21:27:17 +00:00
if (hook == nullptr)
PRINT_DEBUG("We found a renderer but couldn't hook it, aborting overlay hook.\n");
else
PRINT_DEBUG("Hooked renderer in %d tries\n", _hook_retries);
Added hook retry. Handed hook detection to a thread that can then retry. With that, don't need to wait for loadLibrary. Will remove all those commented functions in another version.
2019-08-19 16:57:55 +00:00
_hook_thread->join();
delete _hook_thread;
Added DirectX hooks Warning: DX9 doesn't support resizing (TODO), DX12 has not beed tested and is not finished. No OpenGL support for now.
2019-07-25 21:21:03 +00:00
// Remove all hooks that are unused
_hooks.erase(std::remove_if(_hooks.begin(), _hooks.end(), [&hook](Base_Hook* it_hook) {
if (hook != it_hook)
{
delete it_hook;
return true;
}
return false;
}), _hooks.end());
Reworked how renderers are hooked. Some games doesn't initialise Steam before initalizing their Renderer (even if the doc says to) . So instead of waiting for the game to initialize it, hook to the rendering functions and deduce which implementation should be used.
2019-08-16 08:36:44 +00:00
}
Created a define to not compile overlay.
2019-08-14 13:09:57 +00:00
}
#endif//NO_OVERLAY
Reference in New Issue Copy Permalink