fix(alttab-fullscreen): patch SetFullscreenState to actually keep us windowed

MakeWindowAssociation(NO_ALT_ENTER) only blocks DXGI's automatic alt-enter
on the IDXGIFactory we walked back to via swapchain->GetParent(). It does
nothing against:

  - direct SetFullscreenState(TRUE,...) calls from the engine, which still
    happen because we silently rewrote Windowed=FALSE to TRUE and the engine's
    own renderer state still expects exclusive
  - DXGI's auto alt-enter on any other IDXGIFactory the process creates
    later for the same HWND (HighFPSPhysicsFix, ENB, or the engine itself
    enumerating adapters)

When either path fires, DXGI tries to transition the swap chain back into
exclusive fullscreen. Whether that succeeds, fails, or partially applies
depends on monitor state and timing, which shifts the window focus events
off the vanilla timeline. perchik71 hit the soft Creations load-order
mismatch dialog at ~1-in-10-20 launches, bisected to this module; the
working theory is that the focus-event timing shift races the Bethesda.net
Creations refresh callback against the save's CC list comparison.

This vtable-hooks slot 10 (SetFullscreenState) on the IDXGISwapChain
returned from D3D11CreateDeviceAndSwapChain. TRUE transitions on the game's
HWND are short-circuited to S_OK without forwarding; FALSE transitions
forward to the original. Scoping by HWND inside the hook avoids touching
other mods' swap chains (ReShade/ENB) that share the same vtable.

Notes:
- Pre-publish the original function pointer to std::atomic before calling
  DetourVTable, so a racing thread that catches the patched vtable never
  sees nullptr in the forward path.
- Patch is once-only via compare_exchange; failure rolls the flag back so
  the next D3D11Create attempt can retry.
- Logs MakeWindowAssociation failure (was previously silently swallowed).
- Existing Windowed=TRUE rewrite and MakeWindowAssociation calls preserved
  as belt-and-suspenders.

Author: northaxosky

Addictol/Source/Modules/AdModuleAltTabFullscreen.cpp

@@ -15,7 +15,33 @@ namespace Addictol
 		const DXGI_SWAP_CHAIN_DESC*, IDXGISwapChain**,
 		ID3D11Device**, D3D_FEATURE_LEVEL*, ID3D11DeviceContext**);
 
+	using TSetFullscreenState = HRESULT(WINAPI*)(IDXGISwapChain*, BOOL, IDXGIOutput*);
+
 	static TD3D11CreateDeviceAndSwapChain OriginalCreate = nullptr;
+	static std::atomic<TSetFullscreenState> OriginalSetFullscreenState{ nullptr };
+	static std::atomic<HWND> g_gameHwnd{ nullptr };
+	static std::atomic<bool> g_vtablePatched{ false };
+
+	static HRESULT WINAPI Hook_SetFullscreenState(IDXGISwapChain* a_this, BOOL a_fullscreen, IDXGIOutput* a_output) noexcept
+	{
+		const auto orig = OriginalSetFullscreenState.load(std::memory_order_acquire);
+
+		// Only block exclusive transitions on the game's own swap chain. ReShade/ENB/overlays
+		// that create their own swap chains in-process get their calls forwarded untouched.
+		if (a_fullscreen)
+		{
+			DXGI_SWAP_CHAIN_DESC desc{};
+			const auto descHr = a_this->GetDesc(&desc);
+			const auto gameHwnd = g_gameHwnd.load(std::memory_order_relaxed);
+			if (SUCCEEDED(descHr) && desc.OutputWindow == gameHwnd && gameHwnd)
+			{
+				REX::INFO("Alt-Tab Fullscreen: SetFullscreenState(TRUE) blocked on game window."sv);
+				return S_OK;
+			}
+		}
+
+		return orig ? orig(a_this, a_fullscreen, a_output) : S_OK;
+	}
 
 	static HRESULT WINAPI Hook_D3D11Create(
 		IDXGIAdapter*            a_adapter,
@@ -58,8 +84,43 @@ namespace Addictol
 		IDXGIFactory* factory = nullptr;
 		if (SUCCEEDED((*a_outSwapChain)->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&factory))) && factory)
 		{
-			factory->MakeWindowAssociation(descToUse->OutputWindow, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
+			const auto mwaHr = factory->MakeWindowAssociation(descToUse->OutputWindow, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
 			factory->Release();
+			if (FAILED(mwaHr))
+			{
+				REX::WARN("Alt-Tab Fullscreen: MakeWindowAssociation failed (hr=0x{:08X})."sv, static_cast<std::uint32_t>(mwaHr));
+			}
+		}
+
+		// MakeWindowAssociation only catches DXGI's auto alt-enter on this factory. Direct
+		// SetFullscreenState(TRUE) from the engine or another mod still goes through, and a
+		// second IDXGIFactory created later for the same HWND has its own (unset) association.
+		// Patch the shared swap chain vtable so every path lands in our short-circuit; scope
+		// the block by HWND inside the hook so we don't touch other mods' swap chains.
+		g_gameHwnd.store(descToUse->OutputWindow, std::memory_order_relaxed);
+
+		bool expected = false;
+		if (g_vtablePatched.compare_exchange_strong(expected, true))
+		{
+			constexpr std::uint32_t kSetFullscreenStateSlot = 10;
+			auto** const vtablePtr = *reinterpret_cast<void***>(*a_outSwapChain);
+			// Publish the original first so a racing thread that catches the patched vtable
+			// never sees a null original pointer in the FALSE forward path.
+			OriginalSetFullscreenState.store(
+				reinterpret_cast<TSetFullscreenState>(vtablePtr[kSetFullscreenStateSlot]),
+				std::memory_order_release);
+
+			const auto vtableAddr = reinterpret_cast<std::uintptr_t>(vtablePtr);
+			const auto returned = RELEX::DetourVTable(
+				vtableAddr,
+				reinterpret_cast<std::uintptr_t>(&Hook_SetFullscreenState),
+				kSetFullscreenStateSlot);
+			if (!returned)
+			{
+				REX::WARN("Alt-Tab Fullscreen: SetFullscreenState vtable patch failed."sv);
+				OriginalSetFullscreenState.store(nullptr, std::memory_order_release);
+				g_vtablePatched.store(false);
+			}
 		}
 
 		return hr;