mirror of
https://github.com/spice2x/spice2x.github.io.git
synced 2026-08-01 22:30:42 -07:00
overlay: implement dx11 backend (#707)
## Link to GitHub Issue or related Pull Request, if one exists Fixes #134 ## Description of change Add ImGui DX11 backend implementation, and integrate into the spice overlay. The tricky part is that some of the Unity games: 1. Launch multiple windows, and 2. Can be resized (even full screen games launch at a certain resolution and then expand to fit desktop resolution) 3. lazy load DX11 DLLs This PR also adds screenshot functionality, but screen resize is not implemented. ## Testing Seems to be working for most games. Need to do final tests for: - [x] CCJ (attract movie plays as well) - [x] Busou Shinki (title movie plays) - [x] MFG - [x] QuizKnock - [x] Polaris Chord - [x] check dx9 for regression
This commit is contained in:
bicarus
@@ -0,0 +1,275 @@
|
||||
// dx11 / dxgi hook entrypoint. trampolines d3d11.dll / dxgi.dll exports
|
||||
// the moment those DLLs appear (LDR notification + poll-thread fallback),
|
||||
// then drives proactive vtable capture so we don't lose the race against
|
||||
// the execexe loader. per-vtable hook implementations live in the sibling
|
||||
// files (d3d11_swapchain / d3d11_factory / d3d11_vtable_capture /
|
||||
// d3d11_screenshot).
|
||||
//
|
||||
// note: never LoadLibrary d3d11/dxgi -- execexe pre-loads them itself and
|
||||
// fails (error 0xa) if they're already in the loader's module list.
|
||||
//
|
||||
// 64-bit only.
|
||||
|
||||
#include "d3d11_backend.h"
|
||||
|
||||
#ifndef SPICE_D3D11
|
||||
|
||||
void graphics_d3d11_init() {}
|
||||
void graphics_d3d11_shutdown() {}
|
||||
|
||||
#else
|
||||
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
#include <cwchar>
|
||||
#include <mutex>
|
||||
|
||||
#include <windows.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi.h>
|
||||
#include <dxgi1_2.h>
|
||||
|
||||
#include "d3d11_internal.h"
|
||||
#include "util/nt_loader.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using D3D11CreateDeviceAndSwapChain_t = HRESULT(WINAPI *)(
|
||||
IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT,
|
||||
const D3D_FEATURE_LEVEL *, UINT, UINT,
|
||||
const DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **,
|
||||
ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
|
||||
using CreateDXGIFactory_t = HRESULT(WINAPI *)(REFIID, void **);
|
||||
using CreateDXGIFactory1_t = HRESULT(WINAPI *)(REFIID, void **);
|
||||
using CreateDXGIFactory2_t = HRESULT(WINAPI *)(UINT, REFIID, void **);
|
||||
|
||||
D3D11CreateDeviceAndSwapChain_t D3D11CreateDeviceAndSwapChain_orig = nullptr;
|
||||
CreateDXGIFactory_t CreateDXGIFactory_orig = nullptr;
|
||||
CreateDXGIFactory1_t CreateDXGIFactory1_orig = nullptr;
|
||||
CreateDXGIFactory2_t CreateDXGIFactory2_orig = nullptr;
|
||||
|
||||
std::atomic<bool> g_d3d11_exports_hooked { false };
|
||||
std::atomic<bool> g_dxgi_exports_hooked { false };
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// top-level export hooks
|
||||
|
||||
HRESULT WINAPI D3D11CreateDeviceAndSwapChain_hook(
|
||||
IDXGIAdapter *pAdapter, D3D_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags,
|
||||
const D3D_FEATURE_LEVEL *pFeatureLevels, UINT FeatureLevels, UINT SDKVersion,
|
||||
const DXGI_SWAP_CHAIN_DESC *pSwapChainDesc, IDXGISwapChain **ppSwapChain,
|
||||
ID3D11Device **ppDevice, D3D_FEATURE_LEVEL *pFeatureLevel,
|
||||
ID3D11DeviceContext **ppImmediateContext)
|
||||
{
|
||||
HRESULT res = D3D11CreateDeviceAndSwapChain_orig(
|
||||
pAdapter, DriverType, Software, Flags,
|
||||
pFeatureLevels, FeatureLevels, SDKVersion,
|
||||
pSwapChainDesc, ppSwapChain, ppDevice, pFeatureLevel, ppImmediateContext);
|
||||
if (SUCCEEDED(res) && ppSwapChain && *ppSwapChain) {
|
||||
if (pSwapChainDesc) {
|
||||
d3d11_hooks::note_main_hwnd(pSwapChainDesc->OutputWindow);
|
||||
}
|
||||
d3d11_hooks::install_swapchain_hooks(*ppSwapChain);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
#define DEFINE_FACTORY_HOOK(NAME, SIG_PARAMS, ORIG_ARGS) \
|
||||
HRESULT WINAPI NAME##_hook SIG_PARAMS { \
|
||||
HRESULT res = NAME##_orig ORIG_ARGS; \
|
||||
if (SUCCEEDED(res) && ppFactory && *ppFactory) { \
|
||||
d3d11_hooks::install_factory_hooks( \
|
||||
reinterpret_cast<IUnknown *>(*ppFactory)); \
|
||||
} \
|
||||
return res; \
|
||||
}
|
||||
|
||||
DEFINE_FACTORY_HOOK(CreateDXGIFactory,
|
||||
(REFIID riid, void **ppFactory),
|
||||
(riid, ppFactory))
|
||||
DEFINE_FACTORY_HOOK(CreateDXGIFactory1,
|
||||
(REFIID riid, void **ppFactory),
|
||||
(riid, ppFactory))
|
||||
DEFINE_FACTORY_HOOK(CreateDXGIFactory2,
|
||||
(UINT Flags, REFIID riid, void **ppFactory),
|
||||
(Flags, riid, ppFactory))
|
||||
|
||||
#undef DEFINE_FACTORY_HOOK
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// export trampoline plumbing
|
||||
|
||||
// serializes trampoline_export() so the LDR notification callback and the
|
||||
// poll thread don't race each other into MinHook against the same target.
|
||||
std::mutex g_export_mutex;
|
||||
|
||||
bool trampoline_export(const char *dll, const char *name, void *hook, void **orig) {
|
||||
std::lock_guard<std::mutex> lock(g_export_mutex);
|
||||
if (*orig) {
|
||||
return true;
|
||||
}
|
||||
HMODULE mod = GetModuleHandleA(dll);
|
||||
if (!mod) {
|
||||
return false;
|
||||
}
|
||||
void *addr = reinterpret_cast<void *>(GetProcAddress(mod, name));
|
||||
if (!addr) {
|
||||
return false;
|
||||
}
|
||||
*orig = addr; // trampoline_try reads *orig before overwriting it.
|
||||
if (!detour::trampoline_try(addr, hook, orig)) {
|
||||
*orig = nullptr;
|
||||
return false;
|
||||
}
|
||||
log_info("graphics::d3d11", "trampolined {}!{}", dll, name);
|
||||
return true;
|
||||
}
|
||||
|
||||
void try_install_d3d11_exports() {
|
||||
if (g_d3d11_exports_hooked) {
|
||||
return;
|
||||
}
|
||||
if (trampoline_export("d3d11.dll", "D3D11CreateDeviceAndSwapChain",
|
||||
(void *) D3D11CreateDeviceAndSwapChain_hook,
|
||||
(void **) &D3D11CreateDeviceAndSwapChain_orig)) {
|
||||
g_d3d11_exports_hooked = true;
|
||||
}
|
||||
}
|
||||
|
||||
void try_install_dxgi_exports() {
|
||||
if (g_dxgi_exports_hooked) {
|
||||
return;
|
||||
}
|
||||
struct entry { const char *name; void *hook; void **orig; };
|
||||
const entry entries[] = {
|
||||
{ "CreateDXGIFactory", (void *) CreateDXGIFactory_hook,
|
||||
(void **) &CreateDXGIFactory_orig },
|
||||
{ "CreateDXGIFactory1", (void *) CreateDXGIFactory1_hook,
|
||||
(void **) &CreateDXGIFactory1_orig },
|
||||
{ "CreateDXGIFactory2", (void *) CreateDXGIFactory2_hook,
|
||||
(void **) &CreateDXGIFactory2_orig },
|
||||
};
|
||||
bool any = false;
|
||||
for (auto &e : entries) {
|
||||
any |= trampoline_export("dxgi.dll", e.name, e.hook, e.orig);
|
||||
}
|
||||
if (any) {
|
||||
g_dxgi_exports_hooked = true;
|
||||
}
|
||||
}
|
||||
|
||||
void try_capture_if_ready() {
|
||||
if (g_d3d11_exports_hooked && g_dxgi_exports_hooked) {
|
||||
d3d11_hooks::try_capture_vtables();
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// LDR notification + polling fallback
|
||||
|
||||
bool dll_name_ends_with(PCUNICODE_STRING name, const wchar_t *suffix) {
|
||||
if (!name || !name->Buffer) {
|
||||
return false;
|
||||
}
|
||||
const size_t n = name->Length / sizeof(WCHAR);
|
||||
const size_t s = wcslen(suffix);
|
||||
return n >= s && _wcsnicmp(name->Buffer + n - s, suffix, s) == 0;
|
||||
}
|
||||
|
||||
VOID CALLBACK ldr_dll_notification(
|
||||
ULONG reason, PCLDR_DLL_NOTIFICATION_DATA data, PVOID /*context*/)
|
||||
{
|
||||
if (reason != LDR_DLL_NOTIFICATION_REASON_LOADED || !data) {
|
||||
return;
|
||||
}
|
||||
if (dll_name_ends_with(data->Loaded.BaseDllName, L"d3d11.dll")) {
|
||||
try_install_d3d11_exports();
|
||||
} else if (dll_name_ends_with(data->Loaded.BaseDllName, L"dxgi.dll")) {
|
||||
try_install_dxgi_exports();
|
||||
}
|
||||
}
|
||||
|
||||
// execexe maps d3d11/dxgi via a path that bypasses LdrLoadDll, so the
|
||||
// notification above never fires for those DLLs and we have to poll.
|
||||
std::atomic<bool> g_stop { false };
|
||||
std::thread g_poll_thread;
|
||||
std::mutex g_init_mutex;
|
||||
PVOID g_ldr_cookie = nullptr;
|
||||
|
||||
void poll_thread() {
|
||||
using namespace std::chrono_literals;
|
||||
for (int32_t i = 0; i < 120 && !g_stop.load(); ++i) {
|
||||
try_install_d3d11_exports();
|
||||
try_install_dxgi_exports();
|
||||
if (g_d3d11_exports_hooked && g_dxgi_exports_hooked) {
|
||||
d3d11_hooks::try_capture_vtables();
|
||||
return;
|
||||
}
|
||||
// sliced so shutdown doesn't have to wait a full second.
|
||||
for (int32_t s = 0; s < 10 && !g_stop.load(); ++s) {
|
||||
std::this_thread::sleep_for(100ms);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void graphics_d3d11_init() {
|
||||
// dx11 titles always run under execexe. skipping on pure-dx9 games keeps
|
||||
// their startup path completely untouched (no exports patched, no poll
|
||||
// thread, no LDR callback).
|
||||
if (!GetModuleHandleW(L"execexe.dll")) {
|
||||
return;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(g_init_mutex);
|
||||
if (g_poll_thread.joinable()) {
|
||||
return; // already initialized
|
||||
}
|
||||
|
||||
log_info("graphics::d3d11", "initializing");
|
||||
|
||||
// trampoline now if either DLL is already in the PEB.
|
||||
try_install_d3d11_exports();
|
||||
try_install_dxgi_exports();
|
||||
try_capture_if_ready();
|
||||
|
||||
// catches standard LdrLoadDll loads.
|
||||
auto reg = reinterpret_cast<decltype(&LdrRegisterDllNotification)>(
|
||||
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "LdrRegisterDllNotification"));
|
||||
if (reg) {
|
||||
NTSTATUS st = reg(0, ldr_dll_notification, nullptr, &g_ldr_cookie);
|
||||
if (NT_SUCCESS(st)) {
|
||||
log_info("graphics::d3d11", "registered LDR DLL notification");
|
||||
} else {
|
||||
g_ldr_cookie = nullptr;
|
||||
log_warning("graphics::d3d11",
|
||||
"LdrRegisterDllNotification failed: {:#x}", (unsigned long)st);
|
||||
}
|
||||
}
|
||||
|
||||
// catches the execexe loader path that bypasses LdrLoadDll.
|
||||
g_poll_thread = std::thread(poll_thread);
|
||||
}
|
||||
|
||||
void graphics_d3d11_shutdown() {
|
||||
std::lock_guard<std::mutex> lock(g_init_mutex);
|
||||
|
||||
// unregister first so the callback can't fire mid-teardown.
|
||||
if (g_ldr_cookie) {
|
||||
auto unreg = reinterpret_cast<decltype(&LdrUnregisterDllNotification)>(
|
||||
GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "LdrUnregisterDllNotification"));
|
||||
if (unreg) {
|
||||
unreg(g_ldr_cookie);
|
||||
}
|
||||
g_ldr_cookie = nullptr;
|
||||
}
|
||||
|
||||
g_stop.store(true);
|
||||
if (g_poll_thread.joinable()) {
|
||||
g_poll_thread.join();
|
||||
}
|
||||
}
|
||||
|
||||
#endif // SPICE_D3D11
|
||||
@@ -0,0 +1,24 @@
|
||||
#pragma once
|
||||
|
||||
#include "overlay/overlay.h"
|
||||
|
||||
void graphics_d3d11_init();
|
||||
void graphics_d3d11_shutdown();
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
struct ID3D11Device;
|
||||
struct ID3D11DeviceContext;
|
||||
struct ID3D11RenderTargetView;
|
||||
struct IDXGISwapChain;
|
||||
|
||||
namespace overlay::d3d11 {
|
||||
|
||||
void render(ID3D11Device *device,
|
||||
ID3D11DeviceContext *context,
|
||||
IDXGISwapChain *swapchain,
|
||||
ID3D11RenderTargetView **rtv);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,102 @@
|
||||
// dx11 factory vtable hooks. patches CreateSwapChain / CreateSwapChainForHwnd
|
||||
// so we can install_swapchain_hooks against every newly-created swapchain.
|
||||
|
||||
#include "d3d11_backend.h"
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
#include <mutex>
|
||||
|
||||
#include <windows.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi.h>
|
||||
#include <dxgi1_2.h>
|
||||
|
||||
#include "d3d11_internal.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using CreateSwapChain_t = HRESULT(STDMETHODCALLTYPE *)(
|
||||
IDXGIFactory *, IUnknown *, DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **);
|
||||
using CreateSwapChainForHwnd_t = HRESULT(STDMETHODCALLTYPE *)(
|
||||
IDXGIFactory2 *, IUnknown *, HWND,
|
||||
const DXGI_SWAP_CHAIN_DESC1 *,
|
||||
const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *,
|
||||
IDXGIOutput *, IDXGISwapChain1 **);
|
||||
|
||||
CreateSwapChain_t CreateSwapChain_orig = nullptr;
|
||||
CreateSwapChainForHwnd_t CreateSwapChainForHwnd_orig = nullptr;
|
||||
|
||||
bool g_factory_hooked = false;
|
||||
bool g_factory2_hooked = false;
|
||||
std::mutex g_hook_mutex;
|
||||
|
||||
HRESULT STDMETHODCALLTYPE CreateSwapChain_hook(
|
||||
IDXGIFactory *factory, IUnknown *pDevice,
|
||||
DXGI_SWAP_CHAIN_DESC *pDesc, IDXGISwapChain **ppSwapChain)
|
||||
{
|
||||
HRESULT res = CreateSwapChain_orig(factory, pDevice, pDesc, ppSwapChain);
|
||||
if (SUCCEEDED(res) && ppSwapChain && *ppSwapChain) {
|
||||
if (pDesc) {
|
||||
d3d11_hooks::note_main_hwnd(pDesc->OutputWindow);
|
||||
}
|
||||
d3d11_hooks::install_swapchain_hooks(*ppSwapChain);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd_hook(
|
||||
IDXGIFactory2 *factory, IUnknown *pDevice, HWND hWnd,
|
||||
const DXGI_SWAP_CHAIN_DESC1 *pDesc,
|
||||
const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pFullscreenDesc,
|
||||
IDXGIOutput *pRestrictToOutput, IDXGISwapChain1 **ppSwapChain)
|
||||
{
|
||||
HRESULT res = CreateSwapChainForHwnd_orig(
|
||||
factory, pDevice, hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, ppSwapChain);
|
||||
if (SUCCEEDED(res) && ppSwapChain && *ppSwapChain) {
|
||||
d3d11_hooks::note_main_hwnd(hWnd);
|
||||
d3d11_hooks::install_swapchain_hooks(*ppSwapChain);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
// QI-and-hook helper: dedupes the IDXGIFactory / IDXGIFactory2 install paths.
|
||||
template<typename Iface>
|
||||
void install_on(IUnknown *factory, bool &flag,
|
||||
size_t vtbl_index, void *hook, void **orig, const char *name)
|
||||
{
|
||||
if (flag) {
|
||||
return;
|
||||
}
|
||||
Iface *f = nullptr;
|
||||
if (FAILED(factory->QueryInterface(IID_PPV_ARGS(&f))) || !f) {
|
||||
return;
|
||||
}
|
||||
if (d3d11_hooks::hook_vtbl(f, vtbl_index, hook, orig, name)) {
|
||||
flag = true;
|
||||
}
|
||||
f->Release();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace d3d11_hooks {
|
||||
|
||||
void install_factory_hooks(IUnknown *factory) {
|
||||
if (!factory) {
|
||||
return;
|
||||
}
|
||||
std::lock_guard<std::mutex> lock(g_hook_mutex);
|
||||
|
||||
install_on<IDXGIFactory>(factory, g_factory_hooked, 10,
|
||||
(void *) CreateSwapChain_hook, (void **) &CreateSwapChain_orig,
|
||||
"IDXGIFactory::CreateSwapChain");
|
||||
|
||||
install_on<IDXGIFactory2>(factory, g_factory2_hooked, 15,
|
||||
(void *) CreateSwapChainForHwnd_hook, (void **) &CreateSwapChainForHwnd_orig,
|
||||
"IDXGIFactory2::CreateSwapChainForHwnd");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // SPICE_D3D11
|
||||
@@ -0,0 +1,59 @@
|
||||
#pragma once
|
||||
|
||||
// internal glue for the dx11 backend. all symbols gated on SPICE_D3D11.
|
||||
|
||||
#include "overlay/overlay.h"
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "util/detour.h"
|
||||
#include "util/logging.h"
|
||||
|
||||
struct HWND__; typedef HWND__ *HWND;
|
||||
struct IUnknown;
|
||||
struct IDXGISwapChain;
|
||||
|
||||
namespace d3d11_hooks {
|
||||
|
||||
void install_swapchain_hooks(IDXGISwapChain *swapchain);
|
||||
void install_factory_hooks(IUnknown *factory);
|
||||
void try_capture_vtables();
|
||||
|
||||
// first non-null swapchain HWND wins; later ones (sub-screens, IME
|
||||
// helpers) are ignored. the dummy capture window is exempted via
|
||||
// ignore_hwnd.
|
||||
void note_main_hwnd(HWND hwnd);
|
||||
HWND main_hwnd();
|
||||
void ignore_hwnd(HWND hwnd);
|
||||
|
||||
// capture backbuffer to PNG if a screenshot was requested.
|
||||
void try_screenshot(IDXGISwapChain *swapchain);
|
||||
|
||||
// trampoline a virtual method by vtable index. on failure *orig is null.
|
||||
inline bool hook_vtbl(void *iface, size_t index,
|
||||
void *hook, void **orig, const char *name)
|
||||
{
|
||||
void **vtbl = *reinterpret_cast<void ***>(iface);
|
||||
void *target = vtbl[index];
|
||||
// trampoline_try reads *orig before overwriting it.
|
||||
*orig = target;
|
||||
if (!detour::trampoline_try(target, hook, orig)) {
|
||||
*orig = nullptr;
|
||||
log_warning("graphics::d3d11", "failed to hook {}", name);
|
||||
return false;
|
||||
}
|
||||
log_info("graphics::d3d11", "hooked {}", name);
|
||||
return true;
|
||||
}
|
||||
|
||||
// minimal COM RAII used by capture / screenshot paths.
|
||||
struct com_release {
|
||||
void operator()(IUnknown *p) const { if (p) p->Release(); }
|
||||
};
|
||||
template<typename T> using com_ptr = std::unique_ptr<T, com_release>;
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,165 @@
|
||||
// dx11 screenshot capture. mirrors the d3d9 backend: copy the current
|
||||
// backbuffer into a staging texture, force alpha=255, write PNG via
|
||||
// stb_image_write, push to clipboard and notify.
|
||||
|
||||
#include "d3d11_backend.h"
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <windows.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi.h>
|
||||
|
||||
#include "d3d11_internal.h"
|
||||
|
||||
#include "external/stb_image_write.h"
|
||||
#include "hooks/graphics/graphics.h"
|
||||
#include "misc/clipboard.h"
|
||||
#include "overlay/notifications.h"
|
||||
#include "util/fileutils.h"
|
||||
|
||||
using d3d11_hooks::com_ptr;
|
||||
|
||||
namespace {
|
||||
|
||||
// copy the swapchain backbuffer into a CPU-readable staging texture and
|
||||
// flatten it into an RGBA8 buffer (BGRA backbuffers are swizzled,
|
||||
// alpha is forced to 255).
|
||||
bool copy_backbuffer_to_rgba(IDXGISwapChain *swapchain,
|
||||
ID3D11Device *device,
|
||||
ID3D11DeviceContext *context,
|
||||
std::vector<uint8_t> &out,
|
||||
uint32_t &out_w, uint32_t &out_h)
|
||||
{
|
||||
ID3D11Texture2D *raw_bb = nullptr;
|
||||
if (FAILED(swapchain->GetBuffer(0, IID_PPV_ARGS(&raw_bb))) || !raw_bb) {
|
||||
return false;
|
||||
}
|
||||
com_ptr<ID3D11Texture2D> backbuffer(raw_bb);
|
||||
|
||||
D3D11_TEXTURE2D_DESC desc {};
|
||||
backbuffer->GetDesc(&desc);
|
||||
|
||||
// MSAA backbuffers can't be CopyResource'd into a non-MS staging target.
|
||||
com_ptr<ID3D11Texture2D> resolved;
|
||||
ID3D11Texture2D *source = backbuffer.get();
|
||||
if (desc.SampleDesc.Count > 1) {
|
||||
D3D11_TEXTURE2D_DESC rd = desc;
|
||||
rd.SampleDesc.Count = 1;
|
||||
rd.SampleDesc.Quality = 0;
|
||||
rd.Usage = D3D11_USAGE_DEFAULT;
|
||||
rd.BindFlags = D3D11_BIND_RENDER_TARGET;
|
||||
rd.CPUAccessFlags = 0;
|
||||
rd.MiscFlags = 0;
|
||||
ID3D11Texture2D *r = nullptr;
|
||||
if (FAILED(device->CreateTexture2D(&rd, nullptr, &r)) || !r) {
|
||||
return false;
|
||||
}
|
||||
resolved.reset(r);
|
||||
context->ResolveSubresource(resolved.get(), 0, backbuffer.get(), 0, desc.Format);
|
||||
source = resolved.get();
|
||||
}
|
||||
|
||||
D3D11_TEXTURE2D_DESC sd {};
|
||||
sd.Width = desc.Width;
|
||||
sd.Height = desc.Height;
|
||||
sd.MipLevels = 1;
|
||||
sd.ArraySize = 1;
|
||||
sd.Format = desc.Format;
|
||||
sd.SampleDesc.Count = 1;
|
||||
sd.Usage = D3D11_USAGE_STAGING;
|
||||
sd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
|
||||
ID3D11Texture2D *raw_staging = nullptr;
|
||||
if (FAILED(device->CreateTexture2D(&sd, nullptr, &raw_staging)) || !raw_staging) {
|
||||
return false;
|
||||
}
|
||||
com_ptr<ID3D11Texture2D> staging(raw_staging);
|
||||
context->CopyResource(staging.get(), source);
|
||||
|
||||
D3D11_MAPPED_SUBRESOURCE mapped {};
|
||||
if (FAILED(context->Map(staging.get(), 0, D3D11_MAP_READ, 0, &mapped))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// backbuffers from GetDesc are always fully-typed (never _TYPELESS).
|
||||
const bool is_bgra = desc.Format == DXGI_FORMAT_B8G8R8A8_UNORM
|
||||
|| desc.Format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
|
||||
|
||||
out.resize(static_cast<size_t>(desc.Width) * desc.Height * 4);
|
||||
const uint8_t *src_base = reinterpret_cast<const uint8_t *>(mapped.pData);
|
||||
for (uint32_t y = 0; y < desc.Height; ++y) {
|
||||
const uint8_t *row = src_base + static_cast<size_t>(y) * mapped.RowPitch;
|
||||
uint8_t *dst = out.data() + static_cast<size_t>(y) * desc.Width * 4;
|
||||
for (uint32_t x = 0; x < desc.Width; ++x) {
|
||||
dst[x * 4 + 0] = row[x * 4 + (is_bgra ? 2 : 0)];
|
||||
dst[x * 4 + 1] = row[x * 4 + 1];
|
||||
dst[x * 4 + 2] = row[x * 4 + (is_bgra ? 0 : 2)];
|
||||
dst[x * 4 + 3] = 255;
|
||||
}
|
||||
}
|
||||
|
||||
context->Unmap(staging.get(), 0);
|
||||
|
||||
out_w = desc.Width;
|
||||
out_h = desc.Height;
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace d3d11_hooks {
|
||||
|
||||
void try_screenshot(IDXGISwapChain *swapchain) {
|
||||
if (!swapchain || !graphics_screenshot_consume()) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto file_path = graphics_screenshot_genpath();
|
||||
if (file_path.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
ID3D11Device *raw_device = nullptr;
|
||||
if (FAILED(swapchain->GetDevice(IID_PPV_ARGS(&raw_device))) || !raw_device) {
|
||||
return;
|
||||
}
|
||||
com_ptr<ID3D11Device> device(raw_device);
|
||||
ID3D11DeviceContext *raw_ctx = nullptr;
|
||||
device->GetImmediateContext(&raw_ctx);
|
||||
if (!raw_ctx) {
|
||||
return;
|
||||
}
|
||||
com_ptr<ID3D11DeviceContext> context(raw_ctx);
|
||||
|
||||
std::vector<uint8_t> pixels;
|
||||
uint32_t w = 0, h = 0;
|
||||
if (!copy_backbuffer_to_rgba(swapchain, device.get(), context.get(), pixels, w, h)) {
|
||||
log_warning("graphics::d3d11", "screenshot: failed to capture backbuffer");
|
||||
overlay::notifications::add(
|
||||
overlay::notifications::Severity::Error,
|
||||
"Screenshot failed to capture");
|
||||
return;
|
||||
}
|
||||
|
||||
log_info("graphics::d3d11", "saving screenshot to {}", file_path);
|
||||
if (stbi_write_png(file_path.c_str(), (int) w, (int) h, 4,
|
||||
pixels.data(), (int) w * 4))
|
||||
{
|
||||
clipboard::copy_image(file_path);
|
||||
overlay::notifications::add(
|
||||
overlay::notifications::Severity::Success,
|
||||
fmt::format("Screenshot saved: {}", fileutils::basename(file_path)));
|
||||
} else {
|
||||
log_warning("graphics::d3d11", "screenshot: stbi_write_png failed");
|
||||
overlay::notifications::add(
|
||||
overlay::notifications::Severity::Error,
|
||||
"Screenshot failed to save");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // SPICE_D3D11
|
||||
@@ -0,0 +1,289 @@
|
||||
// dx11 swapchain vtable hooks + per-frame overlay pump.
|
||||
//
|
||||
// dxgi shares vtables across swapchain instances, so we only need to patch
|
||||
// Present / Present1 / ResizeBuffers once on the first instance we see.
|
||||
// each frame we lazily attach the overlay to whichever swapchain is
|
||||
// presenting, then drive its imgui update / new_frame / render cycle.
|
||||
|
||||
#include "d3d11_backend.h"
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
#include <atomic>
|
||||
#include <mutex>
|
||||
|
||||
#include <windows.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi.h>
|
||||
#include <dxgi1_2.h>
|
||||
|
||||
#include "d3d11_internal.h"
|
||||
|
||||
#include "external/imgui/imgui.h"
|
||||
#include "external/imgui/backends/imgui_impl_dx11.h"
|
||||
#include "overlay/imgui/impl_spice.h"
|
||||
|
||||
#include "games/io.h"
|
||||
#include "hooks/graphics/graphics.h"
|
||||
#include "launcher/launcher.h"
|
||||
#include "misc/eamuse.h"
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// overlay render bridge
|
||||
|
||||
namespace overlay::d3d11 {
|
||||
|
||||
// sRGB backbuffers need a UNORM view: ImGui vertex colors are already
|
||||
// sRGB-encoded, so an extra linear->sRGB conversion would wash the
|
||||
// overlay out white.
|
||||
static DXGI_FORMAT to_unorm_view(DXGI_FORMAT fmt) {
|
||||
switch (fmt) {
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: return DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: return DXGI_FORMAT_B8G8R8A8_UNORM;
|
||||
default: return fmt;
|
||||
}
|
||||
}
|
||||
|
||||
static void ensure_rtv(ID3D11Device *device,
|
||||
IDXGISwapChain *swapchain,
|
||||
ID3D11RenderTargetView **rtv)
|
||||
{
|
||||
if (*rtv || !device || !swapchain) {
|
||||
return;
|
||||
}
|
||||
ID3D11Texture2D *backbuffer = nullptr;
|
||||
if (FAILED(swapchain->GetBuffer(0, IID_PPV_ARGS(&backbuffer))) || !backbuffer) {
|
||||
return;
|
||||
}
|
||||
D3D11_TEXTURE2D_DESC td {};
|
||||
backbuffer->GetDesc(&td);
|
||||
const DXGI_FORMAT view_fmt = to_unorm_view(td.Format);
|
||||
if (view_fmt != td.Format) {
|
||||
D3D11_RENDER_TARGET_VIEW_DESC rtvd {};
|
||||
rtvd.Format = view_fmt;
|
||||
rtvd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
|
||||
device->CreateRenderTargetView(backbuffer, &rtvd, rtv);
|
||||
} else {
|
||||
device->CreateRenderTargetView(backbuffer, nullptr, rtv);
|
||||
}
|
||||
backbuffer->Release();
|
||||
}
|
||||
|
||||
// bind the backbuffer (lazily creating the RTV) and draw the imgui
|
||||
// frame on top. reset_invalidate releases *rtv on ResizeBuffers.
|
||||
void render(ID3D11Device *device,
|
||||
ID3D11DeviceContext *context,
|
||||
IDXGISwapChain *swapchain,
|
||||
ID3D11RenderTargetView **rtv)
|
||||
{
|
||||
ensure_rtv(device, swapchain, rtv);
|
||||
if (!*rtv || !context) {
|
||||
return;
|
||||
}
|
||||
// present happens immediately after, so no need to save the previous
|
||||
// RT binding (flip-model resets it anyway).
|
||||
context->OMSetRenderTargets(1, rtv, nullptr);
|
||||
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// file-local state + per-frame helpers
|
||||
|
||||
namespace {
|
||||
|
||||
using Present_t = HRESULT(STDMETHODCALLTYPE *)(
|
||||
IDXGISwapChain *, UINT, UINT);
|
||||
using ResizeBuffers_t = HRESULT(STDMETHODCALLTYPE *)(
|
||||
IDXGISwapChain *, UINT, UINT, UINT, DXGI_FORMAT, UINT);
|
||||
using Present1_t = HRESULT(STDMETHODCALLTYPE *)(
|
||||
IDXGISwapChain1 *, UINT, UINT, const DXGI_PRESENT_PARAMETERS *);
|
||||
|
||||
Present_t Present_orig = nullptr;
|
||||
ResizeBuffers_t ResizeBuffers_orig = nullptr;
|
||||
Present1_t Present1_orig = nullptr;
|
||||
|
||||
bool g_swapchain_hooked = false;
|
||||
bool g_swapchain1_hooked = false;
|
||||
|
||||
void try_create_overlay(IDXGISwapChain *swapchain) {
|
||||
if (!swapchain || overlay::OVERLAY) {
|
||||
return;
|
||||
}
|
||||
|
||||
DXGI_SWAP_CHAIN_DESC desc {};
|
||||
if (FAILED(swapchain->GetDesc(&desc)) || !desc.OutputWindow) {
|
||||
return;
|
||||
}
|
||||
|
||||
// only attach to the main game window; ignore sub-screens / IME helpers.
|
||||
HWND main = d3d11_hooks::main_hwnd();
|
||||
if (main && desc.OutputWindow != main) {
|
||||
return;
|
||||
}
|
||||
|
||||
ID3D11Device *device = nullptr;
|
||||
if (FAILED(swapchain->GetDevice(IID_PPV_ARGS(&device))) || !device) {
|
||||
return;
|
||||
}
|
||||
ID3D11DeviceContext *context = nullptr;
|
||||
device->GetImmediateContext(&context);
|
||||
|
||||
if (context) {
|
||||
overlay::create_d3d11(desc.OutputWindow, device, context, swapchain);
|
||||
RECT cr {};
|
||||
::GetClientRect(desc.OutputWindow, &cr);
|
||||
log_info("graphics::d3d11",
|
||||
"attached overlay to swapchain hwnd=0x{:x} backbuffer={}x{} client={}x{}",
|
||||
(uintptr_t) desc.OutputWindow,
|
||||
desc.BufferDesc.Width, desc.BufferDesc.Height,
|
||||
cr.right - cr.left, cr.bottom - cr.top);
|
||||
context->Release();
|
||||
}
|
||||
device->Release();
|
||||
}
|
||||
|
||||
// rising-edge screenshot hotkey poll (mirrors d3d9 backend behaviour).
|
||||
void poll_screenshot_hotkey() {
|
||||
static bool s_down = false;
|
||||
auto buttons = games::get_buttons_overlay(eamuse_get_game());
|
||||
const bool pressed = buttons
|
||||
&& (!overlay::OVERLAY || overlay::OVERLAY->hotkeys_triggered())
|
||||
&& GameAPI::Buttons::getState(RI_MGR,
|
||||
buttons->at(games::OverlayButtons::Screenshot));
|
||||
if (pressed && !s_down) {
|
||||
graphics_screenshot_trigger();
|
||||
}
|
||||
s_down = pressed;
|
||||
}
|
||||
|
||||
void pump_overlay(IDXGISwapChain *swapchain) {
|
||||
if (!overlay::OVERLAY || !overlay::OVERLAY->uses_swapchain(swapchain)) {
|
||||
return;
|
||||
}
|
||||
|
||||
poll_screenshot_hotkey();
|
||||
|
||||
// size imgui to the backbuffer (not window client). dxgi may upscale
|
||||
// a small backbuffer into a larger client rect; without this override
|
||||
// imgui would draw past the RTV and the mouse mapping would be off.
|
||||
DXGI_SWAP_CHAIN_DESC desc {};
|
||||
if (SUCCEEDED(swapchain->GetDesc(&desc))) {
|
||||
ImGui_ImplSpice_SetDisplaySizeOverride(
|
||||
(float) desc.BufferDesc.Width,
|
||||
(float) desc.BufferDesc.Height);
|
||||
}
|
||||
|
||||
overlay::OVERLAY->update();
|
||||
overlay::OVERLAY->new_frame();
|
||||
overlay::OVERLAY->render();
|
||||
|
||||
// after overlay render so toasts/menus end up in the saved image.
|
||||
d3d11_hooks::try_screenshot(swapchain);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// swapchain method hooks
|
||||
|
||||
HRESULT STDMETHODCALLTYPE Present_hook(
|
||||
IDXGISwapChain *swapchain, UINT SyncInterval, UINT Flags)
|
||||
{
|
||||
try_create_overlay(swapchain);
|
||||
pump_overlay(swapchain);
|
||||
return Present_orig(swapchain, SyncInterval, Flags);
|
||||
}
|
||||
|
||||
HRESULT STDMETHODCALLTYPE Present1_hook(
|
||||
IDXGISwapChain1 *swapchain, UINT SyncInterval, UINT Flags,
|
||||
const DXGI_PRESENT_PARAMETERS *pParams)
|
||||
{
|
||||
try_create_overlay(swapchain);
|
||||
pump_overlay(swapchain);
|
||||
return Present1_orig(swapchain, SyncInterval, Flags, pParams);
|
||||
}
|
||||
|
||||
HRESULT STDMETHODCALLTYPE ResizeBuffers_hook(
|
||||
IDXGISwapChain *swapchain, UINT BufferCount, UINT Width, UINT Height,
|
||||
DXGI_FORMAT NewFormat, UINT SwapChainFlags)
|
||||
{
|
||||
const bool ours = overlay::OVERLAY && overlay::OVERLAY->uses_swapchain(swapchain);
|
||||
if (ours) {
|
||||
log_info("graphics::d3d11", "ResizeBuffers {}x{} fmt={}",
|
||||
Width, Height, (int32_t) NewFormat);
|
||||
overlay::OVERLAY->reset_invalidate();
|
||||
}
|
||||
HRESULT res = ResizeBuffers_orig(
|
||||
swapchain, BufferCount, Width, Height, NewFormat, SwapChainFlags);
|
||||
if (ours && SUCCEEDED(res)) {
|
||||
overlay::OVERLAY->reset_recreate();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// d3d11_hooks public surface: main-window tracking + vtable install.
|
||||
|
||||
namespace d3d11_hooks {
|
||||
|
||||
namespace {
|
||||
std::atomic<HWND> g_main_hwnd { nullptr };
|
||||
std::atomic<HWND> g_ignored_hwnd { nullptr };
|
||||
}
|
||||
|
||||
void note_main_hwnd(HWND hwnd) {
|
||||
if (!hwnd || hwnd == g_ignored_hwnd.load()) {
|
||||
return;
|
||||
}
|
||||
HWND expected = nullptr;
|
||||
if (g_main_hwnd.compare_exchange_strong(expected, hwnd)) {
|
||||
log_info("graphics::d3d11", "main hwnd recorded: 0x{:x}",
|
||||
(uintptr_t) hwnd);
|
||||
}
|
||||
}
|
||||
|
||||
HWND main_hwnd() {
|
||||
return g_main_hwnd.load();
|
||||
}
|
||||
|
||||
void ignore_hwnd(HWND hwnd) {
|
||||
g_ignored_hwnd.store(hwnd);
|
||||
}
|
||||
|
||||
// patch IDXGISwapChain::Present + ResizeBuffers and (if implemented)
|
||||
// IDXGISwapChain1::Present1. idempotent; flag is set only after success
|
||||
// so failed attempts can be retried on the next swapchain.
|
||||
void install_swapchain_hooks(IDXGISwapChain *swapchain) {
|
||||
if (!swapchain) {
|
||||
return;
|
||||
}
|
||||
static std::mutex s_hook_mutex;
|
||||
std::lock_guard<std::mutex> lock(s_hook_mutex);
|
||||
|
||||
if (!g_swapchain_hooked) {
|
||||
const bool a = hook_vtbl(swapchain, 8, (void *) Present_hook,
|
||||
(void **) &Present_orig, "IDXGISwapChain::Present");
|
||||
const bool b = hook_vtbl(swapchain, 13, (void *) ResizeBuffers_hook,
|
||||
(void **) &ResizeBuffers_orig, "IDXGISwapChain::ResizeBuffers");
|
||||
if (a && b) {
|
||||
g_swapchain_hooked = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!g_swapchain1_hooked) {
|
||||
IDXGISwapChain1 *sc1 = nullptr;
|
||||
if (SUCCEEDED(swapchain->QueryInterface(IID_PPV_ARGS(&sc1))) && sc1) {
|
||||
if (hook_vtbl(sc1, 22, (void *) Present1_hook,
|
||||
(void **) &Present1_orig, "IDXGISwapChain1::Present1")) {
|
||||
g_swapchain1_hooked = true;
|
||||
}
|
||||
sc1->Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // SPICE_D3D11
|
||||
@@ -0,0 +1,175 @@
|
||||
// proactive vtable capture for the dx11 backend.
|
||||
//
|
||||
// titles under the execexe loader routinely race past our export-level
|
||||
// trampolines, so the game's first real swapchain never goes through us.
|
||||
// we sidestep that by creating a throwaway device + swapchain ourselves
|
||||
// the moment d3d11.dll + dxgi.dll appear, which patches the shared
|
||||
// IDXGISwapChain[1] / IDXGIFactory[2] vtables ahead of the game.
|
||||
|
||||
#include "d3d11_backend.h"
|
||||
|
||||
#ifdef SPICE_D3D11
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
|
||||
#include <windows.h>
|
||||
#include <d3d11.h>
|
||||
#include <dxgi.h>
|
||||
#include <dxgi1_2.h>
|
||||
|
||||
#include "d3d11_internal.h"
|
||||
|
||||
using d3d11_hooks::com_ptr;
|
||||
|
||||
namespace {
|
||||
|
||||
using D3D11CreateDevice_t = HRESULT(WINAPI *)(
|
||||
IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT,
|
||||
const D3D_FEATURE_LEVEL *, UINT, UINT,
|
||||
ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
|
||||
using CreateDXGIFactory1_t = HRESULT(WINAPI *)(REFIID, void **);
|
||||
using CreateDXGIFactory2_t = HRESULT(WINAPI *)(UINT, REFIID, void **);
|
||||
|
||||
std::atomic<bool> g_vtables_captured { false };
|
||||
|
||||
template<typename Fn>
|
||||
Fn resolve(HMODULE mod, const char *name) {
|
||||
return reinterpret_cast<Fn>(GetProcAddress(mod, name));
|
||||
}
|
||||
|
||||
com_ptr<IDXGIFactory2> create_factory2(CreateDXGIFactory2_t f2,
|
||||
CreateDXGIFactory1_t f1)
|
||||
{
|
||||
IDXGIFactory2 *raw = nullptr;
|
||||
if (f2 && SUCCEEDED(f2(0, IID_PPV_ARGS(&raw))) && raw) {
|
||||
return com_ptr<IDXGIFactory2>(raw);
|
||||
}
|
||||
IDXGIFactory1 *factory1 = nullptr;
|
||||
if (f1 && SUCCEEDED(f1(IID_PPV_ARGS(&factory1))) && factory1) {
|
||||
factory1->QueryInterface(IID_PPV_ARGS(&raw));
|
||||
factory1->Release();
|
||||
}
|
||||
return com_ptr<IDXGIFactory2>(raw);
|
||||
}
|
||||
|
||||
bool create_dummy_device(D3D11CreateDevice_t create,
|
||||
com_ptr<ID3D11Device> &device,
|
||||
com_ptr<ID3D11DeviceContext> &context)
|
||||
{
|
||||
static constexpr D3D_FEATURE_LEVEL levels[] = {
|
||||
D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0,
|
||||
D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0,
|
||||
};
|
||||
// hardware first, then WARP so headless / unusual configs still work.
|
||||
for (auto type : { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP }) {
|
||||
ID3D11Device *d = nullptr;
|
||||
ID3D11DeviceContext *c = nullptr;
|
||||
D3D_FEATURE_LEVEL got;
|
||||
if (SUCCEEDED(create(nullptr, type, nullptr, 0,
|
||||
levels, ARRAYSIZE(levels), D3D11_SDK_VERSION,
|
||||
&d, &got, &c)) && d) {
|
||||
device.reset(d);
|
||||
context.reset(c);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace d3d11_hooks {
|
||||
|
||||
// create a throwaway device + swapchain to patch the shared vtables before
|
||||
// the game's loader races past our export trampolines. safe to call
|
||||
// repeatedly; runs at most once.
|
||||
void try_capture_vtables() {
|
||||
if (g_vtables_captured.load()) {
|
||||
return;
|
||||
}
|
||||
|
||||
HMODULE d3d11 = GetModuleHandleW(L"d3d11.dll");
|
||||
HMODULE dxgi = GetModuleHandleW(L"dxgi.dll");
|
||||
if (!d3d11 || !dxgi) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto create_device = resolve<D3D11CreateDevice_t>(d3d11, "D3D11CreateDevice");
|
||||
auto f2 = resolve<CreateDXGIFactory2_t>(dxgi, "CreateDXGIFactory2");
|
||||
auto f1 = resolve<CreateDXGIFactory1_t>(dxgi, "CreateDXGIFactory1");
|
||||
if (!create_device || (!f1 && !f2)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// serialize concurrent calls (poll thread + LDR notification). only
|
||||
// flip g_vtables_captured after success so failed attempts remain
|
||||
// retriable on the next tick.
|
||||
static std::atomic<bool> in_progress { false };
|
||||
if (in_progress.exchange(true)) {
|
||||
return;
|
||||
}
|
||||
struct scope_clear {
|
||||
std::atomic<bool> &flag;
|
||||
~scope_clear() { flag.store(false); }
|
||||
} clear { in_progress };
|
||||
|
||||
// hidden message-only window; STATIC is always registered by user32.
|
||||
HWND dummy_hwnd = CreateWindowExW(
|
||||
0, L"STATIC", L"", 0, 0, 0, 1, 1,
|
||||
HWND_MESSAGE, nullptr, GetModuleHandleW(nullptr), nullptr);
|
||||
if (!dummy_hwnd) {
|
||||
log_warning("graphics::d3d11",
|
||||
"vtable capture: CreateWindowExW failed (gle={})", (unsigned long)GetLastError());
|
||||
return;
|
||||
}
|
||||
auto destroy_hwnd = std::unique_ptr<HWND__, decltype(&DestroyWindow)>(
|
||||
dummy_hwnd, &DestroyWindow);
|
||||
|
||||
// if the game's CreateDXGIFactory_hook already raced us, our
|
||||
// CreateSwapChainForHwnd call below would trip the hook and try to
|
||||
// record dummy_hwnd as the main window. block that.
|
||||
ignore_hwnd(dummy_hwnd);
|
||||
|
||||
auto factory2 = create_factory2(f2, f1);
|
||||
if (!factory2) {
|
||||
log_warning("graphics::d3d11", "vtable capture: CreateDXGIFactory* failed");
|
||||
return;
|
||||
}
|
||||
|
||||
com_ptr<ID3D11Device> device;
|
||||
com_ptr<ID3D11DeviceContext> context;
|
||||
if (!create_dummy_device(create_device, device, context)) {
|
||||
log_warning("graphics::d3d11", "vtable capture: D3D11CreateDevice failed");
|
||||
return;
|
||||
}
|
||||
|
||||
DXGI_SWAP_CHAIN_DESC1 desc {};
|
||||
desc.Width = 1;
|
||||
desc.Height = 1;
|
||||
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
||||
desc.BufferCount = 2;
|
||||
desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
|
||||
|
||||
IDXGISwapChain1 *raw_sc = nullptr;
|
||||
HRESULT hr = factory2->CreateSwapChainForHwnd(
|
||||
device.get(), dummy_hwnd, &desc, nullptr, nullptr, &raw_sc);
|
||||
if (FAILED(hr) || !raw_sc) {
|
||||
log_warning("graphics::d3d11",
|
||||
"vtable capture: CreateSwapChainForHwnd failed (hr={:#x})", (unsigned long)hr);
|
||||
return;
|
||||
}
|
||||
com_ptr<IDXGISwapChain1> swapchain(raw_sc);
|
||||
|
||||
install_swapchain_hooks(swapchain.get());
|
||||
install_factory_hooks(factory2.get());
|
||||
|
||||
g_vtables_captured.store(true);
|
||||
log_info("graphics::d3d11", "vtable capture complete (via dummy swapchain)");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // SPICE_D3D11
|
||||
@@ -18,6 +18,7 @@
|
||||
#include "games/iidx/iidx.h"
|
||||
#include "games/popn/popn.h"
|
||||
#include "hooks/graphics/backends/d3d9/d3d9_backend.h"
|
||||
#include "hooks/graphics/backends/d3d11/d3d11_backend.h"
|
||||
#include "launcher/shutdown.h"
|
||||
#include "overlay/overlay.h"
|
||||
#include "touch/touch.h"
|
||||
@@ -859,6 +860,7 @@ void graphics_init() {
|
||||
|
||||
// init backends
|
||||
graphics_d3d9_init();
|
||||
graphics_d3d11_init();
|
||||
|
||||
// general hooks
|
||||
ChangeDisplaySettingsA_orig = detour::iat_try("ChangeDisplaySettingsA", ChangeDisplaySettingsA_hook);
|
||||
|
||||
Reference in New Issue
Block a user