MCD: Stop Memcard Folders spamming the console/OSD when saving a game

GS/HW: Make readback-on-close a HW fix
Unfortunately it's too risky to enable by default all the time. So, we'll make it a hw fix, and hopefully one day can make it default on. Also makes save states readback the TC as well.
2026-01-31 01:15:24 +01:00 · 2023-02-23 18:02:07 +00:00 · 2023-02-23 17:25:03 +00:00 · 2023-02-23 17:25:03 +00:00 · 2023-02-23 10:12:05 +00:00 · 2023-02-23 10:12:05 +00:00
112 changed files with 3019 additions and 2025 deletions
--- a/README.md
+++ b/README.md
@@ -36,10 +36,10 @@ _Note: Recommended GPU is based on 3x Internal, ~1080p resolution requirements.

 ### Technical Notes

-   You need the [Visual C++ 2019 x64 Redistributables](https://support.microsoft.com/en-us/help/2977003/) to run PCSX2.
+-   You need the [Visual C++ 2019 x64 Redistributables](https://support.microsoft.com/en-us/help/2977003/) to run PCSX2 on Windows.
 -   Windows XP and Direct3D9 support was dropped after stable release 1.4.0.
 -   Windows 7, Windows 8.0, and Windows 8.1 support was dropped after stable release 1.6.0.
-   32-bit and wxwidgets support was dropped after stable release 1.6.0, with the wxwidgets code being removed completely on 25th December 2022.
+-   32-bit and wxWidgets support was dropped after stable release 1.6.0, with the wxWidgets code being removed completely on 25th December 2022.
 -   Make sure to update your operating system and drivers to ensure you have the best experience possible. Having a newer GPU is also recommended so you have the latest supported drivers.
 -   Because of copyright issues, and the complexity of trying to work around it, you need a BIOS dump extracted from a legitimately-owned PS2 console to use the emulator. For more information about the BIOS and how to get it from your console, visit [this page](pcsx2/Docs/PCSX2_FAQ.md#question-13-where-do-i-get-a-ps2-bios).
 -   PCSX2 uses two CPU cores for emulation by default. A third core can be used via the MTVU speed hack, which is compatible with most games. This can be a significant speedup on CPUs with 3+ cores, but it may be a slowdown on GS-limited games (or on CPUs with fewer than 2 cores). Software renderers will then additionally use however many rendering threads it is set to and will need higher core counts to run efficiently.
--- a/bin/resources/GameIndex.yaml
+++ b/bin/resources/GameIndex.yaml
--- a/bin/resources/game_controller_db.txt
+++ b/bin/resources/game_controller_db.txt
@@ -543,7 +543,7 @@
 030000009b2800001e00000000000000,Raphnet Vectrex Adapter,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a1,lefty:a2,x:b2,y:b3,platform:Windows,
 030000009b2800002b00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
 030000009b2800002c00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
-030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,x:b0,y:b5,back:b2,guide:b10,start:b3,leftshoulder:b6,rightshoulder:b7,dpup:b12,dpleft:b14,dpdown:b13,dpright:b15,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b8,righttrigger:b9,platform:Windows,
+030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
 03000000321500000003000000000000,Razer Hydra,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000321500000204000000000000,Razer Panthera PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,
 03000000321500000104000000000000,Razer Panthera PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
@@ -850,6 +850,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f00003801000008010000,Hori PC Engine Mini Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,platform:Mac OS X,
 030000000d0f00009200000000010000,Hori Pokken Tournament DX Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f0000aa00000072050000,Hori Real Arcade Pro,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,
+030000000d0f00000002000015010000,Hori Switch Split Pad Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006e00000000010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006600000000010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006600000000000000,Horipad FPS Plus 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
@@ -992,6 +993,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005e040000130b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000200b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000200b000013050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
+030000005e040000200b000015050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000d102000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
 030000005e040000dd02000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
 030000005e040000e002000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,
@@ -1176,6 +1178,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f00006a00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006b00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00001600000000010000,Hori Real Arcade Pro EXSE,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,
+030000000d0f00008501000015010000,Hori Switch Split Pad Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000000d0f00006e00000011010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006600000011010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f0000ee00000011010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
@@ -1271,6 +1274,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005e0400008902000021010000,Microsoft Xbox pad v2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
 03000000030000000300000002000000,Miroof,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,
 050000004d4f435554452d3035335800,Mocute 053X,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
+05000000e80400006e0400001b010000,Mocute 053X M59,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000004d4f435554452d3035305800,Mocute 054X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 05000000d6200000e589000001000000,Moga 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,
 05000000d6200000ad0d000001000000,Moga Pro,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,
@@ -1547,6 +1551,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 050000005e040000130b000009050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000013050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 060000005e040000120b00000b050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e040000120b00000f050000,Xbox Series Controller,a:b0,b:b1,y:b3,x:b2,start:b7,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:b12,dpleft:b14,dpdown:b13,dpright:b15,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux,
 030000005e040000120b000007050000,Xbox Series X Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000005e040000130b000007050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000011050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
--- a/bin/resources/shaders/dx11/tfx.fx
+++ b/bin/resources/shaders/dx11/tfx.fx
@@ -38,6 +38,7 @@
 #define PS_POINT_SAMPLER 0
 #define PS_SHUFFLE 0
 #define PS_READ_BA 0
+#define PS_READ16_SRC 0
 #define PS_DFMT 0
 #define PS_DEPTH_FMT 0
 #define PS_PAL_FMT 0
@@ -877,26 +878,37 @@ PS_OUTPUT ps_main(PS_INPUT input)
 	{
 		uint4 denorm_c = uint4(C);
 		uint2 denorm_TA = uint2(float2(TA.xy) * 255.0f + 0.5f);
-
-		// Mask will take care of the correct destination
-		if (PS_READ_BA)
-			C.rb = C.bb;
-		else
-			C.rb = C.rr;
-
-		if (PS_READ_BA)
+		
+		if (PS_READ16_SRC)
 		{
+			C.rb = (float2)float((denorm_c.r >> 3) | (((denorm_c.g >> 3) & 0x7u) << 5));
 			if (denorm_c.a & 0x80u)
-				C.ga = (float2)(float((denorm_c.a & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				C.ga = (float2)float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.y & 0x80u));
 			else
-				C.ga = (float2)(float((denorm_c.a & 0x7Fu) | (denorm_TA.x & 0x80u)));
+				C.ga = (float2)float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.x & 0x80u));
 		}
 		else
 		{
-			if (denorm_c.g & 0x80u)
-				C.ga = (float2)(float((denorm_c.g & 0x7Fu) | (denorm_TA.y & 0x80u)));
+			// Mask will take care of the correct destination
+			if (PS_READ_BA)
+				C.rb = C.bb;
 			else
-				C.ga = (float2)(float((denorm_c.g & 0x7Fu) | (denorm_TA.x & 0x80u)));
+				C.rb = C.rr;
+
+			if (PS_READ_BA)
+			{
+				if (denorm_c.a & 0x80u)
+					C.ga = (float2)(float((denorm_c.a & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				else
+					C.ga = (float2)(float((denorm_c.a & 0x7Fu) | (denorm_TA.x & 0x80u)));
+			}
+			else
+			{
+				if (denorm_c.g & 0x80u)
+					C.ga = (float2)(float((denorm_c.g & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				else
+					C.ga = (float2)(float((denorm_c.g & 0x7Fu) | (denorm_TA.x & 0x80u)));
+			}
 		}
 	}

--- a/bin/resources/shaders/opengl/tfx_fs.glsl
+++ b/bin/resources/shaders/opengl/tfx_fs.glsl
@@ -871,7 +871,13 @@ void ps_main()
 #if PS_SHUFFLE
    uvec4 denorm_c = uvec4(C);
    uvec2 denorm_TA = uvec2(vec2(TA.xy) * 255.0f + 0.5f);
-
+#if PS_READ16_SRC
+	C.rb = vec2(float((denorm_c.r >> 3) | (((denorm_c.g >> 3) & 0x7u) << 5)));
+	if (bool(denorm_c.a & 0x80u))
+		C.ga = vec2(float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.y & 0x80u)));
+	else
+		C.ga = vec2(float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.x & 0x80u)));
+#else
    // Write RB part. Mask will take care of the correct destination
 #if PS_READ_BA
    C.rb = C.bb;
@@ -907,9 +913,10 @@ void ps_main()
    // float sel = step(128.0f, c.g);
    // vec2 c_shuffle = vec2((denorm_c.gg & 0x7Fu) | (denorm_TA & 0x80u));
    // c.ga = mix(c_shuffle.xx, c_shuffle.yy, sel);
-#endif
+#endif // PS_READ_BA

-#endif
+#endif // READ16_SRC
+#endif // PS_SHUFFLE

    // Must be done before alpha correction

--- a/bin/resources/shaders/vulkan/tfx.glsl
+++ b/bin/resources/shaders/vulkan/tfx.glsl
@@ -328,6 +328,7 @@ void main()
 #define PS_POINT_SAMPLER 0
 #define PS_SHUFFLE 0
 #define PS_READ_BA 0
+#define PS_READ16_SRC 0
 #define PS_DFMT 0
 #define PS_DEPTH_FMT 0
 #define PS_PAL_FMT 0
@@ -1175,24 +1176,31 @@ void main()
 	#if PS_SHUFFLE
 		uvec4 denorm_c = uvec4(C);
 		uvec2 denorm_TA = uvec2(vec2(TA.xy) * 255.0f + 0.5f);
-
-		// Mask will take care of the correct destination
-		#if PS_READ_BA
-			C.rb = C.bb;
-		#else
-			C.rb = C.rr;
-		#endif
-
-		#if PS_READ_BA
+		#if PS_READ16_SRC
+			C.rb = vec2(float((denorm_c.r >> 3) | (((denorm_c.g >> 3) & 0x7u) << 5)));
 			if ((denorm_c.a & 0x80u) != 0u)
-				C.ga = vec2(float((denorm_c.a & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				C.ga = vec2(float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.y & 0x80u)));
 			else
-				C.ga = vec2(float((denorm_c.a & 0x7Fu) | (denorm_TA.x & 0x80u)));
+				C.ga = vec2(float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.x & 0x80u)));
 		#else
-			if ((denorm_c.g & 0x80u) != 0u)
-				C.ga = vec2(float((denorm_c.g & 0x7Fu) | (denorm_TA.y & 0x80u)));
-			else
-				C.ga = vec2(float((denorm_c.g & 0x7Fu) | (denorm_TA.x & 0x80u)));
+			// Mask will take care of the correct destination
+			#if PS_READ_BA
+				C.rb = C.bb;
+			#else
+				C.rb = C.rr;
+			#endif
+
+			#if PS_READ_BA
+				if ((denorm_c.a & 0x80u) != 0u)
+					C.ga = vec2(float((denorm_c.a & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				else
+					C.ga = vec2(float((denorm_c.a & 0x7Fu) | (denorm_TA.x & 0x80u)));
+			#else
+				if ((denorm_c.g & 0x80u) != 0u)
+					C.ga = vec2(float((denorm_c.g & 0x7Fu) | (denorm_TA.y & 0x80u)));
+				else
+					C.ga = vec2(float((denorm_c.g & 0x7Fu) | (denorm_TA.x & 0x80u)));
+			#endif
 		#endif
 	#endif

--- a/cmake/Pcsx2Utils.cmake
+++ b/cmake/Pcsx2Utils.cmake
@@ -10,8 +10,9 @@ function(detectOperatingSystem)
 	if(WIN32)
 		set(Windows TRUE PARENT_SCOPE)
 	elseif(UNIX AND APPLE)
-		# No easy way to filter out iOS.
-		message(WARNING "OS X/iOS isn't supported, the build will most likely fail")
+		if(IOS)
+			message(WARNING "iOS isn't supported, the build will most likely fail")
+		endif()
 		set(MacOSX TRUE PARENT_SCOPE)
 	elseif(UNIX)
 		if(CMAKE_SYSTEM_NAME MATCHES "Linux")
--- a/common/D3D12/Context.cpp
+++ b/common/D3D12/Context.cpp
@@ -445,7 +445,7 @@ ID3D12GraphicsCommandList4* Context::GetInitCommandList()
 	return res.command_lists[0].get();
 }

-void Context::ExecuteCommandList(WaitType wait_for_completion)
+bool Context::ExecuteCommandList(WaitType wait_for_completion)
 {
 	CommandListResources& res = m_command_lists[m_current_command_list];
 	HRESULT hr;
@@ -463,12 +463,21 @@ void Context::ExecuteCommandList(WaitType wait_for_completion)
 	if (res.init_command_list_used)
 	{
 		hr = res.command_lists[0]->Close();
-		pxAssertRel(SUCCEEDED(hr), "Close init command list");
+		if (FAILED(hr))
+		{
+			Console.Error("Closing init command list failed with HRESULT %08X", hr);
+			return false;
+		}
 	}

 	// Close and queue command list.
 	hr = res.command_lists[1]->Close();
-	pxAssertRel(SUCCEEDED(hr), "Close command list");
+	if (FAILED(hr))
+	{
+		Console.Error("Closing main command list failed with HRESULT %08X", hr);
+		return false;
+	}
+
 	if (res.init_command_list_used)
 	{
 		const std::array<ID3D12CommandList*, 2> execute_lists{res.command_lists[0].get(), res.command_lists[1].get()};
@@ -487,6 +496,8 @@ void Context::ExecuteCommandList(WaitType wait_for_completion)
 	MoveToNextCommandList();
 	if (wait_for_completion != WaitType::None)
 		WaitForFence(res.ready_fence_value, wait_for_completion == WaitType::Spin);
+
+	return true;
 }

 void Context::InvalidateSamplerGroups()
--- a/common/D3D12/Context.h
+++ b/common/D3D12/Context.h
@@ -130,7 +130,7 @@ namespace D3D12
 		};

 		/// Executes the current command list.
-		void ExecuteCommandList(WaitType wait_for_completion);
+		bool ExecuteCommandList(WaitType wait_for_completion);

 		/// Waits for a specific fence.
 		void WaitForFence(u64 fence, bool spin);
--- a/common/GL/Context.cpp
+++ b/common/GL/Context.cpp
@@ -119,7 +119,7 @@ namespace GL
 		if (!context)
 			return nullptr;

-		Console.WriteLn("Created a %s context", context->IsGLES() ? "OpenGL ES" : "OpenGL");
+		Console.WriteLn("Created an %s context", context->IsGLES() ? "OpenGL ES" : "OpenGL");

 		// NOTE: Not thread-safe. But this is okay, since we're not going to be creating more than one context at a time.
 		static Context* context_being_created;
--- a/common/Linux/LnxHostSys.cpp
+++ b/common/Linux/LnxHostSys.cpp
@@ -100,6 +100,8 @@ static void SysPageFaultSignalFilter(int signal, siginfo_t* siginfo, void* ctx)

 #if defined(__APPLE__) && defined(__x86_64__)
 	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext->__ss.__rip);
+#elif defined(__FreeBSD__) && defined(__x86_64__)
+	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.mc_rip);
 #elif defined(__x86_64__)
 	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.gregs[REG_RIP]);
 #else
--- a/common/Vulkan/Context.cpp
+++ b/common/Vulkan/Context.cpp
@@ -1122,9 +1122,13 @@ namespace Vulkan
 	void Context::WaitForCommandBufferCompletion(u32 index)
 	{
 		// Wait for this command buffer to be completed.
-		VkResult res = vkWaitForFences(m_device, 1, &m_frame_resources[index].fence, VK_TRUE, UINT64_MAX);
+		const VkResult res = vkWaitForFences(m_device, 1, &m_frame_resources[index].fence, VK_TRUE, UINT64_MAX);
 		if (res != VK_SUCCESS)
+		{
 			LOG_VULKAN_ERROR(res, "vkWaitForFences failed: ");
+			m_last_submit_failed.store(true, std::memory_order_release);
+			return;
+		}

 		// Clean up any resources for command buffers between the last known completed buffer and this
 		// now-completed command buffer. If we use >2 buffers, this may be more than one buffer.
@@ -1266,11 +1270,12 @@ namespace Vulkan
 			submit_info.pSignalSemaphores = &m_spin_resources[index].semaphore;
 		}

-		VkResult res = vkQueueSubmit(m_graphics_queue, 1, &submit_info, resources.fence);
+		const VkResult res = vkQueueSubmit(m_graphics_queue, 1, &submit_info, resources.fence);
 		if (res != VK_SUCCESS)
 		{
 			LOG_VULKAN_ERROR(res, "vkQueueSubmit failed: ");
-			pxFailRel("Failed to submit command buffer.");
+			m_last_submit_failed.store(true, std::memory_order_release);
+			return;
 		}

 		if (spin_cycles != 0)
@@ -1286,14 +1291,14 @@ namespace Vulkan

 		present_swap_chain->ReleaseCurrentImage();

-		VkResult res = vkQueuePresentKHR(m_present_queue, &present_info);
+		const VkResult res = vkQueuePresentKHR(m_present_queue, &present_info);
 		if (res != VK_SUCCESS)
 		{
 			// VK_ERROR_OUT_OF_DATE_KHR is not fatal, just means we need to recreate our swap chain.
 			if (res != VK_ERROR_OUT_OF_DATE_KHR && res != VK_SUBOPTIMAL_KHR)
 				LOG_VULKAN_ERROR(res, "vkQueuePresentKHR failed: ");

-			m_last_present_failed.store(true);
+			m_last_present_failed.store(true, std::memory_order_release);
 			return;
 		}

@@ -1460,6 +1465,9 @@ namespace Vulkan

 	void Context::ExecuteCommandBuffer(WaitType wait_for_completion)
 	{
+		if (m_last_submit_failed.load(std::memory_order_acquire))
+			return;
+
 		// If we're waiting for completion, don't bother waking the worker thread.
 		const u32 current_frame = m_current_frame;
 		SubmitCommandBuffer();
@@ -1481,9 +1489,12 @@ namespace Vulkan

 	bool Context::CheckLastPresentFail()
 	{
-		bool res = m_last_present_failed;
-		m_last_present_failed = false;
-		return res;
+		return m_last_present_failed.exchange(false, std::memory_order_acq_rel);
+	}
+
+	bool Context::CheckLastSubmitFail()
+	{
+		return m_last_submit_failed.load(std::memory_order_acquire);
 	}

 	void Context::DeferBufferDestruction(VkBuffer object)
@@ -1596,7 +1607,7 @@ namespace Vulkan
 				VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
 			DebugMessengerCallback, nullptr};

-		VkResult res =
+		const VkResult res =
 			vkCreateDebugUtilsMessengerEXT(m_instance, &messenger_info, nullptr, &m_debug_messenger_callback);
 		if (res != VK_SUCCESS)
 		{
@@ -1688,7 +1699,7 @@ namespace Vulkan
 			subpass_dependency_ptr};

 		VkRenderPass pass;
-		VkResult res = vkCreateRenderPass(m_device, &pass_info, nullptr, &pass);
+		const VkResult res = vkCreateRenderPass(m_device, &pass_info, nullptr, &pass);
 		if (res != VK_SUCCESS)
 		{
 			LOG_VULKAN_ERROR(res, "vkCreateRenderPass failed: ");
@@ -1894,9 +1905,14 @@ void main()
 		SpinResources& resources = m_spin_resources[index];
 		if (!resources.in_progress)
 			return;
-		VkResult res = vkWaitForFences(m_device, 1, &resources.fence, VK_TRUE, UINT64_MAX);
+
+		const VkResult res = vkWaitForFences(m_device, 1, &resources.fence, VK_TRUE, UINT64_MAX);
 		if (res != VK_SUCCESS)
+		{
 			LOG_VULKAN_ERROR(res, "vkWaitForFences failed: ");
+			m_last_submit_failed.store(true, std::memory_order_release);
+			return;
+		}
 		SpinCommandCompleted(index);
 	}

@@ -1906,7 +1922,7 @@ void main()
 		resources.in_progress = false;
 		const u32 timestamp_base = (index + NUM_COMMAND_BUFFERS) * 2;
 		std::array<u64, 2> timestamps;
-		VkResult res = vkGetQueryPoolResults(m_device, m_timestamp_query_pool, timestamp_base, static_cast<u32>(timestamps.size()),
+		const VkResult res = vkGetQueryPoolResults(m_device, m_timestamp_query_pool, timestamp_base, static_cast<u32>(timestamps.size()),
 			sizeof(timestamps), timestamps.data(), sizeof(u64), VK_QUERY_RESULT_64_BIT);
 		if (res == VK_SUCCESS)
 		{
@@ -2014,7 +2030,7 @@ void main()
 		constexpr u64 MAX_MAX_DEVIATION = 100000; // 100µs
 		for (int i = 0; i < 4; i++) // 4 tries to get under MAX_MAX_DEVIATION
 		{
-			VkResult res = vkGetCalibratedTimestampsEXT(m_device, std::size(infos), infos, timestamps, &maxDeviation);
+			const VkResult res = vkGetCalibratedTimestampsEXT(m_device, std::size(infos), infos, timestamps, &maxDeviation);
 			if (res != VK_SUCCESS)
 			{
 				LOG_VULKAN_ERROR(res, "vkGetCalibratedTimestampsEXT failed: ");
--- a/common/Vulkan/Context.h
+++ b/common/Vulkan/Context.h
@@ -209,6 +209,7 @@ namespace Vulkan

 		// Was the last present submitted to the queue a failure? If so, we must recreate our swapchain.
 		bool CheckLastPresentFail();
+		bool CheckLastSubmitFail();

 		// Schedule a vulkan resource for destruction later on. This will occur when the command buffer
 		// is next re-used, and the GPU has finished working with the specified resource.
@@ -373,6 +374,7 @@ namespace Vulkan

 		StreamBuffer m_texture_upload_buffer;

+		std::atomic_bool m_last_submit_failed{false};
 		std::atomic_bool m_last_present_failed{false};
 		std::atomic_bool m_present_done{true};
 		std::mutex m_present_mutex;
--- a/pcsx2-gsrunner/Main.cpp
+++ b/pcsx2-gsrunner/Main.cpp
@@ -280,7 +280,7 @@ void Host::ReleaseHostDisplay(bool clear_state)
 	g_host_display.reset();
 }

-bool Host::BeginPresentFrame(bool frame_skip)
+HostDisplay::PresentResult Host::BeginPresentFrame(bool frame_skip)
 {
 	if (s_loop_number == 0)
 	{
@@ -291,12 +291,15 @@ bool Host::BeginPresentFrame(bool frame_skip)
 		std::string dump_path(fmt::format("{}_frame{}.png", s_output_prefix, s_dump_frame_number));
 		GSQueueSnapshot(dump_path);
 	}
-	if (g_host_display->BeginPresent(frame_skip))
-		return true;

-	// don't render imgui
-	ImGuiManager::NewFrame();
-	return false;
+	const HostDisplay::PresentResult result = g_host_display->BeginPresent(frame_skip);
+	if (result != HostDisplay::PresentResult::OK)
+	{
+		// don't render imgui
+		ImGuiManager::SkipFrame();
+	}
+
+	return result;
 }

 void Host::EndPresentFrame()
--- a/pcsx2-qt/CMakeLists.txt
+++ b/pcsx2-qt/CMakeLists.txt
@@ -58,6 +58,7 @@ target_sources(pcsx2-qt PRIVATE
 	Settings/ControllerGlobalSettingsWidget.ui
 	Settings/ControllerMacroEditWidget.ui
 	Settings/ControllerMacroWidget.ui
+	Settings/ControllerMouseSettingsDialog.ui
 	Settings/ControllerSettingsDialog.cpp
 	Settings/ControllerSettingsDialog.h
 	Settings/ControllerSettingsDialog.ui
--- a/pcsx2-qt/MainWindow.cpp
+++ b/pcsx2-qt/MainWindow.cpp
@@ -983,27 +983,28 @@ void MainWindow::saveStateToConfig()
 	if (!isVisible())
 		return;

+	bool changed = false;
+
+	const QByteArray geometry(saveGeometry());
+	const QByteArray geometry_b64(geometry.toBase64());
+	const std::string old_geometry_b64(Host::GetBaseStringSettingValue("UI", "MainWindowGeometry"));
+	if (old_geometry_b64 != geometry_b64.constData())
 	{
-		const QByteArray geometry = saveGeometry();
-		const QByteArray geometry_b64 = geometry.toBase64();
-		const std::string old_geometry_b64 = Host::GetBaseStringSettingValue("UI", "MainWindowGeometry");
-		if (old_geometry_b64 != geometry_b64.constData())
-		{
-			Host::SetBaseStringSettingValue("UI", "MainWindowGeometry", geometry_b64.constData());
-			Host::CommitBaseSettingChanges();
-		}
+		Host::SetBaseStringSettingValue("UI", "MainWindowGeometry", geometry_b64.constData());
+		changed = true;
 	}

+	const QByteArray state(saveState());
+	const QByteArray state_b64(state.toBase64());
+	const std::string old_state_b64(Host::GetBaseStringSettingValue("UI", "MainWindowState"));
+	if (old_state_b64 != state_b64.constData())
 	{
-		const QByteArray state = saveState();
-		const QByteArray state_b64 = state.toBase64();
-		const std::string old_state_b64 = Host::GetBaseStringSettingValue("UI", "MainWindowState");
-		if (old_state_b64 != state_b64.constData())
-		{
-			Host::SetBaseStringSettingValue("UI", "MainWindowState", state_b64.constData());
-			Host::CommitBaseSettingChanges();
-		}
+		Host::SetBaseStringSettingValue("UI", "MainWindowState", state_b64.constData());
+		changed = true;
 	}
+
+	if (changed)
+		Host::CommitBaseSettingChanges();
 }

 void MainWindow::restoreStateFromConfig()
@@ -1979,6 +1980,7 @@ void MainWindow::closeEvent(QCloseEvent* event)
 	// If there's no VM, we can just exit as normal.
 	if (!s_vm_valid)
 	{
+		saveStateToConfig();
 		QMainWindow::closeEvent(event);
 		return;
 	}
@@ -1992,7 +1994,6 @@ void MainWindow::closeEvent(QCloseEvent* event)
 		return;

 	// Application will be exited in VM stopped handler.
-	saveStateToConfig();
 	m_is_closing = true;
 }

--- a/pcsx2-qt/QtHost.cpp
+++ b/pcsx2-qt/QtHost.cpp
@@ -967,17 +967,17 @@ void Host::ReleaseHostDisplay(bool clear_state)
 	g_emu_thread->releaseHostDisplay(clear_state);
 }

-bool Host::BeginPresentFrame(bool frame_skip)
+HostDisplay::PresentResult Host::BeginPresentFrame(bool frame_skip)
 {
-	if (!g_host_display->BeginPresent(frame_skip))
+	const HostDisplay::PresentResult result = g_host_display->BeginPresent(frame_skip);
+	if (result != HostDisplay::PresentResult::OK)
 	{
 		// if we're skipping a frame, we need to reset imgui's state, since
 		// we won't be calling EndPresentFrame().
-		ImGuiManager::NewFrame();
-		return false;
+		ImGuiManager::SkipFrame();
 	}

-	return true;
+	return result;
 }

 void Host::EndPresentFrame()
--- a/pcsx2-qt/Settings/AdvancedSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/AdvancedSettingsWidget.cpp
@@ -72,7 +72,7 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(SettingsDialog* dialog, QWidget*
 	dialog->registerWidgetHelp(m_ui.eeClampMode, tr("Clamping Mode"), tr("Normal (Default)"), tr(""));

 	dialog->registerWidgetHelp(m_ui.eeRecompiler, tr("Enable Recompiler"), tr("Checked"),
-		tr("Performs just - in - time binary translation of 64 - bit MIPS - IV machine code to x86."));
+		tr("Performs just-in-time binary translation of 64-bit MIPS-IV machine code to x86."));

 	dialog->registerWidgetHelp(m_ui.eeWaitLoopDetection, tr("Wait Loop Detection"), tr("Checked"),
 		tr("Moderate speedup for some games, with no known side effects."));
@@ -86,7 +86,7 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(SettingsDialog* dialog, QWidget*
 		tr("Uses backpatching to avoid register flushing on every memory access."));

 	dialog->registerWidgetHelp(m_ui.pauseOnTLBMiss, tr("Pause On TLB Miss"), tr("Unchecked"),
-		tr("Pauses the virtual machine when a TLB miss occurs, instead of ignoring it and continuing. Note the the VM will pause after the "
+		tr("Pauses the virtual machine when a TLB miss occurs, instead of ignoring it and continuing. Note that the VM will pause after the "
 		   "end of the block, not on the instruction which caused the exception. Refer to the console to see the address where the invalid "
 		   "access occurred."));

--- a/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.cpp
@@ -45,10 +45,10 @@ ControllerGlobalSettingsWidget::ControllerGlobalSettingsWidget(QWidget* parent,
 #endif

 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.enableMouseMapping, "UI", "EnableMouseMapping", false);
+	connect(m_ui.mouseSettings, &QToolButton::clicked, this, &ControllerGlobalSettingsWidget::mouseSettingsClicked);
+
 	ControllerSettingWidgetBinder::BindWidgetToInputProfileBool(sif, m_ui.multitapPort1, "Pad", "MultitapPort1", false);
 	ControllerSettingWidgetBinder::BindWidgetToInputProfileBool(sif, m_ui.multitapPort2, "Pad", "MultitapPort2", false);
-	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerXScale, "Pad", "PointerXScale", 8.0f);
-	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerYScale, "Pad", "PointerYScale", 8.0f);

 #ifdef _WIN32
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.enableXInputSource, "InputSources", "XInput", false);
@@ -81,13 +81,6 @@ ControllerGlobalSettingsWidget::ControllerGlobalSettingsWidget(QWidget* parent,
 	for (QCheckBox* cb : {m_ui.multitapPort1, m_ui.multitapPort2})
 		connect(cb, &QCheckBox::stateChanged, this, [this]() { emit bindingSetupChanged(); });

-	connect(m_ui.pointerXScale, &QSlider::valueChanged, this,
-		[this](int value) { m_ui.pointerXScaleLabel->setText(QStringLiteral("%1").arg(value)); });
-	connect(m_ui.pointerYScale, &QSlider::valueChanged, this,
-		[this](int value) { m_ui.pointerYScaleLabel->setText(QStringLiteral("%1").arg(value)); });
-	m_ui.pointerXScaleLabel->setText(QStringLiteral("%1").arg(m_ui.pointerXScale->value()));
-	m_ui.pointerYScaleLabel->setText(QStringLiteral("%1").arg(m_ui.pointerYScale->value()));
-
 	updateSDLOptionsEnabled();
 }

@@ -128,6 +121,12 @@ void ControllerGlobalSettingsWidget::ledSettingsClicked()
 	dialog.exec();
 }

+void ControllerGlobalSettingsWidget::mouseSettingsClicked()
+{
+	ControllerMouseSettingsDialog dialog(this, m_dialog);
+	dialog.exec();
+}
+
 ControllerLEDSettingsDialog::ControllerLEDSettingsDialog(QWidget* parent, ControllerSettingsDialog* dialog)
 	: QDialog(parent)
 	, m_dialog(dialog)
@@ -156,3 +155,35 @@ void ControllerLEDSettingsDialog::linkButton(ColorPickerButton* button, u32 play
 	});
 #endif
 }
+
+ControllerMouseSettingsDialog::ControllerMouseSettingsDialog(QWidget* parent, ControllerSettingsDialog* dialog)
+	: QDialog(parent)
+{
+	m_ui.setupUi(this);
+
+	SettingsInterface* sif = dialog->getProfileSettingsInterface();
+
+	m_ui.icon->setPixmap(QIcon::fromTheme(QStringLiteral("mouse-line")).pixmap(32, 32));
+
+	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerXSpeedSlider, "Pad", "PointerXSpeed", 40.0f);
+	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerYSpeedSlider, "Pad", "PointerYSpeed", 40.0f);
+	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerXDeadZoneSlider, "Pad", "PointerXDeadZone", 20.0f);
+	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerYDeadZoneSlider, "Pad", "PointerYDeadZone", 20.0f);
+	ControllerSettingWidgetBinder::BindWidgetToInputProfileFloat(sif, m_ui.pointerInertiaSlider, "Pad", "PointerInertia", 10.0f);
+
+	connect(m_ui.pointerXSpeedSlider, &QSlider::valueChanged, this, [this](int value) { m_ui.pointerXSpeedVal->setText(QStringLiteral("%1").arg(value)); });
+	connect(m_ui.pointerYSpeedSlider, &QSlider::valueChanged, this, [this](int value) { m_ui.pointerYSpeedVal->setText(QStringLiteral("%1").arg(value)); });
+	connect(m_ui.pointerXDeadZoneSlider, &QSlider::valueChanged, this, [this](int value) { m_ui.pointerXDeadZoneVal->setText(QStringLiteral("%1").arg(value)); });
+	connect(m_ui.pointerYDeadZoneSlider, &QSlider::valueChanged, this, [this](int value) { m_ui.pointerYDeadZoneVal->setText(QStringLiteral("%1").arg(value)); });
+	connect(m_ui.pointerInertiaSlider, &QSlider::valueChanged, this, [this](int value) { m_ui.pointerInertiaVal->setText(QStringLiteral("%1").arg(value)); });
+
+	m_ui.pointerXSpeedVal->setText(QStringLiteral("%1").arg(m_ui.pointerXSpeedSlider->value()));
+	m_ui.pointerYSpeedVal->setText(QStringLiteral("%1").arg(m_ui.pointerYSpeedSlider->value()));
+	m_ui.pointerXDeadZoneVal->setText(QStringLiteral("%1").arg(m_ui.pointerXDeadZoneSlider->value()));
+	m_ui.pointerYDeadZoneVal->setText(QStringLiteral("%1").arg(m_ui.pointerYDeadZoneSlider->value()));
+	m_ui.pointerInertiaVal->setText(QStringLiteral("%1").arg(m_ui.pointerInertiaSlider->value()));
+
+	connect(m_ui.buttonBox->button(QDialogButtonBox::Close), &QPushButton::clicked, this, &QDialog::accept);
+}
+
+ControllerMouseSettingsDialog::~ControllerMouseSettingsDialog() = default;
--- a/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.h
+++ b/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.h
@@ -24,6 +24,7 @@

 #include "ui_ControllerGlobalSettingsWidget.h"
 #include "ui_ControllerLEDSettingsDialog.h"
+#include "ui_ControllerMouseSettingsDialog.h"

 class ControllerSettingsDialog;

@@ -44,6 +45,7 @@ Q_SIGNALS:
 private Q_SLOTS:
 	void updateSDLOptionsEnabled();
 	void ledSettingsClicked();
+	void mouseSettingsClicked();

 private:
 	Ui::ControllerGlobalSettingsWidget m_ui;
@@ -64,3 +66,15 @@ private:
 	Ui::ControllerLEDSettingsDialog m_ui;
 	ControllerSettingsDialog* m_dialog;
 };
+
+class ControllerMouseSettingsDialog : public QDialog
+{
+	Q_OBJECT
+
+public:
+	ControllerMouseSettingsDialog(QWidget* parent, ControllerSettingsDialog* dialog);
+	~ControllerMouseSettingsDialog();
+
+private:
+	Ui::ControllerMouseSettingsDialog m_ui;
+};
--- a/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.ui
+++ b/pcsx2-qt/Settings/ControllerGlobalSettingsWidget.ui
@@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>902</width>
-    <height>677</height>
+    <height>583</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -26,6 +26,32 @@
   <property name="bottomMargin">
    <number>0</number>
   </property>
+   <item row="5" column="0">
+    <widget class="QGroupBox" name="profileSettings">
+     <property name="title">
+      <string>Profile Settings</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_5">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string>When this option is enabled, hotkeys can be set in this input profile, and will be used instead of the global hotkeys. By default, hotkeys are always shared between all profiles.</string>
+        </property>
+        <property name="wordWrap">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QCheckBox" name="useProfileHotkeyBindings">
+        <property name="text">
+         <string>Use Per-Profile Hotkeys</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
   <item row="0" column="0">
    <widget class="QGroupBox" name="sdlGroup">
     <property name="title">
@@ -65,8 +91,7 @@
          </property>
          <property name="icon">
           <iconset theme="lightbulb-line">
-            <normaloff>.</normaloff>.
-           </iconset>
+            <normaloff>.</normaloff>.</iconset>
          </property>
         </widget>
        </item>
@@ -75,6 +100,19 @@
     </layout>
    </widget>
   </item>
+   <item row="6" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>45</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
   <item row="1" column="0">
    <widget class="QGroupBox" name="xinputGroup">
     <property name="title">
@@ -101,71 +139,6 @@
     </layout>
    </widget>
   </item>
-   <item row="2" column="0">
-    <widget class="QGroupBox" name="dinputGroup">
-     <property name="title">
-      <string>DInput Source</string>
-     </property>
-     <layout class="QGridLayout" name="gridLayout_6">
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_9">
-        <property name="text">
-         <string>The DInput source provides support for legacy controllers which do not support XInput. Accessing these controllers via SDL instead is recommended, but DirectInput can be used if they are not compatible with SDL.</string>
-        </property>
-        <property name="wordWrap">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QCheckBox" name="enableDInputSource">
-        <property name="text">
-         <string>Enable DInput Input Source</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item row="6" column="0">
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>45</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="5" column="0">
-    <widget class="QGroupBox" name="profileSettings">
-     <property name="title">
-      <string>Profile Settings</string>
-     </property>
-     <layout class="QGridLayout" name="gridLayout_5">
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_4">
-        <property name="text">
-         <string>When this option is enabled, hotkeys can be set in this input profile, and will be used instead of the global hotkeys. By default, hotkeys are always shared between all profiles.</string>
-        </property>
-        <property name="wordWrap">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QCheckBox" name="useProfileHotkeyBindings">
-        <property name="text">
-         <string>Use Per-Profile Hotkeys</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
   <item row="4" column="0">
    <widget class="QGroupBox" name="multitapGroup">
     <property name="title">
@@ -199,146 +172,6 @@
     </layout>
    </widget>
   </item>
-   <item row="3" column="0">
-    <widget class="QGroupBox" name="mouseGroup">
-     <property name="title">
-      <string>Mouse/Pointer Source</string>
-     </property>
-     <layout class="QFormLayout" name="formLayout">
-      <item row="0" column="0" colspan="2">
-       <widget class="QLabel" name="label_7">
-        <property name="text">
-         <string>Using raw input improves precision when you bind controller sticks to the mouse pointer. Also enables multiple mice to be used.</string>
-        </property>
-        <property name="wordWrap">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="label_5">
-        <property name="text">
-         <string>Horizontal Sensitivity:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="1">
-       <layout class="QHBoxLayout" name="horizontalLayout">
-        <item>
-         <widget class="QSlider" name="pointerXScale">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>150</width>
-            <height>0</height>
-           </size>
-          </property>
-          <property name="minimum">
-           <number>1</number>
-          </property>
-          <property name="maximum">
-           <number>30</number>
-          </property>
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLabel" name="pointerXScaleLabel">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>20</width>
-            <height>0</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>10</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="label_6">
-        <property name="text">
-         <string>Vertical Sensitivity:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="1">
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
-        <item>
-         <widget class="QSlider" name="pointerYScale">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>150</width>
-            <height>0</height>
-           </size>
-          </property>
-          <property name="minimum">
-           <number>1</number>
-          </property>
-          <property name="maximum">
-           <number>30</number>
-          </property>
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QLabel" name="pointerYScaleLabel">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="minimumSize">
-           <size>
-            <width>20</width>
-            <height>0</height>
-           </size>
-          </property>
-          <property name="text">
-           <string>10</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item row="3" column="0" colspan="2">
-       <layout class="QHBoxLayout" name="horizontalLayout_3">
-        <item>
-         <widget class="QCheckBox" name="enableMouseMapping">
-          <property name="text">
-           <string>Enable Mouse Mapping</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </widget>
-   </item>
   <item row="0" column="1" rowspan="7">
    <widget class="QGroupBox" name="groupBox_3">
     <property name="title">
@@ -364,6 +197,72 @@
     </layout>
    </widget>
   </item>
+   <item row="2" column="0">
+    <widget class="QGroupBox" name="dinputGroup">
+     <property name="title">
+      <string>DInput Source</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_6">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_9">
+        <property name="text">
+         <string>The DInput source provides support for legacy controllers which do not support XInput. Accessing these controllers via SDL instead is recommended, but DirectInput can be used if they are not compatible with SDL.</string>
+        </property>
+        <property name="wordWrap">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QCheckBox" name="enableDInputSource">
+        <property name="text">
+         <string>Enable DInput Input Source</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QGroupBox" name="mouseGroup">
+     <property name="title">
+      <string>Mouse/Pointer Source</string>
+     </property>
+     <layout class="QFormLayout" name="formLayout">
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label_7">
+        <property name="text">
+         <string>PCSX2 allows you to use your mouse to simulate analog stick movement.</string>
+        </property>
+        <property name="wordWrap">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout_3" stretch="1,0">
+        <item>
+         <widget class="QCheckBox" name="enableMouseMapping">
+          <property name="text">
+           <string>Enable Mouse Mapping</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="mouseSettings">
+          <property name="toolTip">
+           <string>Controller LED Settings</string>
+          </property>
+          <property name="text">
+           <string>Settings...</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
  </layout>
 </widget>
 <resources/>
--- a/pcsx2-qt/Settings/ControllerMouseSettingsDialog.ui
+++ b/pcsx2-qt/Settings/ControllerMouseSettingsDialog.ui
@@ -0,0 +1,417 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ControllerMouseSettingsDialog</class>
+ <widget class="QDialog" name="ControllerMouseSettingsDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>654</width>
+    <height>169</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Mouse Mapping Settings</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="5" column="1">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Close</set>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <layout class="QHBoxLayout" name="pointerYSpeed">
+     <item>
+      <widget class="QLabel" name="pointerYSpeedLabel">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>70</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Y Speed</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QSlider" name="pointerYSpeedSlider">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="minimum">
+        <number>0</number>
+       </property>
+       <property name="maximum">
+        <number>100</number>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="pointerYSpeedVal">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>10</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0">
+    <layout class="QHBoxLayout" name="pointerXSpeed">
+     <item>
+      <widget class="QLabel" name="pointerXSpeedLabel">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>70</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>X Speed</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QSlider" name="pointerXSpeedSlider">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="minimum">
+        <number>0</number>
+       </property>
+       <property name="maximum">
+        <number>100</number>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="pointerXSpeedVal">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>10</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="0" column="0" colspan="2">
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <property name="bottomMargin">
+      <number>10</number>
+     </property>
+     <item>
+      <widget class="QLabel" name="icon">
+       <property name="minimumSize">
+        <size>
+         <width>32</width>
+         <height>32</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>32</width>
+         <height>32</height>
+        </size>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label_4">
+       <property name="text">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:700;&quot;&gt;Mouse Mapping Settings&lt;/span&gt;&lt;br/&gt;These settings fine-tune the behavior when mapping a mouse to the emulated controller.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
+       <property name="textFormat">
+        <enum>Qt::RichText</enum>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+       </property>
+       <property name="wordWrap">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="4" column="0" colspan="2">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="3" column="0">
+    <layout class="QHBoxLayout" name="pointerInertia">
+     <item>
+      <widget class="QLabel" name="pointerInertiaLabel">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>70</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Inertia</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QSlider" name="pointerInertiaSlider">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="minimum">
+        <number>0</number>
+       </property>
+       <property name="maximum">
+        <number>100</number>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="pointerInertiaVal">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>10</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="1">
+    <layout class="QHBoxLayout" name="pointerXDeadZone">
+     <item>
+      <widget class="QLabel" name="pointerXDeadZoneLabel">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>70</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>X Dead Zone</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QSlider" name="pointerXDeadZoneSlider">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="minimum">
+        <number>0</number>
+       </property>
+       <property name="maximum">
+        <number>100</number>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="pointerXDeadZoneVal">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>10</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="2" column="1">
+    <layout class="QHBoxLayout" name="pointerYDeadZone">
+     <item>
+      <widget class="QLabel" name="pointerYDeadZoneLabel">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>70</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Y Dead Zone</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QSlider" name="pointerYDeadZoneSlider">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="minimum">
+        <number>0</number>
+       </property>
+       <property name="maximum">
+        <number>100</number>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="pointerYDeadZoneVal">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>10</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="../resources/resources.qrc"/>
+ </resources>
+ <connections/>
+</ui>
--- a/pcsx2-qt/Settings/EmulationSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/EmulationSettingsWidget.cpp
@@ -120,8 +120,8 @@ EmulationSettingsWidget::EmulationSettingsWidget(SettingsDialog* dialog, QWidget
 		tr("Allows games and homebrew to access files / folders directly on the host computer."));

 	dialog->registerWidgetHelp(m_ui.optimalFramePacing, tr("Optimal Frame Pacing"), tr("Unchecked"),
-		tr("Sets the vsync queue size to 0, making every frame be completed and presented by the GS before input is polled, and the next frame begins. "
-		   "Using this setting can reduce input lag, at the cost of measurably higher CPU and GPU requirements."));
+		tr("Sets the VSync queue size to 0, making every frame be completed and presented by the GS before input is polled and the next frame begins. "
+		   "Using this setting can reduce input lag at the cost of measurably higher CPU and GPU requirements."));
 	dialog->registerWidgetHelp(m_ui.maxFrameLatency, tr("Maximum Frame Latency"), tr("2 Frames"),
 		tr("Sets the maximum number of frames that can be queued up to the GS, before the CPU thread will wait for one of them to complete before continuing. "
 		   "Higher values can assist with smoothing out irregular frame times, but add additional input lag."));
--- a/pcsx2-qt/Settings/GraphicsSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/GraphicsSettingsWidget.cpp
@@ -198,6 +198,7 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*
 	SettingWidgetBinder::BindWidgetToBoolSetting(
 		sif, m_ui.disablePartialInvalidation, "EmuCore/GS", "UserHacks_DisablePartialInvalidation", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.textureInsideRt, "EmuCore/GS", "UserHacks_TextureInsideRt", false);
+	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.readTCOnClose, "EmuCore/GS", "UserHacks_ReadTCOnClose", false);

 	//////////////////////////////////////////////////////////////////////////
 	// HW Upscaling Fixes
@@ -372,7 +373,8 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*
 		dialog->registerWidgetHelp(m_ui.PCRTCOverscan, tr("Show Overscan"), tr("Unchecked"),
 			tr("Enables the option to show the overscan area on games which draw more than the safe area of the screen."));

-		dialog->registerWidgetHelp(m_ui.fmvAspectRatio, tr("FMV Aspect Ratio"), tr("Off (Default)"), tr("Overrides the FMV aspect ratio."));
+		dialog->registerWidgetHelp(m_ui.fmvAspectRatio, tr("FMV Aspect Ratio"), tr("Off (Default)"),
+			tr("Overrides the full-motion video (FMV) aspect ratio."));

 		dialog->registerWidgetHelp(m_ui.PCRTCAntiBlur, tr("Anti-Blur"), tr("Checked"),
 			tr("Enables internal Anti-Blur hacks. Less accurate to PS2 rendering but will make a lot of games look less blurry."));
@@ -402,24 +404,32 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*
 			tr("Selects the quality at which screenshots will be compressed. Higher values preserve more detail for JPEG, and reduce file "
 			   "size for PNG."));

-		dialog->registerWidgetHelp(m_ui.stretchY, tr("Stretch Height"), tr("100%"), tr(""));
+		dialog->registerWidgetHelp(m_ui.stretchY, tr("Stretch Height"), tr("100%"),
+			tr("Stretches (> 100%) or squashes (< 100%) the vertical component of the display"));

 		dialog->registerWidgetHelp(m_ui.fullscreenModes, tr("Fullscreen Mode"), tr("Borderless Fullscreen"),
 			tr("Chooses the fullscreen resolution and frequency."));

-		dialog->registerWidgetHelp(m_ui.cropLeft, tr("Left"), tr("0px"), tr(""));
+		dialog->registerWidgetHelp(m_ui.cropLeft, tr("Left"), tr("0px"),
+			tr("Changes number of pixels cropped from the left side of the display"));

-		dialog->registerWidgetHelp(m_ui.cropTop, tr("Top"), tr("0px"), tr(""));
+		dialog->registerWidgetHelp(m_ui.cropTop, tr("Top"), tr("0px"),
+			tr("Changes number of pixels cropped from the top of the display"));

-		dialog->registerWidgetHelp(m_ui.cropRight, tr("Right"), tr("0px"), tr(""));
+		dialog->registerWidgetHelp(m_ui.cropRight, tr("Right"), tr("0px"),
+			tr("Changes number of pixels cropped from the right side of the display"));

-		dialog->registerWidgetHelp(m_ui.cropBottom, tr("Bottom"), tr("0px"), tr(""));
+		dialog->registerWidgetHelp(m_ui.cropBottom, tr("Bottom"), tr("0px"),
+			tr("Changes number of pixels cropped from the bottom of the display"));
 	}

 	// Rendering tab
 	{
 		// Hardware
-		dialog->registerWidgetHelp(m_ui.upscaleMultiplier, tr("Internal Resolution"), tr("Native (PS2) (Default)"), tr(""));
+		dialog->registerWidgetHelp(m_ui.upscaleMultiplier, tr("Internal Resolution"), tr("Native (PS2) (Default)"),
+			tr("Control the resolution at which games are rendered. High resolutions can impact performance on"
+			   "older or lower-end GPUs.<br>Non-native resolution may cause minor graphical issues in some games.<br>"
+			   "FMV resolution will remain unchanged, as the video files are pre-rendered."));

 		dialog->registerWidgetHelp(
 			m_ui.mipmapping, tr("Mipmapping"), tr("Automatic (Default)"), tr("Control the accuracy level of the mipmapping emulation."));
@@ -491,7 +501,7 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*

 		dialog->registerWidgetHelp(m_ui.cpuSpriteRenderBW, tr("CPU Sprite Renderer Size"), tr("0 (Disabled)"), tr(""));

-		dialog->registerWidgetHelp(m_ui.cpuCLUTRender, tr("Software Clut Render"), tr("0 (Disabled)"), tr(""));
+		dialog->registerWidgetHelp(m_ui.cpuCLUTRender, tr("Software CLUT Render"), tr("0 (Disabled)"), tr(""));

 		dialog->registerWidgetHelp(m_ui.skipDrawStart, tr("Skipdraw Range Start"), tr("0"),
 			tr("Completely skips drawing surfaces from the surface in the left box up to the surface specified in the box on the right."));
@@ -528,6 +538,10 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*
 		dialog->registerWidgetHelp(m_ui.textureInsideRt, tr("Texture Inside RT"), tr("Unchecked"),
 			tr("Allows the texture cache to reuse as an input texture the inner portion of a previous framebuffer. "
 			   "In some selected games this is enabled by default regardless of this setting."));
+
+		dialog->registerWidgetHelp(m_ui.readTCOnClose, tr("Read Targets When Closing"), tr("Unchecked"),
+			tr("Flushes all targets in the texture cache back to local memory when shutting down. Can prevent lost visuals when saving "
+			   "state or switching renderers, but can also cause graphical corruption."));
 	}

 	// Upscaling Fixes tab
@@ -592,13 +606,14 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*

 		dialog->registerWidgetHelp(m_ui.shadeBoostSaturation, tr("Saturation"), tr("50"), tr(""));

-		dialog->registerWidgetHelp(m_ui.tvShader, tr("TV Shader"), tr("None (Default)"), tr(""));
+		dialog->registerWidgetHelp(m_ui.tvShader, tr("TV Shader"), tr("None (Default)"),
+			tr("Applies a shader which replicates the visual effects of different styles of television set."));
 	}

 	// OSD tab
 	{
 		dialog->registerWidgetHelp(
-			m_ui.osdScale, tr("OSD Scale"), tr("100%"), tr("Scales the size of the onscreen OSD from 100% to 500%."));
+			m_ui.osdScale, tr("OSD Scale"), tr("100%"), tr("Scales the size of the onscreen OSD from 50% to 500%."));

 		dialog->registerWidgetHelp(m_ui.osdShowMessages, tr("Show OSD Messages"), tr("Checked"),
 			tr("Shows on-screen-display messages when events occur such as save states being "
@@ -654,7 +669,8 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsDialog* dialog, QWidget*
 			tr("Allows the GPU instead of just the CPU to transform lines into sprites. "
 			   "This reduces CPU load and bandwidth requirement, but it is heavier on the GPU."));

-		dialog->registerWidgetHelp(m_ui.gsDumpCompression, tr("GS Dump Compression"), tr("Zstandard (zst)"), tr(""));
+		dialog->registerWidgetHelp(m_ui.gsDumpCompression, tr("GS Dump Compression"), tr("Zstandard (zst)"),
+			tr("Change the compression algorithm used when creating a GS dump."));

 		dialog->registerWidgetHelp(m_ui.useBlitSwapChain, tr("Use Blit Swap Chain"), tr("Unchecked"),
 			tr("Uses a blit presentation model instead of flipping when using the Direct3D 11 "
--- a/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
+++ b/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
@@ -947,13 +947,6 @@
       </item>
       <item row="5" column="0" colspan="2">
        <layout class="QGridLayout" name="gridLayout">
-         <item row="0" column="0">
-          <widget class="QCheckBox" name="hwAutoFlush">
-           <property name="text">
-            <string>Auto Flush</string>
-           </property>
-          </widget>
-         </item>
         <item row="0" column="1">
          <widget class="QCheckBox" name="frameBufferConversion">
           <property name="text">
@@ -961,6 +954,13 @@
           </property>
          </widget>
         </item>
+         <item row="0" column="0">
+          <widget class="QCheckBox" name="hwAutoFlush">
+           <property name="text">
+            <string>Auto Flush</string>
+           </property>
+          </widget>
+         </item>
         <item row="1" column="0">
          <widget class="QCheckBox" name="disableDepthEmulation">
           <property name="text">
@@ -968,10 +968,10 @@
           </property>
          </widget>
         </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="disableSafeFeatures">
+         <item row="1" column="1">
+          <widget class="QCheckBox" name="preloadFrameData">
           <property name="text">
-            <string>Disable Safe Features</string>
+            <string>Preload Frame Data</string>
           </property>
          </widget>
         </item>
@@ -982,10 +982,10 @@
           </property>
          </widget>
         </item>
-         <item row="1" column="1">
-          <widget class="QCheckBox" name="preloadFrameData">
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="disableSafeFeatures">
           <property name="text">
-            <string>Preload Frame Data</string>
+            <string>Disable Safe Features</string>
           </property>
          </widget>
         </item>
@@ -996,6 +996,13 @@
           </property>
          </widget>
         </item>
+         <item row="3" column="1">
+          <widget class="QCheckBox" name="readTCOnClose">
+           <property name="text">
+            <string>Read Targets When Closing</string>
+           </property>
+          </widget>
+         </item>
        </layout>
       </item>
       <item row="2" column="1">
@@ -1536,7 +1543,7 @@
             <string>%</string>
            </property>
            <property name="minimum">
-             <number>100</number>
+             <number>50</number>
            </property>
            <property name="maximum">
             <number>500</number>
--- a/pcsx2-qt/Settings/InterfaceSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/InterfaceSettingsWidget.cpp
@@ -129,7 +129,7 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsDialog* dialog, QWidget
 		m_ui.confirmShutdown, tr("Confirm Shutdown"), tr("Checked"),
 		tr("Determines whether a prompt will be displayed to confirm shutting down the virtual machine "
 		   "when the hotkey is pressed."));
-	dialog->registerWidgetHelp(m_ui.saveStateOnShutdown, tr("Save State On Shutdown"), tr("Checked"),
+	dialog->registerWidgetHelp(m_ui.saveStateOnShutdown, tr("Save State On Shutdown"), tr("Unchecked"),
 		tr("Automatically saves the emulator state when powering down or exiting. You can then "
 		   "resume directly from where you left off next time."));
 	dialog->registerWidgetHelp(m_ui.pauseOnStart, tr("Pause On Start"), tr("Unchecked"),
--- a/pcsx2-qt/Settings/MemoryCardConvertDialog.cpp
+++ b/pcsx2-qt/Settings/MemoryCardConvertDialog.cpp
@@ -58,7 +58,7 @@ MemoryCardConvertDialog::MemoryCardConvertDialog(QWidget* parent, QString select
 							SetType(MemoryCardType::File, MemoryCardFileType::PS2_8MB, "A standard, 8 MB memory card. Most compatible, but smallest capacity.");
 							break;
 						case 16:
-							SetType(MemoryCardType::File, MemoryCardFileType::PS2_16MB, "2x larger as a standard memory card. May have some compatibility issues.");
+							SetType(MemoryCardType::File, MemoryCardFileType::PS2_16MB, "2x larger than a standard memory card. May have some compatibility issues.");
 							break;
 						case 32:
 							SetType(MemoryCardType::File, MemoryCardFileType::PS2_32MB, "4x larger than a standard memory card. Likely to have compatibility issues.");
--- a/pcsx2-qt/Settings/SettingsDialog.cpp
+++ b/pcsx2-qt/Settings/SettingsDialog.cpp
@@ -115,7 +115,7 @@ void SettingsDialog::setupUi(const GameList::Entry* game)
 	{
 		addWidget(m_game_fix_settings_widget = new GameFixSettingsWidget(this, m_ui.settingsContainer), tr("Game Fix"),
 			QStringLiteral("close-line"),
-			tr("<strong>Game Fix Settings</strong><hr>Gamefixes can work around incorrect emulation in some titles<br>however they can "
+			tr("<strong>Game Fix Settings</strong><hr>Gamefixes can work around incorrect emulation in some titles.<br>However, they can "
 			   "also cause problems in games if used incorrectly.<br>It is best to leave them all disabled unless advised otherwise."));
 	}

--- a/pcsx2-qt/pcsx2-qt.vcxproj
+++ b/pcsx2-qt/pcsx2-qt.vcxproj
@@ -423,6 +423,9 @@
    <QtUi Include="Settings\ControllerLEDSettingsDialog.ui">
      <FileType>Document</FileType>
    </QtUi>
+    <QtUi Include="Settings\ControllerMouseSettingsDialog.ui">
+      <FileType>Document</FileType>
+    </QtUi>
    <None Include="Settings\USBBindingWidget_DrivingForce.ui" />
    <None Include="Settings\USBBindingWidget_GTForce.ui" />
    <QtUi Include="Settings\USBDeviceWidget.ui">
@@ -439,4 +442,4 @@
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <Import Project="$(SolutionDir)common\vsprops\QtCompile.targets" />
  <ImportGroup Label="ExtensionTargets" />
-</Project>
+</Project>
--- a/pcsx2-qt/pcsx2-qt.vcxproj.filters
+++ b/pcsx2-qt/pcsx2-qt.vcxproj.filters
@@ -583,6 +583,9 @@
    <QtUi Include="Settings\ControllerLEDSettingsDialog.ui">
      <Filter>Settings</Filter>
    </QtUi>
+    <QtUi Include="Settings\ControllerMouseSettingsDialog.ui">
+      <Filter>Settings</Filter>
+    </QtUi>
  </ItemGroup>
  <ItemGroup>
    <None Include="Settings\FolderSettingsWidget.ui">
--- a/pcsx2-qt/resources/icons/black/svg/mouse-line.svg
+++ b/pcsx2-qt/resources/icons/black/svg/mouse-line.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path fill="none" d="M0 0h24v24H0z"/><path d="M11.141 4c-1.582 0-2.387.169-3.128.565a3.453 3.453 0 0 0-1.448 1.448C6.169 6.753 6 7.559 6 9.14v5.718c0 1.582.169 2.387.565 3.128.337.63.818 1.111 1.448 1.448.74.396 1.546.565 3.128.565h1.718c1.582 0 2.387-.169 3.128-.565a3.453 3.453 0 0 0 1.448-1.448c.396-.74.565-1.546.565-3.128V9.14c0-1.582-.169-2.387-.565-3.128a3.453 3.453 0 0 0-1.448-1.448C15.247 4.169 14.441 4 12.86 4H11.14zm0-2h1.718c2.014 0 3.094.278 4.072.801a5.452 5.452 0 0 1 2.268 2.268c.523.978.801 2.058.801 4.072v5.718c0 2.014-.278 3.094-.801 4.072a5.452 5.452 0 0 1-2.268 2.268c-.978.523-2.058.801-4.072.801H11.14c-2.014 0-3.094-.278-4.072-.801a5.452 5.452 0 0 1-2.268-2.268C4.278 17.953 4 16.873 4 14.859V9.14c0-2.014.278-3.094.801-4.072A5.452 5.452 0 0 1 7.07 2.801C8.047 2.278 9.127 2 11.141 2zM11 6h2v5h-2V6z"/></svg>
--- a/pcsx2-qt/resources/icons/white/svg/mouse-line.svg
+++ b/pcsx2-qt/resources/icons/white/svg/mouse-line.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path fill="none" d="M0 0h24v24H0z"/><path d="M11.141 4c-1.582 0-2.387.169-3.128.565a3.453 3.453 0 0 0-1.448 1.448C6.169 6.753 6 7.559 6 9.14v5.718c0 1.582.169 2.387.565 3.128.337.63.818 1.111 1.448 1.448.74.396 1.546.565 3.128.565h1.718c1.582 0 2.387-.169 3.128-.565a3.453 3.453 0 0 0 1.448-1.448c.396-.74.565-1.546.565-3.128V9.14c0-1.582-.169-2.387-.565-3.128a3.453 3.453 0 0 0-1.448-1.448C15.247 4.169 14.441 4 12.86 4H11.14zm0-2h1.718c2.014 0 3.094.278 4.072.801a5.452 5.452 0 0 1 2.268 2.268c.523.978.801 2.058.801 4.072v5.718c0 2.014-.278 3.094-.801 4.072a5.452 5.452 0 0 1-2.268 2.268c-.978.523-2.058.801-4.072.801H11.14c-2.014 0-3.094-.278-4.072-.801a5.452 5.452 0 0 1-2.268-2.268C4.278 17.953 4 16.873 4 14.859V9.14c0-2.014.278-3.094.801-4.072A5.452 5.452 0 0 1 7.07 2.801C8.047 2.278 9.127 2 11.141 2zM11 6h2v5h-2V6z" fill="#ffffff"/></svg>
--- a/pcsx2-qt/resources/resources.qrc
+++ b/pcsx2-qt/resources/resources.qrc
@@ -40,6 +40,7 @@
 		<file>icons/black/svg/lightbulb-line.svg</file>
 		<file>icons/black/svg/list-check.svg</file>
 		<file>icons/black/svg/login-box-line.svg</file>
+		<file>icons/black/svg/mouse-line.svg</file>
 		<file>icons/black/svg/pause-line.svg</file>
 		<file>icons/black/svg/play-line.svg</file>
 		<file>icons/black/svg/price-tag-3-line.svg</file>
@@ -100,6 +101,7 @@
 		<file>icons/white/svg/lightbulb-line.svg</file>
 		<file>icons/white/svg/list-check.svg</file>
 		<file>icons/white/svg/login-box-line.svg</file>
+		<file>icons/white/svg/mouse-line.svg</file>
 		<file>icons/white/svg/pause-line.svg</file>
 		<file>icons/white/svg/play-line.svg</file>
 		<file>icons/white/svg/price-tag-3-line.svg</file>
--- a/pcsx2/CDVD/Darwin/IOCtlSrc.cpp
+++ b/pcsx2/CDVD/Darwin/IOCtlSrc.cpp
@@ -66,6 +66,7 @@ bool IOCtlSrc::Reopen()

 void IOCtlSrc::SetSpindleSpeed(bool restore_defaults) const
 {
+#ifdef __APPLE__
 	u16 speed = restore_defaults ? 0xFFFF : m_media_type >= 0 ? 5540 :
 																3600;
 	int ioctl_code = m_media_type >= 0 ? DKIOCDVDSETSPEED : DKIOCCDSETSPEED;
@@ -77,6 +78,10 @@ void IOCtlSrc::SetSpindleSpeed(bool restore_defaults) const
 	{
 		DevCon.WriteLn("CDVD: Spindle speed set to %d", speed);
 	}
+#else
+	// FIXME: FreeBSD equivalent for DKIOCDVDSETSPEED DKIOCCDSETSPEED.
+	DevCon.Warning("CDVD: Setting spindle speed not supported!");
+#endif
 }

 u32 IOCtlSrc::GetSectorCount() const
--- a/pcsx2/Config.h
+++ b/pcsx2/Config.h
@@ -664,6 +664,7 @@ struct Pcsx2Config
 					UserHacks_AlignSpriteX : 1,
 					UserHacks_AutoFlush : 1,
 					UserHacks_CPUFBConversion : 1,
+					UserHacks_ReadTCOnClose : 1,
 					UserHacks_DisableDepthSupport : 1,
 					UserHacks_DisablePartialInvalidation : 1,
 					UserHacks_DisableSafeFeatures : 1,
--- a/pcsx2/Counters.cpp
+++ b/pcsx2/Counters.cpp
@@ -543,12 +543,16 @@ static __fi void DoFMVSwitch()
 		RendererSwitched = false;
 }

-// Convenience function to update UI thread and set patches.
-static __fi void frameLimitUpdateCore()
+// Convenience function to update UI thread and set patches. 
+static __fi void VSyncUpdateCore()
 {
 	DoFMVSwitch();

 	VMManager::Internal::VSyncOnCPUThread();
+}
+
+static __fi void VSyncCheckExit()
+{
 	if (VMManager::Internal::IsExecutionInterrupted())
 		Cpu->ExitExecution();
 }
@@ -559,10 +563,7 @@ static __fi void frameLimit()
 {
 	// Framelimiter off in settings? Framelimiter go brrr.
 	if (EmuConfig.GS.LimitScalar == 0.0f || s_use_vsync_for_timing)
-	{
-		frameLimitUpdateCore();
 		return;
-	}

 	const u64 uExpectedEnd = m_iStart + m_iTicks;  // Compute when we would expect this frame to end, assuming everything goes perfectly perfect.
 	const u64 iEnd = GetCPUTicks();                // The current tick we actually stopped on.
@@ -573,7 +574,6 @@ static __fi void frameLimit()
 	{
 		// ... Fudge the next frame start over a bit. Prevents fast forward zoomies.
 		m_iStart += (sDeltaTime / m_iTicks) * m_iTicks;
-		frameLimitUpdateCore();
 		return;
 	}

@@ -597,16 +597,17 @@ static __fi void frameLimit()

 	// Finally, set our next frame start to when this one ends
 	m_iStart = uExpectedEnd;
-	frameLimitUpdateCore();
 }

 static __fi void VSyncStart(u32 sCycle)
 {
 	// Update vibration at the end of a frame.
+	VSyncUpdateCore();
 	PAD::Update();

 	frameLimit(); // limit FPS
 	gsPostVsyncStart(); // MUST be after framelimit; doing so before causes funk with frame times!
+	VSyncCheckExit();

 	if(EmuConfig.Trace.Enabled && EmuConfig.Trace.EE.m_EnableAll)
 		SysTrace.EE.Counters.Write( "    ================  EE COUNTER VSYNC START (frame: %d)  ================", g_FrameCount );
--- a/pcsx2/Docs/GameIndex.md
+++ b/pcsx2/Docs/GameIndex.md
@@ -169,8 +169,8 @@ The clamp modes are also numerically based.
 *   alignSprite              [`0` or `1`]                      {Off or On}       Default: Off (`0`)
 *   mergeSprite              [`0` or `1`]                      {Off or On}       Default: Off (`0`)
 *   wildArmsHack             [`0` or `1`]                      {Off or On}       Default: Off (`0`)
-*   skipDrawStart            [Value between `0` to `100000`]   {0-100000}        Default: Off (`0`)
-*   skipDrawEnd              [Value between `0` to `100000`]   {0-100000}        Default: Off (`0`)
+*   skipDrawStart            [Value between `0` to `10000`]    {0-10000}         Default: Off (`0`)
+*   skipDrawEnd              [Value between `0` to `10000`]    {0-10000}         Default: Off (`0`)
 *   halfPixelOffset          [`0` or `1` or `2` or `3`]   {Off, Normal Vertex, Special Texture or Special Texture Aggressive}    Default: Off (`0`)
 *   roundSprite              [`0` or `1` or `2`]          {Off, Half or Full}    Default: Off (`0`)

--- a/pcsx2/Docs/gamedb-schema.json
+++ b/pcsx2/Docs/gamedb-schema.json
@@ -126,6 +126,11 @@
              "minimum": 0,
              "maximum": 1
            },
+            "readTCOnClose": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 1
+            },
            "disableDepthSupport": {
              "type": "integer",
              "minimum": 0,
--- a/pcsx2/Frontend/CommonHost.cpp
+++ b/pcsx2/Frontend/CommonHost.cpp
@@ -160,7 +160,7 @@ void CommonHost::SetDataDirectory()
 			EmuFolders::DataRoot = Path::Combine(StringUtil::WideStringToUTF8String(documents_directory), "PCSX2");
 		CoTaskMemFree(documents_directory);
 	}
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__FreeBSD__)
 	// Use $XDG_CONFIG_HOME/PCSX2 if it exists.
 	const char* xdg_config_home = getenv("XDG_CONFIG_HOME");
 	if (xdg_config_home && Path::IsAbsolute(xdg_config_home))
--- a/pcsx2/Frontend/D3D11HostDisplay.cpp
+++ b/pcsx2/Frontend/D3D11HostDisplay.cpp
@@ -16,6 +16,7 @@
 #include "PrecompiledHeader.h"

 #include "Frontend/D3D11HostDisplay.h"
+#include "GS/Renderers/DX11/D3D.h"

 #include "imgui.h"
 #include "imgui_impl_dx11.h"
@@ -439,49 +440,6 @@ void D3D11HostDisplay::DestroySurface()
 	m_swap_chain.reset();
 }

-static std::string GetDriverVersionFromLUID(const LUID& luid)
-{
-	std::string ret;
-
-	HKEY hKey;
-	if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\DirectX", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
-	{
-		DWORD max_key_len = 0, adapter_count = 0;
-		if (RegQueryInfoKeyW(hKey, nullptr, nullptr, nullptr, &adapter_count, &max_key_len,
-				nullptr, nullptr, nullptr, nullptr, nullptr, nullptr) == ERROR_SUCCESS)
-		{
-			std::vector<TCHAR> current_name(max_key_len + 1);
-			for (DWORD i = 0; i < adapter_count; ++i)
-			{
-				DWORD subKeyLength = static_cast<DWORD>(current_name.size());
-				if (RegEnumKeyExW(hKey, i, current_name.data(), &subKeyLength, nullptr, nullptr, nullptr, nullptr) == ERROR_SUCCESS)
-				{
-					LUID current_luid = {};
-					DWORD current_luid_size = sizeof(uint64_t);
-					if (RegGetValueW(hKey, current_name.data(), L"AdapterLuid", RRF_RT_QWORD, nullptr, &current_luid, &current_luid_size) == ERROR_SUCCESS &&
-						current_luid.HighPart == luid.HighPart && current_luid.LowPart == luid.LowPart)
-					{
-						LARGE_INTEGER driver_version = {};
-						DWORD driver_version_size = sizeof(driver_version);
-						if (RegGetValueW(hKey, current_name.data(), L"DriverVersion", RRF_RT_QWORD, nullptr, &driver_version, &driver_version_size) == ERROR_SUCCESS)
-						{
-							WORD nProduct = HIWORD(driver_version.HighPart);
-							WORD nVersion = LOWORD(driver_version.HighPart);
-							WORD nSubVersion = HIWORD(driver_version.LowPart);
-							WORD nBuild = LOWORD(driver_version.LowPart);
-							ret = StringUtil::StdStringFromFormat("%u.%u.%u.%u", nProduct, nVersion, nSubVersion, nBuild);
-						}
-					}
-				}
-			}
-		}
-
-		RegCloseKey(hKey);
-	}
-
-	return ret;
-}
-
 std::string D3D11HostDisplay::GetDriverInfo() const
 {
 	std::string ret = "Unknown Feature Level";
@@ -518,7 +476,7 @@ std::string D3D11HostDisplay::GetDriverInfo() const
 				ret += StringUtil::WideStringToUTF8String(desc.Description);
 				ret += "\n";

-				const std::string driver_version(GetDriverVersionFromLUID(desc.AdapterLuid));
+				const std::string driver_version(D3D::GetDriverVersionFromLUID(desc.AdapterLuid));
 				if (!driver_version.empty())
 				{
 					ret += "Driver Version: ";
@@ -641,13 +599,10 @@ bool D3D11HostDisplay::UpdateImGuiFontTexture()
 	return true;
 }

-bool D3D11HostDisplay::BeginPresent(bool frame_skip)
+HostDisplay::PresentResult D3D11HostDisplay::BeginPresent(bool frame_skip)
 {
 	if (frame_skip || !m_swap_chain)
-	{
-		ImGui::EndFrame();
-		return false;
-	}
+		return PresentResult::FrameSkipped;

 	// When using vsync, the time here seems to include the time for the buffer to become available.
 	// This blows our our GPU usage number considerably, so read the timestamp before the final blit
@@ -664,7 +619,7 @@ bool D3D11HostDisplay::BeginPresent(bool frame_skip)
 	const CD3D11_RECT scissor(0, 0, m_window_info.surface_width, m_window_info.surface_height);
 	m_context->RSSetViewports(1, &vp);
 	m_context->RSSetScissorRects(1, &scissor);
-	return true;
+	return PresentResult::OK;
 }

 void D3D11HostDisplay::EndPresent()
--- a/pcsx2/Frontend/D3D11HostDisplay.h
+++ b/pcsx2/Frontend/D3D11HostDisplay.h
@@ -65,7 +65,7 @@ public:

 	void SetVSync(VsyncMode mode) override;

-	bool BeginPresent(bool frame_skip) override;
+	PresentResult BeginPresent(bool frame_skip) override;
 	void EndPresent() override;

 	bool SetGPUTimingEnabled(bool enabled) override;
--- a/pcsx2/Frontend/D3D12HostDisplay.cpp
+++ b/pcsx2/Frontend/D3D12HostDisplay.cpp
@@ -16,6 +16,8 @@
 #include "PrecompiledHeader.h"

 #include "Frontend/D3D12HostDisplay.h"
+#include "GS/Renderers/DX11/D3D.h"
+
 #include "common/Assertions.h"
 #include "common/Console.h"
 #include "common/D3D12/Context.h"
@@ -343,49 +345,6 @@ void D3D12HostDisplay::DestroySurface()
 	m_swap_chain.reset();
 }

-static std::string GetDriverVersionFromLUID(const LUID& luid)
-{
-	std::string ret;
-
-	HKEY hKey;
-	if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\DirectX", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
-	{
-		DWORD max_key_len = 0, adapter_count = 0;
-		if (RegQueryInfoKey(hKey, nullptr, nullptr, nullptr, &adapter_count, &max_key_len,
-				nullptr, nullptr, nullptr, nullptr, nullptr, nullptr) == ERROR_SUCCESS)
-		{
-			std::vector<TCHAR> current_name(max_key_len + 1);
-			for (DWORD i = 0; i < adapter_count; ++i)
-			{
-				DWORD subKeyLength = static_cast<DWORD>(current_name.size());
-				if (RegEnumKeyExW(hKey, i, current_name.data(), &subKeyLength, nullptr, nullptr, nullptr, nullptr) == ERROR_SUCCESS)
-				{
-					LUID current_luid = {};
-					DWORD current_luid_size = sizeof(uint64_t);
-					if (RegGetValueW(hKey, current_name.data(), L"AdapterLuid", RRF_RT_QWORD, nullptr, &current_luid, &current_luid_size) == ERROR_SUCCESS &&
-						current_luid.HighPart == luid.HighPart && current_luid.LowPart == luid.LowPart)
-					{
-						LARGE_INTEGER driver_version = {};
-						DWORD driver_version_size = sizeof(driver_version);
-						if (RegGetValueW(hKey, current_name.data(), L"DriverVersion", RRF_RT_QWORD, nullptr, &driver_version, &driver_version_size) == ERROR_SUCCESS)
-						{
-							WORD nProduct = HIWORD(driver_version.HighPart);
-							WORD nVersion = LOWORD(driver_version.HighPart);
-							WORD nSubVersion = HIWORD(driver_version.LowPart);
-							WORD nBuild = LOWORD(driver_version.LowPart);
-							ret = StringUtil::StdStringFromFormat("%u.%u.%u.%u", nProduct, nVersion, nSubVersion, nBuild);
-						}
-					}
-				}
-			}
-		}
-
-		RegCloseKey(hKey);
-	}
-
-	return ret;
-}
-
 std::string D3D12HostDisplay::GetDriverInfo() const
 {
 	std::string ret = "Unknown Feature Level";
@@ -417,7 +376,7 @@ std::string D3D12HostDisplay::GetDriverInfo() const
 		ret += StringUtil::WideStringToUTF8String(desc.Description);
 		ret += "\n";

-		const std::string driver_version(GetDriverVersionFromLUID(desc.AdapterLuid));
+		const std::string driver_version(D3D::GetDriverVersionFromLUID(desc.AdapterLuid));
 		if (!driver_version.empty())
 		{
 			ret += "Driver Version: ";
@@ -554,13 +513,13 @@ bool D3D12HostDisplay::UpdateImGuiFontTexture()
 	return ImGui_ImplDX12_CreateFontsTexture();
 }

-bool D3D12HostDisplay::BeginPresent(bool frame_skip)
+HostDisplay::PresentResult D3D12HostDisplay::BeginPresent(bool frame_skip)
 {
+	if (m_device_lost)
+		return HostDisplay::PresentResult::DeviceLost;
+
 	if (frame_skip || !m_swap_chain)
-	{
-		ImGui::EndFrame();
-		return false;
-	}
+		return PresentResult::FrameSkipped;

 	static constexpr std::array<float, 4> clear_color = {};
 	D3D12::Texture& swap_chain_buf = m_swap_chain_buffers[m_current_swap_chain_buffer];
@@ -574,7 +533,7 @@ bool D3D12HostDisplay::BeginPresent(bool frame_skip)
 	const D3D12_RECT scissor{0, 0, static_cast<LONG>(m_window_info.surface_width), static_cast<LONG>(m_window_info.surface_height)};
 	cmdlist->RSSetViewports(1, &vp);
 	cmdlist->RSSetScissorRects(1, &scissor);
-	return true;
+	return PresentResult::OK;
 }

 void D3D12HostDisplay::EndPresent()
@@ -586,7 +545,11 @@ void D3D12HostDisplay::EndPresent()
 	m_current_swap_chain_buffer = ((m_current_swap_chain_buffer + 1) % static_cast<u32>(m_swap_chain_buffers.size()));

 	swap_chain_buf.TransitionToState(g_d3d12_context->GetCommandList(), D3D12_RESOURCE_STATE_PRESENT);
-	g_d3d12_context->ExecuteCommandList(D3D12::Context::WaitType::None);
+	if (!g_d3d12_context->ExecuteCommandList(D3D12::Context::WaitType::None))
+	{
+		m_device_lost = true;
+		return;
+	}

 	const bool vsync = static_cast<UINT>(m_vsync_mode != VsyncMode::Off);
 	if (!vsync && m_using_allow_tearing)
--- a/pcsx2/Frontend/D3D12HostDisplay.h
+++ b/pcsx2/Frontend/D3D12HostDisplay.h
@@ -71,7 +71,7 @@ public:

 	void SetVSync(VsyncMode mode) override;

-	bool BeginPresent(bool frame_skip) override;
+	PresentResult BeginPresent(bool frame_skip) override;
 	void EndPresent() override;

 	bool SetGPUTimingEnabled(bool enabled) override;
@@ -97,4 +97,5 @@ protected:

 	bool m_allow_tearing_supported = false;
 	bool m_using_allow_tearing = false;
+	bool m_device_lost = false;
 };
--- a/pcsx2/Frontend/FullscreenUI.cpp
+++ b/pcsx2/Frontend/FullscreenUI.cpp
@@ -3196,6 +3196,9 @@ void FullscreenUI::DrawGraphicsSettingsPage()
 			DrawToggleSetting(bsi, "Texture Inside Render Target",
 				"Allows the texture cache to reuse as an input texture the inner portion of a previous framebuffer.", "EmuCore/GS",
 				"UserHacks_TextureInsideRt", false, manual_hw_fixes);
+			DrawToggleSetting(bsi, "Read Targets When Closing",
+				"Flushes all targets in the texture cache back to local memory when shutting down.", "EmuCore/GS",
+				"UserHacks_ReadTCOnClose", false, manual_hw_fixes);

 			MenuHeading("Upscaling Fixes");
 			DrawIntListSetting(bsi, "Half-Pixel Offset", "Adjusts vertices relative to upscaling.", "EmuCore/GS",
--- a/pcsx2/Frontend/ImGuiManager.cpp
+++ b/pcsx2/Frontend/ImGuiManager.cpp
@@ -90,7 +90,7 @@ bool ImGuiManager::Initialize()
 		return false;
 	}

-	s_global_scale = std::max(1.0f, g_host_display->GetWindowScale() * (EmuConfig.GS.OsdScale / 100.0f));
+	s_global_scale = std::max(0.5f, g_host_display->GetWindowScale() * (EmuConfig.GS.OsdScale / 100.0f));

 	ImGui::CreateContext();

@@ -185,7 +185,7 @@ void ImGuiManager::WindowResized()
 void ImGuiManager::UpdateScale()
 {
 	const float window_scale = g_host_display ? g_host_display->GetWindowScale() : 1.0f;
-	const float scale = std::max(window_scale * (EmuConfig.GS.OsdScale / 100.0f), 1.0f);
+	const float scale = std::max(window_scale * (EmuConfig.GS.OsdScale / 100.0f), 0.5f);

 	if (scale == s_global_scale && (!HasFullscreenFonts() || !ImGuiFullscreen::UpdateLayoutScale()))
 		return;
@@ -229,6 +229,12 @@ void ImGuiManager::NewFrame()
 	}
 }

+void ImGuiManager::SkipFrame()
+{
+	ImGui::EndFrame();
+	NewFrame();
+}
+
 void ImGuiManager::SetStyle()
 {
 	ImGuiStyle& style = ImGui::GetStyle();
--- a/pcsx2/Frontend/ImGuiManager.h
+++ b/pcsx2/Frontend/ImGuiManager.h
@@ -40,6 +40,9 @@ namespace ImGuiManager
 	/// Call at the beginning of the frame to set up ImGui state.
 	void NewFrame();

+	/// Call when skipping rendering a frame, to update internal state.
+	void SkipFrame();
+
 	/// Renders any on-screen display elements.
 	void RenderOSD();

--- a/pcsx2/Frontend/ImGuiOverlays.cpp
+++ b/pcsx2/Frontend/ImGuiOverlays.cpp
@@ -421,6 +421,8 @@ void ImGuiManager::DrawSettingsOverlay()
 			APPEND("AF ");
 		if (GSConfig.UserHacks_CPUFBConversion)
 			APPEND("FBC ");
+		if (GSConfig.UserHacks_ReadTCOnClose)
+			APPEND("FTC ");
 		if(GSConfig.UserHacks_DisableDepthSupport)
 			APPEND("DDE ");
 		if (GSConfig.UserHacks_DisablePartialInvalidation)
--- a/pcsx2/Frontend/InputManager.cpp
+++ b/pcsx2/Frontend/InputManager.cpp
@@ -160,7 +160,11 @@ struct PointerAxisState
 static std::array<std::array<float, static_cast<u8>(InputPointerAxis::Count)>, InputManager::MAX_POINTER_DEVICES> s_host_pointer_positions;
 static std::array<std::array<PointerAxisState, static_cast<u8>(InputPointerAxis::Count)>, InputManager::MAX_POINTER_DEVICES>
 	s_pointer_state;
-static std::array<float, static_cast<u8>(InputPointerAxis::Count)> s_pointer_axis_scale;
+static std::array<float, 2> s_pointer_axis_speed;
+static std::array<float, 2> s_pointer_axis_dead_zone;
+static std::array<float, 2> s_pointer_axis_range;
+static std::array<float, 2> s_pointer_pos = {0.0f, 0.0f};
+static float s_pointer_inertia = 0.0f;

 using PointerMoveCallback = std::function<void(InputBindingKey key, float value)>;
 using KeyboardEventCallback = std::function<void(InputBindingKey key, float value)>;
@@ -950,15 +954,34 @@ void InputManager::GenerateRelativeMouseEvents()
 	{
 		for (u32 axis = 0; axis < static_cast<u32>(static_cast<u8>(InputPointerAxis::Count)); axis++)
 		{
+			const InputBindingKey key(MakePointerAxisKey(device, static_cast<InputPointerAxis>(axis)));
+
 			PointerAxisState& state = s_pointer_state[device][axis];
 			const float delta = static_cast<float>(state.delta.exchange(0, std::memory_order_acquire)) / 65536.0f;
-			const float unclamped_value = delta * s_pointer_axis_scale[axis];
+			float value = 0.0f;

-			const InputBindingKey key(MakePointerAxisKey(device, static_cast<InputPointerAxis>(axis)));
-			if (axis >= static_cast<u32>(InputPointerAxis::WheelX) && ImGuiManager::ProcessPointerAxisEvent(key, unclamped_value))
-				continue;
+			if (axis <= static_cast<u32>(InputPointerAxis::Y))
+			{
+				s_pointer_pos[axis] += delta * s_pointer_axis_speed[axis];
+				value = std::clamp(s_pointer_pos[axis], -1.0f, 1.0f);
+				s_pointer_pos[axis] -= value;
+				s_pointer_pos[axis] *= s_pointer_inertia;
+
+				value *= s_pointer_axis_range[axis];
+				if (value > 0.0f)
+					value += s_pointer_axis_dead_zone[axis];
+				else if (value < 0.0f)
+					value -= s_pointer_axis_dead_zone[axis];
+			}
+			else
+			{
+				// ImGui can consume mouse wheel events when the mouse is over a UI element.
+				if (delta != 0.0f && ImGuiManager::ProcessPointerAxisEvent(key, delta))
+					continue;
+
+				value = std::clamp(delta, -1.0f, 1.0f);
+			}

-			const float value = std::clamp(unclamped_value, -1.0f, 1.0f);
 			if (value != state.last_value)
 			{
 				state.last_value = value;
@@ -1203,14 +1226,18 @@ void InputManager::ReloadBindings(SettingsInterface& si, SettingsInterface& bind
 	for (u32 pad = 0; pad < PAD::NUM_CONTROLLER_PORTS; pad++)
 		AddPadBindings(binding_si, pad, PAD::GetDefaultPadType(pad));

-	for (u32 axis = 0; axis < static_cast<u32>(InputPointerAxis::Count); axis++)
+	constexpr float ui_ctrl_range = 100.0f;
+	constexpr float pointer_sensitivity = 0.05f;
+	for (u32 axis = 0; axis <= static_cast<u32>(InputPointerAxis::Y); axis++)
 	{
-		// From lilypad: 1 mouse pixel = 1/8th way down.
-		const float default_scale = (axis <= static_cast<u32>(InputPointerAxis::Y)) ? 8.0f : 1.0f;
-		s_pointer_axis_scale[axis] =
-			1.0f /
-			std::max(si.GetFloatValue("Pad", fmt::format("Pointer{}Scale", s_pointer_axis_names[axis]).c_str(), default_scale), 1.0f);
+		s_pointer_axis_speed[axis] = si.GetFloatValue("Pad", fmt::format("Pointer{}Speed", s_pointer_axis_names[axis]).c_str(), 40.0f) /
+									 ui_ctrl_range * pointer_sensitivity;
+		s_pointer_axis_dead_zone[axis] = std::min(
+			si.GetFloatValue("Pad", fmt::format("Pointer{}DeadZone", s_pointer_axis_names[axis]).c_str(), 20.0f) / ui_ctrl_range, 1.0f);
+		s_pointer_axis_range[axis] = 1.0f - s_pointer_axis_dead_zone[axis];
 	}
+	s_pointer_inertia = si.GetFloatValue("Pad", "PointerInertia", 10.0f) / ui_ctrl_range;
+	s_pointer_pos = {};

 	for (u32 port = 0; port < USB::NUM_PORTS; port++)
 		AddUSBBindings(binding_si, port);
--- a/pcsx2/Frontend/MetalHostDisplay.h
+++ b/pcsx2/Frontend/MetalHostDisplay.h
@@ -81,7 +81,7 @@ public:
 	std::unique_ptr<HostDisplayTexture> CreateTexture(u32 width, u32 height, const void* data, u32 data_stride, bool dynamic = false) override;
 	void UpdateTexture(id<MTLTexture> texture, u32 x, u32 y, u32 width, u32 height, const void* data, u32 data_stride);
 	void UpdateTexture(HostDisplayTexture* texture, u32 x, u32 y, u32 width, u32 height, const void* data, u32 data_stride) override;
-	bool BeginPresent(bool frame_skip) override;
+	PresentResult BeginPresent(bool frame_skip) override;
 	void EndPresent() override;
 	void SetVSync(VsyncMode mode) override;

--- a/pcsx2/Frontend/MetalHostDisplay.mm
+++ b/pcsx2/Frontend/MetalHostDisplay.mm
@@ -265,7 +265,7 @@ void MetalHostDisplay::UpdateTexture(HostDisplayTexture* texture, u32 x, u32 y,

 static bool s_capture_next = false;

-bool MetalHostDisplay::BeginPresent(bool frame_skip)
+HostDisplay::PresentResult MetalHostDisplay::BeginPresent(bool frame_skip)
 { @autoreleasepool {
 	GSDeviceMTL* dev = static_cast<GSDeviceMTL*>(g_gs_device.get());
 	if (dev && m_capture_start_frame && dev->FrameNo() == m_capture_start_frame)
@@ -273,7 +273,7 @@ bool MetalHostDisplay::BeginPresent(bool frame_skip)
 	if (frame_skip || m_window_info.type == WindowInfo::Type::Surfaceless || !g_gs_device)
 	{
 		ImGui::EndFrame();
-		return false;
+		return PresentResult::FrameSkipped;
 	}
 	id<MTLCommandBuffer> buf = dev->GetRenderCmdBuf();
 	m_current_drawable = MRCRetain([m_layer nextDrawable]);
@@ -284,13 +284,13 @@ bool MetalHostDisplay::BeginPresent(bool frame_skip)
 		[buf popDebugGroup];
 		dev->FlushEncoders();
 		ImGui::EndFrame();
-		return false;
+		return PresentResult::FrameSkipped;
 	}
 	[m_pass_desc colorAttachments][0].texture = [m_current_drawable texture];
 	id<MTLRenderCommandEncoder> enc = [buf renderCommandEncoderWithDescriptor:m_pass_desc];
 	[enc setLabel:@"Present"];
 	dev->m_current_render.encoder = MRCRetain(enc);
-	return true;
+	return PresentResult::OK;
 }}

 void MetalHostDisplay::EndPresent()
--- a/pcsx2/Frontend/OpenGLHostDisplay.cpp
+++ b/pcsx2/Frontend/OpenGLHostDisplay.cpp
@@ -335,13 +335,10 @@ bool OpenGLHostDisplay::UpdateImGuiFontTexture()
 	return ImGui_ImplOpenGL3_CreateFontsTexture();
 }

-bool OpenGLHostDisplay::BeginPresent(bool frame_skip)
+HostDisplay::PresentResult OpenGLHostDisplay::BeginPresent(bool frame_skip)
 {
 	if (frame_skip || m_window_info.type == WindowInfo::Type::Surfaceless)
-	{
-		ImGui::EndFrame();
-		return false;
-	}
+		return PresentResult::FrameSkipped;

 	glDisable(GL_SCISSOR_TEST);
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
@@ -350,7 +347,7 @@ bool OpenGLHostDisplay::BeginPresent(bool frame_skip)
 	glClear(GL_COLOR_BUFFER_BIT);
 	glViewport(0, 0, m_window_info.surface_width, m_window_info.surface_height);

-	return true;
+	return PresentResult::OK;
 }

 void OpenGLHostDisplay::EndPresent()
--- a/pcsx2/Frontend/OpenGLHostDisplay.h
+++ b/pcsx2/Frontend/OpenGLHostDisplay.h
@@ -58,7 +58,7 @@ public:

 	void SetVSync(VsyncMode mode) override;

-	bool BeginPresent(bool frame_skip) override;
+	PresentResult BeginPresent(bool frame_skip) override;
 	void EndPresent() override;

 	bool SetGPUTimingEnabled(bool enabled) override;
--- a/pcsx2/Frontend/VulkanHostDisplay.cpp
+++ b/pcsx2/Frontend/VulkanHostDisplay.cpp
@@ -339,17 +339,18 @@ bool VulkanHostDisplay::DoneCurrent()
 	return true;
 }

-bool VulkanHostDisplay::BeginPresent(bool frame_skip)
+HostDisplay::PresentResult VulkanHostDisplay::BeginPresent(bool frame_skip)
 {
 	if (frame_skip || !m_swap_chain)
-	{
-		ImGui::EndFrame();
-		return false;
-	}
+		return PresentResult::FrameSkipped;

 	// Previous frame needs to be presented before we can acquire the swap chain.
 	g_vulkan_context->WaitForPresentComplete();

+	// Check if the device was lost.
+	if (g_vulkan_context->CheckLastSubmitFail())
+		return PresentResult::DeviceLost;
+
 	VkResult res = m_swap_chain->AcquireNextImage();
 	if (res != VK_SUCCESS)
 	{
@@ -367,7 +368,7 @@ bool VulkanHostDisplay::BeginPresent(bool frame_skip)
 			{
 				Console.Error("Failed to recreate surface after loss");
 				g_vulkan_context->ExecuteCommandBuffer(Vulkan::Context::WaitType::None);
-				return false;
+				return PresentResult::FrameSkipped;
 			}

 			res = m_swap_chain->AcquireNextImage();
@@ -380,7 +381,7 @@ bool VulkanHostDisplay::BeginPresent(bool frame_skip)
 			// Still submit the command buffer, otherwise we'll end up with several frames waiting.
 			LOG_VULKAN_ERROR(res, "vkAcquireNextImageKHR() failed: ");
 			g_vulkan_context->ExecuteCommandBuffer(Vulkan::Context::WaitType::None);
-			return false;
+			return PresentResult::FrameSkipped;
 		}
 	}

@@ -401,7 +402,7 @@ bool VulkanHostDisplay::BeginPresent(bool frame_skip)
 	const VkRect2D scissor{{0, 0}, {static_cast<u32>(swap_chain_texture.GetWidth()), static_cast<u32>(swap_chain_texture.GetHeight())}};
 	vkCmdSetViewport(g_vulkan_context->GetCurrentCommandBuffer(), 0, 1, &vp);
 	vkCmdSetScissor(g_vulkan_context->GetCurrentCommandBuffer(), 0, 1, &scissor);
-	return true;
+	return PresentResult::OK;
 }

 void VulkanHostDisplay::EndPresent()
--- a/pcsx2/Frontend/VulkanHostDisplay.h
+++ b/pcsx2/Frontend/VulkanHostDisplay.h
@@ -47,7 +47,7 @@ public:

 	void SetVSync(VsyncMode mode) override;

-	bool BeginPresent(bool frame_skip) override;
+	PresentResult BeginPresent(bool frame_skip) override;
 	void EndPresent() override;

 	bool SetGPUTimingEnabled(bool enabled) override;
--- a/pcsx2/GS/GS.cpp
+++ b/pcsx2/GS/GS.cpp
@@ -209,15 +209,15 @@ static bool DoGSOpen(GSRendererType renderer, u8* basemem)
 			return false;
 	}

-	try
+	if (!g_gs_device->Create())
 	{
-		if (!g_gs_device->Create())
-		{
-			g_gs_device->Destroy();
-			g_gs_device.reset();
-			return false;
-		}
+		g_gs_device->Destroy();
+		g_gs_device.reset();
+		return false;
+	}

+	if (!g_gs_renderer)
+	{
 		if (renderer == GSRendererType::Null)
 		{
 			g_gs_renderer = std::make_unique<GSRendererNull>();
@@ -230,55 +230,71 @@ static bool DoGSOpen(GSRendererType renderer, u8* basemem)
 		{
 			g_gs_renderer = std::unique_ptr<GSRenderer>(MULTI_ISA_SELECT(makeGSRendererSW)(GSConfig.SWExtraThreads));
 		}
+
+		g_gs_renderer->SetRegsMem(basemem);
+		g_gs_renderer->ResetPCRTC();
 	}
-	catch (std::exception& ex)
+	else
 	{
-		Host::ReportFormattedErrorAsync("GS", "GS error: Exception caught in GSopen: %s", ex.what());
-		g_gs_renderer.reset();
-		g_gs_device->Destroy();
-		g_gs_device.reset();
-		return false;
+		Console.Warning("(DoGSOpen) Using existing renderer.");
 	}

 	GSConfig.OsdShowGPU = EmuConfig.GS.OsdShowGPU && g_host_display->SetGPUTimingEnabled(true);

-	g_gs_renderer->SetRegsMem(basemem);
 	g_perfmon.Reset();
 	return true;
 }

-bool GSreopen(bool recreate_display, const Pcsx2Config::GSOptions& old_config)
+bool GSreopen(bool recreate_display, bool recreate_renderer, const Pcsx2Config::GSOptions& old_config)
 {
 	Console.WriteLn("Reopening GS with %s display", recreate_display ? "new" : "existing");

-	g_gs_renderer->Flush(GSState::GSFlushReason::GSREOPEN);
+	if (recreate_renderer)
+		g_gs_renderer->Flush(GSState::GSFlushReason::GSREOPEN);
+
+	if (GSConfig.UserHacks_ReadTCOnClose)
+		g_gs_renderer->ReadbackTextureCache();

 	freezeData fd = {};
-	if (g_gs_renderer->Freeze(&fd, true) != 0)
+	std::unique_ptr<u8[]> fd_data;
+	if (recreate_renderer)
 	{
-		Console.Error("(GSreopen) Failed to get GS freeze size");
-		return false;
-	}
+		if (g_gs_renderer->Freeze(&fd, true) != 0)
+		{
+			Console.Error("(GSreopen) Failed to get GS freeze size");
+			return false;
+		}

-	std::unique_ptr<u8[]> fd_data = std::make_unique<u8[]>(fd.size);
-	fd.data = fd_data.get();
-	if (g_gs_renderer->Freeze(&fd, false) != 0)
+		fd_data = std::make_unique<u8[]>(fd.size);
+		fd.data = fd_data.get();
+		if (g_gs_renderer->Freeze(&fd, false) != 0)
+		{
+			Console.Error("(GSreopen) Failed to freeze GS");
+			return false;
+		}
+	}
+	else
 	{
-		Console.Error("(GSreopen) Failed to freeze GS");
-		return false;
+		// Make sure nothing is left over.
+		g_gs_renderer->PurgeTextureCache();
+		g_gs_renderer->PurgePool();
 	}

 	if (recreate_display)
 	{
 		g_gs_device->ResetAPIState();
-		if (Host::BeginPresentFrame(true))
+		if (Host::BeginPresentFrame(false) == HostDisplay::PresentResult::OK)
 			Host::EndPresentFrame();
 	}

 	u8* basemem = g_gs_renderer->GetRegsMem();
 	const u32 gamecrc = g_gs_renderer->GetGameCRC();
-	g_gs_renderer->Destroy();
-	g_gs_renderer.reset();
+	if (recreate_renderer)
+	{
+		g_gs_renderer->Destroy();
+		g_gs_renderer.reset();
+	}
+
 	g_gs_device->Destroy();
 	g_gs_device.reset();

@@ -327,13 +343,17 @@ bool GSreopen(bool recreate_display, const Pcsx2Config::GSOptions& old_config)
 		}
 	}

-	if (g_gs_renderer->Defrost(&fd) != 0)
+	if (recreate_renderer)
 	{
-		Console.Error("(GSreopen) Failed to defrost");
-		return false;
+		if (g_gs_renderer->Defrost(&fd) != 0)
+		{
+			Console.Error("(GSreopen) Failed to defrost");
+			return false;
+		}
+
+		g_gs_renderer->SetGameCRC(gamecrc);
 	}

-	g_gs_renderer->SetGameCRC(gamecrc);
 	return true;
 }

@@ -698,7 +718,7 @@ void GSUpdateConfig(const Pcsx2Config::GSOptions& new_config)
 			GSConfig.DisableShaderCache != old_config.DisableShaderCache ||
 			GSConfig.DisableThreadedPresentation != old_config.DisableThreadedPresentation
 		);
-		if (!GSreopen(do_full_restart, old_config))
+		if (!GSreopen(do_full_restart, true, old_config))
 			pxFailRel("Failed to do full GS reopen");
 		return;
 	}
@@ -709,7 +729,7 @@ void GSUpdateConfig(const Pcsx2Config::GSOptions& new_config)
 		GSConfig.SWExtraThreads != old_config.SWExtraThreads ||
 		GSConfig.SWExtraThreadsHeight != old_config.SWExtraThreadsHeight)
 	{
-		if (!GSreopen(false, old_config))
+		if (!GSreopen(false, true, old_config))
 			pxFailRel("Failed to do quick GS reopen");

 		return;
@@ -745,6 +765,8 @@ void GSUpdateConfig(const Pcsx2Config::GSOptions& new_config)
 		GSConfig.UserHacks_CPUCLUTRender != old_config.UserHacks_CPUCLUTRender ||
 		GSConfig.UserHacks_GPUTargetCLUTMode != old_config.UserHacks_GPUTargetCLUTMode)
 	{
+		if (GSConfig.UserHacks_ReadTCOnClose)
+			g_gs_renderer->ReadbackTextureCache();
 		g_gs_renderer->PurgeTextureCache();
 		g_gs_renderer->PurgePool();
 	}
@@ -787,7 +809,7 @@ void GSSwitchRenderer(GSRendererType new_renderer)
 	const bool recreate_display = (!is_software_switch && existing_api != GetAPIForRenderer(new_renderer));
 	const Pcsx2Config::GSOptions old_config(GSConfig);
 	GSConfig.Renderer = new_renderer;
-	if (!GSreopen(recreate_display, old_config))
+	if (!GSreopen(recreate_display, true, old_config))
 		pxFailRel("Failed to reopen GS for renderer switch.");
 }

--- a/pcsx2/GS/GS.h
+++ b/pcsx2/GS/GS.h
@@ -53,7 +53,7 @@ s16 GSLookupBeforeDrawFunctionId(const std::string_view& name);
 int GSinit();
 void GSshutdown();
 bool GSopen(const Pcsx2Config::GSOptions& config, GSRendererType renderer, u8* basemem);
-bool GSreopen(bool recreate_display, const Pcsx2Config::GSOptions& old_config);
+bool GSreopen(bool recreate_display, bool recreate_renderer, const Pcsx2Config::GSOptions& old_config);
 void GSreset(bool hardware_reset);
 void GSclose();
 void GSgifSoftReset(u32 mask);
--- a/pcsx2/GS/GSCrc.cpp
+++ b/pcsx2/GS/GSCrc.cpp
@@ -24,15 +24,6 @@ const CRC::Game CRC::m_games[] =
 {
 	// Note: IDs 0x7ACF7E03, 0x7D4EA48F, 0x37C53760 - shouldn't be added as it's from the multiloaders when packing games.
 	{0x00000000, NoTitle /* NoRegion */},
-	{0x9AAC5309, FFX2 /* EU */},
-	{0x9AAC530C, FFX2 /* FR */},
-	{0x9AAC530A, FFX2 /* ES */},
-	{0x9AAC530D, FFX2 /* DE */},
-	{0x9AAC530B, FFX2 /* IT */},
-	{0x48FE0C71, FFX2 /* US */},
-	{0x8A6D7F14, FFX2 /* JP */},
-	{0xE1FD9A2D, FFX2 /* JP */}, // int.
-	{0x11624CD6, FFX2 /* KO */},
 	{0x08C1ED4D, HauntingGround /* EU */},
 	{0x2CD5794C, HauntingGround /* EU */},
 	{0x867BB945, HauntingGround /* JP */},
--- a/pcsx2/GS/GSCrc.h
+++ b/pcsx2/GS/GSCrc.h
@@ -23,7 +23,6 @@ public:
 	enum Title : u32
 	{
 		NoTitle,
-		FFX2,
 		GetawayGames,
 		HauntingGround,
 		ICO,
--- a/pcsx2/GS/GSLocalMemory.h
+++ b/pcsx2/GS/GSLocalMemory.h
@@ -481,7 +481,7 @@ public:
 	static psm_t m_psm[64];
 	static readImage m_readImageX;

-	static const int m_vmsize = 1024 * 1024 * 4;
+	static constexpr int m_vmsize = 1024 * 1024 * 4;

 	u8* m_vm8;

@@ -981,10 +981,15 @@ public:
 		off.loopPixels(r, vm32(), (u32*)src, pitch, [&](u32* dst, u32* src) { *dst = *src; });
 	}

+	void WritePixel32(u8* RESTRICT src, u32 pitch, const GSOffset& off, const GSVector4i& r, u32 write_mask)
+	{
+		off.loopPixels(r, vm32(), (u32*)src, pitch, [&](u32* dst, u32* src) { *dst = (*dst & ~write_mask) | (*src & write_mask); });
+	}
+
 	void WritePixel24(u8* RESTRICT src, u32 pitch, const GSOffset& off, const GSVector4i& r)
 	{
 		off.loopPixels(r, vm32(), (u32*)src, pitch,
-		[&](u32* dst, u32* src)
+			[&](u32* dst, u32* src)
 		{
 			*dst = (*dst & 0xff000000) | (*src & 0x00ffffff);
 		});
--- a/pcsx2/GS/GSState.cpp
+++ b/pcsx2/GS/GSState.cpp
@@ -26,6 +26,7 @@
 #include <iomanip> // Dump Verticles

 int GSState::s_n = 0;
+int GSState::s_transfer_n = 0;

 static __fi bool IsAutoFlushEnabled()
 {
@@ -37,14 +38,61 @@ static __fi bool IsFirstProvokingVertex()
 	return (GSConfig.Renderer != GSRendererType::SW && !g_gs_device->Features().provoking_vertex_last);
 }

+constexpr int GSState::GetSaveStateSize()
+{
+	int size = 0;
+
+	size += sizeof(STATE_VERSION);
+	size += sizeof(m_env.PRIM);
+	size += sizeof(m_env.PRMODECONT);
+	size += sizeof(m_env.TEXCLUT);
+	size += sizeof(m_env.SCANMSK);
+	size += sizeof(m_env.TEXA);
+	size += sizeof(m_env.FOGCOL);
+	size += sizeof(m_env.DIMX);
+	size += sizeof(m_env.DTHE);
+	size += sizeof(m_env.COLCLAMP);
+	size += sizeof(m_env.PABE);
+	size += sizeof(m_env.BITBLTBUF);
+	size += sizeof(m_env.TRXDIR);
+	size += sizeof(m_env.TRXPOS);
+	size += sizeof(m_env.TRXREG);
+	size += sizeof(m_env.TRXREG); // obsolete
+
+	for (int i = 0; i < 2; i++)
+	{
+		size += sizeof(m_env.CTXT[i].XYOFFSET);
+		size += sizeof(m_env.CTXT[i].TEX0);
+		size += sizeof(m_env.CTXT[i].TEX1);
+		size += sizeof(m_env.CTXT[i].CLAMP);
+		size += sizeof(m_env.CTXT[i].MIPTBP1);
+		size += sizeof(m_env.CTXT[i].MIPTBP2);
+		size += sizeof(m_env.CTXT[i].SCISSOR);
+		size += sizeof(m_env.CTXT[i].ALPHA);
+		size += sizeof(m_env.CTXT[i].TEST);
+		size += sizeof(m_env.CTXT[i].FBA);
+		size += sizeof(m_env.CTXT[i].FRAME);
+		size += sizeof(m_env.CTXT[i].ZBUF);
+	}
+
+	size += sizeof(m_v.RGBAQ);
+	size += sizeof(m_v.ST);
+	size += sizeof(m_v.UV);
+	size += sizeof(m_v.FOG);
+	size += sizeof(m_v.XYZ);
+	size += sizeof(GIFReg); // obsolete
+
+	size += sizeof(m_tr.x);
+	size += sizeof(m_tr.y);
+	size += GSLocalMemory::m_vmsize;
+	size += (sizeof(GIFPath::tag) + sizeof(GIFPath::reg)) * 4 /* std::size(GSState::m_path) */; // std::size won't work without an instance.
+	size += sizeof(m_q);
+
+	return size;
+}
+
 GSState::GSState()
-	: m_version(STATE_VERSION)
-	, m_q(1.0f)
-	, m_scanmask_used(0)
-	, tex_flushed(true)
-	, m_vt(this, IsFirstProvokingVertex())
-	, m_regs(NULL)
-	, m_crc(0)
+	: m_vt(this, IsFirstProvokingVertex())
 {
 	// m_nativeres seems to be a hack. Unfortunately it impacts draw call number which make debug painful in the replayer.
 	// Let's keep it disabled to ease debug.
@@ -63,54 +111,6 @@ GSState::GSState()

 	m_draw_transfers.clear();

-	m_sssize = 0;
-
-	m_sssize += sizeof(m_version);
-	m_sssize += sizeof(m_env.PRIM);
-	m_sssize += sizeof(m_env.PRMODECONT);
-	m_sssize += sizeof(m_env.TEXCLUT);
-	m_sssize += sizeof(m_env.SCANMSK);
-	m_sssize += sizeof(m_env.TEXA);
-	m_sssize += sizeof(m_env.FOGCOL);
-	m_sssize += sizeof(m_env.DIMX);
-	m_sssize += sizeof(m_env.DTHE);
-	m_sssize += sizeof(m_env.COLCLAMP);
-	m_sssize += sizeof(m_env.PABE);
-	m_sssize += sizeof(m_env.BITBLTBUF);
-	m_sssize += sizeof(m_env.TRXDIR);
-	m_sssize += sizeof(m_env.TRXPOS);
-	m_sssize += sizeof(m_env.TRXREG);
-	m_sssize += sizeof(m_env.TRXREG); // obsolete
-
-	for (int i = 0; i < 2; i++)
-	{
-		m_sssize += sizeof(m_env.CTXT[i].XYOFFSET);
-		m_sssize += sizeof(m_env.CTXT[i].TEX0);
-		m_sssize += sizeof(m_env.CTXT[i].TEX1);
-		m_sssize += sizeof(m_env.CTXT[i].CLAMP);
-		m_sssize += sizeof(m_env.CTXT[i].MIPTBP1);
-		m_sssize += sizeof(m_env.CTXT[i].MIPTBP2);
-		m_sssize += sizeof(m_env.CTXT[i].SCISSOR);
-		m_sssize += sizeof(m_env.CTXT[i].ALPHA);
-		m_sssize += sizeof(m_env.CTXT[i].TEST);
-		m_sssize += sizeof(m_env.CTXT[i].FBA);
-		m_sssize += sizeof(m_env.CTXT[i].FRAME);
-		m_sssize += sizeof(m_env.CTXT[i].ZBUF);
-	}
-
-	m_sssize += sizeof(m_v.RGBAQ);
-	m_sssize += sizeof(m_v.ST);
-	m_sssize += sizeof(m_v.UV);
-	m_sssize += sizeof(m_v.FOG);
-	m_sssize += sizeof(m_v.XYZ);
-	m_sssize += sizeof(GIFReg); // obsolete
-
-	m_sssize += sizeof(m_tr.x);
-	m_sssize += sizeof(m_tr.y);
-	m_sssize += m_mem.m_vmsize;
-	m_sssize += (sizeof(m_path[0].tag) + sizeof(m_path[0].reg)) * std::size(m_path);
-	m_sssize += sizeof(m_q);
-
 	PRIM = &m_env.PRIM;
 	//CSR->rREV = 0x20;
 	m_env.PRMODECONT.AC = 1;
@@ -285,6 +285,14 @@ void GSState::ResetHandlers()
 	m_fpGIFRegHandlers[GIF_A_D_REG_LABEL] = &GSState::GIFRegHandlerNull;
 }

+void GSState::ResetPCRTC()
+{
+	PCRTCDisplays.SetVideoMode(GetVideoMode());
+	PCRTCDisplays.EnableDisplays(m_regs->PMODE, m_regs->SMODE2, isReallyInterlaced());
+	PCRTCDisplays.SetRects(0, m_regs->DISP[0].DISPLAY, m_regs->DISP[0].DISPFB);
+	PCRTCDisplays.SetRects(1, m_regs->DISP[1].DISPLAY, m_regs->DISP[1].DISPFB);
+}
+
 void GSState::UpdateSettings(const Pcsx2Config::GSOptions& old_config)
 {
 	m_mipmap = GSConfig.Mipmap;
@@ -340,264 +348,6 @@ GSVideoMode GSState::GetVideoMode()
 	__assume(0); // unreachable
 }

-bool GSState::IsAnalogue()
-{
-	return GetVideoMode() == GSVideoMode::NTSC || GetVideoMode() == GSVideoMode::PAL || GetVideoMode() == GSVideoMode::HDTV_1080I;
-}
-
-GSVector4i GSState::GetFrameMagnifiedRect(int i)
-{
-	GSVector4i rectangle = { 0, 0, 0, 0 };
-
-	if (!IsEnabled(i))
-		return rectangle;
-
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	const auto& DISP = m_regs->DISP[i].DISPLAY;
-	const bool ignore_offset = !GSConfig.PCRTCOffsets;
-
-	const u32 DW = DISP.DW + 1;
-	const u32 DH = DISP.DH + 1;
-;
-	// The number of sub pixels to draw are given in DH and DW, the MAGH/V relates to the size of the original square in the FB
-	// but the size it's drawn to uses the default size of the display mode (for PAL/NTSC this is a MAGH of 3)
-	// so for example a game will have a DW of 2559 and a MAGH of 4 to make it 512 (from the FB), but because it's drawing 2560 subpixels
-	// it will cover the entire 640 wide of the screen (2560 / (3+1)).
-	int width;
-	int height;
-	if (ignore_offset)
-	{
-		width = (DW / (DISP.MAGH + 1));
-		height = (DH / (DISP.MAGV + 1));
-	}
-	else
-	{
-		width = (DW / (VideoModeDividers[videomode].x + 1));
-		height = (DH / (VideoModeDividers[videomode].y + 1));
-	}
-
-	int res_multi = 1;
-
-	if (isinterlaced() && m_regs->SMODE2.FFMD && height > 1)
-		res_multi = 2;
-
-	// Set up the display rectangle based on the values obtained from DISPLAY registers
-	rectangle.right = width;
-	rectangle.bottom = height / res_multi;
-
-	return rectangle;
-}
-
-int GSState::GetDisplayHMagnification()
-{
-	// Pick one of the DISPLAY's and hope that they are both the same. Favour DISPLAY[1]
-	for (int i = 1; i >= 0; i--)
-	{
-		if (IsEnabled(i))
-			return m_regs->DISP[i].DISPLAY.MAGH + 1;
-	}
-
-	// If neither DISPLAY is enabled, fallback to resolution offset (should never happen)
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	return VideoModeDividers[videomode].x + 1;
-}
-
-GSVector4i GSState::GetDisplayRect(int i)
-{
-	GSVector4i rectangle = { 0, 0, 0, 0 };
-
-	if (i == -1)
-	{
-		return GetDisplayRect(0).runion(GetDisplayRect(1));
-	}
-
-	if (!IsEnabled(i))
-		return rectangle;
-
-	const auto& DISP = m_regs->DISP[i].DISPLAY;
-
-	const u32 DW = DISP.DW + 1;
-	const u32 DH = DISP.DH + 1;
-	const u32 MAGH = DISP.MAGH + 1;
-	const u32 MAGV = DISP.MAGV + 1;
-
-	const GSVector2i magnification(MAGH, MAGV);
-
-	const int width = DW / magnification.x;
-	const int height = DH / magnification.y;
-
-	const GSVector2i offsets = GetResolutionOffset(i);
-
-	// Set up the display rectangle based on the values obtained from DISPLAY registers
-	rectangle.left = offsets.x;
-	rectangle.top = offsets.y;
-
-	rectangle.right = rectangle.left + width;
-	rectangle.bottom = rectangle.top + height;
-
-	return rectangle;
-}
-
-GSVector2i GSState::GetResolutionOffset(int i)
-{
-	GSVector2i offset = { 0, 0 };
-
-	if (!IsEnabled(i))
-		return offset;
-
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	const auto& DISP = m_regs->DISP[i].DISPLAY;
-
-	const auto& SMODE2 = m_regs->SMODE2;
-	const int res_multi = (SMODE2.INT + 1);
-	const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
-
-	offset.x = (static_cast<int>(DISP.DX) - offsets.z) / (VideoModeDividers[videomode].x + 1);
-	offset.y = (static_cast<int>(DISP.DY) - (offsets.w * ((IsAnalogue() && res_multi) ? res_multi : 1))) / (VideoModeDividers[videomode].y + 1);
-
-	return offset;
-}
-
-GSVector2i GSState::GetResolution()
-{
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	const bool ignore_offset = !GSConfig.PCRTCOffsets;
-
-	const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
-
-	GSVector2i resolution(offsets.x, offsets.y);
-
-	// The resolution of the framebuffer is double when in FRAME mode and interlaced.
-	// Also we need a special check because no-interlace patches like to render in the original height, but in non-interlaced mode
-	// which means it would normally go off the bottom of the screen. Advantages of emulation, i guess... Limited to Ignore Offsets + Deinterlacing = Off.
-	if ((isinterlaced() && !m_regs->SMODE2.FFMD) || (GSConfig.InterlaceMode == GSInterlaceMode::Off && !GSConfig.PCRTCOffsets && !isinterlaced()))
-		resolution.y *= 2;
-
-	if (ignore_offset)
-	{
-		// Ideally we'd just cut the width at the resolution, but of course we have to hack the hack...
-		// Some games (Mortal Kombat Armageddon) render the image at 834 pixels then shrink it to 624 pixels
-		// which does fit, but when we ignore offsets we go on framebuffer size and some other games
-		// such as Johnny Mosleys Mad Trix and Transformers render too much but design it to go off the screen.
-		int magnified_width = (VideoModeDividers[videomode].z + 1) / GetDisplayHMagnification();
-
-		// When viewing overscan allow up to the overscan size
-		if (GSConfig.PCRTCOverscan)
-			magnified_width = std::max(magnified_width, offsets.x);
-
-		GSVector4i total_rect = GetDisplayRect(0).runion(GetDisplayRect(1));
-		total_rect.z = total_rect.z - total_rect.x;
-		total_rect.w = total_rect.w - total_rect.y;
-		total_rect.z = std::min(total_rect.z, magnified_width);
-		total_rect.w = std::min(total_rect.w, resolution.y);
-		resolution.x = total_rect.z;
-		resolution.y = total_rect.w;
-	}
-
-	return resolution;
-}
-
-GSVector4i GSState::GetFrameRect(int i, bool ignore_off)
-{
-	// If no specific context is requested then pass the merged rectangle as return value
-	if (i == -1)
-		return GetFrameRect(0, ignore_off).runion(GetFrameRect(1, ignore_off));
-
-	GSVector4i rectangle = { 0, 0, 0, 0 };
-
-	if (!IsEnabled(i))
-		return rectangle;
-
-	const auto& DISP = m_regs->DISP[i].DISPLAY;
-
-	const u32 DW = DISP.DW + 1;
-	const u32 DH = DISP.DH + 1;
-	const GSVector2i magnification(DISP.MAGH+1, DISP.MAGV + 1);
-
-	const u32 DBX = m_regs->DISP[i].DISPFB.DBX;
-	int DBY = m_regs->DISP[i].DISPFB.DBY;
-
-
-	const int w = DW / magnification.x;
-	const int h = DH / magnification.y;
-
-	// If the combined height overflows 2048, it's likely adding a bit of extra data before the picture for offsetting the interlace
-	// only game known to do this is NASCAR '08
-	if (!ignore_off && (DBY + h) >= 2048)
-		DBY = DBY - 2048;
-
-	rectangle.left = (ignore_off) ? 0 : DBX;
-	rectangle.top = (ignore_off) ? 0 : DBY;
-
-	rectangle.right = rectangle.left + w;
-	rectangle.bottom = rectangle.top + h;
-
-	if (isinterlaced() && m_regs->SMODE2.FFMD && h > 1)
-	{
-		rectangle.bottom += 1;
-		rectangle.bottom >>= 1;
-	}
-
-	return rectangle;
-}
-
-int GSState::GetFramebufferHeight()
-{
-	// Framebuffer height is 11 bits max
-	constexpr int height_limit = (1 << 11);
-
-	const GSVector4i disp1_rect = GetFrameRect(0, true);
-	const GSVector4i disp2_rect = GetFrameRect(1, true);
-	const GSVector4i combined = disp1_rect.runion(disp2_rect);
-
-	// DBY isn't an offset to the frame memory but rather an offset to read output circuit inside
-	// the frame memory, hence the top offset should also be calculated for the total height of the
-	// frame memory. Also we need to wrap the value only when we're dealing with values with range of the
-	// frame memory (offset + read output circuit height, IOW bottom of merged_output)
-	const int max_height = std::max(disp1_rect.height(), disp2_rect.height());
-	const int frame_memory_height = std::max(max_height, combined.bottom % height_limit);
-
-	if (frame_memory_height > 1024)
-		GL_PERF("Massive framebuffer height detected! (height:%d)", frame_memory_height);
-
-	return frame_memory_height;
-}
-
-int GSState::GetFramebufferBitDepth()
-{
-	if (IsEnabled(0))
-		return GSLocalMemory::m_psm[m_regs->DISP[0].DISPFB.PSM].bpp;
-	else if (IsEnabled(1))
-		return GSLocalMemory::m_psm[m_regs->DISP[1].DISPFB.PSM].bpp;
-
-	return 32;
-}
-
-int GSState::GetFramebufferWidth()
-{
-	const GSVector4i disp1_rect = GetFrameRect(0, true);
-	const GSVector4i disp2_rect = GetFrameRect(1, true);
-
-	const int max_width = std::max(disp1_rect.width(), disp2_rect.width());
-
-	return max_width;
-}
-
-bool GSState::IsEnabled(int i)
-{
-	ASSERT(i >= 0 && i < 2);
-
-	const auto& DISP = m_regs->DISP[i].DISPLAY;
-
-	const bool disp1_enabled = m_regs->PMODE.EN1;
-	const bool disp2_enabled = m_regs->PMODE.EN2;
-
-	if ((i == 0 && disp1_enabled) || (i == 1 && disp2_enabled))
-		return DISP.DW && DISP.DH;
-
-	return false;
-}
-
 float GSState::GetTvRefreshRate()
 {
 	const GSVideoMode videomode = GetVideoMode();
@@ -1771,6 +1521,7 @@ void GSState::FlushWrite()
 	m_tr.start += len;

 	g_perfmon.Put(GSPerfMon::Swizzle, len);
+	s_transfer_n++;
 }

 // This function decides if the context has changed in a way which warrants flushing the draw.
@@ -2007,14 +1758,18 @@ void GSState::Write(const u8* mem, int len)
 	// Invalid the CLUT if it crosses paths.
 	m_mem.m_clut.InvalidateRange(write_start_bp, write_end_bp);

-	if (GSConfig.PreloadFrameWithGSData)
+	GSVector4i r;
+
+	r.left = m_env.TRXPOS.DSAX;
+	r.top = m_env.TRXPOS.DSAY;
+	r.right = r.left + m_env.TRXREG.RRW;
+	r.bottom = r.top + m_env.TRXREG.RRH;
+
+	// Store the transfer for preloading new RT's.
+	if (m_draw_transfers.size() == 0 || (m_draw_transfers.size() > 0 && blit.DBP != m_draw_transfers.back().blit.DBP))
 	{
-		// Store the transfer for preloading new RT's.
-		if (m_draw_transfers.size() == 0 || (m_draw_transfers.size() > 0 && blit.DBP != m_draw_transfers.back().blit.DBP))
-		{
-			GSUploadQueue new_transfer = { blit, s_n };
-			m_draw_transfers.push_back(new_transfer);
-		}
+		GSUploadQueue new_transfer = { blit, r, s_n };
+		m_draw_transfers.push_back(new_transfer);
 	}

 	GL_CACHE("Write! ...  => 0x%x W:%d F:%s (DIR %d%d), dPos(%d %d) size(%d %d)",
@@ -2025,12 +1780,6 @@ void GSState::Write(const u8* mem, int len)
 	if (m_tr.end == 0 && len >= m_tr.total)
 	{
 		// received all data in one piece, no need to buffer it
-		GSVector4i r;
-
-		r.left = m_env.TRXPOS.DSAX;
-		r.top = m_env.TRXPOS.DSAY;
-		r.right = r.left + m_env.TRXREG.RRW;
-		r.bottom = r.top + m_env.TRXREG.RRH;
 		ExpandTarget(m_env.BITBLTBUF, r);
 		InvalidateVideoMem(blit, r, true);

@@ -2039,6 +1788,7 @@ void GSState::Write(const u8* mem, int len)
 		m_tr.start = m_tr.end = m_tr.total;

 		g_perfmon.Put(GSPerfMon::Swizzle, len);
+		s_transfer_n++;
 	}
 	else
 	{
@@ -2105,6 +1855,7 @@ void GSState::Move()
 {
 	// ffxii uses this to move the top/bottom of the scrolling menus offscreen and then blends them back over the text to create a shading effect
 	// guitar hero copies the far end of the board to do a similar blend too
+	s_transfer_n++;

 	int sx = m_env.TRXPOS.SSAX;
 	int sy = m_env.TRXPOS.SSAY;
@@ -2164,15 +1915,20 @@ void GSState::Move()
 		Flush(GSFlushReason::LOCALTOLOCALMOVE);
 	}

-	if (GSConfig.PreloadFrameWithGSData)
+	// Store the transfer for preloading new RT's.
+	if (m_draw_transfers.size() == 0 || (m_draw_transfers.size() > 0 && dbp != m_draw_transfers.back().blit.DBP))
 	{
-		// Store the transfer for preloading new RT's.
-		if (m_draw_transfers.size() == 0 || (m_draw_transfers.size() > 0 && dbp != m_draw_transfers.back().blit.DBP))
-		{
-			GSUploadQueue new_transfer = { m_env.BITBLTBUF, s_n };
-			m_draw_transfers.push_back(new_transfer);
-		}
+		GSVector4i r;
+
+		r.left = m_env.TRXPOS.DSAX;
+		r.top = m_env.TRXPOS.DSAY;
+		r.right = r.left + m_env.TRXREG.RRW;
+		r.bottom = r.top + m_env.TRXREG.RRH;
+
+		GSUploadQueue new_transfer = { m_env.BITBLTBUF, r, s_n };
+		m_draw_transfers.push_back(new_transfer);
 	}
+
 	// Invalid the CLUT if it crosses paths.
 	m_mem.m_clut.InvalidateRange(write_start_bp, write_end_bp);

@@ -2370,6 +2126,19 @@ void GSState::ReadLocalMemoryUnsync(u8* mem, int qwc, GIFRegBITBLTBUF BITBLTBUF,
 	m_mem.ReadImageX(tb.x, tb.y, mem, len, BITBLTBUF, TRXPOS, TRXREG);
 }

+void GSState::PurgePool()
+{
+	g_gs_device->PurgePool();
+}
+
+void GSState::PurgeTextureCache()
+{
+}
+
+void GSState::ReadbackTextureCache()
+{
+}
+
 template void GSState::Transfer<0>(const u8* mem, u32 size);
 template void GSState::Transfer<1>(const u8* mem, u32 size);
 template void GSState::Transfer<2>(const u8* mem, u32 size);
@@ -2580,18 +2349,22 @@ int GSState::Freeze(freezeData* fd, bool sizeonly)
 {
 	if (sizeonly)
 	{
-		fd->size = m_sssize;
+		fd->size = GetSaveStateSize();
 		return 0;
 	}

-	if (!fd->data || fd->size < m_sssize)
+	if (!fd->data || fd->size < GetSaveStateSize())
 		return -1;

 	Flush(GSFlushReason::SAVESTATE);

-	u8* data = fd->data;
+	if (GSConfig.UserHacks_ReadTCOnClose)
+		ReadbackTextureCache();

-	WriteState(data, &m_version);
+	u8* data = fd->data;
+	const u32 version = STATE_VERSION;
+
+	WriteState(data, &version);
 	WriteState(data, &m_env.PRIM);
 	WriteState(data, &m_env.PRMODECONT);
 	WriteState(data, &m_env.TEXCLUT);
@@ -2659,7 +2432,7 @@ int GSState::Defrost(const freezeData* fd)
 	if (!fd || !fd->data || fd->size == 0)
 		return -1;

-	if (fd->size < m_sssize)
+	if (fd->size < GetSaveStateSize())
 		return -1;

 	u8* data = fd->data;
@@ -2668,7 +2441,7 @@ int GSState::Defrost(const freezeData* fd)

 	ReadState(&version, data);

-	if (version > m_version)
+	if (version > STATE_VERSION)
 	{
 		Console.Error("GS: Savestate version is incompatible.  Load aborted.");
 		return -1;
@@ -2775,6 +2548,8 @@ int GSState::Defrost(const freezeData* fd)

 	g_perfmon.SetFrame(5000);

+	ResetPCRTC();
+
 	return 0;
 }

@@ -3164,7 +2939,7 @@ __forceinline void GSState::HandleAutoFlush()

 				const GSVector2i offset = GSVector2i(m_context->XYOFFSET.OFX, m_context->XYOFFSET.OFY);
 				const GSVector4i scissor = GSVector4i(m_context->scissor.in);
-				GSVector4i old_tex_rect = GSVector4i(0, 0, 0, 0);
+				GSVector4i old_tex_rect = GSVector4i::zero();
 				int current_draw_end = m_index.tail;

 				while (current_draw_end >= n)
@@ -4098,9 +3873,6 @@ GIFRegTEX0 GSState::GetTex0Layer(u32 lod)

 GSState::GSTransferBuffer::GSTransferBuffer()
 {
-	x = y = 0;
-	start = end = total = 0;
-
 	constexpr size_t alloc_size = 1024 * 1024 * 4;
 	buff = reinterpret_cast<u8*>(_aligned_malloc(alloc_size, 32));
 }
--- a/pcsx2/GS/GSState.h
+++ b/pcsx2/GS/GSState.h
@@ -35,13 +35,15 @@ public:
 	GSState();
 	virtual ~GSState();

+	static constexpr int GetSaveStateSize();
+
 private:
 	// RESTRICT prevents multiple loads of the same part of the register when accessing its bitfields (the compiler is happy to know that memory writes in-between will not go there)

 	typedef void (GSState::*GIFPackedRegHandler)(const GIFPackedReg* RESTRICT r);

-	GIFPackedRegHandler m_fpGIFPackedRegHandlers[16];
-	GIFPackedRegHandler m_fpGIFPackedRegHandlerXYZ[8][4];
+	GIFPackedRegHandler m_fpGIFPackedRegHandlers[16] = {};
+	GIFPackedRegHandler m_fpGIFPackedRegHandlerXYZ[8][4] = {};

 	void CheckFlushes();

@@ -58,14 +60,14 @@ private:

 	typedef void (GSState::*GIFRegHandler)(const GIFReg* RESTRICT r);

-	GIFRegHandler m_fpGIFRegHandlers[256];
-	GIFRegHandler m_fpGIFRegHandlerXYZ[8][4];
+	GIFRegHandler m_fpGIFRegHandlers[256] = {};
+	GIFRegHandler m_fpGIFRegHandlerXYZ[8][4] = {};

 	typedef void (GSState::*GIFPackedRegHandlerC)(const GIFPackedReg* RESTRICT r, u32 size);

-	GIFPackedRegHandlerC m_fpGIFPackedRegHandlersC[2];
-	GIFPackedRegHandlerC m_fpGIFPackedRegHandlerSTQRGBAXYZF2[8];
-	GIFPackedRegHandlerC m_fpGIFPackedRegHandlerSTQRGBAXYZ2[8];
+	GIFPackedRegHandlerC m_fpGIFPackedRegHandlersC[2] = {};
+	GIFPackedRegHandlerC m_fpGIFPackedRegHandlerSTQRGBAXYZF2[8] = {};
+	GIFPackedRegHandlerC m_fpGIFPackedRegHandlerSTQRGBAXYZ2[8] = {};

 	template<u32 prim, bool auto_flush, bool index_swap> void GIFPackedRegHandlerSTQRGBAXYZF2(const GIFPackedReg* RESTRICT r, u32 size);
 	template<u32 prim, bool auto_flush, bool index_swap> void GIFPackedRegHandlerSTQRGBAXYZ2(const GIFPackedReg* RESTRICT r, u32 size);
@@ -117,15 +119,12 @@ private:
 	template<bool auto_flush, bool index_swap>
 	void SetPrimHandlers();

-	u32 m_version;
-	int m_sssize;
-
 	struct GSTransferBuffer
 	{
-		int x, y;
-		int start, end, total;
-		u8* buff;
-		GIFRegBITBLTBUF m_blit;
+		int x = 0, y = 0;
+		int start = 0, end = 0, total = 0;
+		u8* buff = nullptr;
+		GIFRegBITBLTBUF m_blit = {};

 		GSTransferBuffer();
 		virtual ~GSTransferBuffer();
@@ -139,14 +138,14 @@ private:
 	void CalcAlphaMinMax();

 protected:
-	GSVertex m_v;
-	float m_q;
-	GSVector4i m_scissor;
-	GSVector4i m_ofxy;
+	GSVertex m_v = {};
+	float m_q = 1.0f;
+	GSVector4i m_scissor = {};
+	GSVector4i m_ofxy = {};

-	u8 m_scanmask_used;
-	bool tex_flushed;
-	bool m_isPackedUV_HackFlag;
+	u8 m_scanmask_used = 0;
+	bool tex_flushed = true;
+	bool m_isPackedUV_HackFlag = false;

 	struct
 	{
@@ -154,13 +153,13 @@ protected:
 		u32 head, tail, next, maxcount; // head: first vertex, tail: last vertex + 1, next: last indexed + 1
 		u32 xy_tail;
 		u64 xy[4];
-	} m_vertex;
+	} m_vertex = {};

 	struct
 	{
 		u32* buff;
 		u32 tail;
-	} m_index;
+	} m_index = {};

 	void UpdateContext();
 	void UpdateScissor();
@@ -210,29 +209,31 @@ public:
 	struct GSUploadQueue
 	{
 		GIFRegBITBLTBUF blit;
+		GSVector4i rect;
 		int draw;
 	};

-	GIFPath m_path[4];
-	GIFRegPRIM* PRIM;
-	GSPrivRegSet* m_regs;
+	GIFPath m_path[4] = {};
+	GIFRegPRIM* PRIM = nullptr;
+	GSPrivRegSet* m_regs = nullptr;
 	GSLocalMemory m_mem;
-	GSDrawingEnvironment m_env;
-	GSDrawingEnvironment m_backup_env;
-	GSDrawingEnvironment m_prev_env;
-	GSVector4i temp_draw_rect;
-	GSDrawingContext* m_context;
-	u32 m_crc;
-	CRC::Game m_game;
+	GSDrawingEnvironment m_env = {};
+	GSDrawingEnvironment m_backup_env = {};
+	GSDrawingEnvironment m_prev_env = {};
+	GSVector4i temp_draw_rect = {};
+	GSDrawingContext* m_context = nullptr;
+	u32 m_crc = 0;
+	CRC::Game m_game = {};
 	std::unique_ptr<GSDumpBase> m_dump;
-	bool m_nativeres;
-	bool m_mipmap;
-	u32 m_dirty_gs_regs;
-	int m_backed_up_ctx;
+	bool m_nativeres = false;
+	bool m_mipmap = false;
+	u8 m_force_preload = 0;
+	u32 m_dirty_gs_regs = 0;
+	int m_backed_up_ctx = 0;
 	std::vector<GSUploadQueue> m_draw_transfers;
-	bool m_force_preload;

 	static int s_n;
+	static int s_transfer_n;

 	static constexpr u32 STATE_VERSION = 8;

@@ -278,7 +279,7 @@ public:
 		GSREOPEN = 1 << 13,
 	};

-	GSFlushReason m_state_flush_reason;
+	GSFlushReason m_state_flush_reason = UNKNOWN;

 	enum PRIM_OVERLAP
 	{
@@ -287,62 +288,592 @@ public:
 		PRIM_OVERLAP_NO
 	};

-	PRIM_OVERLAP m_prim_overlap;
+	PRIM_OVERLAP m_prim_overlap = PRIM_OVERLAP_UNKNOW;
 	std::vector<size_t> m_drawlist;

-	// The horizontal offset values (under z) for PAL and NTSC have been tweaked
-	// they should be apparently 632 and 652 respectively, but that causes a thick black line on the left
-	// these values leave a small black line on the right in a bunch of games, but it's not so bad.
-	// The only conclusion I can come to is there is horizontal overscan expected so there would normally
-	// be black borders either side anyway, or both sides slightly covered.
-	const GSVector4i VideoModeOffsets[6] = {
-		GSVector4i(640, 224, 642, 25),
-		GSVector4i(640, 256, 676, 36),
-		GSVector4i(640, 480, 276, 34),
-		GSVector4i(720, 480, 232, 35),
-		GSVector4i(1280, 720, 302, 24),
-		GSVector4i(1920, 540, 238, 40)
-	};
+	struct GSPCRTCRegs
+	{
+		// The horizontal offset values (under z) for PAL and NTSC have been tweaked
+		// they should be apparently 632 and 652 respectively, but that causes a thick black line on the left
+		// these values leave a small black line on the right in a bunch of games, but it's not so bad.
+		// The only conclusion I can come to is there is horizontal overscan expected so there would normally
+		// be black borders either side anyway, or both sides slightly covered.
+		static inline constexpr GSVector4i VideoModeOffsets[6] = {
+			GSVector4i::cxpr(640, 224, 642, 25),
+			GSVector4i::cxpr(640, 256, 676, 36),
+			GSVector4i::cxpr(640, 480, 276, 34),
+			GSVector4i::cxpr(720, 480, 232, 35),
+			GSVector4i::cxpr(1280, 720, 302, 24),
+			GSVector4i::cxpr(1920, 540, 238, 40)
+		};

-	const GSVector4i VideoModeOffsetsOverscan[6] = {
-		GSVector4i(711, 243, 498, 12),
-		GSVector4i(702, 288, 532, 18),
-		GSVector4i(640, 480, 276, 34),
-		GSVector4i(720, 480, 232, 35),
-		GSVector4i(1280, 720, 302, 24),
-		GSVector4i(1920, 540, 238, 40)
-	};
+		static inline constexpr GSVector4i VideoModeOffsetsOverscan[6] = {
+			GSVector4i::cxpr(711, 243, 498, 12),
+			GSVector4i::cxpr(702, 288, 532, 18),
+			GSVector4i::cxpr(640, 480, 276, 34),
+			GSVector4i::cxpr(720, 480, 232, 35),
+			GSVector4i::cxpr(1280, 720, 302, 24),
+			GSVector4i::cxpr(1920, 540, 238, 40)
+		};

-	const GSVector4i VideoModeDividers[6] = {
-		GSVector4i(3, 0, 2559, 239),
-		GSVector4i(3, 0, 2559, 287),
-		GSVector4i(1, 0, 1279, 479),
-		GSVector4i(1, 0, 1439, 479),
-		GSVector4i(0, 0, 1279, 719),
-		GSVector4i(0, 0, 1919, 1079)
-	};
+		static inline constexpr GSVector4i VideoModeDividers[6] = {
+			GSVector4i::cxpr(3, 0, 2559, 239),
+			GSVector4i::cxpr(3, 0, 2559, 287),
+			GSVector4i::cxpr(1, 0, 1279, 479),
+			GSVector4i::cxpr(1, 0, 1439, 479),
+			GSVector4i::cxpr(0, 0, 1279, 719),
+			GSVector4i::cxpr(0, 0, 1919, 1079)
+		};
+
+		struct PCRTCDisplay
+		{
+			bool enabled;
+			int FBP;
+			int FBW;
+			int PSM;
+			GSRegDISPFB prevFramebufferReg;
+			GSVector2i prevDisplayOffset;
+			GSVector2i displayOffset;
+			GSVector4i displayRect;
+			GSVector2i magnification;
+			GSVector2i prevFramebufferOffsets;
+			GSVector2i framebufferOffsets;
+			GSVector4i framebufferRect;
+
+			int Block()
+			{
+				return FBP << 5;
+			}
+		};
+
+		int videomode = 0;
+		int interlaced = 0;
+		int FFMD = 0;
+		bool PCRTCSameSrc = false;
+		bool toggling_field = false;
+		PCRTCDisplay PCRTCDisplays[2] = {};
+
+		bool IsAnalogue()
+		{
+			const GSVideoMode video = static_cast<GSVideoMode>(videomode + 1);
+			return video == GSVideoMode::NTSC || video == GSVideoMode::PAL || video == GSVideoMode::HDTV_1080I;
+		}
+
+		// Calculates which display is closest to matching zero offsets in either direction.
+		GSVector2i NearestToZeroOffset()
+		{
+			GSVector2i returnValue = { 1, 1 };
+
+			if (!PCRTCDisplays[0].enabled && !PCRTCDisplays[1].enabled)
+				return returnValue;
+
+			for (int i = 0; i < 2; i++)
+			{
+				if (!PCRTCDisplays[i].enabled)
+				{
+					returnValue.x = 1 - i;
+					returnValue.y = 1 - i;
+					return returnValue;
+				}
+			}
+
+			if (abs(PCRTCDisplays[0].displayOffset.x - VideoModeOffsets[videomode].z) <
+				abs(PCRTCDisplays[1].displayOffset.x - VideoModeOffsets[videomode].z))
+				returnValue.x = 0;
+
+			// When interlaced, the vertical base offset is doubled
+			const int verticalOffset = VideoModeOffsets[videomode].w * (1 << interlaced);
+
+			if (abs(PCRTCDisplays[0].displayOffset.y - verticalOffset) <
+				abs(PCRTCDisplays[1].displayOffset.y - verticalOffset))
+				returnValue.y = 0;
+
+			return returnValue;
+		}
+
+		void SetVideoMode(GSVideoMode videoModeIn)
+		{
+			videomode = static_cast<int>(videoModeIn) - 1;
+		}
+
+		// Enable each of the displays.
+		void EnableDisplays(GSRegPMODE pmode, GSRegSMODE2 smode2, bool smodetoggle)
+		{
+			PCRTCDisplays[0].enabled = pmode.EN1;
+			PCRTCDisplays[1].enabled = pmode.EN2;
+
+			interlaced = smode2.INT && IsAnalogue();
+			FFMD = smode2.FFMD;
+			toggling_field = smodetoggle && IsAnalogue();
+		}
+
+		void CheckSameSource()
+		{
+			if (PCRTCDisplays[0].enabled != PCRTCDisplays[1].enabled || (PCRTCDisplays[0].enabled | PCRTCDisplays[1].enabled) == false)
+			{
+				PCRTCSameSrc = false;
+				return;
+			}
+
+			PCRTCSameSrc = PCRTCDisplays[0].FBP == PCRTCDisplays[1].FBP &&
+			PCRTCDisplays[0].FBW == PCRTCDisplays[1].FBW &&
+			GSUtil::HasCompatibleBits(PCRTCDisplays[0].PSM, PCRTCDisplays[1].PSM);
+		}
+		
+		bool FrameWrap()
+		{
+			const GSVector4i combined_rect = GSVector4i(PCRTCDisplays[0].framebufferRect.runion(PCRTCDisplays[1].framebufferRect));
+			return combined_rect.w >= 2048 || combined_rect.z >= 2048;
+		}
+
+		// If the start point of both frames match, we can do a single read
+		bool FrameRectMatch()
+		{
+			return PCRTCSameSrc;
+		}
+
+		GSVector2i GetResolution()
+		{
+			GSVector2i resolution;
+
+			const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
+			const bool is_full_height = interlaced || (toggling_field && GSConfig.InterlaceMode != GSInterlaceMode::Off) || GSConfig.InterlaceMode == GSInterlaceMode::Off;
+
+			if (!GSConfig.PCRTCOffsets)
+			{
+				if (PCRTCDisplays[0].enabled && PCRTCDisplays[1].enabled)
+				{
+					const GSVector4i combined_size = PCRTCDisplays[0].displayRect.runion(PCRTCDisplays[1].displayRect);
+					resolution = { combined_size.width(), combined_size.height() };
+				}
+				else if (PCRTCDisplays[0].enabled)
+				{
+					resolution = { PCRTCDisplays[0].displayRect.width(), PCRTCDisplays[0].displayRect.height() };
+				}
+				else
+				{
+					resolution = { PCRTCDisplays[1].displayRect.width(), PCRTCDisplays[1].displayRect.height() };
+				}
+			}
+			else
+			{
+				const int shift = is_full_height ? 1 : 0;
+				resolution = { offsets.x, offsets.y << shift };
+			}
+
+			resolution.x = std::min(resolution.x, offsets.x);
+			resolution.y = std::min(resolution.y, is_full_height ? offsets.y << 1 : offsets.y);
+
+			return resolution;
+		}
+
+		GSVector4i GetFramebufferRect(int display)
+		{
+			if (display == -1)
+			{
+				return GSVector4i(PCRTCDisplays[0].framebufferRect.runion(PCRTCDisplays[1].framebufferRect));
+			}
+			else
+			{
+				return PCRTCDisplays[display].framebufferRect;
+			}
+		}
+
+		int GetFramebufferBitDepth()
+		{
+			if (PCRTCDisplays[0].enabled)
+				return GSLocalMemory::m_psm[PCRTCDisplays[0].PSM].bpp;
+			else if (PCRTCDisplays[1].enabled)
+				return GSLocalMemory::m_psm[PCRTCDisplays[1].PSM].bpp;
+
+			return 32;
+		}
+
+		GSVector2i GetFramebufferSize(int display)
+		{
+			int max_height = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode].y : VideoModeOffsetsOverscan[videomode].y;
+
+			if (!(FFMD && interlaced))
+			{
+				max_height *= 2;
+			}
+
+			if (display == -1)
+			{
+				GSVector4i combined_rect = PCRTCDisplays[0].framebufferRect.runion(PCRTCDisplays[1].framebufferRect);
+
+				if (combined_rect.z >= 2048)
+				{
+					const int high_x = (PCRTCDisplays[0].framebufferRect.x > PCRTCDisplays[1].framebufferRect.x) ? PCRTCDisplays[0].framebufferRect.x : PCRTCDisplays[1].framebufferRect.x;
+					combined_rect.z -= GSConfig.UseHardwareRenderer() ? 2048 : high_x;
+					combined_rect.x = 0;
+				}
+
+				if (combined_rect.w >= 2048)
+				{
+					const int high_y = (PCRTCDisplays[0].framebufferRect.y > PCRTCDisplays[1].framebufferRect.y) ? PCRTCDisplays[0].framebufferRect.y : PCRTCDisplays[1].framebufferRect.y;
+					combined_rect.w -= GSConfig.UseHardwareRenderer() ? 2048 : high_y;
+					combined_rect.y = 0;
+				}
+
+				// Cap the framebuffer read to the maximum display height, otherwise the hardware renderer gets messy.
+				const int min_mag = std::max(1, std::min(PCRTCDisplays[0].magnification.y, PCRTCDisplays[1].magnification.y));
+				int offset = PCRTCDisplays[0].displayRect.runion(PCRTCDisplays[1].displayRect).y;
+
+				if (FFMD && interlaced)
+				{
+					offset = (offset - 1) / 2;
+				}
+
+				// Hardware mode needs a wider framebuffer as it can't offset the read.
+				if (GSConfig.UseHardwareRenderer())
+				{
+					combined_rect.z += std::max(PCRTCDisplays[0].framebufferOffsets.x, PCRTCDisplays[1].framebufferOffsets.x);
+					combined_rect.w += std::max(PCRTCDisplays[0].framebufferOffsets.y, PCRTCDisplays[1].framebufferOffsets.y);
+				}
+				offset = (max_height / min_mag) - offset;
+				combined_rect.w = std::min(combined_rect.w, offset);
+				return GSVector2i(combined_rect.z, combined_rect.w);
+			}
+			else
+			{
+				GSVector4i out_rect = PCRTCDisplays[display].framebufferRect;
+
+				if (out_rect.z >= 2048)
+				{
+					out_rect.z -= GSConfig.UseHardwareRenderer() ? 2048 : out_rect.x;
+					out_rect.x = 0;
+				}
+
+				if (out_rect.w >= 2048)
+				{
+					out_rect.w -= GSConfig.UseHardwareRenderer() ? 2048 : out_rect.y;
+					out_rect.y = 0;
+				}
+
+				// Cap the framebuffer read to the maximum display height, otherwise the hardware renderer gets messy.
+				const int min_mag = std::max(1, PCRTCDisplays[display].magnification.y);
+				int offset = PCRTCDisplays[display].displayRect.y;
+
+				if (FFMD && interlaced)
+				{
+					offset = (offset - 1) / 2;
+				}
+
+				offset = (max_height / min_mag) - offset;
+				out_rect.w = std::min(out_rect.w, offset);
+
+				// Hardware mode needs a wider framebuffer as it can't offset the read.
+				if (GSConfig.UseHardwareRenderer())
+				{
+					out_rect.z += PCRTCDisplays[display].framebufferOffsets.x;
+					out_rect.w += PCRTCDisplays[display].framebufferOffsets.y;
+				}
+				return GSVector2i(out_rect.z, out_rect.w);
+			}
+		}
+
+		// Sets up the rectangles for both the framebuffer read and the displays for the merge circuit.
+		void SetRects(int display, GSRegDISPLAY displayReg, GSRegDISPFB framebufferReg)
+		{
+			// Save framebuffer information first, while we're here.
+			PCRTCDisplays[display].FBP = framebufferReg.FBP;
+			PCRTCDisplays[display].FBW = framebufferReg.FBW;
+			PCRTCDisplays[display].PSM = framebufferReg.PSM;
+			PCRTCDisplays[display].prevFramebufferReg = framebufferReg;
+			// Probably not really enabled but will cause a mess.
+			// Q-Ball Billiards enables both circuits but doesn't set one of them up.
+			if (PCRTCDisplays[display].FBW == 0 && displayReg.DW == 0 && displayReg.DH == 0 && displayReg.MAGH == 0)
+			{
+				PCRTCDisplays[display].enabled = false;
+				return;
+			}
+			PCRTCDisplays[display].magnification = GSVector2i(displayReg.MAGH + 1, displayReg.MAGV + 1);
+			const u32 DW = displayReg.DW + 1;
+			const u32 DH = displayReg.DH + 1;
+
+			const int renderWidth = DW / PCRTCDisplays[display].magnification.x;
+			const int renderHeight = DH / PCRTCDisplays[display].magnification.y;
+
+			u32 finalDisplayWidth = renderWidth;
+			u32 finalDisplayHeight = renderHeight;
+			// When using screen offsets the screen gets squashed/resized in to the actual screen size.
+			if (GSConfig.PCRTCOffsets)
+			{
+				finalDisplayWidth = DW / (VideoModeDividers[videomode].x + 1);
+				finalDisplayHeight = DH / (VideoModeDividers[videomode].y + 1);
+			}
+			else
+			{
+				finalDisplayWidth = std::min(finalDisplayWidth ,DW / (VideoModeDividers[videomode].x + 1));
+				finalDisplayHeight = std::min(finalDisplayHeight, DH / (VideoModeDividers[videomode].y + 1));
+			}
+
+			// Framebuffer size and offsets.
+			PCRTCDisplays[display].prevFramebufferOffsets = PCRTCDisplays[display].framebufferOffsets;
+			PCRTCDisplays[display].framebufferRect.x = 0;
+			PCRTCDisplays[display].framebufferRect.y = 0;
+			PCRTCDisplays[display].framebufferRect.z = renderWidth;
+
+			if(FFMD && interlaced) // Round up the height as if it's an odd value, this will cause havok with the merge circuit.
+				PCRTCDisplays[display].framebufferRect.w = (renderHeight + 1) >> (FFMD * interlaced); // Half height read if FFMD + INT enabled.
+			else
+				PCRTCDisplays[display].framebufferRect.w = renderHeight;
+			PCRTCDisplays[display].framebufferOffsets.x = framebufferReg.DBX;
+			PCRTCDisplays[display].framebufferOffsets.y = framebufferReg.DBY;
+
+			const bool is_interlaced_resolution = interlaced || (toggling_field && GSConfig.InterlaceMode != GSInterlaceMode::Off);
+
+			// If the interlace flag isn't set, but it's still interlacing, the height is likely reported wrong.
+			// Q-Ball Billiards.
+			if (is_interlaced_resolution && !interlaced)
+				finalDisplayHeight *= 2;
+
+			// Display size and offsets.
+			PCRTCDisplays[display].displayRect.x = 0;
+			PCRTCDisplays[display].displayRect.y = 0;
+			PCRTCDisplays[display].displayRect.z = finalDisplayWidth;
+			PCRTCDisplays[display].displayRect.w = finalDisplayHeight;
+			PCRTCDisplays[display].prevDisplayOffset = PCRTCDisplays[display].displayOffset;
+			PCRTCDisplays[display].displayOffset.x = displayReg.DX;
+			PCRTCDisplays[display].displayOffset.y = displayReg.DY;
+		}
+
+		// Calculate framebuffer read offsets, should be considered if only one circuit is enabled, or difference is more than 1 line.
+		// Only considered if "Anti-blur" is enabled.
+		void CalculateFramebufferOffset()
+		{
+			if (GSConfig.PCRTCAntiBlur && PCRTCSameSrc)
+			{
+				if (abs(PCRTCDisplays[1].framebufferOffsets.y - PCRTCDisplays[0].framebufferOffsets.y) == 1
+					&& PCRTCDisplays[0].displayRect.y == PCRTCDisplays[1].displayRect.y)
+				{
+					if (PCRTCDisplays[1].framebufferOffsets.y < PCRTCDisplays[0].framebufferOffsets.y)
+						PCRTCDisplays[0].framebufferOffsets.y = PCRTCDisplays[1].framebufferOffsets.y;
+					else
+						PCRTCDisplays[1].framebufferOffsets.y = PCRTCDisplays[0].framebufferOffsets.y;
+				}
+				if (abs(PCRTCDisplays[1].framebufferOffsets.x - PCRTCDisplays[0].framebufferOffsets.x) == 1
+					&& PCRTCDisplays[0].displayRect.x == PCRTCDisplays[1].displayRect.x)
+				{
+					if (PCRTCDisplays[1].framebufferOffsets.x < PCRTCDisplays[0].framebufferOffsets.x)
+						PCRTCDisplays[0].framebufferOffsets.x = PCRTCDisplays[1].framebufferOffsets.x;
+					else
+						PCRTCDisplays[1].framebufferOffsets.x = PCRTCDisplays[0].framebufferOffsets.x;
+				}
+			}
+			PCRTCDisplays[0].framebufferRect.x += PCRTCDisplays[0].framebufferOffsets.x;
+			PCRTCDisplays[0].framebufferRect.z += PCRTCDisplays[0].framebufferOffsets.x;
+			PCRTCDisplays[0].framebufferRect.y += PCRTCDisplays[0].framebufferOffsets.y;
+			PCRTCDisplays[0].framebufferRect.w += PCRTCDisplays[0].framebufferOffsets.y;
+
+			PCRTCDisplays[1].framebufferRect.x += PCRTCDisplays[1].framebufferOffsets.x;
+			PCRTCDisplays[1].framebufferRect.z += PCRTCDisplays[1].framebufferOffsets.x;
+			PCRTCDisplays[1].framebufferRect.y += PCRTCDisplays[1].framebufferOffsets.y;
+			PCRTCDisplays[1].framebufferRect.w += PCRTCDisplays[1].framebufferOffsets.y;
+		}
+
+		// Used in software mode to align the buffer when reading. Offset is accounted for (block aligned) by GetOutput.
+		void RemoveFramebufferOffset(int display)
+		{
+			if (display >= 0)
+			{
+				// Hardware needs nothing but handling for wrapped framebuffers.
+				if (GSConfig.UseHardwareRenderer())
+				{
+					if (PCRTCDisplays[display].framebufferRect.z >= 2048)
+					{
+						PCRTCDisplays[display].framebufferRect.x = 0;
+						PCRTCDisplays[display].framebufferRect.z -= 2048;
+					}
+					if (PCRTCDisplays[display].framebufferRect.w >= 2048)
+					{
+						PCRTCDisplays[display].framebufferRect.y = 0;
+						PCRTCDisplays[display].framebufferRect.w -= 2048;
+					}
+				}
+				else
+				{
+					const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[PCRTCDisplays[display].PSM];
+
+					// Software mode - See note below.
+					GSVector4i r = PCRTCDisplays[display].framebufferRect;
+					r = r.ralign<Align_Outside>(psm.bs);
+
+					PCRTCDisplays[display].framebufferRect.z -= r.x;
+					PCRTCDisplays[display].framebufferRect.w -= r.y;
+					PCRTCDisplays[display].framebufferRect.x -= r.x;
+					PCRTCDisplays[display].framebufferRect.y -= r.y;
+				}
+			}
+			else
+			{
+				// Software Mode Note:
+				// This code is to read the framebuffer nicely block aligned in software, then leave the remaining offset in to the block.
+				// In hardware mode this doesn't happen, it reads the whole framebuffer, so we need to keep the offset.
+				if (!GSConfig.UseHardwareRenderer())
+				{
+					const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[PCRTCDisplays[1].PSM];
+
+					GSVector4i r = PCRTCDisplays[0].framebufferRect.runion(PCRTCDisplays[1].framebufferRect);
+					r = r.ralign<Align_Outside>(psm.bs);
+
+					PCRTCDisplays[0].framebufferRect.x -= r.x;
+					PCRTCDisplays[0].framebufferRect.y -= r.y;
+					PCRTCDisplays[0].framebufferRect.z -= r.x;
+					PCRTCDisplays[0].framebufferRect.w -= r.y;
+					PCRTCDisplays[1].framebufferRect.x -= r.x;
+					PCRTCDisplays[1].framebufferRect.y -= r.y;
+					PCRTCDisplays[1].framebufferRect.z -= r.x;
+					PCRTCDisplays[1].framebufferRect.w -= r.y;
+				}
+			}
+		}
+
+		// If the two displays are offset from each other, move them to the correct offsets.
+		// If using screen offsets, calculate the positions here.
+		void CalculateDisplayOffset(bool scanmask)
+		{
+			const bool both_enabled = PCRTCDisplays[0].enabled && PCRTCDisplays[1].enabled;
+			// Offsets are generally ignored, the "hacky" way of doing the displays, but direct to framebuffers.
+			if (!GSConfig.PCRTCOffsets)
+			{
+				const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
+				int int_off[2] = { 0, 0 };
+				GSVector2i zeroDisplay = NearestToZeroOffset();
+				GSVector2i baseOffset = PCRTCDisplays[zeroDisplay.y].displayOffset;
+
+				if (both_enabled)
+				{
+					int blurOffset = abs(PCRTCDisplays[1].displayOffset.y - PCRTCDisplays[0].displayOffset.y);
+					if (GSConfig.PCRTCAntiBlur && !scanmask && blurOffset < 4)
+					{
+						if (PCRTCDisplays[1].displayOffset.y > PCRTCDisplays[0].displayOffset.y)
+							PCRTCDisplays[1].displayOffset.y -= blurOffset;
+						else
+							PCRTCDisplays[0].displayOffset.y -= blurOffset;
+					}
+				}
+
+				// If there's a single pixel offset, account for it else it can throw interlacing out.
+				for (int i = 0; i < 2; i++)
+				{
+					if (!PCRTCDisplays[i].enabled)
+						continue;
+
+					// Should this be MAGV/H in the DISPLAY register rather than the "default" magnification?
+					const int offset = (PCRTCDisplays[i].displayOffset.y - (offsets.w * (interlaced + 1))) / (VideoModeDividers[videomode].y + 1);
+
+					if (offset > 4)
+						continue;
+
+					int_off[i] = offset & 1;
+					if (offset < 0)
+						int_off[i] = -int_off[i];
+
+					PCRTCDisplays[i].displayRect.y += int_off[i];
+					PCRTCDisplays[i].displayRect.w += int_off[i];
+				}
+
+				// Handle difference in offset between the two displays, used in games like DmC and Time Crisis 2 (for split screen).
+				// Offset is not screen based, but relative to each other.
+				if (both_enabled)
+				{
+					GSVector2i offset;
+
+					offset.x = (PCRTCDisplays[1 - zeroDisplay.x].displayOffset.x - PCRTCDisplays[zeroDisplay.x].displayOffset.x) / (VideoModeDividers[videomode].x + 1);
+					offset.y = (PCRTCDisplays[1 - zeroDisplay.y].displayOffset.y - PCRTCDisplays[zeroDisplay.y].displayOffset.y) / (VideoModeDividers[videomode].y + 1);
+
+					if (offset.x >= 4 || !GSConfig.PCRTCAntiBlur)
+					{
+						PCRTCDisplays[1 - zeroDisplay.x].displayRect.x += offset.x;
+						PCRTCDisplays[1 - zeroDisplay.x].displayRect.z += offset.x;
+					}
+					if (offset.y >= 4 || !GSConfig.PCRTCAntiBlur)
+					{
+						PCRTCDisplays[1 - zeroDisplay.y].displayRect.y += offset.y - int_off[1 - zeroDisplay.y];
+						PCRTCDisplays[1 - zeroDisplay.y].displayRect.w += offset.y - int_off[1 - zeroDisplay.y];
+					}
+
+					baseOffset = PCRTCDisplays[zeroDisplay.y].displayOffset;
+				}
+
+				// Handle any large vertical offset from the zero position on the screen.
+				// Example: Hokuto no Ken, does a rougly -14 offset to bring the screen up.
+				// Ignore the lowest bit, we've already accounted for this
+				int vOffset = ((static_cast<int>(baseOffset.y) - (offsets.w * (interlaced + 1))) / (VideoModeDividers[videomode].y + 1));
+
+				if(vOffset <= 4 && vOffset != 0)
+				{
+					PCRTCDisplays[0].displayRect.y += vOffset - int_off[0];
+					PCRTCDisplays[0].displayRect.w += vOffset - int_off[0];
+					PCRTCDisplays[1].displayRect.y += vOffset - int_off[1];
+					PCRTCDisplays[1].displayRect.w += vOffset - int_off[1];
+				}
+			}
+			else // We're using screen offsets, so just calculate the entire offset.
+			{
+				const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
+				GSVector2i offset = { 0, 0 };
+				GSVector2i zeroDisplay = NearestToZeroOffset();
+
+				if (both_enabled)
+				{
+					int blurOffset = abs(PCRTCDisplays[1].displayOffset.y - PCRTCDisplays[0].displayOffset.y);
+					if (GSConfig.PCRTCAntiBlur && !scanmask && blurOffset < 4)
+					{
+						if (PCRTCDisplays[1].displayOffset.y > PCRTCDisplays[0].displayOffset.y)
+							PCRTCDisplays[1].displayOffset.y -= blurOffset;
+						else
+							PCRTCDisplays[0].displayOffset.y -= blurOffset;
+					}
+				}
+
+				for (int i = 0; i < 2; i++)
+				{
+					// Should this be MAGV/H in the DISPLAY register rather than the "default" magnification?
+					offset.x = (static_cast<int>(PCRTCDisplays[i].displayOffset.x) - offsets.z) / (VideoModeDividers[videomode].x + 1);
+					offset.y = (static_cast<int>(PCRTCDisplays[i].displayOffset.y) - (offsets.w * (interlaced + 1))) / (VideoModeDividers[videomode].y + 1);
+
+					PCRTCDisplays[i].displayRect.x += offset.x;
+					PCRTCDisplays[i].displayRect.z += offset.x;
+					PCRTCDisplays[i].displayRect.y += offset.y;
+					PCRTCDisplays[i].displayRect.w += offset.y;
+				}
+
+				if (both_enabled)
+				{
+					GSVector2i offset;
+
+					offset.x = (PCRTCDisplays[1 - zeroDisplay.x].displayRect.x - PCRTCDisplays[zeroDisplay.x].displayRect.x);
+					offset.y = (PCRTCDisplays[1 - zeroDisplay.y].displayRect.y - PCRTCDisplays[zeroDisplay.y].displayRect.y);
+
+					if (offset.x > 0 && offset.x < 4 && GSConfig.PCRTCAntiBlur)
+					{
+						PCRTCDisplays[1 - zeroDisplay.x].displayRect.x -= offset.x;
+						PCRTCDisplays[1 - zeroDisplay.x].displayRect.z -= offset.x;
+					}
+					if (offset.y > 0 && offset.y < 4 && GSConfig.PCRTCAntiBlur)
+					{
+						PCRTCDisplays[1 - zeroDisplay.y].displayRect.y -= offset.y;
+						PCRTCDisplays[1 - zeroDisplay.y].displayRect.w -= offset.y;
+					}
+				}
+			}
+		}
+	} PCRTCDisplays;

 public:
 	/// Returns the appropriate directory for draw dumping.
 	static std::string GetDrawDumpPath(const char* format, ...);

 	void ResetHandlers();
+	void ResetPCRTC();

-	int GetFramebufferHeight();
-	int GetFramebufferWidth();
-	int GetFramebufferBitDepth();
-	int GetDisplayHMagnification();
-	GSVector4i GetDisplayRect(int i = -1);
-	GSVector4i GetFrameMagnifiedRect(int i = -1);
-	GSVector2i GetResolutionOffset(int i = -1);
-	GSVector2i GetResolution();
-	GSVector4i GetFrameRect(int i = -1, bool ignore_off = false);
 	GSVideoMode GetVideoMode();

-	bool IsEnabled(int i);
 	bool isinterlaced();
 	bool isReallyInterlaced();
-	bool IsAnalogue();

 	float GetTvRefreshRate();

@@ -355,7 +886,9 @@ public:
 	bool TestDrawChanged();
 	void FlushWrite();
 	virtual void Draw() = 0;
-	virtual void PurgePool() = 0;
+	virtual void PurgePool();
+	virtual void PurgeTextureCache();
+	virtual void ReadbackTextureCache();
 	virtual void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r, bool eewrite = false) {}
 	virtual void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r, bool clut = false) {}
 	virtual void ExpandTarget(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r) {}
--- a/pcsx2/GS/GSUtil.cpp
+++ b/pcsx2/GS/GSUtil.cpp
@@ -156,14 +156,19 @@ GSRendererType GSUtil::GetPreferredRenderer()
 	// Mac: Prefer Metal hardware.
 	return GSRendererType::Metal;
 #elif defined(_WIN32)
-	if (D3D::ShouldPreferRenderer() == D3D::Renderer::Vulkan)
+	const u8 preferred = D3D::ShouldPreferRenderer();
+#if defined(ENABLE_VULKAN)
+	if (preferred == D3D::Renderer::Vulkan)
 		return GSRendererType::VK;
+#endif
 #if defined(ENABLE_OPENGL)
-	else if (D3D::ShouldPreferRenderer() == D3D::Renderer::OpenGL)
+	if (preferred == D3D::Renderer::OpenGL)
 		return GSRendererType::OGL;
 #endif
-	else
-		return GSRendererType::DX11;
+	if (preferred == D3D::Renderer::Direct3D12)
+		return GSRendererType::DX12;
+
+	return GSRendererType::DX11;
 #else
 	// Linux: Prefer GL/Vulkan, whatever is available.
 #if defined(ENABLE_OPENGL)
--- a/pcsx2/GS/Renderers/Common/GSDevice.cpp
+++ b/pcsx2/GS/Renderers/Common/GSDevice.cpp
@@ -299,7 +299,7 @@ void GSDevice::Merge(GSTexture* sTex[3], GSVector4* sRect, GSVector4* dRect, con
 			}
 		}

-		DoMerge(tex, sRect, m_merge, dRect, PMODE, EXTBUF, c);
+		DoMerge(tex, sRect, m_merge, dRect, PMODE, EXTBUF, c, GSConfig.PCRTCOffsets);

 		for (size_t i = 0; i < std::size(tex); i++)
 		{
@@ -356,6 +356,7 @@ void GSDevice::Interlace(const GSVector2i& ds, int field, int mode, float yoffse
 			break;
 		default:
 			m_current = m_merge;
+			break;
 	}
 }

--- a/pcsx2/GS/Renderers/Common/GSDevice.h
+++ b/pcsx2/GS/Renderers/Common/GSDevice.h
@@ -314,6 +314,7 @@ struct alignas(16) GSHWDrawConfig
 				u32 ltf : 1;
 				// Shuffle and fbmask effect
 				u32 shuffle  : 1;
+				u32 real16src: 1;
 				u32 read_ba  : 1;
 				u32 write_rg : 1;
 				u32 fbmask   : 1;
@@ -758,7 +759,7 @@ protected:
 	virtual GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) = 0;
 	GSTexture* FetchSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format, bool clear, bool prefer_reuse);

-	virtual void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c) = 0;
+	virtual void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) = 0;
 	virtual void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset, int bufIdx) = 0;
 	virtual void DoFXAA(GSTexture* sTex, GSTexture* dTex) {}
 	virtual void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) {}
--- a/pcsx2/GS/Renderers/Common/GSDirtyRect.cpp
+++ b/pcsx2/GS/Renderers/Common/GSDirtyRect.cpp
@@ -31,7 +31,7 @@ GSDirtyRect::GSDirtyRect(GSVector4i& r, u32 psm, u32 bw) :
 {
 }

-GSVector4i GSDirtyRect::GetDirtyRect(GIFRegTEX0& TEX0)
+GSVector4i GSDirtyRect::GetDirtyRect(GIFRegTEX0 TEX0) const
 {
 	GSVector4i _r;

@@ -54,7 +54,7 @@ GSVector4i GSDirtyRect::GetDirtyRect(GIFRegTEX0& TEX0)
 	return _r;
 }

-GSVector4i GSDirtyRectList::GetTotalRect(GIFRegTEX0& TEX0, const GSVector2i& size)
+GSVector4i GSDirtyRectList::GetTotalRect(GIFRegTEX0 TEX0, const GSVector2i& size) const
 {
 	if (!empty())
 	{
@@ -73,31 +73,12 @@ GSVector4i GSDirtyRectList::GetTotalRect(GIFRegTEX0& TEX0, const GSVector2i& siz
 	return GSVector4i::zero();
 }

-GSVector4i GSDirtyRectList::GetDirtyRect(GIFRegTEX0& TEX0, const GSVector2i& size, bool clear)
+GSVector4i GSDirtyRectList::GetDirtyRect(size_t index, GIFRegTEX0 TEX0, const GSVector4i& clamp) const
 {
-	if (!empty())
-	{
-		const std::vector<GSDirtyRect>::iterator &it = begin();
-		const GSVector4i r = it[0].GetDirtyRect(TEX0);
+	const GSVector4i r = (*this)[index].GetDirtyRect(TEX0);

-		if (clear)
-			erase(it);
+	GSVector2i bs = GSLocalMemory::m_psm[TEX0.PSM].bs;

-		GSVector2i bs = GSLocalMemory::m_psm[TEX0.PSM].bs;
-
-		return r.ralign<Align_Outside>(bs).rintersect(GSVector4i(0, 0, size.x, size.y));
-	}
-
-	return GSVector4i::zero();
+	return r.ralign<Align_Outside>(bs).rintersect(clamp);
 }

-GSVector4i GSDirtyRectList::GetDirtyRectAndClear(GIFRegTEX0& TEX0, const GSVector2i& size)
-{
-	const GSVector4i r = GetDirtyRect(TEX0, size, true);
-	return r;
-}
-
-void GSDirtyRectList::ClearDirty()
-{
-	clear();
-}
--- a/pcsx2/GS/Renderers/Common/GSDirtyRect.h
+++ b/pcsx2/GS/Renderers/Common/GSDirtyRect.h
@@ -26,15 +26,13 @@ public:

 	GSDirtyRect();
 	GSDirtyRect(GSVector4i& r, u32 psm, u32 bw);
-	GSVector4i GetDirtyRect(GIFRegTEX0& TEX0);
+	GSVector4i GetDirtyRect(GIFRegTEX0 TEX0) const;
 };

 class GSDirtyRectList : public std::vector<GSDirtyRect>
 {
 public:
 	GSDirtyRectList() {}
-	GSVector4i GetTotalRect(GIFRegTEX0& TEX0, const GSVector2i& size);
-	GSVector4i GetDirtyRect(GIFRegTEX0& TEX0, const GSVector2i& size, bool clear = false);
-	GSVector4i GetDirtyRectAndClear(GIFRegTEX0& TEX0, const GSVector2i& size);
-	void ClearDirty();
+	GSVector4i GetTotalRect(GIFRegTEX0 TEX0, const GSVector2i& size) const;
+	GSVector4i GetDirtyRect(size_t index, GIFRegTEX0 TEX0, const GSVector4i& clamp) const;
 };
--- a/pcsx2/GS/Renderers/Common/GSRenderer.cpp
+++ b/pcsx2/GS/Renderers/Common/GSRenderer.cpp
@@ -50,6 +50,8 @@ std::unique_ptr<GSRenderer> g_gs_renderer;
 // we might be switching while the other thread reads it.
 static GSVector4 s_last_draw_rect;

+// Last time we reset the renderer due to a GPU crash, if any.
+static Common::Timer::Value s_last_gpu_reset_time;

 GSRenderer::GSRenderer()
 	: m_shader_time_start(Common::Timer::GetCurrentValue())
@@ -75,264 +77,109 @@ void GSRenderer::Destroy()

 bool GSRenderer::Merge(int field)
 {
-	bool en[2];
-
-	GSVector4i fr[2];
-	GSVector4i dr[2];
-	GSVector2i display_offsets[2];
-
-	GSVector2i display_baseline = {INT_MAX, INT_MAX};
-	GSVector2i frame_baseline = {INT_MAX, INT_MAX};
-	GSVector2i display_combined = {0, 0};
-	bool feedback_merge = m_regs->EXTWRITE.WRITE == 1;
-	bool display_offset = false;
-
-	for (int i = 0; i < 2; i++)
-	{
-		en[i] = IsEnabled(i) || (m_regs->EXTBUF.FBIN == i && feedback_merge);
-
-		if (en[i])
-		{
-			fr[i] = GetFrameRect(i);
-			dr[i] = GetDisplayRect(i);
-			display_offsets[i] = GetResolutionOffset(i);
-
-			display_combined.x = std::max(((dr[i].right) - dr[i].left) + display_offsets[i].x, display_combined.x);
-			display_combined.y = std::max((dr[i].bottom - dr[i].top) + display_offsets[i].y, display_combined.y);
-
-			display_baseline.x = std::min(display_offsets[i].x, display_baseline.x);
-			display_baseline.y = std::min(display_offsets[i].y, display_baseline.y);
-			frame_baseline.x = std::min(std::max(fr[i].left, 0), frame_baseline.x);
-			frame_baseline.y = std::min(std::max(fr[i].top, 0), frame_baseline.y);
-
-			display_offset |= std::abs(display_baseline.y - display_offsets[i].y) == 1;
-			/*DevCon.Warning("Read offset was X %d(left %d) Y %d(top %d)", display_baseline.x, dr[i].left, display_baseline.y, dr[i].top);
-			DevCon.Warning("[%d]: %d %d %d %d, %d %d %d %d\n", i, fr[i].x,fr[i].y,fr[i].z,fr[i].w , dr[i].x,dr[i].y,dr[i].z,dr[i].w);
-			DevCon.Warning("Offset X %d Offset Y %d", display_offsets[i].x, display_offsets[i].y);*/
-		}
-	}
-
-	if (!en[0] && !en[1])
-	{
-		return false;
-	}
-
-	GL_PUSH("Renderer Merge %d (0: enabled %d 0x%x, 1: enabled %d 0x%x)", s_n, en[0], m_regs->DISP[0].DISPFB.Block(), en[1], m_regs->DISP[1].DISPFB.Block());
-
-	// try to avoid fullscreen blur, could be nice on tv but on a monitor it's like double vision, hurts my eyes (persona 4, guitar hero)
-	//
-	// NOTE: probably the technique explained in graphtip.pdf (Antialiasing by Supersampling / 4. Reading Odd/Even Scan Lines Separately with the PCRTC then Blending)
-
-	const bool samesrc =
-		en[0] && en[1] &&
-		m_regs->DISP[0].DISPFB.FBP == m_regs->DISP[1].DISPFB.FBP &&
-		m_regs->DISP[0].DISPFB.FBW == m_regs->DISP[1].DISPFB.FBW &&
-		GSUtil::HasCompatibleBits(m_regs->DISP[0].DISPFB.PSM, m_regs->DISP[1].DISPFB.PSM);
-	bool single_fetch = false;
-
 	GSVector2i fs(0, 0);
-	GSVector2i ds(0, 0);
+	GSTexture* tex[3] = { NULL, NULL, NULL };
+	int y_offset[3] = { 0, 0, 0 };
+	const bool feedback_merge = m_regs->EXTWRITE.WRITE == 1;

-	GSTexture* tex[3] = {NULL, NULL, NULL};
-	int y_offset[3] = {0, 0, 0};
+	PCRTCDisplays.SetVideoMode(GetVideoMode());
+	PCRTCDisplays.EnableDisplays(m_regs->PMODE, m_regs->SMODE2, isReallyInterlaced());
+	PCRTCDisplays.CheckSameSource();

-	s_n++;
+	if (!PCRTCDisplays.PCRTCDisplays[0].enabled && !PCRTCDisplays.PCRTCDisplays[1].enabled)
+		return false;
+
+	// Need to do this here, if the user has Anti-Blur enabled, these offsets can get wiped out/changed.
+	const bool game_deinterlacing = (m_regs->DISP[0].DISPFB.DBY != PCRTCDisplays.PCRTCDisplays[0].prevFramebufferReg.DBY) !=
+									(m_regs->DISP[1].DISPFB.DBY != PCRTCDisplays.PCRTCDisplays[1].prevFramebufferReg.DBY);
+
+	PCRTCDisplays.SetRects(0, m_regs->DISP[0].DISPLAY, m_regs->DISP[0].DISPFB);
+	PCRTCDisplays.SetRects(1, m_regs->DISP[1].DISPLAY, m_regs->DISP[1].DISPFB);
+	PCRTCDisplays.CalculateDisplayOffset(m_scanmask_used);
+	PCRTCDisplays.CalculateFramebufferOffset();

 	// Only need to check the right/bottom on software renderer, hardware always gets the full texture then cuts a bit out later.
-	if (samesrc && !feedback_merge && (GSConfig.UseHardwareRenderer() || (fr[0].right == fr[1].right && fr[0].bottom == fr[1].bottom)))
+	if (PCRTCDisplays.FrameRectMatch() && !PCRTCDisplays.FrameWrap() && !feedback_merge)
 	{
-		tex[0] = GetOutput(0, y_offset[0]);
+		tex[0] = GetOutput(-1, y_offset[0]);
 		tex[1] = tex[0]; // saves one texture fetch
 		y_offset[1] = y_offset[0];
-		single_fetch = true;
 	}
 	else
 	{
-		if (en[0])
+		if (PCRTCDisplays.PCRTCDisplays[0].enabled)
 			tex[0] = GetOutput(0, y_offset[0]);
-		if (en[1])
+		if (PCRTCDisplays.PCRTCDisplays[1].enabled)
 			tex[1] = GetOutput(1, y_offset[1]);
 		if (feedback_merge)
 			tex[2] = GetFeedbackOutput();
 	}

+	if (!tex[0] && !tex[1])
+		return false;
+
+	s_n++;
+
 	GSVector4 src_out_rect[2];
 	GSVector4 src_gs_read[2];
 	GSVector4 dst[3];

-	const bool slbg = m_regs->PMODE.SLBG;
-
-	GSVector2i resolution(GetResolution());
-	bool scanmask_frame = m_scanmask_used && !display_offset;
-	const bool ignore_offset = !GSConfig.PCRTCOffsets;
-	const bool is_bob = GSConfig.InterlaceMode == GSInterlaceMode::BobTFF || GSConfig.InterlaceMode == GSInterlaceMode::BobBFF;
-
 	// Use offset for bob deinterlacing always, extra offset added later for FFMD mode.
-	float offset = is_bob ? (tex[1] ? tex[1]->GetScale().y : tex[0]->GetScale().y) : 0.0f;
-
+	const bool scanmask_frame = m_scanmask_used && abs(PCRTCDisplays.PCRTCDisplays[0].displayRect.y - PCRTCDisplays.PCRTCDisplays[1].displayRect.y) != 1;
 	int field2 = 0;
-	int mode = 3;
+	int mode = 3; // If the game is manually deinterlacing then we need to bob (if we want to get away with no deinterlacing).
+	bool is_bob = GSConfig.InterlaceMode == GSInterlaceMode::BobTFF || GSConfig.InterlaceMode == GSInterlaceMode::BobBFF;

-	// FFMD (half frames) requires blend deinterlacing, so automatically use that. Same when SCANMSK is used but not blended in the merge circuit (Alpine Racer 3)
+	// FFMD (half frames) requires blend deinterlacing, so automatically use that. Same when SCANMSK is used but not blended in the merge circuit (Alpine Racer 3).
 	if (GSConfig.InterlaceMode != GSInterlaceMode::Automatic || (!m_regs->SMODE2.FFMD && !scanmask_frame))
 	{
-		field2 = ((static_cast<int>(GSConfig.InterlaceMode) - 2) & 1);
-		mode = ((static_cast<int>(GSConfig.InterlaceMode) - 2) >> 1);
+		// If the game is offsetting each frame itself and we're using full height buffers, we can offset this with Bob.
+		if (game_deinterlacing && !scanmask_frame && GSConfig.InterlaceMode == GSInterlaceMode::Automatic)
+		{
+			mode = 1; // Bob.
+			is_bob = true;
+		}
+		else
+		{
+			field2 = ((static_cast<int>(GSConfig.InterlaceMode) - 2) & 1);
+			mode = ((static_cast<int>(GSConfig.InterlaceMode) - 2) >> 1);
+		}
 	}

 	for (int i = 0; i < 2; i++)
 	{
-		if (!en[i] || !tex[i])
+		 const GSPCRTCRegs::PCRTCDisplay& curCircuit = PCRTCDisplays.PCRTCDisplays[i];
+
+		if (!curCircuit.enabled || !tex[i])
 			continue;

-		GSVector4i r = GetFrameMagnifiedRect(i);
 		GSVector4 scale = GSVector4(tex[i]->GetScale()).xyxy();

-
-		GSVector2i off(ignore_offset ? 0 : display_offsets[i]);
-		GSVector2i display_diff(display_offsets[i].x - display_baseline.x, display_offsets[i].y - display_baseline.y);
-		GSVector2i frame_diff(fr[i].left - frame_baseline.x, fr[i].top - frame_baseline.y);
-
-		if (!GSConfig.UseHardwareRenderer())
-		{
-			// Clear any frame offsets, offset is already done in the software GetOutput.
-			fr[i].right -= fr[i].left;
-			fr[i].left = 0;
-			fr[i].bottom -= fr[i].top;
-			fr[i].top = 0;
-
-			// Put any frame offset difference back if we aren't anti-blurring on a single fetch (not offset).
-			if (!GSConfig.PCRTCAntiBlur && single_fetch)
-			{
-				fr[i].right += frame_diff.x;
-				fr[i].left += frame_diff.x;
-				fr[i].bottom += frame_diff.y;
-				fr[i].top += frame_diff.y;
-			}
-			
-		}
-
-		// If using scanmsk we have to keep the single line offset, regardless of upscale
-		// so we handle this separately after the rect calculations.
-		float interlace_offset = 0.0f;
-
-		if ((!GSConfig.PCRTCAntiBlur || m_scanmask_used) && display_offset)
-		{
-			interlace_offset = static_cast<float>(display_diff.y & 1);
-
-			// When the displays are offset by 1 we need to adjust for upscale to handle it (reduces bounce in MGS2 when upscaling)
-			interlace_offset += (tex[i]->GetScale().y - 1.0f)  / 2;
-
-			if (interlace_offset >= 1.0f)
-			{
-				if (!ignore_offset)
-					off.y -= 1;
-
-				display_diff.y -= 1;
-			}
-		}
-
-		// Start of Anti-Blur code.
-		if (!ignore_offset)
-		{
-			if (GSConfig.PCRTCAntiBlur)
-			{
-				if (samesrc)
-				{
-					// Offset by DISPLAY setting
-					if (display_diff.x < 4)
-						off.x -= display_diff.x;
-					if (display_diff.y < 4)
-						off.y -= display_diff.y;
-
-					// Only functional in HW mode, software clips/positions the framebuffer on read.
-					if (GSConfig.UseHardwareRenderer())
-					{
-						// Offset by DISPFB setting
-						if (abs(frame_diff.x) < 4)
-							off.x += frame_diff.x;
-						if (abs(frame_diff.y) < 4)
-							off.y += frame_diff.y;
-					}
-				}
-			}
-		}
-		else
-		{
-			if (!slbg || !feedback_merge)
-			{
-				// If the offsets between the two displays are quite large, it's probably intended for an effect.
-				if (display_diff.x >= 4 || !GSConfig.PCRTCAntiBlur)
-					off.x = display_diff.x;
-
-				if (display_diff.y >= 4 || !GSConfig.PCRTCAntiBlur)
-					off.y = display_diff.y;
-
-				// Need to check if only circuit 2 is enabled. Stuntman toggles circuit 1 on and off every other frame.
-				if (samesrc || m_regs->PMODE.EN == 2)
-				{
-					// Adjusting the screen offset when using a negative offset.
-					const int videomode = static_cast<int>(GetVideoMode()) - 1;
-					const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
-					GSVector2i base_resolution(offsets.x, offsets.y);
-
-					if (isinterlaced() && !m_regs->SMODE2.FFMD)
-						base_resolution.y *= 2;
-
-					// Offset by DISPLAY setting
-					if (display_diff.x < 0)
-					{
-						off.x = 0;
-						if (base_resolution.x > resolution.x)
-							resolution.x -= display_diff.x;
-					}
-					if (display_diff.y < 0)
-					{
-						off.y = 0;
-						if (base_resolution.y > resolution.y)
-							resolution.y -= display_diff.y;
-					}
-
-					// Don't do X, we only care about height, this would need to be tailored for games using X (Black does -5).
-					// Mainly for Hokuto no Ken which does -14 Y offset.
-					if (display_baseline.y < -4)
-						off.y += display_baseline.y;
-
-					// Anti-Blur stuff
-					// Only functional in HW mode, software clips/positions the framebuffer on read.
-					if (GSConfig.PCRTCAntiBlur && GSConfig.UseHardwareRenderer())
-					{
-						// Offset by DISPFB setting
-						if (abs(frame_diff.x) < 4)
-							off.x += frame_diff.x;
-						if (abs(frame_diff.y) < 4)
-							off.y += frame_diff.y;
-					}
-				}
-			}
-		}
-		// End of Anti-Blur code.
-
-		if (isinterlaced() && m_regs->SMODE2.FFMD)
-			off.y >>= 1;
-
 		// dst is the final destination rect with offset on the screen.
-		dst[i] = scale * (GSVector4(off).xyxy() + GSVector4(r.rsize()));
+		dst[i] = scale * GSVector4(curCircuit.displayRect);

 		// src_gs_read is the size which we're really reading from GS memory.
-		src_gs_read[i] = ((GSVector4(fr[i]) + GSVector4(0, y_offset[i], 0, y_offset[i])) * scale) / GSVector4(tex[i]->GetSize()).xyxy();
-
-		// src_out_rect is the resized rect for output. (Not really used)
-		src_out_rect[i] = (GSVector4(r) * scale) / GSVector4(tex[i]->GetSize()).xyxy();
-
-		if (m_regs->SMODE2.FFMD && !is_bob && !GSConfig.DisableInterlaceOffset && GSConfig.InterlaceMode != GSInterlaceMode::Off)
+		src_gs_read[i] = ((GSVector4(curCircuit.framebufferRect) + GSVector4(0, y_offset[i], 0, y_offset[i])) * scale) / GSVector4(tex[i]->GetSize()).xyxy();
+		
+		float interlace_offset = 0.0f;
+		if (isReallyInterlaced() && m_regs->SMODE2.FFMD && !is_bob && !GSConfig.DisableInterlaceOffset && GSConfig.InterlaceMode != GSInterlaceMode::Off)
 		{
-			// We do half because FFMD is a half sized framebuffer, then we offset by 1 in the shader for the actual interlace
-			if(GetUpscaleMultiplier() > 1.0f)
-				interlace_offset += ((((tex[1] ? tex[1]->GetScale().y : tex[0]->GetScale().y) + 0.5f) * 0.5f) - 1.0f) * static_cast<float>(field ^ field2);
-			offset = 1.0f;
+			interlace_offset = (scale.y) * static_cast<float>(field ^ field2);
 		}
-		// Restore manually offset "interlace" lines
+		// Scanmask frame offsets. It's gross, I'm sorry but it sucks.
+		if (m_scanmask_used)
+		{
+			int displayIntOffset = PCRTCDisplays.PCRTCDisplays[i].displayRect.y - PCRTCDisplays.PCRTCDisplays[1 - i].displayRect.y;
+			
+			if (displayIntOffset > 0)
+			{
+				displayIntOffset &= 1;
+				dst[i].y -= displayIntOffset * scale.y;
+				dst[i].w -= displayIntOffset * scale.y;
+				interlace_offset += displayIntOffset;
+			}
+		}
+
 		dst[i] += GSVector4(0.0f, interlace_offset, 0.0f, interlace_offset);
 	}

@@ -349,41 +196,18 @@ bool GSRenderer::Merge(int field)
 		dst[2] = GSVector4(scale * GSVector4(feedback_rect.rsize()));
 	}

-	// Set the resolution to the height of the displays (kind of a saturate height)
-	if (ignore_offset && !feedback_merge)
-	{
-		GSVector2i max_resolution = GetResolution();
-		resolution.x = display_combined.x - display_baseline.x;
-		resolution.y = display_combined.y - display_baseline.y;
-
-		if (isinterlaced() && m_regs->SMODE2.FFMD)
-		{
-			resolution.y >>= 1;
-		}
-
-		resolution.x = std::min(max_resolution.x, resolution.x);
-		resolution.y = std::min(max_resolution.y, resolution.y);
-	}
-
+	GSVector2i resolution = PCRTCDisplays.GetResolution();
 	fs = GSVector2i(static_cast<int>(static_cast<float>(resolution.x) * GetUpscaleMultiplier()),
 		static_cast<int>(static_cast<float>(resolution.y) * GetUpscaleMultiplier()));
-	ds = fs;

-	// When interlace(FRAME) mode, the rect is half height, so it needs to be stretched.
-	const bool is_interlaced_resolution = m_regs->SMODE2.INT || (isReallyInterlaced() && IsAnalogue() && GSConfig.InterlaceMode != GSInterlaceMode::Off);
+	m_real_size = GSVector2i(fs.x, fs.y);

-	if (is_interlaced_resolution && m_regs->SMODE2.FFMD)
-		ds.y *= 2;
-
-	m_real_size = GSVector2i(fs.x, is_interlaced_resolution ? ds.y : fs.y);
-
-	if (!tex[0] && !tex[1])
-		return false;
-
-	if ((tex[0] == tex[1]) && (src_out_rect[0] == src_out_rect[1]).alltrue() && (dst[0] == dst[1]).alltrue() && !feedback_merge && !slbg)
+	if ((tex[0] == tex[1]) && (src_out_rect[0] == src_out_rect[1]).alltrue() && 
+		(PCRTCDisplays.PCRTCDisplays[0].displayRect == PCRTCDisplays.PCRTCDisplays[1].displayRect).alltrue() &&
+		(PCRTCDisplays.PCRTCDisplays[0].framebufferRect == PCRTCDisplays.PCRTCDisplays[1].framebufferRect).alltrue() &&
+		!feedback_merge && !m_regs->PMODE.SLBG)
 	{
 		// the two outputs are identical, skip drawing one of them (the one that is alpha blended)
-
 		tex[0] = NULL;
 	}

@@ -392,7 +216,11 @@ bool GSRenderer::Merge(int field)
 	g_gs_device->Merge(tex, src_gs_read, dst, fs, m_regs->PMODE, m_regs->EXTBUF, c);

 	if (isReallyInterlaced() && GSConfig.InterlaceMode != GSInterlaceMode::Off)
-		g_gs_device->Interlace(ds, field ^ field2, mode, offset);
+	{
+		const float offset = is_bob ? (tex[1] ? tex[1]->GetScale().y : tex[0]->GetScale().y) : 0.0f;
+
+		g_gs_device->Interlace(fs, field ^ field2, mode, offset);
+	}

 	if (GSConfig.ShadeBoost)
 		g_gs_device->ShadeBoost();
@@ -602,6 +430,40 @@ void GSJoinSnapshotThreads()
 	}
 }

+bool GSRenderer::BeginPresentFrame(bool frame_skip)
+{
+	const HostDisplay::PresentResult result = Host::BeginPresentFrame(frame_skip);
+	if (result == HostDisplay::PresentResult::OK)
+		return true;
+	else if (result == HostDisplay::PresentResult::FrameSkipped)
+		return false;
+
+	// If we're constantly crashing on something in particular, we don't want to end up in an
+	// endless reset loop.. that'd probably end up leaking memory and/or crashing us for other
+	// reasons. So just abort in such case.
+	const Common::Timer::Value current_time = Common::Timer::GetCurrentValue();
+	if (s_last_gpu_reset_time != 0 &&
+		Common::Timer::ConvertValueToSeconds(current_time - s_last_gpu_reset_time) < 15.0f)
+	{
+		pxFailRel("Host GPU lost too many times, device is probably completely wedged.");
+	}
+	s_last_gpu_reset_time = current_time;
+
+	// Device lost, something went really bad.
+	// Let's just toss out everything, and try to hobble on.
+	if (!GSreopen(true, false, GSConfig))
+	{
+		pxFailRel("Failed to recreate GS device after loss.");
+		return false;
+	}
+
+	// First frame after reopening is definitely going to be trash, so skip it.
+	Host::AddIconOSDMessage("GSDeviceLost", ICON_FA_EXCLAMATION_TRIANGLE,
+		"Host GPU device encountered an error and was recovered. This may have broken rendering.",
+		Host::OSD_CRITICAL_ERROR_DURATION);
+	return false;
+}
+
 void GSRenderer::VSync(u32 field, bool registers_written)
 {
 	Flush(GSFlushReason::VSYNC);
@@ -647,7 +509,7 @@ void GSRenderer::VSync(u32 field, bool registers_written)
 	if (skip_frame)
 	{
 		g_gs_device->ResetAPIState();
-		if (Host::BeginPresentFrame(true))
+		if (BeginPresentFrame(true))
 			Host::EndPresentFrame();
 		g_gs_device->RestoreAPIState();
 		PerformanceMetrics::Update(registers_written, fb_sprite_frame, true);
@@ -694,7 +556,7 @@ void GSRenderer::VSync(u32 field, bool registers_written)
 	}

 	g_gs_device->ResetAPIState();
-	if (Host::BeginPresentFrame(false))
+	if (BeginPresentFrame(false))
 	{
 		if (current && !blank_frame)
 		{
@@ -910,7 +772,7 @@ void GSRenderer::StopGSDump()
 void GSRenderer::PresentCurrentFrame()
 {
 	g_gs_device->ResetAPIState();
-	if (Host::BeginPresentFrame(false))
+	if (BeginPresentFrame(false))
 	{
 		GSTexture* current = g_gs_device->GetCurrent();
 		if (current)
@@ -967,15 +829,6 @@ void GSRenderer::EndCapture()
 	GSCapture::EndCapture();
 }

-void GSRenderer::PurgePool()
-{
-	g_gs_device->PurgePool();
-}
-
-void GSRenderer::PurgeTextureCache()
-{
-}
-
 GSTexture* GSRenderer::LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, const GSVector2i& size)
 {
 	return nullptr;
--- a/pcsx2/GS/Renderers/Common/GSRenderer.h
+++ b/pcsx2/GS/Renderers/Common/GSRenderer.h
@@ -23,6 +23,7 @@ class GSRenderer : public GSState
 {
 private:
 	bool Merge(int field);
+	bool BeginPresentFrame(bool frame_skip);

 	u64 m_shader_time_start = 0;

@@ -33,6 +34,7 @@ private:
 protected:
 	GSVector2i m_real_size{0, 0};
 	bool m_texture_shuffle = false;
+	bool m_copy_16bit_to_target_shuffle = false;

 	virtual GSTexture* GetOutput(int i, int& y_offset) = 0;
 	virtual GSTexture* GetFeedbackOutput() { return nullptr; }
@@ -51,9 +53,6 @@ public:
 	virtual GSVector2 GetTextureScaleFactor() { return { 1.0f, 1.0f }; }
 	GSVector2i GetInternalResolution();

-	virtual void PurgePool() override;
-	virtual void PurgeTextureCache();
-
 	virtual GSTexture* LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, const GSVector2i& size);

 	bool SaveSnapshotToMemory(u32 window_width, u32 window_height, bool apply_aspect, bool crop_borders,
--- a/pcsx2/GS/Renderers/Common/GSVertexTrace.cpp
+++ b/pcsx2/GS/Renderers/Common/GSVertexTrace.cpp
@@ -19,10 +19,8 @@
 #include "GS/GSState.h"

 GSVertexTrace::GSVertexTrace(const GSState* state, bool provoking_vertex_first)
-	: m_accurate_stq(false), m_state(state), m_primclass(GS_INVALID_CLASS)
+	: m_state(state)
 {
-	memset(&m_alpha, 0, sizeof(m_alpha));
-
 	MULTI_ISA_SELECT(GSVertexTracePopulateFunctions)(*this, provoking_vertex_first);
 }

--- a/pcsx2/GS/Renderers/Common/GSVertexTrace.h
+++ b/pcsx2/GS/Renderers/Common/GSVertexTrace.h
@@ -44,7 +44,7 @@ public:
 		int min, max;
 		bool valid;
 	};
-	bool m_accurate_stq;
+	bool m_accurate_stq = false;

 protected:
 	const GSState* m_state;
@@ -54,25 +54,25 @@ protected:
 	FindMinMaxPtr m_fmm[2][2][2][2][4];

 public:
-	GS_PRIM_CLASS m_primclass;
+	GS_PRIM_CLASS m_primclass = GS_INVALID_CLASS;

-	Vertex m_min;
-	Vertex m_max;
-	VertexAlpha m_alpha; // source alpha range after tfx, GSRenderer::GetAlphaMinMax() updates it
+	Vertex m_min = {};
+	Vertex m_max = {};
+	VertexAlpha m_alpha = {}; // source alpha range after tfx, GSRenderer::GetAlphaMinMax() updates it

 	union
 	{
 		u32 value;
 		struct { u32 r:4, g:4, b:4, a:4, x:1, y:1, z:1, f:1, s:1, t:1, q:1, _pad:1; };
 		struct { u32 rgba:16, xyzf:4, stq:4; };
-	} m_eq;
+	} m_eq = {};

 	union
 	{
 		struct { u32 mmag:1, mmin:1, linear:1, opt_linear:1; };
-	} m_filter;
+	} m_filter = {};

-	GSVector2 m_lod; // x = min, y = max
+	GSVector2 m_lod = {}; // x = min, y = max

 public:
 	GSVertexTrace(const GSState* state, bool provoking_vertex_first);
--- a/pcsx2/GS/Renderers/DX11/D3D.cpp
+++ b/pcsx2/GS/Renderers/DX11/D3D.cpp
@@ -17,8 +17,12 @@
 #include "GS/Renderers/DX11/D3D.h"
 #include "GS/GSExtra.h"

+#include "common/StringUtil.h"
+
 #include <d3d11.h>

+#include "fmt/format.h"
+
 namespace D3D
 {
 	wil::com_ptr_nothrow<IDXGIFactory2> CreateFactory(bool debug)
@@ -69,6 +73,52 @@ namespace D3D
 		return adapter;
 	}

+	std::string GetDriverVersionFromLUID(const LUID& luid)
+	{
+		std::string ret;
+
+		HKEY hKey;
+		if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\DirectX", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
+		{
+			DWORD max_key_len = 0, adapter_count = 0;
+			if (RegQueryInfoKeyW(hKey, nullptr, nullptr, nullptr, &adapter_count, &max_key_len, nullptr, nullptr,
+					nullptr, nullptr, nullptr, nullptr) == ERROR_SUCCESS)
+			{
+				std::vector<TCHAR> current_name(max_key_len + 1);
+				for (DWORD i = 0; i < adapter_count; ++i)
+				{
+					DWORD subKeyLength = static_cast<DWORD>(current_name.size());
+					if (RegEnumKeyExW(hKey, i, current_name.data(), &subKeyLength, nullptr, nullptr, nullptr,
+							nullptr) == ERROR_SUCCESS)
+					{
+						LUID current_luid = {};
+						DWORD current_luid_size = sizeof(uint64_t);
+						if (RegGetValueW(hKey, current_name.data(), L"AdapterLuid", RRF_RT_QWORD, nullptr,
+								&current_luid, &current_luid_size) == ERROR_SUCCESS &&
+							current_luid.HighPart == luid.HighPart && current_luid.LowPart == luid.LowPart)
+						{
+							LARGE_INTEGER driver_version = {};
+							DWORD driver_version_size = sizeof(driver_version);
+							if (RegGetValueW(hKey, current_name.data(), L"DriverVersion", RRF_RT_QWORD, nullptr,
+									&driver_version, &driver_version_size) == ERROR_SUCCESS)
+							{
+								WORD nProduct = HIWORD(driver_version.HighPart);
+								WORD nVersion = LOWORD(driver_version.HighPart);
+								WORD nSubVersion = HIWORD(driver_version.LowPart);
+								WORD nBuild = LOWORD(driver_version.LowPart);
+								ret = fmt::format("{}.{}.{}.{}", nProduct, nVersion, nSubVersion, nBuild);
+							}
+						}
+					}
+				}
+			}
+
+			RegCloseKey(hKey);
+		}
+
+		return ret;
+	}
+
 	u8 Vendor()
 	{
 		auto factory = CreateFactory(false);
@@ -124,22 +174,37 @@ namespace D3D
 		switch (Vendor())
 		{
 			case VendorID::Nvidia:
+			{
 				if (feature_level == D3D_FEATURE_LEVEL_12_0)
 					return Renderer::Vulkan;
 				else if (feature_level == D3D_FEATURE_LEVEL_11_0)
 					return Renderer::OpenGL;
-				[[fallthrough]];
+				else
+					return Renderer::Direct3D11;
+			}
+
 			case VendorID::AMD:
+			{
 				if (feature_level == D3D_FEATURE_LEVEL_12_0)
 					return Renderer::Vulkan;
-				[[fallthrough]];
+				else
+					return Renderer::Direct3D11;
+			}
+
 			case VendorID::Intel:
-				if (feature_level == D3D_FEATURE_LEVEL_12_0)
-					return Renderer::OpenGL;
-				[[fallthrough]];
+			{
+				// Older Intel GPUs prior to Xe seem to have broken OpenGL drivers which choke
+				// on some of our shaders, causing what appears to be GPU timeouts+device removals.
+				// Vulkan has broken barriers, also prior to Xe. So just fall back to DX11 everywhere,
+				// unless we can find some way of differentiating Xe.
+				return Renderer::Direct3D11;
+			}
+
 			default:
+			{
 				// Default is D3D11
-				return Renderer::Default;
+				return Renderer::Direct3D11;
+			}
 		}
 	}
 }
--- a/pcsx2/GS/Renderers/DX11/D3D.h
+++ b/pcsx2/GS/Renderers/DX11/D3D.h
@@ -32,6 +32,9 @@ namespace D3D
 	// however in the event that the adapter is not found due to the above, use the default
 	wil::com_ptr_nothrow<IDXGIAdapter1> GetAdapterFromIndex(IDXGIFactory2* factory, int index);

+	// returns the driver version from the registry as a string
+	std::string GetDriverVersionFromLUID(const LUID& luid);
+
 	// this is sort of a legacy thing that doesn't have much to do with d3d (just the easiest way)
 	// checks to see if the adapter at 0 is NV and thus we should prefer OpenGL
 	enum VendorID
--- a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
@@ -798,7 +798,7 @@ void GSDevice11::UpdateCLUTTexture(GSTexture* sTex, u32 offsetX, u32 offsetY, GS
 	StretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
 }

-void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
+void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear)
 {
 	const GSVector4 full_r(0.0f, 0.0f, 1.0f, 1.0f);
 	const bool feedback_write_2 = PMODE.EN2 && sTex[2] != nullptr && EXTBUF.FBIN == 1;
@@ -821,14 +821,14 @@ void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	{
 		// 2nd output is enabled and selected. Copy it to destination so we can blend it with 1st output
 		// Note: value outside of dRect must contains the background color (c)
-		StretchRect(sTex[1], sRect[1], dTex, PMODE.SLBG ? dRect[2] : dRect[1], ShaderConvert::COPY);
+		StretchRect(sTex[1], sRect[1], dTex, PMODE.SLBG ? dRect[2] : dRect[1], ShaderConvert::COPY, linear);
 	}

 	// Save 2nd output
 	if (feedback_write_2)
 	{
 		StretchRect(dTex, full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
-			m_merge.cb.get(), nullptr, true);
+			m_merge.cb.get(), nullptr, linear);
 	}

 	// Restore background color to process the normal merge
@@ -838,13 +838,13 @@ void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	if (sTex[0])
 	{
 		// 1st output is enabled. It must be blended
-		StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[PMODE.MMOD].get(), m_merge.cb.get(), m_merge.bs.get(), true);
+		StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[PMODE.MMOD].get(), m_merge.cb.get(), m_merge.bs.get(), linear);
 	}

 	if (feedback_write_1)
 	{
 		StretchRect(sTex[0], full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
-			m_merge.cb.get(), nullptr, true);
+			m_merge.cb.get(), nullptr, linear);
 	}
 }

--- a/pcsx2/GS/Renderers/DX11/GSDevice11.h
+++ b/pcsx2/GS/Renderers/DX11/GSDevice11.h
@@ -126,7 +126,7 @@ private:

 	std::unique_ptr<GSDownloadTexture> CreateDownloadTexture(u32 width, u32 height, GSTexture::Format format) final;

-	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c) final;
+	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) final;
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset = 0, int bufIdx = 0) final;
 	void DoFXAA(GSTexture* sTex, GSTexture* dTex) final;
 	void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) final;
--- a/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp
@@ -160,6 +160,7 @@ void GSDevice11::SetupPS(const PSSelector& sel, const GSHWDrawConfig::PSConstant
 		sm.AddMacro("PS_POINT_SAMPLER", sel.point_sampler);
 		sm.AddMacro("PS_SHUFFLE", sel.shuffle);
 		sm.AddMacro("PS_READ_BA", sel.read_ba);
+		sm.AddMacro("PS_READ16_SRC", sel.real16src);
 		sm.AddMacro("PS_CHANNEL_FETCH", sel.channel);
 		sm.AddMacro("PS_TALES_OF_ABYSS_HLE", sel.tales_of_abyss_hle);
 		sm.AddMacro("PS_URBAN_CHAOS_HLE", sel.urban_chaos_hle);
--- a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp
+++ b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp
@@ -567,7 +567,7 @@ void GSDevice12::DrawStretchRect(const GSVector4& sRect, const GSVector4& dRect,
 }

 void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect,
-	const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
+	const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear)
 {
 	GL_PUSH("DoMerge");

@@ -575,7 +575,7 @@ void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	const bool feedback_write_2 = PMODE.EN2 && sTex[2] != nullptr && EXTBUF.FBIN == 1;
 	const bool feedback_write_1 = PMODE.EN1 && sTex[2] != nullptr && EXTBUF.FBIN == 0;
 	const bool feedback_write_2_but_blend_bg = feedback_write_2 && PMODE.SLBG == 1;
-
+	const D3D12::DescriptorHandle& sampler = linear ? m_linear_sampler_cpu : m_point_sampler_cpu;
 	// Merge the 2 source textures (sTex[0],sTex[1]). Final results go to dTex. Feedback write will go to sTex[2].
 	// If either 2nd output is disabled or SLBG is 1, a background color will be used.
 	// Note: background color is also used when outside of the unit rectangle area
@@ -605,7 +605,7 @@ void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		{
 			static_cast<GSTexture12*>(sTex[1])->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
 			OMSetRenderTargets(dTex, nullptr, darea);
-			SetUtilityTexture(sTex[1], m_linear_sampler_cpu);
+			SetUtilityTexture(sTex[1], sampler);
 			BeginRenderPass(D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE,
 				D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS,
 				D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS, c);
@@ -625,7 +625,7 @@ void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		EndRenderPass();
 		OMSetRenderTargets(sTex[2], nullptr, fbarea);
 		if (dcleared)
-			SetUtilityTexture(dTex, m_linear_sampler_cpu);
+			SetUtilityTexture(dTex, sampler);

 		// sTex[2] can be sTex[0], in which case it might be cleared (e.g. Xenosaga).
 		BeginRenderPassForStretchRect(static_cast<GSTexture12*>(sTex[2]), fbarea, GSVector4i(dRect[2]));
@@ -663,7 +663,7 @@ void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	{
 		// 1st output is enabled. It must be blended
 		SetUtilityRootSignature();
-		SetUtilityTexture(sTex[0], m_linear_sampler_cpu);
+		SetUtilityTexture(sTex[0], sampler);
 		SetPipeline(m_merge[PMODE.MMOD].get());
 		DrawStretchRect(sRect[0], dRect[0], dTex->GetSize());
 	}
@@ -673,7 +673,7 @@ void GSDevice12::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		EndRenderPass();
 		SetUtilityRootSignature();
 		SetPipeline(m_convert[static_cast<int>(ShaderConvert::YUV)].get());
-		SetUtilityTexture(dTex, m_linear_sampler_cpu);
+		SetUtilityTexture(dTex, sampler);
 		OMSetRenderTargets(sTex[2], nullptr, fbarea);
 		BeginRenderPass(D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE);
 		DrawStretchRect(full_r, dRect[2], dsize);
@@ -1501,6 +1501,7 @@ const ID3DBlob* GSDevice12::GetTFXPixelShader(const GSHWDrawConfig::PSSelector&
 	sm.AddMacro("PS_POINT_SAMPLER", sel.point_sampler);
 	sm.AddMacro("PS_SHUFFLE", sel.shuffle);
 	sm.AddMacro("PS_READ_BA", sel.read_ba);
+	sm.AddMacro("PS_READ16_SRC", sel.real16src);
 	sm.AddMacro("PS_CHANNEL_FETCH", sel.channel);
 	sm.AddMacro("PS_TALES_OF_ABYSS_HLE", sel.tales_of_abyss_hle);
 	sm.AddMacro("PS_URBAN_CHAOS_HLE", sel.urban_chaos_hle);
--- a/pcsx2/GS/Renderers/DX12/GSDevice12.h
+++ b/pcsx2/GS/Renderers/DX12/GSDevice12.h
@@ -183,7 +183,7 @@ private:
 	GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) override;

 	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE,
-		const GSRegEXTBUF& EXTBUF, const GSVector4& c) final;
+		const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) final;
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset = 0, int bufIdx = 0) final;
 	void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) final;
 	void DoFXAA(GSTexture* sTex, GSTexture* dTex) final;
--- a/pcsx2/GS/Renderers/HW/GSHwHack.cpp
+++ b/pcsx2/GS/Renderers/HW/GSHwHack.cpp
@@ -170,25 +170,6 @@ bool GSHwHack::GSC_SacredBlaze(GSRendererHW& r, const GSFrameInfo& fi, int& skip
 	return true;
 }

-bool GSHwHack::GSC_Spartan(GSRendererHW& r, const GSFrameInfo& fi, int& skip)
-{
-	if (skip == 0)
-	{
-		if (fi.TME)
-		{
-			// depth textures (bully, mgs3s1 intro, Front Mission 5)
-			if ((fi.TPSM == PSM_PSMZ32 || fi.TPSM == PSM_PSMZ24 || fi.TPSM == PSM_PSMZ16 || fi.TPSM == PSM_PSMZ16S) ||
-				// General, often problematic post processing
-				(GSUtil::HasSharedBits(fi.FBP, fi.FPSM, fi.TBP0, fi.TPSM)))
-			{
-				skip = 2;
-			}
-		}
-	}
-
-	return true;
-}
-
 bool GSHwHack::GSC_Oneechanbara2Special(GSRendererHW& r, const GSFrameInfo& fi, int& skip)
 {
 	if (skip == 0)
@@ -499,21 +480,6 @@ bool GSHwHack::GSC_SakuraWarsSoLongMyLove(GSRendererHW& r, const GSFrameInfo& fi
 	return true;
 }

-bool GSHwHack::GSC_FightingBeautyWulong(GSRendererHW& r, const GSFrameInfo& fi, int& skip)
-{
-	if (skip == 0)
-	{
-		if (!s_nativeres && fi.TME && (fi.TBP0 == 0x0700 || fi.TBP0 == 0x0a80) && (fi.TPSM == PSM_PSMCT32 || fi.TPSM == PSM_PSMCT24))
-		{
-			// Don't enable hack on native res if crc is below aggressive.
-			// removes glow/blur which cause ghosting and other sprite issues similar to Tekken 5
-			skip = 1;
-		}
-	}
-
-	return true;
-}
-
 bool GSHwHack::GSC_GodHand(GSRendererHW& r, const GSFrameInfo& fi, int& skip)
 {
 	if (skip == 0)
@@ -1036,30 +1002,6 @@ bool GSHwHack::OI_FFX(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCa
 	return true;
 }

-bool GSHwHack::OI_MetalSlug6(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t)
-{
-	// missing red channel fix (looks alright in pcsx2 r5000+)
-
-	GSVertex* RESTRICT v = r.m_vertex.buff;
-
-	for (size_t i = r.m_vertex.next; i > 0; i--, v++)
-	{
-		const u32 c = v->RGBAQ.U32[0];
-
-		const u32 r = (c >> 0) & 0xff;
-		const u32 g = (c >> 8) & 0xff;
-		const u32 b = (c >> 16) & 0xff;
-
-		if (r == 0 && g != 0 && b != 0)
-		{
-			v->RGBAQ.U32[0] = (c & 0xffffff00) | ((g + b + 1) >> 1);
-		}
-	}
-
-	r.m_vt.Update(r.m_vertex.buff, r.m_index.buff, r.m_vertex.tail, r.m_index.tail, r.m_vt.m_primclass);
-
-	return true;
-}

 bool GSHwHack::OI_RozenMaidenGebetGarden(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t)
 {
@@ -1282,7 +1224,6 @@ const GSHwHack::Entry<GSRendererHW::GSC_Ptr> GSHwHack::s_get_skip_count_function
 	// Channel Effect
 	CRC_F(GSC_CrashBandicootWoC, CRCHackLevel::Partial),
 	CRC_F(GSC_GiTS, CRCHackLevel::Partial),
-	CRC_F(GSC_Spartan, CRCHackLevel::Partial),
 	CRC_F(GSC_SteambotChronicles, CRCHackLevel::Partial),

 	// Depth Issue
@@ -1296,7 +1237,6 @@ const GSHwHack::Entry<GSRendererHW::GSC_Ptr> GSHwHack::s_get_skip_count_function
 	CRC_F(GSC_DeathByDegreesTekkenNinaWilliams, CRCHackLevel::Partial), // + Upscaling issues

 	// Upscaling hacks
-	CRC_F(GSC_FightingBeautyWulong, CRCHackLevel::Partial),
 	CRC_F(GSC_Oneechanbara2Special, CRCHackLevel::Partial),
 	CRC_F(GSC_UltramanFightingEvolution, CRCHackLevel::Partial),
 	CRC_F(GSC_YakuzaGames, CRCHackLevel::Partial),
@@ -1322,7 +1262,6 @@ const GSHwHack::Entry<GSRendererHW::OI_Ptr> GSHwHack::s_before_draw_functions[]
 	CRC_F(OI_DBZBTGames, CRCHackLevel::Minimum),
 	CRC_F(OI_FFXII, CRCHackLevel::Minimum),
 	CRC_F(OI_FFX, CRCHackLevel::Minimum),
-	CRC_F(OI_MetalSlug6, CRCHackLevel::Minimum),
 	CRC_F(OI_RozenMaidenGebetGarden, CRCHackLevel::Minimum),
 	CRC_F(OI_SonicUnleashed, CRCHackLevel::Minimum),
 	CRC_F(OI_ArTonelico2, CRCHackLevel::Minimum),
--- a/pcsx2/GS/Renderers/HW/GSHwHack.h
+++ b/pcsx2/GS/Renderers/HW/GSHwHack.h
@@ -24,7 +24,6 @@ public:
 	static bool GSC_Manhunt2(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_CrashBandicootWoC(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_SacredBlaze(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
-	static bool GSC_Spartan(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_Oneechanbara2Special(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_SakuraTaisen(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_SFEX3(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
@@ -39,7 +38,6 @@ public:
 	static bool GSC_Kunoichi(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_ZettaiZetsumeiToshi2(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_SakuraWarsSoLongMyLove(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
-	static bool GSC_FightingBeautyWulong(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_GodHand(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_KnightsOfTheTemple2(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
 	static bool GSC_UltramanFightingEvolution(GSRendererHW& r, const GSFrameInfo& fi, int& skip);
@@ -63,7 +61,6 @@ public:
 	static bool OI_DBZBTGames(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
 	static bool OI_FFXII(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
 	static bool OI_FFX(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
-	static bool OI_MetalSlug6(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
 	static bool OI_RozenMaidenGebetGarden(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
 	static bool OI_SonicUnleashed(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
 	static bool OI_ArTonelico2(GSRendererHW& r, GSTexture* rt, GSTexture* ds, GSTextureCache::Source* t);
--- a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp
+++ b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp
@@ -24,14 +24,6 @@
 GSRendererHW::GSRendererHW()
 	: GSRenderer()
 	, m_tc(new GSTextureCache())
-	, m_src(nullptr)
-	, m_reset(false)
-	, m_tex_is_fb(false)
-	, m_channel_shuffle(false)
-	, m_userhacks_tcoffset(false)
-	, m_userhacks_tcoffset_x(0)
-	, m_userhacks_tcoffset_y(0)
-	, m_lod(GSVector2i(0, 0))
 {
 	MULTI_ISA_SELECT(GSRendererHWPopulateFunctions)(*this);
 	m_mipmap = (GSConfig.HWMipmap >= HWMipmapLevel::Basic);
@@ -44,49 +36,12 @@ GSRendererHW::GSRendererHW()

 	memset(&m_conf, 0, sizeof(m_conf));

-	m_prim_overlap = PRIM_OVERLAP_UNKNOW;
 	ResetStates();
 }

 GSVector2i GSRendererHW::GetOutputSize(int real_h)
 {
-	GSVector2i crtc_size(GetResolution());
-
-	// Correct framebuffer size to get output size when offsets not considered (uses framebuffer height)
-	if (!GSConfig.PCRTCOffsets)
-	{
-		const int videomode = static_cast<int>(GetVideoMode()) - 1;
-		const int display_width = (VideoModeDividers[videomode].z + 1) / GetDisplayHMagnification();
-		const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
-		int display_height = offsets.y;
-
-		if (isinterlaced() && !m_regs->SMODE2.FFMD)
-			display_height *= 2;
-
-		if (crtc_size.x < display_width || crtc_size.y < display_height)
-		{
-			GSVector2i display_baseline = { 4096, 4096 };
-
-			for (int i = 0; i < 2; i++)
-			{
-				if (IsEnabled(i))
-				{
-					const GSVector4i dr = GetDisplayRect(i);
-
-					const GSVector2i display_diff(dr.left - display_baseline.x, dr.top - display_baseline.y);
-
-					if (display_diff.x != 0 && abs(display_diff.x) < 4 && crtc_size.x < display_width)
-						crtc_size.x -= display_diff.x;
-
-					if (display_diff.y != 0 && abs(display_diff.y) < 4 && crtc_size.y < display_height)
-						crtc_size.y -= display_diff.y;
-
-					display_baseline.x = std::min(dr.left, display_baseline.x);
-					display_baseline.y = std::min(dr.top, display_baseline.y);
-				}
-			}
-		}
-	}
+	GSVector2i crtc_size(PCRTCDisplays.GetResolution());

 	// Include negative display offsets in the height here.
 	crtc_size.y = std::max(crtc_size.y, real_h);
@@ -116,10 +71,14 @@ void GSRendererHW::Destroy()

 void GSRendererHW::PurgeTextureCache()
 {
-	GSRenderer::PurgeTextureCache();
 	m_tc->RemoveAll();
 }

+void GSRendererHW::ReadbackTextureCache()
+{
+	m_tc->ReadbackAll();
+}
+
 GSTexture* GSRendererHW::LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, const GSVector2i& size)
 {
 	return m_tc->LookupPaletteSource(CBP, CPSM, CBW, offset, size);
@@ -183,10 +142,11 @@ float GSRendererHW::GetUpscaleMultiplier()

 void GSRendererHW::Reset(bool hardware_reset)
 {
-	// TODO: GSreset can come from the main thread too => crash
-	// m_tc->RemoveAll();
+	// Force targets to preload for 2 frames (for 30fps games).
+	static constexpr u8 TARGET_PRELOAD_FRAMES = 2;

-	m_reset = true;
+	m_tc->RemoveAll();
+	m_force_preload = TARGET_PRELOAD_FRAMES;

 	GSRenderer::Reset(hardware_reset);
 }
@@ -200,32 +160,45 @@ void GSRendererHW::UpdateSettings(const Pcsx2Config::GSOptions& old_config)

 void GSRendererHW::VSync(u32 field, bool registers_written)
 {
-	if (m_reset)
+	if (m_force_preload > 0)
 	{
-		m_tc->RemoveAll();
-		m_reset = false;
-		m_force_preload = true;
-	}
-	else
-	{
-		m_force_preload = false;
-		std::vector<GSState::GSUploadQueue>::iterator iter;
-		for (iter = m_draw_transfers.begin(); iter != m_draw_transfers.end(); ) {
-			if ((s_n - iter->draw) > 5)
-				iter = m_draw_transfers.erase(iter);
-			else
-				iter++;
+		m_force_preload--;
+		if (m_force_preload == 0)
+		{
+			for (auto iter = m_draw_transfers.begin(); iter != m_draw_transfers.end();)
+			{
+				if ((s_n - iter->draw) > 5)
+					iter = m_draw_transfers.erase(iter);
+				else
+				{
+					iter++;
+				}
+
+			}
 		}
 	}
+	else
+		m_draw_transfers.clear();

 	if (GSConfig.LoadTextureReplacements)
 		GSTextureReplacements::ProcessAsyncLoadedTextures();

-	m_tc->IncAge();
+	// Don't age the texture cache when no draws or EE writes have occurred.
+	// Xenosaga needs its targets kept around while it's loading, because it uses them for a fade transition.
+	if (m_last_draw_n == s_n && m_last_transfer_n == s_transfer_n)
+	{
+		GL_INS("No draws or transfers, not aging TC");
+	}
+	else
+	{
+		m_tc->IncAge();
+	}
+
+	m_last_draw_n = s_n + 1; // +1 for vsync
+	m_last_transfer_n = s_transfer_n;

 	GSRenderer::VSync(field, registers_written);

-
 	if (m_tc->GetHashCacheMemoryUsage() > 1024 * 1024 * 1024)
 	{
 		Host::AddKeyedFormattedOSDMessage("HashCacheOverflow", Host::OSD_ERROR_DURATION, "Hash cache has used %.2f MB of VRAM, disabling.",
@@ -241,40 +214,35 @@ void GSRendererHW::VSync(u32 field, bool registers_written)

 GSTexture* GSRendererHW::GetOutput(int i, int& y_offset)
 {
-	const GSRegDISPFB& DISPFB = m_regs->DISP[i].DISPFB;
+	int index = i >= 0 ? i : 1;

-	GIFRegTEX0 TEX0 = {};
+	GSPCRTCRegs::PCRTCDisplay& curFramebuffer = PCRTCDisplays.PCRTCDisplays[index];
+	GSVector2i framebufferSize = PCRTCDisplays.GetFramebufferSize(i);
+	const int fb_width = framebufferSize.x;
+	const int fb_height = framebufferSize.y;

-	TEX0.TBP0 = DISPFB.Block();
-	TEX0.TBW = DISPFB.FBW;
-	TEX0.PSM = DISPFB.PSM;
-
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	const GSVector4i offsets = VideoModeOffsets[videomode];
-
-	const int fb_width = std::min<int>(std::min<int>(GetFramebufferWidth(), DISPFB.FBW * 64) + static_cast<int>(DISPFB.DBX), 2048);
-	const int display_height = offsets.y * ((isinterlaced() && !m_regs->SMODE2.FFMD) ? 2 : 1);
-	const int display_offset = GetResolutionOffset(i).y;
-	int fb_height = (std::min<int>(GetFramebufferHeight(), display_height) + static_cast<int>(DISPFB.DBY)) % 2048;
-	// If there is a negative vertical offset on the picture, we need to read more.
-	if (display_offset < 0)
-	{
-		fb_height += -display_offset;
-	}
-	// TRACE(_T("[%d] GetOutput %d %05x (%d)\n"), static_cast<int>(g_perfmon.GetFrame()), i, static_cast<int>(TEX0.TBP0), static_cast<int>(TEX0.PSM));
+	PCRTCDisplays.RemoveFramebufferOffset(i);
+	// TRACE(_T("[%d] GetOutput %d %05x (%d)\n"), (int)m_perfmon.GetFrame(), i, (int)TEX0.TBP0, (int)TEX0.PSM);

 	GSTexture* t = nullptr;

-	if (GSTextureCache::Target* rt = m_tc->LookupDisplayTarget(TEX0, GetOutputSize(fb_height) * GSConfig.UpscaleMultiplier, fb_width, fb_height))
+	GIFRegTEX0 TEX0 = {};
+	TEX0.TBP0 = curFramebuffer.Block();
+	TEX0.TBW = curFramebuffer.FBW;
+	TEX0.PSM = curFramebuffer.PSM;
+
+	const GSVector2i scaled_size(static_cast<int>(static_cast<float>(fb_width) * GSConfig.UpscaleMultiplier),
+		static_cast<int>(static_cast<float>(fb_height) * GSConfig.UpscaleMultiplier));
+	if (GSTextureCache::Target* rt = m_tc->LookupDisplayTarget(TEX0, scaled_size, fb_width, fb_height))
 	{
 		t = rt->m_texture;

 		const int delta = TEX0.TBP0 - rt->m_TEX0.TBP0;
-		if (delta > 0 && DISPFB.FBW != 0)
+		if (delta > 0 && curFramebuffer.FBW != 0)
 		{
 			const int pages = delta >> 5u;
-			int y_pages = pages / DISPFB.FBW;
-			y_offset = y_pages * GSLocalMemory::m_psm[DISPFB.PSM].pgs.y;
+			int y_pages = pages / curFramebuffer.FBW;
+			y_offset = y_pages * GSLocalMemory::m_psm[curFramebuffer.PSM].pgs.y;
 			GL_CACHE("Frame y offset %d pixels, unit %d", y_offset, i);
 		}

@@ -797,14 +765,14 @@ GSVector2i GSRendererHW::GetTargetSize(GSVector2i* unscaled_size)
 		const int page_y = GSLocalMemory::m_psm[m_context->FRAME.PSM].pgs.y - 1;

 		// Round up the page as channel shuffles are generally done in pages at a time
-		width = (std::max(static_cast<u32>(GetResolution().x), width) + page_x) & ~page_x;
-		min_height = (std::max(static_cast<u32>(GetResolution().y), min_height) + page_y) & ~page_y;
+		width = (std::max(static_cast<u32>(PCRTCDisplays.GetResolution().x), width) + page_x) & ~page_x;
+		min_height = (std::max(static_cast<u32>(PCRTCDisplays.GetResolution().y), min_height) + page_y) & ~page_y;
 	}

 	// Align to even lines, reduces the chance of tiny resizes.
 	min_height = Common::AlignUpPow2(min_height, 2);

-	u32 height = m_tc->GetTargetHeight(m_context->FRAME.FBP, m_context->FRAME.FBW, m_context->FRAME.PSM, min_height);
+	u32 height = m_tc->GetTargetHeight(m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, min_height);

 	if (unscaled_size)
 	{
@@ -812,7 +780,7 @@ GSVector2i GSRendererHW::GetTargetSize(GSVector2i* unscaled_size)
 		unscaled_size->y = static_cast<int>(height);
 	}

-	GL_INS("Target size for %x %u %u: %ux%u", m_context->FRAME.FBP, m_context->FRAME.FBW, m_context->FRAME.PSM, width, height);
+	GL_INS("Target size for %x %u %u: %ux%u", m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, width, height);

 	return GSVector2i(static_cast<int>(static_cast<float>(width) * GSConfig.UpscaleMultiplier),
 		static_cast<int>(static_cast<float>(height) * GSConfig.UpscaleMultiplier));
@@ -1345,13 +1313,13 @@ void GSRendererHW::Draw()
 	// 2/ SuperMan really draws (0,0,0,0) color and a (0) 32-bits depth
 	// 3/ 50cents really draws (0,0,0,128) color and a (0) 24 bits depth
 	// Note: FF DoC has both buffer at same location but disable the depth test (write?) with ZTE = 0
-	const bool no_rt = (context->ALPHA.IsCd() && PRIM->ABE && (context->FRAME.PSM == 1));
-	const bool no_ds = !no_rt && (
+	const bool no_rt = (context->ALPHA.IsCd() && PRIM->ABE && (context->FRAME.PSM == 1))
+						|| (!context->TEST.DATE && (context->FRAME.FBMSK & GSLocalMemory::m_psm[context->FRAME.PSM].fmsk) == GSLocalMemory::m_psm[context->FRAME.PSM].fmsk);
+	const bool no_ds = (
 			// Depth is always pass/fail (no read) and write are discarded (tekken 5).  (Note: DATE is currently implemented with a stencil buffer => a depth/stencil buffer)
 			(zm != 0 && m_context->TEST.ZTST <= ZTST_ALWAYS && !m_context->TEST.DATE) ||
 			// Depth will be written through the RT
-			(context->FRAME.FBP == context->ZBUF.ZBP && !PRIM->TME && zm == 0 && (fm & fm_mask) == 0 && context->TEST.ZTE)
-			);
+			(!no_rt && context->FRAME.FBP == context->ZBUF.ZBP && !PRIM->TME && zm == 0 && (fm & fm_mask) == 0 && context->TEST.ZTE));

 	if (no_rt && no_ds)
 	{
@@ -1366,12 +1334,13 @@ void GSRendererHW::Draw()
 	// We trigger the sw prim render here super early, to avoid creating superfluous render targets.
 	if (CanUseSwPrimRender(no_rt, no_ds, draw_sprite_tex) && SwPrimRender(*this, true))
 	{
-		GL_CACHE("Possible texture decompression, drawn with SwPrimRender()");
+		GL_CACHE("Possible texture decompression, drawn with SwPrimRender() (BP %x BW %u TBP0 %x TBW %u)",
+			m_context->FRAME.Block(), m_context->FRAME.FBMSK, m_context->TEX0.TBP0, m_context->TEX0.TBW);
 		return;
 	}

 	// SW CLUT Render enable.
-	bool preload = GSConfig.PreloadFrameWithGSData | m_force_preload;
+	bool force_preload = GSConfig.PreloadFrameWithGSData;
 	if (GSConfig.UserHacks_CPUCLUTRender > 0 || GSConfig.UserHacks_GPUTargetCLUTMode != GSGPUTargetCLUTMode::Disabled)
 	{
 		const CLUTDrawTestResult result = (GSConfig.UserHacks_CPUCLUTRender == 2) ? PossibleCLUTDrawAggressive() : PossibleCLUTDraw();
@@ -1392,14 +1361,17 @@ void GSRendererHW::Draw()
 				!IsOpaque()) // Blending enabled
 			{
 				GL_INS("Forcing preload due to partial/blended CLUT draw");
-				preload = m_force_preload = true;
+				force_preload = true;
 			}
 		}
 	}

 	if (m_channel_shuffle)
 	{
-		m_channel_shuffle = draw_sprite_tex && (m_context->TEX0.PSM == PSM_PSMT8) && single_page;
+		// NFSU2 does consecutive channel shuffles with blending, reducing the alpha channel over time.
+		// Fortunately, it seems to change the FBMSK along the way, so this check alone is sufficient.
+		m_channel_shuffle = draw_sprite_tex && m_context->TEX0.PSM == PSM_PSMT8 && single_page &&
+							m_last_channel_shuffle_fbmsk == m_context->FRAME.FBMSK;
 		if (m_channel_shuffle)
 		{
 			GL_CACHE("Channel shuffle effect detected SKIP");
@@ -1413,6 +1385,7 @@ void GSRendererHW::Draw()
 		{
 			GL_INS("Channel shuffle effect detected");
 			m_channel_shuffle = true;
+			m_last_channel_shuffle_fbmsk = m_context->FRAME.FBMSK;
 		}
 		else
 		{
@@ -1429,6 +1402,7 @@ void GSRendererHW::Draw()

 	m_src = nullptr;
 	m_texture_shuffle = false;
+	m_copy_16bit_to_target_shuffle = false;
 	m_tex_is_fb = false;

 	// The rectangle of the draw
@@ -1443,13 +1417,14 @@ void GSRendererHW::Draw()
 			const bool clear_height_valid = (m_r.w >= 1024);
 			if (clear_height_valid && context->FRAME.FBW == 1)
 			{
-				u32 width = ceil(static_cast<float>(m_r.w) / GetFramebufferHeight()) * 64;
+				GSVector2i fb_size = PCRTCDisplays.GetFramebufferSize(-1);
+				u32 width = ceil(static_cast<float>(m_r.w) / fb_size.y) * 64;
 				// Framebuffer is likely to be read as 16bit later, so we will need to double the width if the write is 32bit.
-				const bool double_width = GSLocalMemory::m_psm[context->FRAME.PSM].bpp == 32 && GetFramebufferBitDepth() == 16;
+				const bool double_width = GSLocalMemory::m_psm[context->FRAME.PSM].bpp == 32 && PCRTCDisplays.GetFramebufferBitDepth() == 16;
 				m_r.x = 0;
 				m_r.y = 0;
-				m_r.w = GetFramebufferHeight();
-				m_r.z = std::max((width * (double_width ? 2 : 1)), static_cast<u32>(GetFramebufferWidth()));
+				m_r.w = fb_size.y;
+				m_r.z = std::max((width * (double_width ? 2 : 1)), static_cast<u32>(fb_size.x));
 				context->FRAME.FBW = (m_r.z + 63) / 64;
 				m_context->scissor.in.z = context->FRAME.FBW * 64;

@@ -1486,8 +1461,9 @@ void GSRendererHW::Draw()
 		}
 	}
 	TextureMinMaxResult tmm;
+	const bool process_texture = PRIM->TME && !(PRIM->ABE && m_context->ALPHA.IsBlack() && !m_context->TEX0.TCC);
 	// Disable texture mapping if the blend is black and using alpha from vertex.
-	if (PRIM->TME && !(PRIM->ABE && m_context->ALPHA.IsBlack() && !m_context->TEX0.TCC))
+	if (process_texture)
 	{
 		GIFRegCLAMP MIP_CLAMP = context->CLAMP;
 		GSVector2i hash_lod_range(0, 0);
@@ -1597,7 +1573,7 @@ void GSRendererHW::Draw()

 	GSTextureCache::Target* rt = nullptr;
 	if (!no_rt)
-		rt = m_tc->LookupTarget(TEX0, t_size, GSTextureCache::RenderTarget, true, fm, false, unscaled_target_size.x, unscaled_target_size.y, preload);
+		rt = m_tc->LookupTarget(TEX0, t_size, GSTextureCache::RenderTarget, true, fm, false, unscaled_target_size.x, unscaled_target_size.y, force_preload);

 	TEX0.TBP0 = context->ZBUF.Block();
 	TEX0.TBW = context->FRAME.FBW;
@@ -1605,18 +1581,17 @@ void GSRendererHW::Draw()

 	GSTextureCache::Target* ds = nullptr;
 	if (!no_ds)
-		ds = m_tc->LookupTarget(TEX0, t_size, GSTextureCache::DepthStencil, context->DepthWrite(), 0, false, 0, 0, preload);
+		ds = m_tc->LookupTarget(TEX0, t_size, GSTextureCache::DepthStencil, context->DepthWrite(), 0, false, unscaled_target_size.x, unscaled_target_size.y, force_preload);

-	if (PRIM->TME)
+	if (process_texture)
 	{
 		GIFRegCLAMP MIP_CLAMP = context->CLAMP;

-		bool copy_16bit_to_target_shuffle = false;
-
 		if (rt)
 		{
 			// copy of a 16bit source in to this target, make sure it's opaque and not bilinear to reduce false positives.
-			copy_16bit_to_target_shuffle = context->TEX0.TBP0 != context->FRAME.Block() && rt->m_32_bits_fmt == true && IsOpaque() && !(context->TEX1.MMIN & 1);
+			m_copy_16bit_to_target_shuffle = context->TEX0.TBP0 != context->FRAME.Block() && rt->m_32_bits_fmt == true && IsOpaque()
+											&& !(context->TEX1.MMIN & 1) && !m_src->m_32_bits_fmt && context->FRAME.FBMSK;
 		}

 		// Hypothesis: texture shuffle is used as a postprocessing effect so texture will be an old target.
@@ -1624,7 +1599,7 @@ void GSRendererHW::Draw()
 		//
 		// Both input and output are 16 bits and texture was initially 32 bits!
 		m_texture_shuffle = (GSLocalMemory::m_psm[context->FRAME.PSM].bpp == 16) && (tex_psm.bpp == 16)
-			&& draw_sprite_tex && (m_src->m_32_bits_fmt || copy_16bit_to_target_shuffle);
+			&& draw_sprite_tex && (m_src->m_32_bits_fmt || m_copy_16bit_to_target_shuffle);

 		// Okami mustn't call this code
 		if (m_texture_shuffle && m_vertex.next < 3 && PRIM->FST && ((m_context->FRAME.FBMSK & fm_mask) == 0))
@@ -1657,6 +1632,7 @@ void GSRendererHW::Draw()
 		{
 			GL_INS("Channel shuffle effect detected (2nd shot)");
 			m_channel_shuffle = true;
+			m_last_channel_shuffle_fbmsk = m_context->FRAME.FBMSK;
 		}
 		else
 		{
@@ -1752,7 +1728,7 @@ void GSRendererHW::Draw()
 			m_vt.m_max.t = tmax;
 		}
 	}
-	
+
 	if (rt)
 	{
 		// Be sure texture shuffle detection is properly propagated
@@ -1761,6 +1737,8 @@ void GSRendererHW::Draw()
 		rt->m_32_bits_fmt = m_texture_shuffle || (GSLocalMemory::m_psm[context->FRAME.PSM].bpp != 16);
 	}

+	const bool is_mem_clear = IsConstantDirectWriteMemClear(false);
+	const bool can_update_size = !is_mem_clear && !m_texture_shuffle && !m_channel_shuffle;
 	{
 		// We still need to make sure the dimensions of the targets match.
 		const GSVector2 up_s(GetTextureScaleFactor());
@@ -1769,15 +1747,82 @@ void GSRendererHW::Draw()

 		if (rt)
 		{
+			const u32 old_end_block = rt->m_end_block;
+			const bool new_height = new_h > rt->m_texture->GetHeight();
+			const int old_height = rt->m_texture->GetHeight();
+
 			pxAssert(rt->m_texture->GetScale() == up_s);
 			rt->ResizeTexture(new_w, new_h, up_s);
-			rt->UpdateValidity(m_r);
+			const GSVector2i tex_size = rt->m_texture->GetSize();
+			
+			// Avoid temporary format changes, as this will change the end block and could break things.
+			if ((old_height != tex_size.y) && can_update_size)
+			{
+				const GSVector2 tex_scale = rt->m_texture->GetScale();
+				const GSVector4i new_valid = GSVector4i(0, 0, tex_size.x / tex_scale.x, tex_size.y / tex_scale.y);
+				rt->ResizeValidity(new_valid);
+			}
+			GSVector2i resolution = PCRTCDisplays.GetResolution();
+			// Limit to 2x the vertical height of the resolution (for double buffering)
+			rt->UpdateValidity(m_r, can_update_size || m_r.w <= (resolution.y * 2));
+
+			// Probably changing to double buffering, so invalidate any old target that was next to it.
+			// This resolves an issue where the PCRTC will find the old target in FMV's causing flashing.
+			// Grandia Xtreme, Onimusha Warlord.
+			if (new_height && old_end_block != rt->m_end_block)
+			{
+				GSTextureCache::Target* old_rt = nullptr;
+				old_rt = m_tc->FindTargetOverlap(old_end_block, rt->m_end_block, GSTextureCache::RenderTarget, context->FRAME.PSM);
+
+				if (old_rt && old_rt != rt && GSUtil::HasSharedBits(old_rt->m_TEX0.PSM, rt->m_TEX0.PSM))
+				{
+					const int copy_width = (old_rt->m_texture->GetWidth()) > (rt->m_texture->GetWidth()) ? (rt->m_texture->GetWidth()) : old_rt->m_texture->GetWidth();
+					const int copy_height = (old_rt->m_texture->GetHeight()) > (rt->m_texture->GetHeight() - old_height) ? (rt->m_texture->GetHeight() - old_height) : old_rt->m_texture->GetHeight();
+
+					g_gs_device->CopyRect(old_rt->m_texture, rt->m_texture, GSVector4i(0, 0, copy_width, copy_height), 0, old_height);
+
+					m_tc->InvalidateVideoMemType(GSTextureCache::RenderTarget, old_rt->m_TEX0.TBP0);
+					old_rt = nullptr;
+				}
+			}
 		}
 		if (ds)
 		{
+			const u32 old_end_block = ds->m_end_block;
+			const bool new_height = new_h > ds->m_texture->GetHeight();
+			const int old_height = ds->m_texture->GetHeight();
+
 			pxAssert(ds->m_texture->GetScale() == up_s);
 			ds->ResizeTexture(new_w, new_h, up_s);
-			ds->UpdateValidity(m_r);
+			const GSVector2i tex_size = ds->m_texture->GetSize();
+			
+			if ((old_height != tex_size.y) && can_update_size)
+			{
+				const GSVector2 tex_scale = ds->m_texture->GetScale();
+				const GSVector4i new_valid = GSVector4i(0, 0, tex_size.x / tex_scale.x, tex_size.y / tex_scale.y);
+				ds->ResizeValidity(new_valid);
+			}
+
+			GSVector2i resolution = PCRTCDisplays.GetResolution();
+			// Limit to 2x the vertical height of the resolution (for double buffering)
+			ds->UpdateValidity(m_r, can_update_size || m_r.w <= (resolution.y * 2));
+
+			if (new_height && old_end_block != ds->m_end_block)
+			{
+				GSTextureCache::Target* old_ds = nullptr;
+				old_ds = m_tc->FindTargetOverlap(old_end_block, ds->m_end_block, GSTextureCache::DepthStencil, context->ZBUF.PSM);
+
+				if (old_ds && old_ds != ds && GSUtil::HasSharedBits(old_ds->m_TEX0.PSM, ds->m_TEX0.PSM))
+				{
+					const int copy_width = (old_ds->m_texture->GetWidth()) > (ds->m_texture->GetWidth()) ? (ds->m_texture->GetWidth()) : old_ds->m_texture->GetWidth();
+					const int copy_height = (old_ds->m_texture->GetHeight()) > (ds->m_texture->GetHeight() - old_height) ? (ds->m_texture->GetHeight() - old_height) : old_ds->m_texture->GetHeight();
+
+					g_gs_device->CopyRect(old_ds->m_texture, ds->m_texture, GSVector4i(0, 0, copy_width, copy_height), 0, old_height);
+
+					m_tc->InvalidateVideoMemType(GSTextureCache::DepthStencil, old_ds->m_TEX0.TBP0);
+					old_ds = nullptr;
+				}
+			}
 		}
 	}

@@ -1910,12 +1955,15 @@ void GSRendererHW::Draw()
 	// Temporary source *must* be invalidated before normal, because otherwise it'll be double freed.
 	m_tc->InvalidateTemporarySource();

-	//
-
+	// If it's a mem clear or shuffle we don't want to resize the texture, it can cause textures to take up the entire
+	// video memory, and that is not good.
 	if ((fm & fm_mask) != fm_mask && rt)
 	{
 		//rt->m_valid = rt->m_valid.runion(r);
-		rt->UpdateValidity(m_r);
+		if(can_update_size)
+			rt->UpdateValidity(m_r);
+
+		rt->UpdateValidBits(~fm & fm_mask);

 		m_tc->InvalidateVideoMem(context->offset.fb, m_r, false, false);

@@ -1925,7 +1973,11 @@ void GSRendererHW::Draw()
 	if (zm != 0xffffffff && ds)
 	{
 		//ds->m_valid = ds->m_valid.runion(r);
-		ds->UpdateValidity(m_r);
+		// Shouldn't be a problem as Z will be masked.
+		if (can_update_size)
+			ds->UpdateValidity(m_r);
+
+		ds->UpdateValidBits(GSLocalMemory::m_psm[context->ZBUF.PSM].fmsk);

 		m_tc->InvalidateVideoMem(context->offset.zb, m_r, false, false);

@@ -1953,7 +2005,7 @@ void GSRendererHW::Draw()
 			s = GetDrawDumpPath("%05d_f%lld_rz1_%05x_%s.bmp", s_n, frame, context->ZBUF.Block(), psm_str(context->ZBUF.PSM));

 			if (ds)
-				rt->m_texture->Save(s);
+				ds->m_texture->Save(s);
 		}

 		if (GSConfig.SaveL > 0 && (s_n - GSConfig.SaveN) > GSConfig.SaveL)
@@ -2239,7 +2291,7 @@ void GSRendererHW::EmulateTextureShuffleAndFbmask()
 		m_conf.ps.write_rg = !write_ba && features.texture_barrier && m_context->TEST.DATE;

 		m_conf.ps.read_ba = read_ba;
-
+		m_conf.ps.real16src = m_copy_16bit_to_target_shuffle;
 		// Please bang my head against the wall!
 		// 1/ Reduce the frame mask to a 16 bit format
 		const u32 m = m_context->FRAME.FBMSK & GSLocalMemory::m_psm[m_context->FRAME.PSM].fmsk;
@@ -3121,7 +3173,7 @@ __ri static constexpr bool IsRedundantClamp(u8 clamp, u32 clamp_min, u32 clamp_m
 	// That way trilinear etc still works.
 	const u32 textent = (1u << tsize) - 1u;
 	if (clamp == CLAMP_REGION_CLAMP)
-		return (clamp_min == 0 && clamp_max == textent);
+		return (clamp_min == 0 && clamp_max >= textent);
 	else if (clamp == CLAMP_REGION_REPEAT)
 		return (clamp_max == 0 && clamp_min == textent);
 	else
@@ -3152,10 +3204,10 @@ void GSRendererHW::EmulateTextureSampler(const GSTextureCache::Source* tex)
 	const u8 wms = EffectiveClamp(m_context->CLAMP.WMS, tex->m_region.HasX() || redundant_wms);
 	const u8 wmt = EffectiveClamp(m_context->CLAMP.WMT, tex->m_region.HasY() || redundant_wmt);
 	const bool complex_wms_wmt = !!((wms | wmt) & 2);
-	GL_CACHE("WMS: %s [%s%s] WMT: %s [%s%s] Complex: %d MINU: %d MINV: %d MINV: %d MAXV: %d",
+	GL_CACHE("WMS: %s [%s%s] WMT: %s [%s%s] Complex: %d MINU: %d MAXU: %d MINV: %d MAXV: %d",
 		clamp_modes[m_context->CLAMP.WMS], redundant_wms ? "redundant," : "", clamp_modes[wms],
 		clamp_modes[m_context->CLAMP.WMT], redundant_wmt ? "redundant," : "", clamp_modes[wmt],
-		complex_wms_wmt, m_context->CLAMP.MINU, m_context->CLAMP.MINV, m_context->CLAMP.MAXU, m_context->CLAMP.MAXV);
+		complex_wms_wmt, m_context->CLAMP.MINU, m_context->CLAMP.MAXU, m_context->CLAMP.MINV, m_context->CLAMP.MAXV);

 	const bool need_mipmap = IsMipMapDraw();
 	const bool shader_emulated_sampler = tex->m_palette || cpsm.fmt != 0 || complex_wms_wmt || psm.depth;
@@ -3384,8 +3436,8 @@ void GSRendererHW::EmulateTextureSampler(const GSTextureCache::Source* tex)
 	m_conf.cb_vs.texture_scale = GSVector2(tc_oh_ts.x, tc_oh_ts.y);

 	// Only enable clamping in CLAMP mode. REGION_CLAMP will be done manually in the shader
-	m_conf.sampler.tau = (wms != CLAMP_CLAMP);
-	m_conf.sampler.tav = (wmt != CLAMP_CLAMP);
+	m_conf.sampler.tau = (wms == CLAMP_REPEAT);
+	m_conf.sampler.tav = (wmt == CLAMP_REPEAT);
 	if (shader_emulated_sampler)
 	{
 		m_conf.sampler.biln = 0;
@@ -4025,8 +4077,8 @@ GSRendererHW::CLUTDrawTestResult GSRendererHW::PossibleCLUTDraw()
 		(PRIM->TME && ((m_regs->DISP[0].DISPFB.Block() == m_context->TEX0.TBP0) || (m_regs->DISP[1].DISPFB.Block() == m_context->TEX0.TBP0)) && !(m_mem.m_clut.IsInvalid() & 2)))
 		return CLUTDrawTestResult::NotCLUTDraw;

-	// Ignore recursive/shuffle effects, but possible it will recursively draw, but make sure it's staying in page width
-	if (PRIM->TME && m_context->TEX0.TBP0 == m_context->FRAME.Block() && (m_context->FRAME.FBW != 1 && m_context->TEX0.TBW == m_context->FRAME.FBW))
+	// Ignore large render targets, make sure it's staying in page width.
+	if (PRIM->TME && (m_context->FRAME.FBW != 1 && m_context->TEX0.TBW == m_context->FRAME.FBW))
 		return CLUTDrawTestResult::NotCLUTDraw;

 	// Hopefully no games draw a CLUT with a CLUT, that would be evil, most likely a channel shuffle.
--- a/pcsx2/GS/Renderers/HW/GSRendererHW.h
+++ b/pcsx2/GS/Renderers/HW/GSRendererHW.h
@@ -97,8 +97,8 @@ private:
 	void SetTCOffset();

 	GSTextureCache* m_tc;
-	GSVector4i m_r;
-	GSTextureCache::Source* m_src;
+	GSVector4i m_r = {};
+	GSTextureCache::Source* m_src = nullptr;

 	// CRC Hacks
 	bool IsBadFrame();
@@ -107,22 +107,27 @@ private:
 	int m_skip = 0;
 	int m_skip_offset = 0;

-	bool m_reset;
-	bool m_tex_is_fb;
-	bool m_channel_shuffle;
-	bool m_userhacks_tcoffset;
-	float m_userhacks_tcoffset_x;
-	float m_userhacks_tcoffset_y;
+	u32 m_last_channel_shuffle_fbmsk = 0;
+	bool m_channel_shuffle = false;

-	GSVector2i m_lod; // Min & Max level of detail
+	bool m_tex_is_fb = false;
+	bool m_userhacks_tcoffset = false;
+	float m_userhacks_tcoffset_x = 0.0f;
+	float m_userhacks_tcoffset_y = 0.0f;

-	GSHWDrawConfig m_conf;
+	GSVector2i m_lod = {}; // Min & Max level of detail
+
+	GSHWDrawConfig m_conf = {};

 	// software sprite renderer state
 	std::vector<GSVertexSW> m_sw_vertex_buffer;
 	std::unique_ptr<GSTextureCacheSW::Texture> m_sw_texture[7 + 1];
 	std::unique_ptr<GSVirtualAlignedClass<32>> m_sw_rasterizer;

+	// Tracking draw counters for idle frame detection.
+	int m_last_draw_n = 0;
+	int m_last_transfer_n = 0;
+
 public:
 	GSRendererHW();
 	virtual ~GSRendererHW() override;
@@ -161,6 +166,7 @@ public:
 	void Draw() override;

 	void PurgeTextureCache() override;
+	void ReadbackTextureCache() override;
 	GSTexture* LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, const GSVector2i& size) override;

 	// Called by the texture cache to know if current texture is useful
--- a/pcsx2/GS/Renderers/HW/GSTextureCache.cpp
+++ b/pcsx2/GS/Renderers/HW/GSTextureCache.cpp
@@ -43,21 +43,15 @@ GSTextureCache::~GSTextureCache()

 	RemoveAll();

-	m_surface_offset_cache.clear();
-
 	_aligned_free(s_unswizzle_buffer);
 }

-void GSTextureCache::RemovePartial()
+void GSTextureCache::ReadbackAll()
 {
-	//m_src.RemoveAll();
-
 	for (int type = 0; type < 2; type++)
 	{
 		for (auto t : m_dst[type])
-			delete t;
-
-		m_dst[type].clear();
+			Read(t, t->m_drawn_since_read);
 	}
 }

@@ -85,6 +79,8 @@ void GSTextureCache::RemoveAll()

 	m_source_memory_usage = 0;
 	m_target_memory_usage = 0;
+
+	m_surface_offset_cache.clear();
 }

 void GSTextureCache::AddDirtyRectTarget(Target* target, GSVector4i rect, u32 psm, u32 bw)
@@ -161,7 +157,7 @@ GSTextureCache::Source* GSTextureCache::LookupDepthSource(const GIFRegTEX0& TEX0
 		for (auto t : m_dst[RenderTarget])
 		{
 			// FIXME: do I need to allow m_age == 1 as a potential match (as DepthStencil) ???
-			if (!t->m_age && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
+			if (t->m_age <= 1 && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
 			{
 				ASSERT(GSLocalMemory::m_psm[t->m_TEX0.PSM].depth);
 				dst = t;
@@ -229,7 +225,7 @@ GSTextureCache::Source* GSTextureCache::LookupDepthSource(const GIFRegTEX0& TEX0

 __ri static GSTextureCache::Source* FindSourceInMap(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA,
 	const GSLocalMemory::psm_t& psm_s, const u32* clut, const GSTexture* gpu_clut, const GSVector2i& compare_lod,
-	const GSTextureCache::SourceRegion& region, FastList<GSTextureCache::Source*>& map)
+	const GSTextureCache::SourceRegion& region, u32 fixed_tex0, FastList<GSTextureCache::Source*>& map)
 {
 	for (auto i = map.begin(); i != map.end(); ++i)
 	{
@@ -261,7 +257,10 @@ __ri static GSTextureCache::Source* FindSourceInMap(const GIFRegTEX0& TEX0, cons
 					continue;
 			}

-			if (s->m_region.bits != 0 && s->m_region.bits != region.bits)
+			// When fixed tex0 is used, we must find a matching region texture. The base likely
+			// doesn't contain to the correct region. Bit cheeky here, avoid a logical or by
+			// adding the invalid tex0 bit in.
+			if (((s->m_region.bits | fixed_tex0) != 0) && s->m_region.bits != region.bits)
 				continue;

 			// Same base mip texture, but we need to check that MXL was the same as well.
@@ -292,7 +291,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 	{
 		// Another Lupin case here, it uses region clamp with UV (not ST), puts a clamp region further
 		// into the texture, but a smaller TW/TH. Catch this by looking for a clamp range above TW.
-		const u32 rw = CLAMP.MAXU - CLAMP.MAXU + 1;
+		const u32 rw = CLAMP.MAXU - CLAMP.MINU + 1;
 		if (rw < (1u << TEX0.TW) || CLAMP.MAXU >= (1u << TEX0.TW))
 		{
 			region.SetX(CLAMP.MINU, CLAMP.MAXU + 1);
@@ -305,7 +304,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 		// to offset the actual texture data to elsewhere. So, we'll just force any cases like this down
 		// the region texture path.
 		const u32 rw = ((CLAMP.MINU | CLAMP.MAXU) - CLAMP.MAXU) + 1;
-		if (rw < (1u << TEX0.TW) || CLAMP.MAXU != 0)
+		if (rw < (1u << TEX0.TW) || (CLAMP.MAXU != 0 && (rw <= (1u << TEX0.TW))))
 		{
 			region.SetX(CLAMP.MAXU, (CLAMP.MINU | CLAMP.MAXU) + 1);
 			GL_CACHE("TC: Region repeat optimization: %d width -> %d", 1 << TEX0.TW, region.GetWidth());
@@ -323,7 +322,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 	else if (CLAMP.WMT == CLAMP_REGION_REPEAT && CLAMP.MINV != 0)
 	{
 		const u32 rh = ((CLAMP.MINV | CLAMP.MAXV) - CLAMP.MAXV) + 1;
-		if (rh < (1u << TEX0.TH) || CLAMP.MAXV != 0)
+		if (rh < (1u << TEX0.TH) || (CLAMP.MAXV != 0 && (rh <= (1u << TEX0.TH))))
 		{
 			region.SetY(CLAMP.MAXV, (CLAMP.MINV | CLAMP.MAXV) + 1);
 			GL_CACHE("TC: Region repeat optimization: %d height -> %d", 1 << TEX0.TW, region.GetHeight());
@@ -335,15 +334,16 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con

 	// Region textures might be placed in a different page, so check that first.
 	const u32 lookup_page = TEX0.TBP0 >> 5;
+	const bool is_fixed_tex0 = region.IsFixedTEX0(1 << TEX0.TW, 1 << TEX0.TH);
 	if (region.GetMinX() != 0 || region.GetMinY() != 0)
 	{
 		const GSOffset offset(psm_s.info, TEX0.TBP0, TEX0.TBW, TEX0.PSM);
 		const u32 region_page = offset.bn(region.GetMinX(), region.GetMinY()) >> 5;
 		if (lookup_page != region_page)
-			src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, m_src.m_map[region_page]);
+			src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, is_fixed_tex0, m_src.m_map[region_page]);
 	}
 	if (!src)
-		src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, m_src.m_map[lookup_page]);
+		src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, is_fixed_tex0, m_src.m_map[lookup_page]);


 	Target* dst = nullptr;
@@ -399,11 +399,18 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 						// 2/ even with upscaling
 						// 3/ for both Direct3D and OpenGL
 						if (GSConfig.UserHacks_CPUFBConversion && (psm == PSM_PSMT4 || psm == PSM_PSMT8))
+						{
 							// Forces 4-bit and 8-bit frame buffer conversion to be done on the CPU instead of the GPU, but performance will be slower.
 							// There is no dedicated shader to handle 4-bit conversion (Stuntman has been confirmed to use 4-bit).
 							// Direct3D10/11 and OpenGL support 8-bit fb conversion but don't render some corner cases properly (Harry Potter games).
 							// The hack can fix glitches in some games.
-							Read(t, t->m_valid);
+							if (!t->m_drawn_since_read.rempty())
+							{
+								Read(t, t->m_drawn_since_read);
+
+								t->m_drawn_since_read = GSVector4i::zero();
+							}
+						}
 						else
 							dst = t;

@@ -429,7 +436,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 				}
 				// Make sure the texture actually is INSIDE the RT, it's possibly not valid if it isn't.
 				// Also check BP >= TBP, create source isn't equpped to expand it backwards and all data comes from the target. (GH3)
-				else if (GSConfig.UserHacks_TextureInsideRt && psm == PSM_PSMCT32 && t->m_TEX0.PSM == psm &&
+				else if (GSConfig.UserHacks_TextureInsideRt && psm >= PSM_PSMCT32 && psm <= PSM_PSMCT16S && t->m_TEX0.PSM == psm &&
 						(t->Overlaps(bp, bw, psm, r) || t_wraps) && t->m_age <= 1 && !found_t && bp >= t->m_TEX0.TBP0)
 				{
 					// Only PSMCT32 to limit false hits.
@@ -517,7 +524,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 			// 1/ Check only current frame, I guess it is only used as a postprocessing effect
 			for (auto t : m_dst[DepthStencil])
 			{
-				if (!t->m_age && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
+				if (t->m_age <= 1 && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
 				{
 					GL_INS("TC: Warning depth format read as color format. Pixels will be scrambled");
 					// Let's fetch a depth format texture. Rational, it will avoid the texture allocation and the
@@ -579,6 +586,19 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, con
 	return src;
 }

+GSTextureCache::Target* GSTextureCache::FindTargetOverlap(u32 bp, u32 end_block, int type, int psm)
+{
+	u32 end_block_bp = end_block < bp ? (MAX_BP + 1) : end_block;
+
+	for (auto t : m_dst[type])
+	{
+		// Only checks that the texure starts at the requested bp, which shares data. Size isn't considered.
+		if (t->m_TEX0.TBP0 >= bp && t->m_TEX0.TBP0 < end_block_bp && GSUtil::HasSharedBits(t->m_TEX0.PSM, psm))
+			return t;
+	}
+	return nullptr;
+}
+
 GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, const GSVector2i& size, int type, bool used, u32 fbmask, const bool is_frame, const int real_w, const int real_h, bool preload)
 {
 	const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[TEX0.PSM];
@@ -620,7 +640,18 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 				dst = t;

 				dst->m_32_bits_fmt |= (psm_s.bpp != 16);
-				dst->m_TEX0 = TEX0;
+				// Nicktoons Unite tries to change the width from 10 to 8 and breaks FMVs.
+				// Haunting ground has some messed textures if you don't modify the rest.
+				if (!dst->m_is_frame)
+				{
+					dst->m_TEX0 = TEX0;
+				}
+				else
+				{
+					u32 width = dst->m_TEX0.TBW;
+					dst->m_TEX0 = TEX0;
+					dst->m_TEX0.TBW = width;
+				}

 				break;
 			}
@@ -697,7 +728,10 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 		}

 		if (dst)
+		{
 			dst->m_TEX0.TBW = TEX0.TBW; // Fix Jurassic Park - Operation Genesis loading disk logo.
+			dst->m_is_frame |= is_frame; // Nicktoons Unite tries to change the width from 10 to 8 and breaks FMVs.
+		}
 	}

 	if (dst)
@@ -775,7 +809,6 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 		GL_CACHE("TC: Lookup %s(%s) %dx%d, miss (0x%x, %s)", is_frame ? "Frame" : "Target", to_string(type), size.x, size.y, bp, psm_str(TEX0.PSM));

 		dst = CreateTarget(TEX0, size.x, size.y, type, true);
-
 		// In theory new textures contain invalidated data. Still in theory a new target
 		// must contains the content of the GS memory.
 		// In practice, TC will wrongly invalidate some RT. For example due to write on the alpha
@@ -788,18 +821,22 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 		// From a performance point of view, it might cost a little on big upscaling
 		// but normally few RT are miss so it must remain reasonable.
 		const bool supported_fmt = !GSConfig.UserHacks_DisableDepthSupport || psm_s.depth == 0;
-		const bool forced_preload = static_cast<GSRendererHW*>(g_gs_renderer.get())->m_force_preload;
-		if ((is_frame || preload || forced_preload) && TEX0.TBW > 0 && supported_fmt)
+
+		if (TEX0.TBW > 0 && supported_fmt)
 		{
-			if (!is_frame && !forced_preload)
+			const bool forced_preload = GSRendererHW::GetInstance()->m_force_preload > 0;
+			const GSVector4i newrect = GSVector4i(0, 0, real_w, real_h);
+
+			if (!is_frame && !forced_preload && !preload)
 			{
 				std::vector<GSState::GSUploadQueue>::iterator iter;
-				for (iter = static_cast<GSRendererHW*>(g_gs_renderer.get())->m_draw_transfers.begin(); iter != static_cast<GSRendererHW*>(g_gs_renderer.get())->m_draw_transfers.end(); ) {
-					if (iter->blit.DBP == TEX0.TBP0 && GSUtil::HasSharedBits(iter->blit.DPSM, TEX0.PSM))
+				for (iter = GSRendererHW::GetInstance()->m_draw_transfers.begin(); iter != GSRendererHW::GetInstance()->m_draw_transfers.end(); )
+				{
+					// If the format, and location doesn't match, but also the upload is at least the size of the target, don't preload.
+					if (iter->blit.DBP == TEX0.TBP0 && GSUtil::HasCompatibleBits(iter->blit.DPSM, TEX0.PSM) && iter->rect.rintersect(newrect).eq(newrect))
 					{
-						iter = static_cast<GSRendererHW*>(g_gs_renderer.get())->m_draw_transfers.erase(iter);
+						GSRendererHW::GetInstance()->m_draw_transfers.erase(iter);
 						GL_INS("Preloading the RT DATA");
-						const GSVector4i newrect = GSVector4i(0, 0, real_w, real_h);
 						AddDirtyRectTarget(dst, newrect, TEX0.PSM, TEX0.TBW);
 						dst->Update(true);
 						break;
@@ -810,7 +847,6 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 			else
 			{
 				GL_INS("Preloading the RT DATA");
-				const GSVector4i newrect = GSVector4i(0, 0, real_w, real_h);
 				AddDirtyRectTarget(dst, newrect, TEX0.PSM, TEX0.TBW);
 				dst->Update(true);
 			}
@@ -823,7 +859,8 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(const GIFRegTEX0& TEX0, con
 	}
 	if (is_frame)
 		dst->m_dirty_alpha = false;
-	
+
+	dst->readbacks_since_draw = 0;

 	assert(dst && dst->m_texture && dst->m_texture->GetScale() == new_s);
 	assert(dst && dst->m_dirty.empty());
@@ -973,6 +1010,7 @@ void GSTextureCache::ExpandTarget(const GIFRegBITBLTBUF& BITBLTBUF, const GSVect
 				AddDirtyRectTarget(dst, r, TEX0.PSM, TEX0.TBW);
 				GetTargetHeight(TEX0.TBP0, TEX0.TBW, TEX0.PSM, aligned_height);
 				dst->UpdateValidity(r);
+				dst->UpdateValidBits(GSLocalMemory::m_psm[TEX0.PSM].fmsk);
 			}
 		}
 	}
@@ -983,6 +1021,7 @@ void GSTextureCache::ExpandTarget(const GIFRegBITBLTBUF& BITBLTBUF, const GSVect
 				static_cast<int>(dst->m_texture->GetHeight() / dst->m_texture->GetScale().y))));
 		AddDirtyRectTarget(dst, clamped_r, TEX0.PSM, TEX0.TBW);
 		dst->UpdateValidity(clamped_r);
+		dst->UpdateValidBits(GSLocalMemory::m_psm[TEX0.PSM].fmsk);
 	}
 }
 // Goal: Depth And Target at the same address is not possible. On GS it is
@@ -1160,6 +1199,10 @@ void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& r
 	if (!target)
 		return;

+	// Handle the case where the transfer wrapped around the end of GS memory.
+	const u32 end_bp = off.bn(rect.z - 1, rect.w - 1);
+	const u32 unwrapped_end_bp = end_bp + ((end_bp < bp) ? MAX_BLOCKS : 0);
+
 	for (int type = 0; type < 2; type++)
 	{
 		auto& list = m_dst[type];
@@ -1168,6 +1211,13 @@ void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& r
 			auto j = i;
 			Target* t = *j;

+			// Don't bother checking any further if the target doesn't overlap with the write/invalidation.
+			if ((bp < t->m_TEX0.TBP0 && unwrapped_end_bp < t->m_TEX0.TBP0) || bp > t->UnwrappedEndBlock())
+			{
+				++i;
+				continue;
+			}
+
 			// GH: (I think) this code is completely broken. Typical issue:
 			// EE write an alpha channel into 32 bits texture
 			// Results: the target is deleted (because HasCompatibleBits is false)
@@ -1313,8 +1363,6 @@ void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& r
 							GL_CACHE("TC: Dirty After Target(%s) %d (0x%x)", to_string(type),
 								t->m_texture ? t->m_texture->GetID() : 0,
 								t->m_TEX0.TBP0);
-							// TODO: do not add this rect above too
-							t->m_TEX0.TBW = bw;

 							if (eewrite)
 								t->m_age = 0;
@@ -1350,8 +1398,6 @@ void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& r
 						if (eewrite)
 							t->m_age = 0;

-						t->m_TEX0.TBW = bw;
-
 						const GSVector4i dirty_r = GSVector4i(r.left, r.top + y, r.right, r.bottom + y);
 						AddDirtyRectTarget(t, dirty_r, psm, bw);
 						continue;
@@ -1359,13 +1405,23 @@ void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& r
 				}
 				else if (GSConfig.UserHacks_TextureInsideRt && t->Overlaps(bp, bw, psm, rect) && GSUtil::HasCompatibleBits(psm, t->m_TEX0.PSM))
 				{
-					const SurfaceOffset so = ComputeSurfaceOffset(off, r, t);
+					SurfaceOffsetKey sok;
+					sok.elems[0].bp = bp;
+					sok.elems[0].bw = bw;
+					sok.elems[0].psm = psm;
+					sok.elems[0].rect = r;
+					sok.elems[1].bp = t->m_TEX0.TBP0;
+					sok.elems[1].bw = t->m_TEX0.TBW;
+					sok.elems[1].psm = t->m_TEX0.PSM;
+					sok.elems[1].rect = t->m_valid;
+
+					const SurfaceOffset so = ComputeSurfaceOffset(sok);
 					if (so.is_valid)
 					{
 						if (eewrite)
 							t->m_age = 0;

-						AddDirtyRectTarget(t, so.b2a_offset, psm, bw);
+						AddDirtyRectTarget(t, so.b2a_offset, t->m_TEX0.PSM, t->m_TEX0.TBW);
 					}
 				}
 #endif
@@ -1407,11 +1463,20 @@ void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r
 			for (auto it = dss.rbegin(); it != dss.rend(); ++it) // Iterate targets from LRU to MRU.
 			{
 				Target* t = *it;
-				if (GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
-				{
-					if (GSUtil::HasCompatibleBits(psm, t->m_TEX0.PSM))
-						Read(t, r.rintersect(t->m_valid));
-				}
+
+				if (!t->Overlaps(bp, bw, psm, r) || !GSUtil::HasSharedBits(psm, t->m_TEX0.PSM) || t->m_age >= 30)
+					continue;
+
+				const bool bpp_match = GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == GSLocalMemory::m_psm[psm].bpp;
+				const bool format_match = (bp == t->m_TEX0.TBP0 && bw == t->m_TEX0.TBW && bpp_match);
+				// Calculate the rect offset if the BP doesn't match.
+				const GSVector4i targetr = (format_match) ? r.rintersect(t->m_valid) : ComputeSurfaceOffset(bp, bw, psm, r, t).b2a_offset;
+				const GSVector4i draw_rect = (t->readbacks_since_draw > 0) ? t->m_drawn_since_read : targetr.rintersect(t->m_drawn_since_read);
+				Read(t, draw_rect);
+
+				t->readbacks_since_draw++;
+				if(draw_rect.rintersect(t->m_drawn_since_read).eq(t->m_drawn_since_read))
+					t->m_drawn_since_read = GSVector4i::zero();
 			}
 		}
 		return;
@@ -1427,17 +1492,22 @@ void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r
 		Target* t = *it;
 		if (t->m_TEX0.PSM != PSM_PSMZ32 && t->m_TEX0.PSM != PSM_PSMZ24 && t->m_TEX0.PSM != PSM_PSMZ16 && t->m_TEX0.PSM != PSM_PSMZ16S)
 		{
+			if (!t->Overlaps(bp, bw, psm, r) || !GSUtil::HasSharedBits(psm, t->m_TEX0.PSM) || t->m_age >= 30)
+				continue;
+
+			const bool bpp_match = GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == GSLocalMemory::m_psm[psm].bpp;
+			const bool format_match = (bp == t->m_TEX0.TBP0 && bw == t->m_TEX0.TBW && bpp_match);
+			// Calculate the rect offset if the BP doesn't match.
+			const GSVector4i targetr = (format_match) ? r.rintersect(t->m_valid) : ComputeSurfaceOffset(bp, bw, psm, r, t).b2a_offset;
+
 			// Some games like to offset their GS download memory addresses by
 			// using overly big source Y position values.
 			// Checking for targets that overlap with the requested memory region
 			// instead of just comparing TBPs should fix that.
 			// For example, this fixes Judgement ring rendering in Shadow Hearts 2.
 			// Be wary of old targets being misdetected, set a sensible range of 30 frames (like Display source lookups).
-			if (t->Overlaps(bp, bw, psm, r) && t->m_TEX0.TBP0 >= bp && GSUtil::HasSharedBits(psm, t->m_TEX0.PSM) && t->m_age <= 30)
+			if (!targetr.rempty())
 			{
-				// Enforce full invalidation if BP's don't match.
-				const GSVector4i targetr = (bp == t->m_TEX0.TBP0) ? r : t->m_valid;
-
 				// GH Note: Read will do a StretchRect and then will sizzle data to the GS memory
 				// t->m_valid will do the full target texture whereas r.intersect(t->m_valid) will be limited
 				// to the useful part for the transfer.
@@ -1448,6 +1518,12 @@ void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r

 				// note: r.rintersect breaks Wizardry and Chaos Legion
 				// Read(t, t->m_valid) works in all tested games but is very slow in GUST titles ><
+				// Update: 18/02/2023: Chaos legion breaks because it reads the width at half of the real width.
+				// Surface offset deals with this.
+
+				// If the game has been spamming downloads, we've already read the whole texture back at this point.
+				if (t->m_drawn_since_read.rempty())
+					continue;

 				// propagate the format from the result of a channel effect
 				// texture is 16/8 bit but the real data is 32
@@ -1464,16 +1540,49 @@ void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r
 					const GSVector4i rb_rc((!GSConfig.UserHacks_DisablePartialInvalidation && targetr.x == 0 && targetr.y == 0) ? t->m_valid : targetr.rintersect(t->m_valid));
 					DevCon.Error("Skipping depth readback of %ux%u @ %u,%u", rb_rc.width(), rb_rc.height(), rb_rc.left, rb_rc.top);
 				}
-				else if (GSConfig.UserHacks_DisablePartialInvalidation)
-				{
-					Read(t, targetr.rintersect(t->m_valid));
-				}
 				else
 				{
-					if (targetr.x == 0 && targetr.y == 0) // Full screen read?
-						Read(t, t->m_valid);
-					else // Block level read?
-						Read(t, targetr.rintersect(t->m_valid));
+					// If it's a download to the EE, or we've done multiple reads of the same texture between draws, just get it all.
+					if (!GSConfig.UserHacks_DisablePartialInvalidation && t->readbacks_since_draw > 0)
+					{
+						Read(t, t->m_drawn_since_read);
+						t->m_drawn_since_read = GSVector4i::zero();
+						t->readbacks_since_draw++;
+					}
+					else if(!targetr.rintersect(t->m_drawn_since_read).rempty()) // Block level read?
+					{
+						// Read the width of the draw, reading too much could wipe out dirty memory.
+						GSVector4i full_lines = GSVector4i(0, targetr.y, t->m_drawn_since_read.z, targetr.w);
+						full_lines = targetr.rintersect(t->m_drawn_since_read);
+						
+						Read(t, full_lines);
+
+						// After reading, try to cut down our "dirty" rect.
+						if (full_lines.rintersect(t->m_drawn_since_read).eq(t->m_drawn_since_read))
+							t->m_drawn_since_read = GSVector4i::zero();
+						else
+						{
+							// Try to cut down how much we read next, if we can.
+							// Fatal Frame reads in vertical strips, SOCOM 2 does horizontal, so we can handle that below.
+							if (full_lines.width() == t->m_drawn_since_read.width()
+								&& full_lines.w >= t->m_drawn_since_read.y)
+							{
+								if (full_lines.y <= t->m_drawn_since_read.y)
+									t->m_drawn_since_read.y = full_lines.w;
+								else if (full_lines.w >= t->m_drawn_since_read.w)
+									t->m_drawn_since_read.w = full_lines.y;
+							}
+							else if (full_lines.height() == t->m_drawn_since_read.height()
+									&& full_lines.z >= t->m_drawn_since_read.x)
+							{
+								if (full_lines.x <= t->m_drawn_since_read.x)
+									t->m_drawn_since_read.x = full_lines.z;
+								else if (full_lines.z >= t->m_drawn_since_read.z)
+									t->m_drawn_since_read.z = full_lines.x;
+							}
+						}
+						t->readbacks_since_draw++;
+					}
 				}
 			}
 		}
@@ -1579,6 +1688,28 @@ bool GSTextureCache::Move(u32 SBP, u32 SBW, u32 SPSM, int sx, int sy, u32 DBP, u
 	// Look for an exact match on the targets.
 	GSTextureCache::Target* src = GetExactTarget(SBP, SBW, SPSM);
 	GSTextureCache::Target* dst = GetExactTarget(DBP, DBW, DPSM);
+
+	// Beware of the case where a game might create a larger texture by moving a bunch of chunks around.
+	// We use dx/dy == 0 and the TBW check as a safeguard to make sure these go through to local memory.
+	// Good test case for this is the Xenosaga I cutscene transitions, or Gradius V.
+	if (src && !dst && dx == 0 && dy == 0 && ((static_cast<u32>(w) + 63) / 64) == DBW)
+	{
+		GIFRegTEX0 new_TEX0 = {};
+		new_TEX0.TBP0 = DBP;
+		new_TEX0.TBW = DBW;
+		new_TEX0.PSM = DPSM;
+
+		const int real_height = GetTargetHeight(DBP, DBW, DPSM, h);
+		const GSVector2 scale(src->m_texture->GetScale());
+		dst = LookupTarget(new_TEX0, GSVector2i(static_cast<int>(w * scale.x), static_cast<int>(real_height * scale.y)), src->m_type, true);
+		if (dst)
+		{
+			dst->m_texture->SetScale(scale);
+			dst->UpdateValidity(GSVector4i(dx, dy, dx + w, dy + h));
+			dst->m_valid_bits = src->m_valid_bits;
+		}
+	}
+
 	if (!src || !dst || src->m_texture->GetScale() != dst->m_texture->GetScale())
 		return false;

@@ -2603,6 +2734,16 @@ void GSTextureCache::Read(Target* t, const GSVector4i& r)
 			return;
 	}

+	// Don't overwrite bits which aren't used in the target's format.
+	// Stops Burnout 3's sky from breaking when flushing targets to local memory.
+	const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
+	const u32 write_mask = t->m_valid_bits & psm.fmsk;
+	if (psm.bpp > 16 && write_mask == 0)
+	{
+		Console.Warning("Not reading back target %x PSM %s due to no write mask", TEX0.TBP0, psm_str(TEX0.PSM));
+		return;
+	}
+
 	// Yes lots of logging, but I'm not confident with this code
 	GL_PUSH("Texture Cache Read. Format(0x%x)", TEX0.PSM);

@@ -2648,11 +2789,9 @@ void GSTextureCache::Read(Target* t, const GSVector4i& r)
 	{
 		case PSM_PSMCT32:
 		case PSM_PSMZ32:
-			g_gs_renderer->m_mem.WritePixel32(bits, pitch, off, r);
-			break;
 		case PSM_PSMCT24:
 		case PSM_PSMZ24:
-			g_gs_renderer->m_mem.WritePixel24(bits, pitch, off, r);
+			g_gs_renderer->m_mem.WritePixel32(bits, pitch, off, r, write_mask);
 			break;
 		case PSM_PSMCT16:
 		case PSM_PSMCT16S:
@@ -3067,63 +3206,67 @@ void GSTextureCache::Target::Update(bool reset_age)
 	{
 		// do the most likely thing a direct write would do, clear it
 		GL_INS("ERROR: Update DepthStencil dummy");
-		m_dirty.ClearDirty();
+		m_dirty.clear();
 		return;
 	}
-	else if (m_type == DepthStencil && g_gs_renderer->m_game.title == CRC::FFX2)
+
+	const GSVector2i unscaled_size(static_cast<int>(m_texture->GetWidth() / m_texture->GetScale().x),
+		static_cast<int>(m_texture->GetHeight() / m_texture->GetScale().y));
+	const GSVector4i total_rect(m_dirty.GetTotalRect(m_TEX0, unscaled_size));
+	if (total_rect.rempty())
 	{
-		GL_INS("ERROR: bad invalidation detected, depth buffer will be cleared");
-		// FFX2 menu. Invalidation of the depth is wrongly done and only the first
-		// page is invalidated. Technically a CRC hack will be better but I don't expect
-		// any games to only upload a single page of data for the depth.
-		//
-		// FFX2 menu got another bug. I'm not sure the top-left is properly written or not. It
-		// could be a gs transfer bug too due to unaligned-page transfer.
-		//
-		// So the quick and dirty solution is just to clean the depth buffer.
-		g_gs_device->ClearDepth(m_texture);
-		m_dirty.ClearDirty();
+		GL_INS("ERROR: Nothing to update?");
+		m_dirty.clear();
 		return;
 	}

+	const GSVector4i t_offset(total_rect.xyxy());
+	const GSVector4i t_size(total_rect - t_offset);
+	const GSVector4 t_sizef(t_size.zwzw());
+
+	// This'll leave undefined data in pixels that we're not reading from... shouldn't hurt anything.
+	GSTexture* const t = g_gs_device->CreateTexture(t_size.z, t_size.w, 1, GSTexture::Format::Color);
+	GSTexture::GSMap m;
+	const bool mapped = t->Map(m);
+
 	GIFRegTEXA TEXA = {};
-
 	TEXA.AEM = 1;
 	TEXA.TA0 = 0;
 	TEXA.TA1 = 0x80;

-	const GSOffset off = g_gs_renderer->m_mem.GetOffset(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM);
-
-	GSTexture::GSMap m;
-
-	const GSVector4i unscaled_size = GSVector4i(GSVector4(m_texture->GetSize()) / GSVector4(m_texture->GetScale()));
-	const GSVector4i rect_size = m_dirty.GetTotalRect(m_TEX0, GSVector2i(unscaled_size.x, unscaled_size.y));
-
-	GSTexture* t = g_gs_device->CreateTexture(rect_size.z, rect_size.w, 1, GSTexture::Format::Color);
-
-	while (m_dirty.size() > 0)
+	const GSOffset off(g_gs_renderer->m_mem.GetOffset(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM));
+	for (size_t i = 0; i < m_dirty.size(); i++)
 	{
-		const GSVector4i r = m_dirty.GetDirtyRectAndClear(m_TEX0, GSVector2i(unscaled_size.x, unscaled_size.y));
-
+		const GSVector4i r(m_dirty.GetDirtyRect(i, m_TEX0, total_rect));
 		if (r.rempty())
 			continue;

-		if (t->Map(m))
+		const GSVector4i t_r(r - t_offset);
+		if (mapped)
 		{
-			g_gs_renderer->m_mem.ReadTexture(off, r, m.bits, m.pitch, TEXA);
-
-			t->Unmap();
+			g_gs_renderer->m_mem.ReadTexture(
+				off, r, m.bits + t_r.y * static_cast<u32>(m.pitch) + (t_r.x * sizeof(u32)), m.pitch, TEXA);
 		}
 		else
 		{
-			int pitch = ((r.width()+3) & ~3) * 4;
+			const int pitch = Common::AlignUpPow2(r.width() * sizeof(u32), 32);
 			g_gs_renderer->m_mem.ReadTexture(off, r, s_unswizzle_buffer, pitch, TEXA);

-			t->Update(r, s_unswizzle_buffer, pitch);
+			t->Update(t_r, s_unswizzle_buffer, pitch);
 		}
+	}

-		const GSVector4 sRect = GSVector4(0.0f, 0.0f, static_cast<float>(r.width()) / rect_size.z, static_cast<float>(r.height()) / rect_size.w);
-		const GSVector4 dest_rect = (GSVector4(r) * GSVector4(m_texture->GetScale()).xyxy());
+	if (mapped)
+		t->Unmap();
+
+	for (size_t i = 0; i < m_dirty.size(); i++)
+	{
+		const GSVector4i r(m_dirty.GetDirtyRect(i, m_TEX0, total_rect));
+		if (r.rempty())
+			continue;
+
+		const GSVector4 sRect(GSVector4(r - t_offset) / t_sizef);
+		const GSVector4 dRect(GSVector4(r) * GSVector4(m_texture->GetScale()).xyxy());

 		// Copy the new GS memory content into the destination texture.
 		if (m_type == RenderTarget)
@@ -3131,21 +3274,21 @@ void GSTextureCache::Target::Update(bool reset_age)
 			GL_INS("ERROR: Update RenderTarget 0x%x bw:%d (%d,%d => %d,%d)", m_TEX0.TBP0, m_TEX0.TBW, r.x, r.y, r.z, r.w);

 			// Bilinear filtering this is probably not a good thing, at least in native, but upscaling Nearest can be gross and messy.
-			g_gs_device->StretchRect(t, sRect, m_texture, dest_rect,ShaderConvert::COPY, g_gs_renderer->CanUpscale());
+			g_gs_device->StretchRect(t, sRect, m_texture, dRect, ShaderConvert::COPY, g_gs_renderer->CanUpscale());
 		}
 		else if (m_type == DepthStencil)
 		{
 			GL_INS("ERROR: Update DepthStencil 0x%x", m_TEX0.TBP0);

 			// FIXME linear or not?
-			const GSVector4 sRect = GSVector4(0.0f, 0.0f, static_cast<float>(r.width()) / rect_size.z, static_cast<float>(r.height()) / rect_size.w);
-			g_gs_device->StretchRect(t, sRect, m_texture, dest_rect, ShaderConvert::RGBA8_TO_FLOAT32_BILN);
+			g_gs_device->StretchRect(t, sRect, m_texture, dRect, ShaderConvert::RGBA8_TO_FLOAT32_BILN);
 		}
 	}
-	// m_renderer->m_perfmon.Put(GSPerfMon::Unswizzle, w * h * 4);
-	g_gs_device->Recycle(t);

-	UpdateValidity(rect_size);
+	UpdateValidity(total_rect);
+
+	g_gs_device->Recycle(t);
+	m_dirty.clear();
 }

 void GSTextureCache::Target::UpdateIfDirtyIntersects(const GSVector4i& rc)
@@ -3165,13 +3308,18 @@ void GSTextureCache::Target::UpdateIfDirtyIntersects(const GSVector4i& rc)
 	}
 }

-void GSTextureCache::Target::UpdateValidity(const GSVector4i& rect)
+void GSTextureCache::Target::ResizeValidity(const GSVector4i& rect)
 {
-	if (m_valid.eq(GSVector4i::zero()))
-		m_valid = rect;
+	if (!m_valid.eq(GSVector4i::zero()))
+	{
+		m_valid = m_valid.rintersect(rect);
+		m_drawn_since_read = m_drawn_since_read.rintersect(rect);
+	}
 	else
-		m_valid = m_valid.runion(rect);
-
+	{
+		m_valid = rect;
+		m_drawn_since_read = rect;
+	}
 	// Block of the bottom right texel of the validity rectangle, last valid block of the texture
 	// TODO: This is not correct when the PSM changes. e.g. a 512x448 target being shuffled will become 512x896 temporarily, and
 	// at the moment, we blow the valid rect out to twice the size. The only thing stopping everything breaking is the fact
@@ -3181,6 +3329,40 @@ void GSTextureCache::Target::UpdateValidity(const GSVector4i& rect)
 	// GL_CACHE("UpdateValidity (0x%x->0x%x) from R:%d,%d Valid: %d,%d", m_TEX0.TBP0, m_end_block, rect.z, rect.w, m_valid.z, m_valid.w);
 }

+void GSTextureCache::Target::UpdateValidity(const GSVector4i& rect, bool can_resize)
+{
+	if (m_valid.runion(rect).eq(m_valid))
+	{
+		m_drawn_since_read = m_drawn_since_read.runion(rect);
+		return;
+	}
+
+	if (can_resize)
+	{
+		if (m_valid.eq(GSVector4i::zero()))
+			m_valid = rect;
+		else
+			m_valid = m_valid.runion(rect);
+	}
+
+	if (m_drawn_since_read.eq(GSVector4i::zero()) || !can_resize)
+	{
+		m_drawn_since_read = rect.rintersect(m_valid);
+	}
+	else
+		m_drawn_since_read = m_drawn_since_read.runion(rect);
+	// Block of the bottom right texel of the validity rectangle, last valid block of the texture
+	// TODO: This is not correct when the PSM changes. e.g. a 512x448 target being shuffled will become 512x896 temporarily, and
+	// at the moment, we blow the valid rect out to twice the size. The only thing stopping everything breaking is the fact
+	// that we clamp the draw rect to the target size in GSRendererHW::Draw().
+	m_end_block = GSLocalMemory::m_psm[m_TEX0.PSM].info.bn(m_valid.z - 1, m_valid.w - 1, m_TEX0.TBP0, m_TEX0.TBW); // Valid only for color formats
+	// GL_CACHE("UpdateValidity (0x%x->0x%x) from R:%d,%d Valid: %d,%d", m_TEX0.TBP0, m_end_block, rect.z, rect.w, m_valid.z, m_valid.w);
+}
+
+void GSTextureCache::Target::UpdateValidBits(u32 bits_written)
+{
+	m_valid_bits |= bits_written;
+}

 bool GSTextureCache::Target::ResizeTexture(int new_width, int new_height, bool recycle_old)
 {
@@ -3197,6 +3379,7 @@ bool GSTextureCache::Target::ResizeTexture(int new_width, int new_height, GSVect
 	// These exceptions *really* need to get lost. This gets called outside of draws, which just crashes
 	// when it tries to propogate the exception back.
 	const bool clear = (new_width > width || new_height > height);
+
 	GSTexture* tex = nullptr;
 	try
 	{
@@ -3238,6 +3421,7 @@ bool GSTextureCache::Target::ResizeTexture(int new_width, int new_height, GSVect
 		delete m_texture;

 	m_texture = tex;
+
 	return true;
 }

--- a/pcsx2/GS/Renderers/HW/GSTextureCache.h
+++ b/pcsx2/GS/Renderers/HW/GSTextureCache.h
@@ -234,19 +234,31 @@ public:
 	class Target : public Surface
 	{
 	public:
-		const int m_type;
-		bool m_used;
+		const int m_type = 0;
+		const bool m_depth_supported = false;
+		bool m_dirty_alpha = true;
+		bool m_is_frame = false;
+		bool m_used = false;
 		GSDirtyRectList m_dirty;
-		GSVector4i m_valid;
-		const bool m_depth_supported;
-		bool m_dirty_alpha;
-		bool m_is_frame;
+		GSVector4i m_valid{};
+		GSVector4i m_drawn_since_read{};
+		u32 m_valid_bits = 0;
+		int readbacks_since_draw = 0;

 	public:
 		Target(const GIFRegTEX0& TEX0, const bool depth_supported, const int type);
 		~Target();

-		void UpdateValidity(const GSVector4i& rect);
+		/// Returns true if the target wraps around the end of GS memory.
+		bool Wraps() const { return (m_end_block < m_TEX0.TBP0); }
+
+		/// Returns the end block for the target, but doesn't wrap at 0x3FFF.
+		/// Can be used for overlap tests.
+		u32 UnwrappedEndBlock() const { return (m_end_block + (Wraps() ? MAX_BLOCKS : 0)); }
+
+		void ResizeValidity(const GSVector4i& rect);
+		void UpdateValidity(const GSVector4i& rect, bool can_resize = true);
+		void UpdateValidBits(u32 bits_written);

 		void Update(bool reset_age);

@@ -303,10 +315,10 @@ public:

 			struct
 			{
-				u32 fbp : 9;
+				u32 fbp : 14;
 				u32 fbw : 6;
 				u32 psm : 6;
-				u32 pad : 11;
+				u32 pad : 6;
 			};
 		};

@@ -395,7 +407,7 @@ public:
 	void Read(Target* t, const GSVector4i& r);
 	void Read(Source* t, const GSVector4i& r);
 	void RemoveAll();
-	void RemovePartial();
+	void ReadbackAll();
 	void AddDirtyRectTarget(Target* target, GSVector4i rect, u32 psm, u32 bw);

 	GSTexture* LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, const GSVector2i& size);
@@ -403,6 +415,7 @@ public:
 	Source* LookupSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GIFRegCLAMP& CLAMP, const GSVector4i& r, const GSVector2i* lod);
 	Source* LookupDepthSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GIFRegCLAMP& CLAMP, const GSVector4i& r, bool palette = false);

+	Target* FindTargetOverlap(u32 bp, u32 end_block, int type, int psm);
 	Target* LookupTarget(const GIFRegTEX0& TEX0, const GSVector2i& size, int type, bool used, u32 fbmask = 0, const bool is_frame = false, const int real_w = 0, const int real_h = 0, bool preload = GSConfig.PreloadFrameWithGSData);
 	Target* LookupDisplayTarget(const GIFRegTEX0& TEX0, const GSVector2i& size, const int real_w, const int real_h);

--- a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h
+++ b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h
@@ -351,7 +351,7 @@ public:

 	GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) override;

-	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c) override;
+	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) override;
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset, int bufIdx) override;
 	void DoFXAA(GSTexture* sTex, GSTexture* dTex) override;
 	void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) override;
--- a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm
+++ b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm
@@ -542,7 +542,7 @@ GSTexture* GSDeviceMTL::CreateSurface(GSTexture::Type type, int width, int heigh
 	}
 }}

-void GSDeviceMTL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
+void GSDeviceMTL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear)
 { @autoreleasepool {
 	id<MTLCommandBuffer> cmdbuf = GetRenderCmdBuf();
 	GSScopedDebugGroupMTL dbg(cmdbuf, @"DoMerge");
@@ -563,12 +563,12 @@ void GSDeviceMTL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	{
 		// 2nd output is enabled and selected. Copy it to destination so we can blend it with 1st output
 		// Note: value outside of dRect must contains the background color (c)
-		StretchRect(sTex[1], sRect[1], dTex, dRect[1], ShaderConvert::COPY);
+		StretchRect(sTex[1], sRect[1], dTex, dRect[1], ShaderConvert::COPY, linear);
 	}

 	// Save 2nd output
 	if (feedback_write_2) // FIXME I'm not sure dRect[1] is always correct
-		DoStretchRect(dTex, full_r, sTex[2], dRect[1], m_convert_pipeline[static_cast<int>(ShaderConvert::YUV)], true, LoadAction::DontCareIfFull, &cb_yuv, sizeof(cb_yuv));
+		DoStretchRect(dTex, full_r, sTex[2], dRect[1], m_convert_pipeline[static_cast<int>(ShaderConvert::YUV)], linear, LoadAction::DontCareIfFull, &cb_yuv, sizeof(cb_yuv));

 	if (feedback_write_2_but_blend_bg)
 		ClearRenderTarget(dTex, c);
@@ -582,17 +582,17 @@ void GSDeviceMTL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		if (PMODE.MMOD == 1)
 		{
 			// Blend with a constant alpha
-			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], pipeline, true, LoadAction::Load, &cb_c, sizeof(cb_c));
+			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], pipeline, linear, LoadAction::Load, &cb_c, sizeof(cb_c));
 		}
 		else
 		{
 			// Blend with 2 * input alpha
-			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], pipeline, true, LoadAction::Load, nullptr, 0);
+			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], pipeline, linear, LoadAction::Load, nullptr, 0);
 		}
 	}

 	if (feedback_write_1) // FIXME I'm not sure dRect[0] is always correct
-		StretchRect(dTex, full_r, sTex[2], dRect[0], ShaderConvert::YUV);
+		StretchRect(dTex, full_r, sTex[2], dRect[0], ShaderConvert::YUV, linear);
 }}

 void GSDeviceMTL::DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset, int bufIdx)
@@ -1379,6 +1379,7 @@ void GSDeviceMTL::MRESetHWPipelineState(GSHWDrawConfig::VSSelector vssel, GSHWDr
 		setFnConstantB(m_fn_constants, pssel.ltf,                GSMTLConstantIndex_PS_LTF);
 		setFnConstantB(m_fn_constants, pssel.shuffle,            GSMTLConstantIndex_PS_SHUFFLE);
 		setFnConstantB(m_fn_constants, pssel.read_ba,            GSMTLConstantIndex_PS_READ_BA);
+		setFnConstantB(m_fn_constants, pssel.real16src,          GSMTLConstantIndex_PS_READ16_SRC);
 		setFnConstantB(m_fn_constants, pssel.write_rg,           GSMTLConstantIndex_PS_WRITE_RG);
 		setFnConstantB(m_fn_constants, pssel.fbmask,             GSMTLConstantIndex_PS_FBMASK);
 		setFnConstantI(m_fn_constants, pssel.blend_a,            GSMTLConstantIndex_PS_BLEND_A);
--- a/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h
+++ b/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h
@@ -175,6 +175,7 @@ enum GSMTLFnConstants
 	GSMTLConstantIndex_PS_LTF,
 	GSMTLConstantIndex_PS_SHUFFLE,
 	GSMTLConstantIndex_PS_READ_BA,
+	GSMTLConstantIndex_PS_READ16_SRC,
 	GSMTLConstantIndex_PS_WRITE_RG,
 	GSMTLConstantIndex_PS_FBMASK,
 	GSMTLConstantIndex_PS_BLEND_A,
--- a/pcsx2/GS/Renderers/Metal/tfx.metal
+++ b/pcsx2/GS/Renderers/Metal/tfx.metal
@@ -42,6 +42,7 @@ constant bool PS_ADJT               [[function_constant(GSMTLConstantIndex_PS_AD
 constant bool PS_LTF                [[function_constant(GSMTLConstantIndex_PS_LTF)]];
 constant bool PS_SHUFFLE            [[function_constant(GSMTLConstantIndex_PS_SHUFFLE)]];
 constant bool PS_READ_BA            [[function_constant(GSMTLConstantIndex_PS_READ_BA)]];
+constant bool PS_READ16_SRC         [[function_constant(GSMTLConstantIndex_PS_READ16_SRC)]];
 constant bool PS_WRITE_RG           [[function_constant(GSMTLConstantIndex_PS_WRITE_RG)]];
 constant bool PS_FBMASK             [[function_constant(GSMTLConstantIndex_PS_FBMASK)]];
 constant uint PS_BLEND_A            [[function_constant(GSMTLConstantIndex_PS_BLEND_A)]];
@@ -950,11 +951,22 @@ struct PSMain
 			uint4 denorm_c = uint4(C);
 			uint2 denorm_TA = uint2(cb.ta * 255.5f);

-			C.rb = PS_READ_BA ? C.bb : C.rr;
-			if (PS_READ_BA)
-				C.ga = (denorm_c.a & 0x7F) | (denorm_c.a & 0x80 ? denorm_TA.y & 0x80 : denorm_TA.x & 0x80);
+			if (PS_READ16_SRC)
+			{
+				C.rb = (denorm_c.r >> 3) | (((denorm_c.g >> 3) & 0x7u) << 5);
+				if (denorm_c.a & 0x80)
+					C.ga = (denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.y & 0x80);
+				else
+					C.ga = (denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.x & 0x80);
+			}
 			else
-				C.ga = (denorm_c.g & 0x7F) | (denorm_c.g & 0x80 ? denorm_TA.y & 0x80 : denorm_TA.x & 0x80);
+			{
+				C.rb = PS_READ_BA ? C.bb : C.rr;
+				if (PS_READ_BA)
+					C.ga = (denorm_c.a & 0x7F) | (denorm_c.a & 0x80 ? denorm_TA.y & 0x80 : denorm_TA.x & 0x80);
+				else
+					C.ga = (denorm_c.g & 0x7F) | (denorm_c.g & 0x80 ? denorm_TA.y & 0x80 : denorm_TA.x & 0x80);
+			}
 		}

 		// Must be done before alpha correction
--- a/pcsx2/GS/Renderers/Null/GSDeviceNull.h
+++ b/pcsx2/GS/Renderers/Null/GSDeviceNull.h
@@ -23,7 +23,7 @@ class GSDeviceNull : public GSDevice
 private:
 	GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format);

-	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c) {}
+	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) {}
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset = 0, int bufIdx = 0) {}
 	u16 ConvertBlendEnum(u16 generic) { return 0xFFFF; }

--- a/pcsx2/GS/Renderers/OpenGL/GLLoader.cpp
+++ b/pcsx2/GS/Renderers/OpenGL/GLLoader.cpp
@@ -17,6 +17,7 @@
 #include "GLLoader.h"
 #include "GS/GS.h"
 #include "Host.h"
+#include "HostSettings.h"

 namespace ReplaceGL
 {
@@ -112,8 +113,8 @@ namespace GLLoader
 	bool vendor_id_amd = false;
 	bool vendor_id_nvidia = false;
 	bool vendor_id_intel = false;
-	bool mesa_driver = false;
 	bool buggy_pbo = false;
+	bool disable_download_pbo = false;

 	bool is_gles = false;
 	bool has_dual_source_blend = false;
@@ -131,14 +132,8 @@ namespace GLLoader
 			vendor_id_amd = true;
 		else if (strstr(vendor, "NVIDIA Corporation"))
 			vendor_id_nvidia = true;
-
-#ifdef _WIN32
 		else if (strstr(vendor, "Intel"))
 			vendor_id_intel = true;
-#else
-		// On linux assumes the free driver if it isn't nvidia or amd pro driver
-		mesa_driver = !vendor_id_nvidia && !vendor_id_amd;
-#endif

 		if (GSConfig.OverrideGeometryShaders != -1)
 		{
@@ -225,10 +220,16 @@ namespace GLLoader

 		// Don't use PBOs when we don't have ARB_buffer_storage, orphaning buffers probably ends up worse than just
 		// using the normal texture update routines and letting the driver take care of it.
-		GLLoader::buggy_pbo = !GLAD_GL_VERSION_4_4 && !GLAD_GL_ARB_buffer_storage && !GLAD_GL_EXT_buffer_storage;
-		if (GLLoader::buggy_pbo)
+		buggy_pbo = !GLAD_GL_VERSION_4_4 && !GLAD_GL_ARB_buffer_storage && !GLAD_GL_EXT_buffer_storage;
+		if (buggy_pbo)
 			Console.Warning("Not using PBOs for texture uploads because buffer_storage is unavailable.");

+		// Give the user the option to disable PBO usage for downloads.
+		// Most drivers seem to be faster with PBO.
+		disable_download_pbo = Host::GetBoolSettingValue("EmuCore/GS", "DisableGLDownloadPBO", false);
+		if (disable_download_pbo)
+			Console.Warning("Not using PBOs for texture downloads, this may reduce performance.");
+
 		return true;
 	}

--- a/pcsx2/GS/Renderers/OpenGL/GLLoader.h
+++ b/pcsx2/GS/Renderers/OpenGL/GLLoader.h
@@ -29,9 +29,8 @@ namespace GLLoader
 	extern bool vendor_id_amd;
 	extern bool vendor_id_nvidia;
 	extern bool vendor_id_intel;
-	extern bool mesa_driver;
 	extern bool buggy_pbo;
-	extern bool in_replayer;
+	extern bool disable_download_pbo;

 	// GL
 	extern bool is_gles;
--- a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp
+++ b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp
@@ -1060,6 +1060,7 @@ std::string GSDeviceOGL::GetPSSource(const PSSelector& sel)
 		+ fmt::format("#define PS_IIP {}\n", sel.iip)
 		+ fmt::format("#define PS_SHUFFLE {}\n", sel.shuffle)
 		+ fmt::format("#define PS_READ_BA {}\n", sel.read_ba)
+		+ fmt::format("#define PS_READ16_SRC {}\n", sel.real16src)
 		+ fmt::format("#define PS_WRITE_RG {}\n", sel.write_rg)
 		+ fmt::format("#define PS_FBMASK {}\n", sel.fbmask)
 		+ fmt::format("#define PS_HDR {}\n", sel.hdr)
@@ -1308,7 +1309,7 @@ void GSDeviceOGL::DrawStretchRect(const GSVector4& sRect, const GSVector4& dRect
 	DrawPrimitive();
 }

-void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
+void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear)
 {
 	GL_PUSH("DoMerge");

@@ -1327,7 +1328,7 @@ void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	{
 		// 2nd output is enabled and selected. Copy it to destination so we can blend it with 1st output
 		// Note: value outside of dRect must contains the background color (c)
-		StretchRect(sTex[1], sRect[1], dTex, PMODE.SLBG ? dRect[2] : dRect[1], ShaderConvert::COPY);
+		StretchRect(sTex[1], sRect[1], dTex, PMODE.SLBG ? dRect[2] : dRect[1], ShaderConvert::COPY, linear);
 	}

 	// Upload constant to select YUV algo
@@ -1340,7 +1341,7 @@ void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,

 	// Save 2nd output
 	if (feedback_write_2)
-		StretchRect(dTex, full_r, sTex[2], dRect[2], ShaderConvert::YUV);
+		StretchRect(dTex, full_r, sTex[2], dRect[2], ShaderConvert::YUV, linear);

 	// Restore background color to process the normal merge
 	if (feedback_write_2_but_blend_bg)
@@ -1357,17 +1358,17 @@ void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 			// Blend with a constant alpha
 			m_merge_obj.ps[1].Bind();
 			m_merge_obj.ps[1].Uniform4fv(0, c.v);
-			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[1], true, OMColorMaskSelector());
+			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[1], true, OMColorMaskSelector(), linear);
 		}
 		else
 		{
 			// Blend with 2 * input alpha
-			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[0], true, OMColorMaskSelector());
+			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[0], true, OMColorMaskSelector(), linear);
 		}
 	}

 	if (feedback_write_1)
-		StretchRect(dTex, full_r, sTex[2], dRect[2], ShaderConvert::YUV);
+		StretchRect(dTex, full_r, sTex[2], dRect[2], ShaderConvert::YUV, linear);
 }

 void GSDeviceOGL::DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset, int bufIdx)
--- a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.h
+++ b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.h
@@ -276,7 +276,7 @@ private:

 	GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) final;

-	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c) final;
+	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) final;
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset = 0, int bufIdx = 0) final;
 	void DoFXAA(GSTexture* sTex, GSTexture* dTex) final;
 	void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) final;
--- a/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp
+++ b/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp
@@ -453,9 +453,10 @@ GSDownloadTextureOGL::~GSDownloadTextureOGL()

 std::unique_ptr<GSDownloadTextureOGL> GSDownloadTextureOGL::Create(u32 width, u32 height, GSTexture::Format format)
 {
-	const u32 buffer_size = GetBufferSize(width, height, format, GSTexture::GetCompressedBytesPerBlock(format));
+	const u32 buffer_size = GetBufferSize(width, height, format, TEXTURE_UPLOAD_PITCH_ALIGNMENT);

-	const bool use_buffer_storage = (GLAD_GL_VERSION_4_4 || GLAD_GL_ARB_buffer_storage || GLAD_GL_EXT_buffer_storage);
+	const bool use_buffer_storage = (GLAD_GL_VERSION_4_4 || GLAD_GL_ARB_buffer_storage || GLAD_GL_EXT_buffer_storage) &&
+									!GLLoader::disable_download_pbo;
 	if (use_buffer_storage)
 	{
 		GLuint buffer_id;
--- a/pcsx2/GS/Renderers/SW/GSRendererSW.cpp
+++ b/pcsx2/GS/Renderers/SW/GSRendererSW.cpp
@@ -82,22 +82,6 @@ void GSRendererSW::VSync(u32 field, bool registers_written)
 {
 	Sync(0); // IncAge might delete a cached texture in use

-	if (0) if (LOG)
-	{
-		fprintf(s_fp, "%llu\n", g_perfmon.GetFrame());
-
-		GSVector4i dr = GetDisplayRect();
-		GSVector4i fr = GetFrameRect();
-
-		fprintf(s_fp, "dr %d %d %d %d, fr %d %d %d %d\n",
-			dr.x, dr.y, dr.z, dr.w,
-			fr.x, fr.y, fr.z, fr.w);
-
-		m_regs->Dump(s_fp);
-
-		fflush(s_fp);
-	}
-
 	/*
 	int draw[8], sum = 0;

@@ -127,27 +111,20 @@ GSTexture* GSRendererSW::GetOutput(int i, int& y_offset)
 {
 	Sync(1);

-	const GSRegDISPFB& DISPFB = m_regs->DISP[i].DISPFB;
+	int index = i >= 0 ? i : 1;
+	GSPCRTCRegs::PCRTCDisplay& curFramebuffer = PCRTCDisplays.PCRTCDisplays[index];
+	GSVector2i framebufferSize = PCRTCDisplays.GetFramebufferSize(i);
+	GSVector4i framebufferRect = PCRTCDisplays.GetFramebufferRect(i);
+	int w = curFramebuffer.FBW * 64;
+	int h = framebufferSize.y;

-	int w = DISPFB.FBW * 64;
-
-	const int videomode = static_cast<int>(GetVideoMode()) - 1;
-	const int display_offset = GetResolutionOffset(i).y;
-	const GSVector4i offsets = !GSConfig.PCRTCOverscan ? VideoModeOffsets[videomode] : VideoModeOffsetsOverscan[videomode];
-	const int display_height = offsets.y * ((isinterlaced() && !m_regs->SMODE2.FFMD) ? 2 : 1);
-	int h = std::min(GetFramebufferHeight(), display_height);
-
-	// If there is a negative vertical offset on the picture, we need to read more.
-	if (display_offset < 0)
-	{
-		h += -display_offset;
-	}
-
-	if (g_gs_device->ResizeTarget(&m_texture[i], w, h))
+	if (g_gs_device->ResizeTarget(&m_texture[index], w, h))
 	{
+		const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[curFramebuffer.PSM];
 		constexpr int pitch = 1024 * 4;
-		const int off_x = DISPFB.DBX & 0x7ff;
-		const int off_y = DISPFB.DBY & 0x7ff;
+		// Should really be framebufferOffsets rather than framebufferRect but this might be compensated with anti-blur in some games.
+		const int off_x = (framebufferRect.x & 0x7ff) & ~(psm.bs.x-1);
+		const int off_y = (framebufferRect.y & 0x7ff) & ~(psm.bs.y-1);
 		const GSVector4i out_r(0, 0, w, h);
 		GSVector4i r(off_x, off_y, w + off_x, h + off_y);
 		GSVector4i rh(off_x, off_y, w + off_x, (h + off_y) & 0x7FF);
@@ -155,6 +132,7 @@ GSTexture* GSRendererSW::GetOutput(int i, int& y_offset)
 		bool h_wrap = false;
 		bool w_wrap = false;

+		PCRTCDisplays.RemoveFramebufferOffset(i);
 		// Need to read it in 2 parts, since you can't do a split rect.
 		if (r.bottom >= 2048)
 		{
@@ -172,50 +150,51 @@ GSTexture* GSRendererSW::GetOutput(int i, int& y_offset)
 			w_wrap = true;
 		}

-		const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[DISPFB.PSM];
-
 		// Display doesn't use texa, and instead uses the equivalent of this
 		GIFRegTEXA texa = {};
 		texa.AEM = 0;
-		texa.TA0 = (DISPFB.PSM == PSM_PSMCT24 || DISPFB.PSM == PSM_PSGPU24) ? 0x80 : 0;
+		texa.TA0 = (curFramebuffer.PSM == PSM_PSMCT24 || curFramebuffer.PSM == PSM_PSGPU24) ? 0x80 : 0;
 		texa.TA1 = 0x80;

 		// Top left rect
-		psm.rtx(m_mem, m_mem.GetOffset(DISPFB.Block(), DISPFB.FBW, DISPFB.PSM), r.ralign<Align_Outside>(psm.bs), m_output, pitch, texa);
+		psm.rtx(m_mem, m_mem.GetOffset(curFramebuffer.Block(), curFramebuffer.FBW, curFramebuffer.PSM), r.ralign<Align_Outside>(psm.bs), m_output, pitch, texa);
+
+		// Top left rect
+		psm.rtx(m_mem, m_mem.GetOffset(curFramebuffer.Block(), curFramebuffer.FBW, curFramebuffer.PSM), r.ralign<Align_Outside>(psm.bs), m_output, pitch, texa);

 		int top = (h_wrap) ? ((r.bottom - r.top) * pitch) : 0;
-		int left = (w_wrap) ? (r.right - r.left) * (GSLocalMemory::m_psm[DISPFB.PSM].bpp / 8) : 0;
+		int left = (w_wrap) ? (r.right - r.left) * (GSLocalMemory::m_psm[curFramebuffer.PSM].bpp / 8) : 0;

 		// The following only happen if the DBX/DBY wrap around at 2048.

 		// Top right rect
 		if (w_wrap)
-			psm.rtx(m_mem, m_mem.GetOffset(DISPFB.Block(), DISPFB.FBW, DISPFB.PSM), rw.ralign<Align_Outside>(psm.bs), &m_output[left], pitch, texa);
+			psm.rtx(m_mem, m_mem.GetOffset(curFramebuffer.Block(), curFramebuffer.FBW, curFramebuffer.PSM), rw.ralign<Align_Outside>(psm.bs), &m_output[left], pitch, texa);

 		// Bottom left rect
 		if (h_wrap)
-			psm.rtx(m_mem, m_mem.GetOffset(DISPFB.Block(), DISPFB.FBW, DISPFB.PSM), rh.ralign<Align_Outside>(psm.bs), &m_output[top], pitch, texa);
+			psm.rtx(m_mem, m_mem.GetOffset(curFramebuffer.Block(), curFramebuffer.FBW, curFramebuffer.PSM), rh.ralign<Align_Outside>(psm.bs), &m_output[top], pitch, texa);

 		// Bottom right rect
 		if (h_wrap && w_wrap)
 		{
 			// Needs also rw with the start/end height of rh, fills in the bottom right rect which will be missing if both overflow.
 			const GSVector4i rwh(rw.left, rh.top, rw.right, rh.bottom);
-			psm.rtx(m_mem, m_mem.GetOffset(DISPFB.Block(), DISPFB.FBW, DISPFB.PSM), rwh.ralign<Align_Outside>(psm.bs), &m_output[top + left], pitch, texa);
+			psm.rtx(m_mem, m_mem.GetOffset(curFramebuffer.Block(), curFramebuffer.FBW, curFramebuffer.PSM), rwh.ralign<Align_Outside>(psm.bs), &m_output[top + left], pitch, texa);
 		}

-		m_texture[i]->Update(out_r, m_output, pitch);
+		m_texture[index]->Update(out_r, m_output, pitch);

 		if (GSConfig.DumpGSData)
 		{
 			if (GSConfig.SaveFrame && s_n >= GSConfig.SaveN)
 			{
-				m_texture[i]->Save(GetDrawDumpPath("%05d_f%lld_fr%d_%05x_%s.bmp", s_n, g_perfmon.GetFrame(), i, (int)DISPFB.Block(), psm_str(DISPFB.PSM)));
+				m_texture[index]->Save(GetDrawDumpPath("%05d_f%lld_fr%d_%05x_%s.bmp", s_n, g_perfmon.GetFrame(), i, (int)curFramebuffer.Block(), psm_str(curFramebuffer.PSM)));
 			}
 		}
 	}

-	return m_texture[i];
+	return m_texture[index];
 }

 GSTexture* GSRendererSW::GetFeedbackOutput()
@@ -490,18 +469,18 @@ void GSRendererSW::Draw()
 			{
 				// Dump the RT in 32 bits format. It helps to debug texture shuffle effect
 				s = GetDrawDumpPath("%05d_f%lld_rt0_%05x_32bits.bmp", s_n, frame, m_context->FRAME.Block());
-				m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, 0, GetFrameRect().width(), 512);
+				m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, 0, r.width(), r.height());
 			}

 			s = GetDrawDumpPath("%05d_f%lld_rt0_%05x_%s.bmp", s_n, frame, m_context->FRAME.Block(), psm_str(m_context->FRAME.PSM));
-			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, r.width(), r.height());
 		}

 		if (GSConfig.SaveDepth && s_n >= GSConfig.SaveN)
 		{
 			s = GetDrawDumpPath("%05d_f%lld_rz0_%05x_%s.bmp", s_n, frame, m_context->ZBUF.Block(), psm_str(m_context->ZBUF.PSM));

-			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, r.width(), r.height());
 		}

 		Queue(data);
@@ -514,18 +493,18 @@ void GSRendererSW::Draw()
 			{
 				// Dump the RT in 32 bits format. It helps to debug texture shuffle effect
 				s = GetDrawDumpPath("%05d_f%lld_rt1_%05x_32bits.bmp", s_n, frame, m_context->FRAME.Block());
-				m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, 0, GetFrameRect().width(), 512);
+				m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, 0, r.width(), r.height());
 			}

 			s = GetDrawDumpPath("%05d_f%lld_rt1_%05x_%s.bmp", s_n, frame, m_context->FRAME.Block(), psm_str(m_context->FRAME.PSM));
-			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, r.width(), r.height());
 		}

 		if (GSConfig.SaveDepth && s_n >= GSConfig.SaveN)
 		{
 			s = GetDrawDumpPath("%05d_f%lld_rz1_%05x_%s.bmp", s_n, frame, m_context->ZBUF.Block(), psm_str(m_context->ZBUF.PSM));

-			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, r.width(), r.height());
 		}

 		if (GSConfig.SaveL > 0 && (s_n - GSConfig.SaveN) > GSConfig.SaveL)
@@ -613,14 +592,14 @@ void GSRendererSW::Sync(int reason)
 		{
 			s = GetDrawDumpPath("%05d_f%lld_rt1_%05x_%s.bmp", s_n, g_perfmon.GetFrame(), m_context->FRAME.Block(), psm_str(m_context->FRAME.PSM));

-			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, PCRTCDisplays.GetFramebufferRect(-1).width(), 512);
 		}

 		if (GSConfig.SaveDepth)
 		{
 			s = GetDrawDumpPath("%05d_f%lld_zb1_%05x_%s.bmp", s_n, g_perfmon.GetFrame(), m_context->ZBUF.Block(), psm_str(m_context->ZBUF.PSM));

-			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameRect().width(), 512);
+			m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, PCRTCDisplays.GetFramebufferRect(-1).width(), 512);
 		}
 	}

--- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp
+++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp
@@ -705,7 +705,7 @@ void GSDeviceVK::UpdateCLUTTexture(GSTexture* sTex, u32 offsetX, u32 offsetY, GS
 }

 void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect,
-	const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
+	const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear)
 {
 	GL_PUSH("DoMerge");

@@ -714,7 +714,7 @@ void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	const bool feedback_write_2 = PMODE.EN2 && sTex[2] != nullptr && EXTBUF.FBIN == 1;
 	const bool feedback_write_1 = PMODE.EN1 && sTex[2] != nullptr && EXTBUF.FBIN == 0;
 	const bool feedback_write_2_but_blend_bg = feedback_write_2 && PMODE.SLBG == 1;
-
+	const VkSampler& sampler = linear? m_linear_sampler : m_point_sampler;
 	// Merge the 2 source textures (sTex[0],sTex[1]). Final results go to dTex. Feedback write will go to sTex[2].
 	// If either 2nd output is disabled or SLBG is 1, a background color will be used.
 	// Note: background color is also used when outside of the unit rectangle area
@@ -736,7 +736,7 @@ void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		{
 			static_cast<GSTextureVK*>(sTex[1])->TransitionToLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 			OMSetRenderTargets(dTex, nullptr, darea, false);
-			SetUtilityTexture(sTex[1], m_linear_sampler);
+			SetUtilityTexture(sTex[1], sampler);
 			BeginClearRenderPass(m_utility_color_render_pass_clear, darea, c);
 			SetPipeline(m_convert[static_cast<int>(ShaderConvert::COPY)]);
 			DrawStretchRect(sRect[1], PMODE.SLBG ? dRect[2] : dRect[1], dsize);
@@ -753,7 +753,7 @@ void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 		EndRenderPass();
 		OMSetRenderTargets(sTex[2], nullptr, fbarea, false);
 		if (dcleared)
-			SetUtilityTexture(dTex, m_linear_sampler);
+			SetUtilityTexture(dTex, sampler);
 		// sTex[2] can be sTex[0], in which case it might be cleared (e.g. Xenosaga).
 		BeginRenderPassForStretchRect(static_cast<GSTextureVK*>(sTex[2]), fbarea, GSVector4i(dRect[2]));
 		if (dcleared)
@@ -787,7 +787,7 @@ void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	if (sTex[0] && sTex[0]->GetState() == GSTexture::State::Dirty)
 	{
 		// 1st output is enabled. It must be blended
-		SetUtilityTexture(sTex[0], m_linear_sampler);
+		SetUtilityTexture(sTex[0], sampler);
 		SetPipeline(m_merge[PMODE.MMOD]);
 		SetUtilityPushConstants(&c, sizeof(c));
 		DrawStretchRect(sRect[0], dRect[0], dTex->GetSize());
@@ -797,7 +797,7 @@ void GSDeviceVK::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	{
 		EndRenderPass();
 		SetPipeline(m_convert[static_cast<int>(ShaderConvert::YUV)]);
-		SetUtilityTexture(dTex, m_linear_sampler);
+		SetUtilityTexture(dTex, sampler);
 		SetUtilityPushConstants(yuv_constants, sizeof(yuv_constants));
 		OMSetRenderTargets(sTex[2], nullptr, fbarea, false);
 		BeginRenderPass(m_utility_color_render_pass_load, fbarea);
@@ -1983,6 +1983,7 @@ VkShaderModule GSDeviceVK::GetTFXFragmentShader(const GSHWDrawConfig::PSSelector
 	AddMacro(ss, "PS_IIP", sel.iip);
 	AddMacro(ss, "PS_SHUFFLE", sel.shuffle);
 	AddMacro(ss, "PS_READ_BA", sel.read_ba);
+	AddMacro(ss, "PS_READ16_SRC", sel.real16src);
 	AddMacro(ss, "PS_WRITE_RG", sel.write_rg);
 	AddMacro(ss, "PS_FBMASK", sel.fbmask);
 	AddMacro(ss, "PS_HDR", sel.hdr);
--- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h
+++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h
@@ -154,7 +154,7 @@ private:
 	GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) override;

 	void DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE,
-		const GSRegEXTBUF& EXTBUF, const GSVector4& c) final;
+		const GSRegEXTBUF& EXTBUF, const GSVector4& c, const bool linear) final;
 	void DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool linear, float yoffset = 0, int bufIdx = 0) final;
 	void DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4]) final;
 	void DoFXAA(GSTexture* sTex, GSTexture* dTex) final;
--- a/pcsx2/GameDatabase.cpp
+++ b/pcsx2/GameDatabase.cpp
@@ -342,6 +342,7 @@ void GameDatabase::parseAndInsert(const std::string_view& serial, const c4::yml:
 static const char* s_gs_hw_fix_names[] = {
 	"autoFlush",
 	"cpuFramebufferConversion",
+	"readTCOnClose",
 	"disableDepthSupport",
 	"wrapGSMem",
 	"preloadFrameData",
@@ -548,6 +549,9 @@ bool GameDatabaseSchema::GameEntry::configMatchesHWFix(const Pcsx2Config::GSOpti
 		case GSHWFixId::CPUFramebufferConversion:
 			return (static_cast<int>(config.UserHacks_CPUFBConversion) == value);

+		case GSHWFixId::FlushTCOnClose:
+			return (static_cast<int>(config.UserHacks_ReadTCOnClose) == value);
+
 		case GSHWFixId::DisableDepthSupport:
 			return (static_cast<int>(config.UserHacks_DisableDepthSupport) == value);

@@ -654,6 +658,10 @@ u32 GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 				config.UserHacks_CPUFBConversion = (value > 0);
 				break;

+			case GSHWFixId::FlushTCOnClose:
+				config.UserHacks_ReadTCOnClose = (value > 0);
+				break;
+
 			case GSHWFixId::DisableDepthSupport:
 				config.UserHacks_DisableDepthSupport = (value > 0);
 				break;
--- a/pcsx2/GameDatabase.h
+++ b/pcsx2/GameDatabase.h
@@ -62,6 +62,7 @@ namespace GameDatabaseSchema
 		// boolean settings
 		AutoFlush,
 		CPUFramebufferConversion,
+		FlushTCOnClose,
 		DisableDepthSupport,
 		WrapGSMem,
 		PreloadFrameData,
--- a/pcsx2/HostDisplay.h
+++ b/pcsx2/HostDisplay.h
@@ -60,6 +60,13 @@ public:
 		RightOrBottom
 	};

+	enum class PresentResult
+	{
+		OK,
+		FrameSkipped,
+		DeviceLost
+	};
+
 	struct AdapterAndModeList
 	{
 		std::vector<std::string> adapter_names;
@@ -137,7 +144,7 @@ public:

 	/// Returns false if the window was completely occluded. If frame_skip is set, the frame won't be
 	/// displayed, but the GPU command queue will still be flushed.
-	virtual bool BeginPresent(bool frame_skip) = 0;
+	virtual PresentResult BeginPresent(bool frame_skip) = 0;

 	/// Presents the frame to the display, and renders OSD elements.
 	virtual void EndPresent() = 0;
@@ -184,7 +191,7 @@ namespace Host

 	/// Returns false if the window was completely occluded. If frame_skip is set, the frame won't be
 	/// displayed, but the GPU command queue will still be flushed.
-	bool BeginPresentFrame(bool frame_skip);
+	HostDisplay::PresentResult BeginPresentFrame(bool frame_skip);

 	/// Presents the frame to the display, and renders OSD elements.
 	void EndPresentFrame();
--- a/pcsx2/IopBios.cpp
+++ b/pcsx2/IopBios.cpp
@@ -96,6 +96,11 @@ void Hle_SetElfPath(const char* elfFileName)
 	Console.WriteLn("HLE Host: Set 'host:' root path to: %s\n", hostRoot.c_str());
 }

+void Hle_ClearElfPath()
+{
+	hostRoot = {};
+}
+
 namespace R3000A
 {

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
$refractionpcsx2$ refractionpcsx2	a7714b2725	MCD: Stop Memcard Folders spamming the console/OSD when saving a game	2023-02-23 18:02:07 +00:00
Stenzek	f9dcac8cd0	GS/HW: Make readback-on-close a HW fix Unfortunately it's too risky to enable by default all the time. So, we'll make it a hw fix, and hopefully one day can make it default on. Also makes save states readback the TC as well.	2023-02-23 17:25:03 +00:00
Stenzek	2487322e47	GS/HW: Track which bits are actually written to targets Fixes Burnout 3 sky getting corrupted when flushing.	2023-02-23 17:25:03 +00:00
Stenzek	c7e9c9542e	GS/HW: Don't try to dirty targets which don't overlap The current invalidation code sucks, but at least this stops things which are blatently wrong from happening.	2023-02-23 10:12:05 +00:00
Stenzek	c1bc1af302	GS/HW: Don't mess with the buffer width of the target on invalidate	2023-02-23 10:12:05 +00:00
Stenzek	739f9ec758	GS/HW: Set valid rect on targets created by Move	2023-02-23 10:12:05 +00:00
$refractionpcsx2$ refractionpcsx2	f70a140f42	GS-HW: Fix Download readbacks and limit FB resizing	2023-02-22 11:50:11 +00:00
$refractionpcsx2$ refractionpcsx2	a716e69dc0	GameDB: Remove no longer needed SW FMV switch fixes	2023-02-21 16:15:29 +00:00
$refractionpcsx2$ refractionpcsx2	0c6e1a4d56	GS-HW: Invalidate overlapped target when expanding.	2023-02-21 16:15:29 +00:00
Stenzek	faf36ecba6	GS/D3D: Default to D3D11 for Intel	2023-02-21 15:49:59 +00:00
Stenzek	49f2900e1f	GS/D3D: Combine driver version lookup for D3D11+D3D12	2023-02-21 15:49:59 +00:00
AKuHAK	8bd522d283	BiosTools: Implement SysGetBiosDiscID function, for Bios Serial used EXTINFO build unique timestamp	2023-02-21 15:24:36 +00:00
AKuHAK	e9034a1ba1	Biostools: remove unused external variable BiosZone	2023-02-21 15:24:36 +00:00
Stenzek	03feacd69a	GS/HW: Use FB size instead of output size for target lookup Fixes render target height doubling unnecessarily in Ridge Racer V.	2023-02-21 15:22:09 +00:00
Stenzek	0c9f44d8a4	GS/HW: Don't allow region textures to make sources larger Currently not handled. Fixes Ridge Racer V intro again.	2023-02-21 15:22:09 +00:00
RedDevilus	39fb64cdcd	GameDB: Dark Cloud 2 + Dark Chronicle I had a dark joke on the fix, but let's not jester about it. The clown now has more colors than just 1.	2023-02-21 14:10:14 +00:00
JordanTheToaster	d531a7f1af	GameDB: Remove CPU CLUT from Transformers The Game Something changed and now this just causes rainbow vomit in game and in menus instead of fixing the issue it was originally put in for.	2023-02-21 09:36:49 +00:00
PCSX2 Bot	bb7ff414ae	PAD: Update to latest controller database.	2023-02-21 02:14:48 +01:00
JordanTheToaster	215f112521	GameDB: Port patch to PAL Transformers ROTF Ports a patch over to the PAL version to fix the pause menu hud and other parts.	2023-02-19 15:50:05 +00:00
Florin9doi	644766d965	USB: Fix Sega Seamic buttons	2023-02-19 13:15:53 +01:00
JordanTheToaster	1e1a555d3b	GameDB: Various fixes Fixes for Transformers Revenge of the Fallen misaligned bloom and soft shadows and Legend of Kay broken shadow rectangles and misaligned bloom.	2023-02-19 03:53:20 +00:00
$refractionpcsx2$ refractionpcsx2	c64ae2684d	GS-PCRTC: Handle extended height when there's a negative offset	2023-02-19 00:57:52 +00:00
$refractionpcsx2$ refractionpcsx2	50ed04436d	GS-HW: Preserve width of frame textures	2023-02-19 00:57:38 +00:00
Stenzek	2fb9beca52	GS/HW: Use block instead of page pointer for height lookup Some callers were using blocks, others were using pages before. Enables target expansion in Stuntman, which slightly improves rendering without CPU sprite. The full "fix" needs page handling in P8 conversion.	2023-02-19 00:57:24 +00:00
$refractionpcsx2$ refractionpcsx2	cd4c1e920e	GS: Flush targets back to GS memory when swapping renderers	2023-02-19 00:57:01 +00:00
$refractionpcsx2$ refractionpcsx2	e846ac367a	GS-HW: Fix downloads in offset BP and different widths	2023-02-19 00:03:49 +00:00
Mrlinkwii	ef31c733ee	Gamedb: update Armored Core - Nexus	2023-02-18 15:53:30 +00:00
Stenzek	724aa657f3	Qt: Fix window geometry not saving on exit	2023-02-18 14:50:09 +00:00
kenshen112	0284c35f4c	GameDB: Add Fatal Frame 1 / Project Zero final boss game bug fix patch	2023-02-18 05:04:20 +00:00
TheTechnician27	6ce33de287	UI: Update and Add mouseover dialog (#8119 )	2023-02-18 01:58:32 +00:00
$refractionpcsx2$ refractionpcsx2	6ccfa011d4	Pad/Counters: Rearrange Pad/Core updates on VSync Apparently this gets around some weird input lag issue.	2023-02-18 01:13:39 +00:00
$refractionpcsx2$ refractionpcsx2	c9078af45e	GS: Bump shader cache version	2023-02-17 19:40:16 +00:00
$refractionpcsx2$ refractionpcsx2	6745428d0c	GS-SW: Fix SW texture dumping	2023-02-17 19:06:35 +00:00
$refractionpcsx2$ refractionpcsx2	925e874ada	GS-HW: Fix real 16bit value shuffles	2023-02-17 19:06:35 +00:00
lightningterror	03f0f2f803	GameDB: Add missing db entry for Silent Scope 3. Korean version.	2023-02-17 16:35:46 +01:00
lightningterror	857360d6b2	GameDB: Add full mipmap with ps2 trilinear to Matrix, The - Path of Neo. Improves ground textures to match sw renderer.	2023-02-17 16:35:46 +01:00
Stenzek	2dd76c3f12	GS/HW: Force region match on fixed TEX0 Fixes lightmapping in Spinter Cell - Double Agent.	2023-02-17 13:20:04 +00:00
Stenzek	666de3a874	GS/HW: Allow hardware sampling when clamp_max is larger Fixes some mipmapping issues in GT4.	2023-02-17 13:20:04 +00:00
Stenzek	e0e9b64db6	GS/HW: Fix region textures being used when redundant	2023-02-17 13:20:04 +00:00
JordanTheToaster	2f521348c6	GameDB: Add VU Sync hack to Salt Lake 2002 Fixes the awful flickering and missing textures that happens all over the game.	2023-02-17 13:12:33 +00:00
Stenzek	8ac2949a1f	GS/HW: Fix incorrect bitfield width in height cache This lead to duplication and possibly larger-than-intended heights.	2023-02-16 16:44:40 +00:00
Stenzek	d0d5d991ce	GS/HW: Fix repeat sampler being used for region clamp/repeat The coordinates are clamped in the shader, but normalized UV of 1 and bilinear may repeat.	2023-02-16 16:44:40 +00:00
Mrlinkwii	1fc2d7de3c	GameDB : remove skipdraw from Need for Speed - Undercover	2023-02-16 15:00:27 +00:00
$refractionpcsx2$ refractionpcsx2	2598e8d9b9	GS-PCRTC: Fix Anti-blur in screen offset. No this doesn't mean it won't look blurry, that's a downside of screen offsets in some games, but it might look less blurry.	2023-02-16 14:47:09 +00:00
$refractionpcsx2$ refractionpcsx2	01f65e98e6	GS-PCRTC: Fix up some PCRTC anti-blur behaviour + code cleanup	2023-02-16 14:47:09 +00:00
Ganael Laplanche	c5330cf166	Common: FreeBSD fixes. (#8163 ) * Fix SIGSEGV handler on FreeBSD * Fix config dir location on FreeBSD	2023-02-16 09:30:18 +01:00
JordanTheToaster	b78796d0c1	GameDB: Add HPO Special to Arthur and the minimoys Fixes misaligned bloom that looks gross.	2023-02-16 00:32:17 +00:00
RedDevilus	da1e9db2c0	GameDB: Ruff Trigger Rename Europe serial and fix offset and blooming.	2023-02-15 19:18:11 +00:00
RedDevilus	6beb6aa05b	GameDB: Bakugan Battle Brawlers Se Deinterlace to Adaptive TFF. I thought this was fixed but needs to be checked later.	2023-02-15 19:15:49 +00:00
Mrlinkwii	6ea7777a3a	GS-HW: remove Fighting Beauty Wulong & Spartan Total Warrior CRC (#8158 )	2023-02-15 14:56:53 +00:00
Stenzek	f97191e241	GS/HW: Split up consecutive channel shuffles	2023-02-15 11:04:05 +00:00
Stenzek	51420dade4	VMManager: Clear host root on booting ISO	2023-02-15 10:04:39 +00:00
Tokman5	cc55c01197	GameDB: Add EETimingHack to Crazy Taxi	2023-02-15 10:04:04 +00:00
JordanTheToaster	86ce464ee3	GameDB: Fix V-Rally 3 graphical corruption Fixes random graphical corruption that can happen by adding EE Timing hack.	2023-02-15 00:04:44 +00:00
$refractionpcsx2$ refractionpcsx2	0fa52a75ad	GS-HW: Optimise readback performance for some cases	2023-02-14 22:27:35 +00:00
Mrlinkwii	c91e7dc3b0	GameDB: remove not needed hw fixes for Metal Slug 6	2023-02-14 22:27:17 +00:00
Mrlinkwii	88034b176c	GS-HW:purge MetalSlug6 CRC	2023-02-14 22:27:17 +00:00
JordanTheToaster	efeaff488c	GameDB: Add HPO Special to 007 EON Lines bad must fix lines.	2023-02-14 17:49:53 +00:00
Berylskid	5df30f5bdd	OSD: Change the lower limit of OSD Scale from 100 to 50 (#8135 )	2023-02-14 14:03:24 +00:00
C.W. Betts	cf179c42b8	cmake: Quiet macOS building warning, we can build on macOS just fine. (#8136 )	2023-02-14 11:32:39 +01:00
Berylskid	a615f8bf17	Qt: Change "Save State On Shutdown" to Unchecked (#8147 )	2023-02-14 10:30:34 +00:00
$refractionpcsx2$ refractionpcsx2	b38964e814	GS: Partial revert of #8101 pending investigation. Sometimes great ideas don't always go smoothly to plan, this is one of those, but it will be back when we work out what's up with Soul Calibur 2 and DBZ BT3 :)	2023-02-14 10:23:09 +00:00
JordanTheToaster	013c9eec58	GameDB: Various fixes Some fixes I missed in the last PR because I am a doughnut and can't remember what I needed to do.	2023-02-14 00:20:52 +00:00
$refractionpcsx2$ refractionpcsx2	ddbd6eddf7	GameDB: Add Autoflush for Astro Boy and CPU Sprite for Alias	2023-02-14 00:18:08 +00:00
$refractionpcsx2$ refractionpcsx2	982fd42683	GS: Preload whenever it matches an upload. GUI option forces preloads.	2023-02-14 00:18:08 +00:00
RedDevilus	90e28e7957	GameDB: Fix Japanese KH2 - Final Mix Change Normal Vertex halfpixel with roundsprite	2023-02-13 23:59:41 +00:00
JordanTheToaster	f4201f3947	GameDB: Remove fix from Soulcalibur 3 No longer needed as the hash cache no longer does an explosion.	2023-02-13 23:27:27 +00:00
PCSX2 Bot	7844b40243	PAD: Update to latest controller database.	2023-02-13 17:37:59 +01:00
JordanTheToaster	d0839a3d55	GameDB: Fixes for graphics in Mana Khemia 2 Fixes missing graphical effects in battles by disabling mvu speedhack.	2023-02-13 16:07:31 +00:00
JordanTheToaster	876fd9ba9e	GameDB: Vexx underwater rendering fixes Adds Tex in RT to fix underwater rendering being totally broken.	2023-02-13 09:37:31 +00:00
lightningterror	e12717c108	CDVD: Fix FreeBSD compile.	2023-02-13 03:02:59 +01:00
$refractionpcsx2$ refractionpcsx2	af0b17bb7a	Counters: Present at VSync End	2023-02-12 21:13:42 +00:00
Stenzek	6f595b7d87	GS/HW: Allow previous frame in depth source lookup Fixes pulling random junk from local memory in Black after adjusting vsync timing.	2023-02-12 21:13:42 +00:00
JordanTheToaster	59cbdc79f5	GameDB: Fixes for V-Rally 3 and Berserk Fixes sun occlusion in V-Rally 3 and fixes missing subtitles in FMVs in Berserk.	2023-02-12 19:28:13 +00:00
$refractionpcsx2$ refractionpcsx2	50ff3649b1	GS: Fix divide by zero error	2023-02-12 19:14:54 +00:00
$refractionpcsx2$ refractionpcsx2	9ca9db8770	GS: Fix undefined behaviour bug in PCRTC	2023-02-12 15:03:24 +00:00
Stenzek	fa70f0e764	GS/HW: Don't age texture cache on idle frames	2023-02-12 08:34:39 +00:00
Stenzek	3eb629f133	InputManager: Restore passing wheel events to ImGui	2023-02-12 07:25:56 +00:00
Stenzek	c9aba6bbe1	GS/TextureCache: Allow tex-in-rt for 16/24/32-bit targets Fixes swirl battle transition in Valkyrie Profile 2. Fixes top-left screen rendering in Lego Racers 2.	2023-02-12 07:07:52 +00:00
Stenzek	0a26adae76	GS/TextureCache: Dirty with target PSM/TBW, not the EE write	2023-02-12 07:07:52 +00:00
Stenzek	f0798f6510	GS/HW: Combine dirty rectangles for target updates Fewer texture uploads makes Intel GPUs happy.	2023-02-12 07:07:52 +00:00
$refractionpcsx2$ refractionpcsx2	245b03e208	GS: Limit the height of framebuffer reads	2023-02-12 07:07:26 +00:00
$refractionpcsx2$ refractionpcsx2	4e31e5fdc2	GS: Use linear interpolation for Screen Offsets	2023-02-12 04:34:07 +00:00
Stenzek	750a74206c	InputManager: Warning fix/default interia value	2023-02-12 04:32:47 +00:00
Stenzek	7e64dc2576	GS/HW: Don't defer TC reset until next vsync	2023-02-12 04:32:47 +00:00
Stenzek	8a08e2fd97	GS: Make sure everything in GSState is initialized	2023-02-12 04:32:47 +00:00
Stenzek	d0a933cda8	GS/TextureCache: Clear surface offset cache on reset Also get rid of RemovePartial(), it's never called.	2023-02-12 04:32:47 +00:00
lightningterror	d00845f56b	GameDB: Add missing Need for Speed - Carbon entry.	2023-02-12 00:46:01 +00:00
lightningterror	3350e5ebb1	GameDB: Replace DMABusyHack with InstantDMAHack for MGS2 Sons of Liberty. DMA timing problem. Fixes broken half-bottom artifacts.	2023-02-12 00:46:01 +00:00
SideProjectsLab	aeb4445cad	Qt/Input: Improved how mouse movements are mapped to analog (#7910 )	2023-02-11 23:58:58 +00:00
$refractionpcsx2$ refractionpcsx2	73abae8cb9	GameDB: Remove forced deinterlacing modes which are no longer required	2023-02-11 20:08:36 +00:00
$refractionpcsx2$ refractionpcsx2	7ecc7b76ba	GS-PCRTC: Improve automatic de-interlacing to avoid it more often.	2023-02-11 20:08:36 +00:00
$refractionpcsx2$ refractionpcsx2	71d0bbbc25	GS: Rework of PCRTC code.	2023-02-11 20:08:36 +00:00
JordanTheToaster	26e691ba93	GameDB: Update HPO on Spider Man 2 Changes HPO to HPO Special to fix rainbow garbage on the top and left side of the screen when moving.	2023-02-11 17:43:05 +00:00
Stenzek	c7352d9e10	GS: Attempt to recreate device if GPU crashes	2023-02-11 15:33:55 +00:00
Stenzek	7b8f9a54ec	GS/HW: Purge FFX-2 depth clear CRC hack	2023-02-11 15:26:04 +00:00
JordanTheToaster	28980af858	GameDB: Port COP2 patch for Disneys Cars Ports patch to fix broken collisions to PAL Disney's Cars	2023-02-11 15:24:23 +00:00
Stenzek	80dce398e0	GS/HW: Carefully allow move to create new targets Xenosaga I does a move from BP 1C00 to E00, then from E00 to 2A00 a few frames later for its cutscene transitions. 2A00 then gets used as a texture and blended on top of the later frames. Because there's no target at 2A00, the move falls back to the CPU, and E00 contains junk which gets moved and eventually preloaded instead. Gradius V uses moves for a screen move/wobble-like effect, by moving chunks of the framebuffer out, then using those as a texture. It's not broken at the moment, but it does readback (slow), and break upscaling.	2023-02-11 07:16:19 +00:00
TheTechnician27	06db8eec48	Context.cpp: fix minor typo	2023-02-11 06:46:44 +00:00
Stenzek	9c720efe46	GS/OGL: Fix possible crash downloading odd texture sizes	2023-02-11 06:43:20 +00:00
$refractionpcsx2$ refractionpcsx2	cbf91a8d19	GS-HW: Tighten CLUT detection slightly.	2023-02-11 02:07:01 +00:00
TheTechnician27	f99414708d	Readme: Two minor changes to the README (#8105 )	2023-02-11 00:00:25 +00:00
$refractionpcsx2$ refractionpcsx2	9549a6b16a	GS: Fix TME processing when Alpha->IsBlack & !TEX0->TCC	2023-02-10 23:48:43 +00:00
lightningterror	3206094545	GameDB: Add full mipmap and trilinear ps2 to Hard Hitter games. Improves ground texture rendering.	2023-02-10 22:24:33 +01:00
Stenzek	5cfae80701	GL/OpenGL: Add a hidden [EmuCore/GS] DisableGLDownloadPBO option .. to disable the use of PBOs when reading back.	2023-02-10 14:38:21 +00:00
JordanTheToaster	b4d140c6bb	GameDB: Fixes for 187 Ride or Die Add autoflush to soften bloom and HPO Special Texture to fix misaligned bloom.	2023-02-10 14:15:51 +00:00
Stenzek	c65eb3c3ee	GS/HW: Fix crash with AVX2 due to unaligned pitch	2023-02-10 14:15:33 +00:00
Mrlinkwii	eec0984dbe	Gamedb: remove skipdraw from Need for Speed - Undercover	2023-02-10 14:47:52 +01:00
				`@@ -0,0 +1 @@`
				<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path fill="none" d="M0 0h24v24H0z"/><path d="M11.141 4c-1.582 0-2.387.169-3.128.565a3.453 3.453 0 0 0-1.448 1.448C6.169 6.753 6 7.559 6 9.14v5.718c0 1.582.169 2.387.565 3.128.337.63.818 1.111 1.448 1.448.74.396 1.546.565 3.128.565h1.718c1.582 0 2.387-.169 3.128-.565a3.453 3.453 0 0 0 1.448-1.448c.396-.74.565-1.546.565-3.128V9.14c0-1.582-.169-2.387-.565-3.128a3.453 3.453 0 0 0-1.448-1.448C15.247 4.169 14.441 4 12.86 4H11.14zm0-2h1.718c2.014 0 3.094.278 4.072.801a5.452 5.452 0 0 1 2.268 2.268c.523.978.801 2.058.801 4.072v5.718c0 2.014-.278 3.094-.801 4.072a5.452 5.452 0 0 1-2.268 2.268c-.978.523-2.058.801-4.072.801H11.14c-2.014 0-3.094-.278-4.072-.801a5.452 5.452 0 0 1-2.268-2.268C4.278 17.953 4 16.873 4 14.859V9.14c0-2.014.278-3.094.801-4.072A5.452 5.452 0 0 1 7.07 2.801C8.047 2.278 9.127 2 11.141 2zM11 6h2v5h-2V6z"/></svg>