GS/HW: Add new method of rounding sprites

2026-07-13 18:54:27 +02:00 · 2026-02-03 21:03:20 +00:00
22 changed files with 542 additions and 880 deletions
@@ -236,7 +236,7 @@
 03000000ac0500005b05000000000000,GameSir G3w,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:Windows,
 03000000ac0500002d02000000000000,GameSir G4,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:a5,start:b11,x:b3,y:b4,platform:Windows,
 03000000ac0500004d04000000000000,GameSir G4,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:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
-03000000373500002210000000000000,GameSir G7 Pro,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:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
+03000000373500002210000000000000,GameSir G7 Pro,a:b0,b:b1,x:b3,y:b4,back:b10,start:b11,leftstick:b13,rightstick:b14,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,lefty:a2,rightx:a3,righty:a4,lefttrigger:b8,righttrigger:b9,platform:Window,
 03000000ac0500001a06000000000000,GameSir T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000373500009410000000000000,GameSir Tegenaria Lite,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:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 030000004c0e00001035000000000000,Gamester,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,
@@ -246,6 +246,8 @@
 03000000b62500000100000000000000,Gametel GT004 01,a:b3,b:b0,dpdown:b10,dpleft:b9,dpright:b8,dpup:b11,leftshoulder:b4,rightshoulder:b5,start:b7,x:b1,y:b2,platform:Windows,
 030000008f0e00001411000000000000,Gamo2 Divaller,a:b1,b:b2,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:b0,y:b3,platform:Windows,
 03000000120c0000a857000000000000,Gator Claw,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,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,
+03000000c21100000791000000000000,Nacon GC101 1.03,a:b2,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:b3,y:b0,platform:Windows,
+03000000c9110000f055000000000000,Nacon GC100XF,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:Windows,
 030000008305000009a0000000000000,Genius,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:Windows,
 030000008305000031b0000000000000,Genius Maxfire Blaze 3,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:Windows,
 03000000451300000010000000000000,Genius Maxfire Grandias 12,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:Windows,
@@ -365,7 +367,7 @@
 03000000fd0500002a26000000000000,InterAct Hammerhead FX,a:b3,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b0,y:b1,platform:Windows,
 03000000fd0500002f26000000000000,InterAct Hammerhead FX,a:b4,b:b5,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b1,y:b2,platform:Windows,
 03000000fd0500005302000000000000,InterAct ProPad,a:b3,b:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Windows,
-03000000ac0500002c02000000000000,Ipega Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b8,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
+03000000ac0500002c02000000000000,Ipega Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000491900000204000000000000,Ipega PG9023,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:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000491900000304000000000000,Ipega PG9087,+righty:+a5,-righty:-a4,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:a3,start:b11,x:b3,y:b4,platform:Windows,
 030000007e0500000620000000000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Windows,
@@ -462,8 +464,6 @@
 03000000250900006688000000000000,MP-8866 Super Dual Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,
 03000000091200004488000000000000,MUSIA PlayStation 2 Input Display,a:b0,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b6,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b7,righttrigger:b11,rightx:a2,righty:a3,start:b5,x:b1,y:b3,platform:Windows,
 03000000f70600000100000000000000,N64 Adaptoid,+rightx:b2,+righty:b1,-rightx:b4,-righty:b5,a:b0,b:b3,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,platform:Windows,
-03000000c9110000f055000000000000,Nacon GC100XF,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:Windows,
-03000000c21100000791000000000000,Nacon GC101 1.03,a:b2,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:b3,y:b0,platform:Windows,
 030000006b140000010c000000000000,Nacon GC400ES,a:b0,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:b2,y:b3,platform:Windows,
 030000006b1400001106000000000000,Nacon Revolution 3 PS4 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:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,
 0300000085320000170d000000000000,Nacon Revolution 5 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:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,
@@ -697,7 +697,7 @@
 03000000730700000601000000000000,Sega Saturn Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,
 03000000b40400000a01000000000000,Sega Saturn Controller,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,
 030000003b07000004a1000000000000,SFX,a:b0,b:b2,back:b7,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b9,righttrigger:b5,start:b8,x:b1,y:b3,platform:Windows,
-03000000632500002705000000000000,ShanWan Q36,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,righttrigger:b9,start:b11,x:b3,y:b4,platform:Windows,
+03000000632500002705000000000000,ShanWan Q36,a:b0,b:b1,x:b3,y:b4,leftshoulder:b6,rightshoulder:b7,lefttrigger:b8,righttrigger:b9,back:b10,start:b11,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,platform:Windows,
 03000000f82100001900000000000000,Shogun Bros Chameleon X1,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,
 03000000120c00001c1e000000000000,SnakeByte 4S PS4 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:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,
 03000000140300000918000000000000,SNES Controller,a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,
@@ -888,7 +888,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000c82d00000851000000010000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 03000000c82d00000660000000010000,8BitDo Pro 2,a:b1,b:b0,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:b4,y:b3,platform:Mac OS X,
 03000000c82d00000660000000020000,8BitDo Pro 2,a:b1,b:b0,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:b4,y:b3,platform:Mac OS X,
-03000000c82d00000960000000000000,8BitDo Pro 3,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b17,paddle2:b16,paddle3:b2,paddle4:b5,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000c82d00000131000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000c82d00000231000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000c82d00000331000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,
@@ -1175,7 +1174,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,
 05000000c82d00001038000000010000,8BitDo FC30 Pro,a:b1,b:b0,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:b4,y:b3,platform:Linux,
 05000000c82d00006a28000000010000,8BitDo GameCube,a:b0,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b9,paddle2:b8,rightshoulder:b10,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b1,y:b4,platform:Linux,
-03000000c82d00001251000011010000,8BitDo Lite 2,a:b1,b:b0,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:b4,y:b3,platform:Linux,
+03000000c82d00001251000011010000,8BitDo Lite 2,a:b1,b:b0,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:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,
 05000000c82d00001251000000010000,8BitDo Lite 2,a:b1,b:b0,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:b4,y:b3,platform:Linux,
 03000000c82d00001151000011010000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,
 05000000c82d00001151000000010000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,
@@ -1398,12 +1397,11 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000242e00006a38000010010000,Hyperkin Trooper 2,a:b0,b:b1,back:b4,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b3,start:b5,platform:Linux,
 03000000242e00008816000001010000,Hyperkin X91,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,
 03000000f00300008d03000011010000,HyperX Clutch,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:Linux,
-05000000f00300008d04000000010000,HyperX Clutch,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:Linux,
 03000000830500006020000010010000,iBuffalo Super Famicom Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,
-03000000d80400004aea000011010000,icedragon.io STAC Dance Pad,a:b0,b:b1,back:b4,x:b2,y:b3,platform:Linux,
-03000000d80400004bea000011010000,icedragon.io STAC Dance Pad,a:b0,b:b1,back:b4,x:b2,y:b3,platform:Linux,
-030000008a2e0000d910000011010000,icedragon.io STAC2 Dance Pad,a:b0,b:b1,back:b4,x:b2,y:b3,platform:Linux,
-030000008a2e0000e910000011010000,icedragon.io STAC2 Dance Pad,a:b8,b:b9,back:b12,x:b10,y:b11,platform:Linux,
+03000000d80400004bea000011010000,icedragon.io STAC Dance Pad,a:b0,b:b1,x:b2,y:b3,back:b4,platform:Linux,
+03000000d80400004aea000011010000,icedragon.io STAC Dance Pad,a:b0,b:b1,x:b2,y:b3,back:b4,platform:Linux,
+030000008a2e0000d910000011010000,icedragon.io STAC2 Dance Pad,a:b0,b:b1,x:b2,y:b3,back:b4,platform:Linux,
+030000008a2e0000e910000011010000,icedragon.io STAC2 Dance Pad,a:b8,b:b9,x:b10,y:b11,back:b12,platform:Linux,
 030000008f0e00001330000001010000,iCode Retro Adapter,b:b3,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b9,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b1,start:b7,x:b2,y:b0,platform:Linux,
 050000006964726f69643a636f6e0000,idroidcon Controller,a:b1,b:b2,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:b0,y:b3,platform:Linux,
 03000000b50700001503000010010000,Impact,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,
@@ -1489,7 +1487,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005e040000ea02000008040000,Microsoft Xbox One,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,
 030000005e040000ea0200000f050000,Microsoft Xbox One,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,
 060000005e040000120b000009050000,Microsoft Xbox One,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,
-060000005e040000120b000014050000,Microsoft Xbox One,a:b0,b:b1,x:b2,y:b3,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux
 030000005e040000e302000003020000,Microsoft Xbox One Elite,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,
 030000005e040000000b000007040000,Microsoft Xbox One Elite 2,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,paddle1:b12,paddle2:b14,paddle3:b13,paddle4:b15,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000000b000008040000,Microsoft Xbox One Elite 2,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,paddle1:b12,paddle2:b14,paddle3:b13,paddle4:b15,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
@@ -1507,6 +1504,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 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,
 05000000d62000007162000001000000,Moga Pro 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,
+03000000c82d00000960000000000000,8BitDo Pro 3,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b17,paddle2:b16,paddle3:b2,paddle4:b5,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000c62400002b89000011010000,MOGA XP5A Plus,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:Linux,
 05000000c62400002a89000000010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b22,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,
 05000000c62400001a89000000010000,MOGA XP5X Plus,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:Linux,
@@ -1514,9 +1512,9 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005e0400008e02000010020000,MSI GC20 V2,a:b0,b:b1,back:b6,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,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,
 03000000f70600000100000000010000,N64 Adaptoid,+rightx:b2,+righty:b1,-rightx:b4,-righty:b5,a:b0,b:b3,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,platform:Linux,
 030000006b1400000906000014010000,Nacon Asymmetric Wireless PS4 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,
+030000006b140000010c000010010000,Nacon GC400ES,a:b0,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:b2,y:b3,platform:Linux,
 0300000085320000030c000011010000,Nacon GC100,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:Linux,
 03000000853200000706000012010000,Nacon GC100,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,
-030000006b140000010c000010010000,Nacon GC400ES,a:b0,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:b2,y:b3,platform:Linux,
 05000000853200000503000000010000,Nacon MGX Pro,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:Linux,
 0300000085320000170d000011010000,Nacon Revolution 5 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:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,
 0300000085320000190d000011010000,Nacon Revolution 5 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:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,
@@ -1802,17 +1800,17 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 05000000434f4d4d414e440000000000,VX Gaming Command Series,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 0000000058626f782033363020576900,Xbox 360 Controller,a:b0,b:b1,back:b14,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b7,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Linux,
 030000005e0400001907000000010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,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,
-030000005e0400008e02000000010000,Xbox 360 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,
-030000005e0400008e02000002010000,Xbox 360 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,
-030000005e0400008e02000010010000,Xbox 360 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,
-030000005e0400008e02000014010000,Xbox 360 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,
-030000005e0400008e02000047010000,Xbox 360 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,
-030000005e0400008e02000072050000,Xbox 360 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,
 030000005e0400009102000007010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,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,
 030000005e040000a102000000010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,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,
 030000005e040000a102000007010000,Xbox 360 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,
 030000005e040000a102000030060000,Xbox 360 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,
 030000006f0e00001503000000020000,Xbox 360 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,
+030000005e0400008e02000000010000,Xbox 360 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,
+030000005e0400008e02000010010000,Xbox 360 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,
+030000005e0400008e02000002010000,Xbox 360 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,
+030000005e0400008e02000014010000,Xbox 360 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,
+030000005e0400008e02000047010000,Xbox 360 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,
+030000005e0400008e02000072050000,Xbox 360 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,
 030000005e040000a102000014010000,Xbox 360 Receiver,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,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,
 0000000058626f782047616d65706100,Xbox 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:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400000202000000010000,Xbox Controller,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,
@@ -1,356 +0,0 @@
-// SPDX-FileCopyrightText: 2002-2025 PCSX2 Dev Team
-// SPDX-License-Identifier: GPL-3.0+
-
-#include "AsyncDialogs.h"
-
-#include "common/Assertions.h"
-
-#include <QtWidgets/QPushButton>
-
-template <typename Value>
-static std::function<void(std::optional<Value>)> wrapValueCallback(std::function<void(Value)> callback)
-{
-	return [callback = std::move(callback)](std::optional<Value> input) {
-		if (input.has_value())
-			callback(std::move(*input));
-	};
-}
-
-void AsyncDialogs::getText(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	const QString& text,
-	std::function<void(QString)> value_callback)
-{
-	getText(parent, title, label, QLineEdit::Normal, text, {}, Qt::ImhNone, wrapValueCallback(std::move(value_callback)));
-}
-
-void AsyncDialogs::getText(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	QLineEdit::EchoMode echo,
-	const QString& text,
-	Qt::WindowFlags flags,
-	Qt::InputMethodHints input_method_hints,
-	std::function<void(std::optional<QString>)> callback)
-{
-	QInputDialog* dialog = new QInputDialog(parent, flags);
-	dialog->setWindowTitle(title);
-	dialog->setLabelText(label);
-	dialog->setTextValue(text);
-	dialog->setTextEchoMode(echo);
-	dialog->setInputMethodHints(input_method_hints);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	if (callback)
-	{
-		QObject::connect(dialog, &QDialog::finished, [dialog, callback = std::move(callback)](int result) {
-			callback(result ? std::make_optional<QString>(dialog->textValue()) : std::nullopt);
-		});
-	}
-
-	dialog->open();
-}
-
-void AsyncDialogs::getMultiLineText(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	const QString& text,
-	std::function<void(QString)> value_callback)
-{
-	getMultiLineText(parent, title, label, text, {}, Qt::ImhNone, wrapValueCallback(std::move(value_callback)));
-}
-
-void AsyncDialogs::getMultiLineText(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	const QString& text,
-	Qt::WindowFlags flags,
-	Qt::InputMethodHints input_method_hints,
-	std::function<void(std::optional<QString>)> callback)
-{
-	QInputDialog* dialog = new QInputDialog(parent, flags);
-	dialog->setOptions(QInputDialog::UsePlainTextEditForTextInput);
-	dialog->setWindowTitle(title);
-	dialog->setLabelText(label);
-	dialog->setTextValue(text);
-	dialog->setInputMethodHints(input_method_hints);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	if (callback)
-	{
-		QObject::connect(dialog, &QDialog::finished, [dialog, callback = std::move(callback)](int result) {
-			callback(result ? std::make_optional<QString>(dialog->textValue()) : std::nullopt);
-		});
-	}
-
-	dialog->open();
-}
-
-void AsyncDialogs::getItem(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	const QStringList& items,
-	int current,
-	std::function<void(QString)> value_callback)
-{
-	getItem(parent, title, label, items, current, true, {}, Qt::ImhNone, wrapValueCallback(std::move(value_callback)));
-}
-
-void AsyncDialogs::getItem(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	const QStringList& items,
-	int current,
-	bool editable,
-	Qt::WindowFlags flags,
-	Qt::InputMethodHints input_method_hints,
-	std::function<void(std::optional<QString>)> callback)
-{
-	const QString text(items.value(current));
-
-	QInputDialog* dialog = new QInputDialog(parent, flags);
-	dialog->setWindowTitle(title);
-	dialog->setLabelText(label);
-	dialog->setComboBoxItems(items);
-	dialog->setTextValue(text);
-	dialog->setComboBoxEditable(editable);
-	dialog->setInputMethodHints(input_method_hints);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	if (callback)
-	{
-		QObject::connect(dialog, &QDialog::finished, [dialog, callback = std::move(callback)](int result) {
-			callback(result ? std::make_optional<QString>(dialog->textValue()) : std::nullopt);
-		});
-	}
-
-	dialog->open();
-}
-
-void AsyncDialogs::getInt(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	int value,
-	std::function<void(int)> value_callback)
-{
-	getInt(parent, title, label, value, -2147483647, 2147483647, 1, {}, wrapValueCallback(std::move(value_callback)));
-}
-
-void AsyncDialogs::getInt(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	int value,
-	int min_value,
-	int max_value,
-	int step,
-	Qt::WindowFlags flags,
-	std::function<void(std::optional<int>)> callback)
-{
-	QInputDialog* dialog = new QInputDialog(parent, flags);
-	dialog->setWindowTitle(title);
-	dialog->setLabelText(label);
-	dialog->setIntRange(min_value, max_value);
-	dialog->setIntValue(value);
-	dialog->setIntStep(step);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	if (callback)
-	{
-		QObject::connect(dialog, &QDialog::finished, [dialog, callback = std::move(callback)](int result) {
-			callback(result ? std::make_optional<int>(dialog->intValue()) : std::nullopt);
-		});
-	}
-
-	dialog->open();
-}
-
-void AsyncDialogs::getDouble(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	double value,
-	std::function<void(double)> callback)
-{
-	getDouble(parent, title, label, value, -2147483647, 2147483647, 1, {}, 1, wrapValueCallback(std::move(callback)));
-}
-
-void AsyncDialogs::getDouble(
-	QWidget* parent,
-	const QString& title,
-	const QString& label,
-	double value,
-	double min_value,
-	double max_value,
-	int decimals,
-	Qt::WindowFlags flags,
-	double step,
-	std::function<void(std::optional<double>)> callback)
-{
-	QInputDialog* dialog = new QInputDialog(parent, flags);
-	dialog->setWindowTitle(title);
-	dialog->setLabelText(label);
-	dialog->setDoubleDecimals(decimals);
-	dialog->setDoubleRange(min_value, max_value);
-	dialog->setDoubleValue(value);
-	dialog->setDoubleStep(step);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	if (callback)
-	{
-		QObject::connect(dialog, &QDialog::finished, [dialog, callback = std::move(callback)](int result) {
-			callback(result ? std::make_optional<double>(dialog->doubleValue()) : std::nullopt);
-		});
-	}
-
-	dialog->open();
-}
-
-// Based on the QMessageBoxPrivate::showNewMessageBox function from Qt Widgets.
-static void openAsyncMessageBox(QWidget* parent,
-	QMessageBox::Icon icon,
-	const QString& title,
-	const QString& text,
-	QMessageBox::StandardButtons buttons,
-	QMessageBox::StandardButton default_button,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	// Don't support the fallback for Qt 4.
-	pxAssert(!(default_button && !(buttons & default_button)));
-
-	QMessageBox* message_box = new QMessageBox(icon, title, text, QMessageBox::NoButton, parent);
-	message_box->setAttribute(Qt::WA_DeleteOnClose);
-
-	const QDialogButtonBox* button_box = message_box->findChild<QDialogButtonBox*>();
-	pxAssert(button_box);
-
-	u32 mask = QMessageBox::FirstButton;
-	while (mask <= QMessageBox::LastButton)
-	{
-		QMessageBox::StandardButton standard_button =
-			static_cast<QMessageBox::StandardButton>(static_cast<u32>(buttons) & mask);
-
-		mask <<= 1;
-
-		if (standard_button == QMessageBox::NoButton)
-			continue;
-
-		QPushButton* button = message_box->addButton(standard_button);
-
-		if (message_box->defaultButton())
-			continue;
-
-		if ((default_button == QMessageBox::NoButton &&
-				button_box->buttonRole(button) == QDialogButtonBox::AcceptRole) ||
-			(default_button != QMessageBox::NoButton &&
-				standard_button == default_button))
-			message_box->setDefaultButton(button);
-	}
-
-	if (callback)
-	{
-		QObject::connect(message_box, &QMessageBox::finished, [message_box, callback = std::move(callback)](int result) {
-			callback(message_box->standardButton(message_box->clickedButton()));
-		});
-	}
-
-	message_box->open();
-}
-
-void AsyncDialogs::information(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	information(parent, title, text, QMessageBox::Ok, QMessageBox::NoButton, std::move(callback));
-}
-
-void AsyncDialogs::information(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	QMessageBox::StandardButtons buttons,
-	QMessageBox::StandardButton default_button,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	openAsyncMessageBox(parent, QMessageBox::Information, title, text, buttons, default_button, std::move(callback));
-}
-
-void AsyncDialogs::question(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	std::function<void()> yes_callback)
-{
-	std::function<void(QMessageBox::StandardButton)> callback;
-	if (yes_callback)
-	{
-		callback = [yes_callback = std::move(yes_callback)](QMessageBox::StandardButton result) {
-			if (result == QMessageBox::Yes)
-				yes_callback();
-		};
-	}
-
-	const QMessageBox::StandardButtons buttons(QMessageBox::Yes | QMessageBox::No);
-	question(parent, title, text, buttons, QMessageBox::NoButton, std::move(callback));
-}
-
-void AsyncDialogs::question(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	QMessageBox::StandardButtons buttons,
-	QMessageBox::StandardButton default_button,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	openAsyncMessageBox(parent, QMessageBox::Question, title, text, buttons, default_button, std::move(callback));
-}
-
-void AsyncDialogs::warning(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	warning(parent, title, text, QMessageBox::Ok, QMessageBox::NoButton, std::move(callback));
-}
-
-void AsyncDialogs::warning(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	QMessageBox::StandardButtons buttons,
-	QMessageBox::StandardButton default_button,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	openAsyncMessageBox(parent, QMessageBox::Warning, title, text, buttons, default_button, std::move(callback));
-}
-
-void AsyncDialogs::critical(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	critical(parent, title, text, QMessageBox::Ok, QMessageBox::NoButton, std::move(callback));
-}
-
-void AsyncDialogs::critical(
-	QWidget* parent,
-	const QString& title,
-	const QString& text,
-	QMessageBox::StandardButtons buttons,
-	QMessageBox::StandardButton default_button,
-	std::function<void(QMessageBox::StandardButton)> callback)
-{
-	openAsyncMessageBox(parent, QMessageBox::Critical, title, text, buttons, default_button, std::move(callback));
-}
@@ -1,178 +0,0 @@
-// SPDX-FileCopyrightText: 2002-2025 PCSX2 Dev Team
-// SPDX-License-Identifier: GPL-3.0+
-
-#pragma once
-
-#include <QtWidgets/QInputDialog>
-#include <QtWidgets/QMessageBox>
-
-#include <functional>
-
-/// A collection of helper functions for opening asynchronous dialog boxes.
-/// These should be used in place of Qt's built-in blocking functions as those
-/// are prone to crashing if the parent is destroyed while the dialog is open.
-namespace AsyncDialogs
-{
-	/// Replacement for QInputDialog::getText.
-	void getText(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		const QString& text,
-		std::function<void(QString)> value_callback);
-
-	/// Replacement for QInputDialog::getText.
-	void getText(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		QLineEdit::EchoMode echo,
-		const QString& text,
-		Qt::WindowFlags flags,
-		Qt::InputMethodHints input_method_hints,
-		std::function<void(std::optional<QString>)> callback);
-
-	/// Replacement for QInputDialog::getMultiLineText.
-	void getMultiLineText(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		const QString& text,
-		std::function<void(QString)> value_callback);
-
-	/// Replacement for QInputDialog::getMultiLineText.
-	void getMultiLineText(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		const QString& text,
-		Qt::WindowFlags flags,
-		Qt::InputMethodHints input_method_hints,
-		std::function<void(std::optional<QString>)> callback);
-
-	/// Replacement for QInputDialog::getItem.
-	void getItem(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		const QStringList& items,
-		int current,
-		std::function<void(QString)> value_callback);
-
-	/// Replacement for QInputDialog::getItem.
-	void getItem(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		const QStringList& items,
-		int current,
-		bool editable,
-		Qt::WindowFlags flags,
-		Qt::InputMethodHints input_method_hints,
-		std::function<void(std::optional<QString>)> callback);
-
-	/// Replacement for QInputDialog::getInt.
-	void getInt(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		int value,
-		std::function<void(int)> value_callback);
-
-	/// Replacement for QInputDialog::getInt.
-	void getInt(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		int value,
-		int min_value,
-		int max_value,
-		int step,
-		Qt::WindowFlags flags,
-		std::function<void(std::optional<int>)> callback);
-
-	/// Replacement for QInputDialog::getDouble.
-	void getDouble(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		double value,
-		std::function<void(double)> value_callback);
-
-	/// Replacement for QInputDialog::getDouble.
-	void getDouble(
-		QWidget* parent,
-		const QString& title,
-		const QString& label,
-		double value,
-		double min_value,
-		double max_value,
-		int decimals,
-		Qt::WindowFlags flags,
-		double step,
-		std::function<void(std::optional<double>)> callback);
-
-	/// Replacement for QMessageBox::information.
-	void information(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-
-	/// Replacement for QMessageBox::information.
-	void information(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		QMessageBox::StandardButtons buttons,
-		QMessageBox::StandardButton default_button,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-
-	/// Replacement for QMessageBox::question.
-	void question(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		std::function<void()> yes_callback);
-
-	/// Replacement for QMessageBox::question.
-	void question(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		QMessageBox::StandardButtons buttons,
-		QMessageBox::StandardButton default_button,
-		std::function<void(QMessageBox::StandardButton)> callback);
-
-	/// Replacement for QMessageBox::warning.
-	void warning(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-
-	/// Replacement for QMessageBox::warning.
-	void warning(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		QMessageBox::StandardButtons buttons,
-		QMessageBox::StandardButton default_button,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-
-	/// Replacement for QMessageBox::critical.
-	void critical(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-
-	/// Replacement for QMessageBox::critical.
-	void critical(
-		QWidget* parent,
-		const QString& title,
-		const QString& text,
-		QMessageBox::StandardButtons buttons,
-		QMessageBox::StandardButton default_button,
-		std::function<void(QMessageBox::StandardButton)> callback = {});
-} // namespace AsyncDialogs
@@ -10,8 +10,6 @@ target_sources(pcsx2-qt PRIVATE
 	AboutDialog.cpp
 	AboutDialog.h
 	AboutDialog.ui
-	AsyncDialogs.cpp
-	AsyncDialogs.h
 	AutoUpdaterDialog.cpp
 	AutoUpdaterDialog.h
 	AutoUpdaterDialog.ui
@@ -2,13 +2,12 @@
 // SPDX-License-Identifier: GPL-3.0+

 #include "BreakpointDialog.h"
+#include "DebugTools/Breakpoints.h"

-#include "AsyncDialogs.h"
 #include "QtUtils.h"
 #include "QtHost.h"
-#include "Debugger/DebuggerWindow.h"
-
-#include "DebugTools/Breakpoints.h"
+#include <QtWidgets/QDialog>
+#include <QtWidgets/QMessageBox>

 BreakpointDialog::BreakpointDialog(QWidget* parent, DebugInterface* cpu, BreakpointModel& model)
 	: QDialog(parent)
@@ -101,7 +100,7 @@ void BreakpointDialog::accept()
 		u64 address;
 		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), address, error))
 		{
-			AsyncDialogs::warning(g_debugger_window, tr("Invalid Address"), QString::fromStdString(error));
+			QMessageBox::warning(this, tr("Invalid Address"), QString::fromStdString(error));
 			return;
 		}

@@ -117,7 +116,7 @@ void BreakpointDialog::accept()

 			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr, error))
 			{
-				AsyncDialogs::warning(g_debugger_window, tr("Invalid Condition"), QString::fromStdString(error));
+				QMessageBox::warning(this, tr("Invalid Condition"), QString::fromStdString(error));
 				return;
 			}

@@ -135,14 +134,14 @@ void BreakpointDialog::accept()
 		u64 startAddress;
 		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), startAddress, error))
 		{
-			AsyncDialogs::warning(g_debugger_window, tr("Invalid Address"), QString::fromStdString(error));
+			QMessageBox::warning(this, tr("Invalid Address"), QString::fromStdString(error));
 			return;
 		}

 		u64 size;
 		if (!m_cpu->evaluateExpression(m_ui.txtSize->text().toStdString().c_str(), size, error) || !size)
 		{
-			AsyncDialogs::warning(g_debugger_window, tr("Invalid Size"), QString::fromStdString(error));
+			QMessageBox::warning(this, tr("Invalid Size"), QString::fromStdString(error));
 			return;
 		}

@@ -158,7 +157,7 @@ void BreakpointDialog::accept()
 			PostfixExpression expr;
 			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr, error))
 			{
-				AsyncDialogs::warning(g_debugger_window, tr("Invalid Condition"), QString::fromStdString(error));
+				QMessageBox::warning(this, tr("Invalid Condition"), QString::fromStdString(error));
 				return;
 			}

@@ -3,11 +3,9 @@

 #include "BreakpointModel.h"

-#include "AsyncDialogs.h"
 #include "QtHost.h"
 #include "QtUtils.h"
 #include "Debugger/DebuggerSettingsManager.h"
-#include "Debugger/DebuggerWindow.h"

 #include "DebugTools/DebugInterface.h"
 #include "DebugTools/Breakpoints.h"
@@ -15,6 +13,7 @@
 #include "common/Console.h"

 #include <QtCore/QPointer>
+#include <QtWidgets/QMessageBox>

 #include <algorithm>

@@ -386,7 +385,7 @@ bool BreakpointModel::setData(const QModelIndex& index, const QVariant& value, i
 				std::string error;
 				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr, error))
 				{
-					AsyncDialogs::warning(g_debugger_window, "Condition Error", QString::fromStdString(error));
+					QMessageBox::warning(nullptr, "Condition Error", QString::fromStdString(error));
 					return false;
 				}

@@ -420,7 +419,7 @@ bool BreakpointModel::setData(const QModelIndex& index, const QVariant& value, i
 				std::string error;
 				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr, error))
 				{
-					AsyncDialogs::warning(g_debugger_window, "Condition Error", QString::fromStdString(error));
+					QMessageBox::warning(nullptr, "Condition Error", QString::fromStdString(error));
 					return false;
 				}

@@ -3,7 +3,6 @@

 #include "DebuggerWindow.h"

-#include "AsyncDialogs.h"
 #include "Debugger/DebuggerView.h"
 #include "Debugger/Docking/DockManager.h"

@@ -16,6 +15,8 @@
 #include "MainWindow.h"
 #include "AnalysisOptionsDialog.h"

+#include <QtWidgets/QMessageBox>
+
 DebuggerWindow* g_debugger_window = nullptr;

 DebuggerWindow::DebuggerWindow(QWidget* parent)
@@ -69,21 +70,19 @@ DebuggerWindow::DebuggerWindow(QWidget* parent)
 	});

 	connect(m_ui.actionResetAllLayouts, &QAction::triggered, this, [this]() {
-		const QString title = tr("Confirmation");
-		const QString text = tr("Are you sure you want to reset all layouts?");
+		QString text = tr("Are you sure you want to reset all layouts?");
+		if (QMessageBox::question(g_debugger_window, tr("Confirmation"), text) != QMessageBox::Yes)
+			return;

-		AsyncDialogs::question(this, title, text, [this]() {
-			m_dock_manager->resetAllLayouts();
-		});
+		m_dock_manager->resetAllLayouts();
 	});

 	connect(m_ui.actionResetDefaultLayouts, &QAction::triggered, this, [this]() {
-		const QString title = tr("Confirmation");
-		const QString text = tr("Are you sure you want to reset the default layouts?");
+		QString text = tr("Are you sure you want to reset the default layouts?");
+		if (QMessageBox::question(g_debugger_window, tr("Confirmation"), text) != QMessageBox::Yes)
+			return;

-		AsyncDialogs::question(this, title, text, [this]() {
-			m_dock_manager->resetDefaultLayouts();
-		});
+		m_dock_manager->resetDefaultLayouts();
 	});

 	connect(g_emu_thread, &EmuThread::onVMPaused, this, []() {
@@ -3,7 +3,6 @@

 #include "DisassemblyView.h"

-#include "AsyncDialogs.h"
 #include "Debugger/DebuggerWindow.h"
 #include "Debugger/JsonValueWrapper.h"
 #include "Debugger/Breakpoints/BreakpointModel.h"
@@ -19,6 +18,8 @@
 #include <QtGui/QMouseEvent>
 #include <QtWidgets/QMenu>
 #include <QtGui/QClipboard>
+#include <QtWidgets/QInputDialog>
+#include <QtWidgets/QMessageBox>
 #include "SymbolTree/NewSymbolDialogs.h"
 #include "common/StringUtil.h"

@@ -110,7 +111,7 @@ void DisassemblyView::contextPasteInstructionText()
 {
 	if (!cpu().isCpuPaused())
 	{
-		AsyncDialogs::warning(this, tr("Assemble Error"), tr("Unable to change assembly while core is running"));
+		QMessageBox::warning(this, tr("Assemble Error"), tr("Unable to change assembly while core is running"));
 		return;
 	}

@@ -129,7 +130,7 @@ void DisassemblyView::contextPasteInstructionText()
 		bool valid = MipsAssembleOpcode(newInstructions[instructionIdx].c_str(), &cpu(), replaceAddress, encodedInstruction, errorText);
 		if (!valid)
 		{
-			AsyncDialogs::warning(this, tr("Assemble Error"), QString("%1 %2").arg(errorText.c_str()).arg(newInstructions[instructionIdx].c_str()));
+			QMessageBox::warning(this, tr("Assemble Error"), QString("%1 %2").arg(errorText.c_str()).arg(newInstructions[instructionIdx].c_str()));
 			return;
 		}
 		encodedInstructions.push_back(encodedInstruction);
@@ -147,28 +148,29 @@ void DisassemblyView::contextAssembleInstruction()
 {
 	if (!cpu().isCpuPaused())
 	{
-		AsyncDialogs::warning(this, tr("Assemble Error"), tr("Unable to change assembly while core is running"));
+		QMessageBox::warning(this, tr("Assemble Error"), tr("Unable to change assembly while core is running"));
 		return;
 	}

 	DisassemblyLineInfo line;
+	bool ok;
 	m_disassemblyManager.getLine(m_selectedAddressStart, false, line);
+	QString instruction = QInputDialog::getText(this, tr("Assemble Instruction"), "",
+		QLineEdit::Normal, QString("%1 %2").arg(line.name.c_str()).arg(line.params.c_str()), &ok);

-	const QString title = tr("Assemble Instruction");
-	const QString text = QString("%1 %2").arg(line.name.c_str()).arg(line.params.c_str());
+	if (!ok)
+		return;

-	AsyncDialogs::getText(this, title, "", text, [this](QString instruction) {
-		u32 encodedInstruction;
-		std::string errorText;
-		bool valid = MipsAssembleOpcode(instruction.toLocal8Bit().constData(), &cpu(), m_selectedAddressStart, encodedInstruction, errorText);
-		if (!valid)
-		{
-			AsyncDialogs::warning(this, tr("Assemble Error"), QString::fromStdString(errorText));
-			return;
-		}
+	u32 encodedInstruction;
+	std::string errorText;
+	bool valid = MipsAssembleOpcode(instruction.toLocal8Bit().constData(), &cpu(), m_selectedAddressStart, encodedInstruction, errorText);
+	if (!valid)
+	{
+		QMessageBox::warning(this, tr("Assemble Error"), QString::fromStdString(errorText));
+		return;
+	}

-		setInstructions(m_selectedAddressStart, m_selectedAddressEnd, encodedInstruction);
-	});
+	setInstructions(m_selectedAddressStart, m_selectedAddressEnd, encodedInstruction);
 }

 void DisassemblyView::contextNoopInstruction()
@@ -247,34 +249,34 @@ void DisassemblyView::contextFollowBranch()

 void DisassemblyView::contextGoToAddress()
 {
-	const QString title = tr("Go To In Disassembly");
+	bool ok;
+	const QString targetString = QInputDialog::getText(this, tr("Go To In Disassembly"), "",
+		QLineEdit::Normal, "", &ok);

-	AsyncDialogs::getText(this, title, "", "", [this](QString expression) {
-		u64 address = 0;
-		std::string error;
-		if (!cpu().evaluateExpression(expression.toStdString().c_str(), address, error))
-		{
-			AsyncDialogs::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
-			return;
-		}
+	if (!ok)
+		return;

-		gotoAddressAndSetFocus(static_cast<u32>(address) & ~3);
-	});
+	u64 address = 0;
+	std::string error;
+	if (!cpu().evaluateExpression(targetString.toStdString().c_str(), address, error))
+	{
+		QMessageBox::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
+		return;
+	}
+
+	gotoAddressAndSetFocus(static_cast<u32>(address) & ~3);
 }

 void DisassemblyView::contextAddFunction()
 {
 	NewFunctionDialog* dialog = new NewFunctionDialog(cpu(), this);
+	dialog->setAttribute(Qt::WA_DeleteOnClose);
 	dialog->setName(QString("func_%1").arg(m_selectedAddressStart, 8, 16, QChar('0')));
 	dialog->setAddress(m_selectedAddressStart);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
 	if (m_selectedAddressEnd != m_selectedAddressStart)
 		dialog->setCustomSize(m_selectedAddressEnd - m_selectedAddressStart + 4);
-
-	connect(dialog, &QDialog::accepted, this, [this]() { update(); });
-
-	dialog->open();
+	if (dialog->exec() == QDialog::Accepted)
+		update();
 }

 void DisassemblyView::contextCopyFunctionName()
@@ -302,26 +304,28 @@ void DisassemblyView::contextRemoveFunction()
 void DisassemblyView::contextRenameFunction()
 {
 	const FunctionInfo curFunc = cpu().GetSymbolGuardian().FunctionOverlappingAddress(m_selectedAddressStart);
+
 	if (!curFunc.address.valid())
 	{
-		AsyncDialogs::warning(this, tr("Rename Function Error"), tr("No function / symbol is currently selected."));
+		QMessageBox::warning(this, tr("Rename Function Error"), tr("No function / symbol is currently selected."));
 		return;
 	}

-	const QString title = tr("Rename Function");
-	const QString label = tr("Function name");
-	const QString oldName = QString::fromStdString(curFunc.name);
+	QString oldName = QString::fromStdString(curFunc.name);

-	AsyncDialogs::getText(this, title, label, oldName, [this, curFunc](QString newName) {
-		if (newName.isEmpty())
-		{
-			AsyncDialogs::warning(this, tr("Rename Function Error"), tr("Function name cannot be nothing."));
-			return;
-		}
+	bool ok;
+	QString newName = QInputDialog::getText(this, tr("Rename Function"), tr("Function name"), QLineEdit::Normal, oldName, &ok);
+	if (!ok)
+		return;

-		cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
-			database.functions.rename_symbol(curFunc.handle, newName.toStdString());
-		});
+	if (newName.isEmpty())
+	{
+		QMessageBox::warning(this, tr("Rename Function Error"), tr("Function name cannot be nothing."));
+		return;
+	}
+
+	cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
+		database.functions.rename_symbol(curFunc.handle, newName.toStdString());
 	});
 }

@@ -371,7 +375,7 @@ void DisassemblyView::contextRestoreFunction()
 	}
 	else
 	{
-		AsyncDialogs::warning(this, tr("Restore Function Error"), tr("Unable to stub selected address."));
+		QMessageBox::warning(this, tr("Restore Function Error"), tr("Unable to stub selected address."));
 	}
 }

@@ -3,7 +3,6 @@

 #include "DockManager.h"

-#include "AsyncDialogs.h"
 #include "Debugger/DebuggerView.h"
 #include "Debugger/DebuggerWindow.h"
 #include "Debugger/Docking/DockTables.h"
@@ -25,6 +24,7 @@

 #include <QtCore/QTimer>
 #include <QtCore/QtTranslation>
+#include <QtWidgets/QMessageBox>
 #include <QtWidgets/QProxyStyle>
 #include <QtWidgets/QStyleFactory>

@@ -518,19 +518,17 @@ void DockManager::newLayoutClicked()
 	if (m_menu_bar)
 		m_menu_bar->onCurrentLayoutChanged(m_current_layout);

-	const auto name_validator = [this](const QString& name) {
+	auto name_validator = [this](const QString& name) {
 		return !hasNameConflict(name, DockLayout::INVALID_INDEX);
 	};

-	const bool can_clone_current_layout = m_current_layout != DockLayout::INVALID_INDEX;
+	bool can_clone_current_layout = m_current_layout != DockLayout::INVALID_INDEX;

-	LayoutEditorDialog* dialog = new LayoutEditorDialog(name_validator, can_clone_current_layout, g_debugger_window);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	connect(dialog, &QDialog::accepted, this, [this, dialog, name_validator]() {
-		if (!name_validator(dialog->name()))
-			return;
+	QPointer<LayoutEditorDialog> dialog = new LayoutEditorDialog(
+		name_validator, can_clone_current_layout, g_debugger_window);

+	if (dialog->exec() == QDialog::Accepted && name_validator(dialog->name()))
+	{
 		DockLayout::Index new_layout = DockLayout::INVALID_INDEX;

 		const auto [mode, index] = dialog->initialState();
@@ -567,9 +565,9 @@ void DockManager::newLayoutClicked()
 			updateLayoutSwitcher();
 			switchToLayout(new_layout);
 		}
-	});
+	}

-	dialog->open();
+	delete dialog.get();
 }

 void DockManager::openLayoutSwitcherContextMenu(const QPoint& pos, QTabBar* layout_switcher)
@@ -607,33 +605,26 @@ void DockManager::editLayoutClicked(DockLayout::Index layout_index)
 	if (layout_index >= m_layouts.size())
 		return;

-	const DockLayout& layout = m_layouts[layout_index];
+	DockLayout& layout = m_layouts[layout_index];

-	const auto name_validator = [this, layout_index](const QString& name) {
+	auto name_validator = [this, layout_index](const QString& name) {
 		return !hasNameConflict(name, layout_index);
 	};

-	LayoutEditorDialog* dialog = new LayoutEditorDialog(layout.name(), layout.cpu(), name_validator, g_debugger_window);
-	dialog->setAttribute(Qt::WA_DeleteOnClose);
+	QPointer<LayoutEditorDialog> dialog = new LayoutEditorDialog(
+		layout.name(), layout.cpu(), name_validator, g_debugger_window);

-	connect(dialog, &QDialog::accepted, this, [this, layout_index, dialog, name_validator]() {
-		if (layout_index >= m_layouts.size())
-			return;
+	if (dialog->exec() != QDialog::Accepted || !name_validator(dialog->name()))
+		return;

-		DockLayout& layout = m_layouts[layout_index];
+	layout.setName(dialog->name());
+	layout.setCpu(dialog->cpu());

-		if (!name_validator(dialog->name()))
-			return;
+	layout.save(layout_index);

-		layout.setName(dialog->name());
-		layout.setCpu(dialog->cpu());
+	delete dialog.get();

-		layout.save(layout_index);
-
-		updateLayoutSwitcher();
-	});
-
-	dialog->open();
+	updateLayoutSwitcher();
 }

 void DockManager::resetLayoutClicked(DockLayout::Index layout_index)
@@ -645,28 +636,20 @@ void DockManager::resetLayoutClicked(DockLayout::Index layout_index)
 	if (!layout.canReset())
 		return;

-	const QString title = tr("Confirmation");
-	const QString text = tr("Are you sure you want to reset layout '%1'?").arg(layout.name());
+	QString text = tr("Are you sure you want to reset layout '%1'?").arg(layout.name());
+	if (QMessageBox::question(g_debugger_window, tr("Confirmation"), text) != QMessageBox::Yes)
+		return;

-	AsyncDialogs::question(g_debugger_window, title, text, [this, layout_index]() {
-		if (layout_index >= m_layouts.size())
-			return;
+	bool current_layout = layout_index == m_current_layout;

-		DockLayout& layout = m_layouts[layout_index];
-		if (!layout.canReset())
-			return;
+	if (current_layout)
+		switchToLayout(DockLayout::INVALID_INDEX);

-		bool current_layout = layout_index == m_current_layout;
+	layout.reset();
+	layout.save(layout_index);

-		if (current_layout)
-			switchToLayout(DockLayout::INVALID_INDEX);
-
-		layout.reset();
-		layout.save(layout_index);
-
-		if (current_layout)
-			switchToLayout(layout_index);
-	});
+	if (current_layout)
+		switchToLayout(layout_index);
 }

 void DockManager::deleteLayoutClicked(DockLayout::Index layout_index)
@@ -676,16 +659,12 @@ void DockManager::deleteLayoutClicked(DockLayout::Index layout_index)

 	DockLayout& layout = m_layouts[layout_index];

-	const QString title = tr("Confirmation");
-	const QString text = tr("Are you sure you want to delete layout '%1'?").arg(layout.name());
+	QString text = tr("Are you sure you want to delete layout '%1'?").arg(layout.name());
+	if (QMessageBox::question(g_debugger_window, tr("Confirmation"), text) != QMessageBox::Yes)
+		return;

-	AsyncDialogs::question(g_debugger_window, title, text, [this, layout_index]() {
-		if (layout_index >= m_layouts.size())
-			return;
-
-		deleteLayout(layout_index);
-		updateLayoutSwitcher();
-	});
+	deleteLayout(layout_index);
+	updateLayoutSwitcher();
 }

 void DockManager::layoutSwitcherTabMoved(DockLayout::Index from_index, DockLayout::Index to_index)
@@ -3,7 +3,6 @@

 #include "DockViews.h"

-#include "AsyncDialogs.h"
 #include "QtUtils.h"
 #include "Debugger/DebuggerView.h"
 #include "Debugger/DebuggerWindow.h"
@@ -18,6 +17,8 @@

 #include <QtGui/QActionGroup>
 #include <QtGui/QPalette>
+#include <QtWidgets/QInputDialog>
+#include <QtWidgets/QMessageBox>
 #include <QtWidgets/QMenu>
 #include <QtWidgets/QStyleFactory>

@@ -175,22 +176,19 @@ void DockTabBar::openContextMenu(QPoint pos)
 		if (!widget)
 			return;

-		const QString title = tr("Rename Window");
-		const QString label = tr("New name:");
-		const QString text = widget->displayNameWithoutSuffix();
+		bool ok;
+		QString new_name = QInputDialog::getText(
+			this, tr("Rename Window"), tr("New name:"), QLineEdit::Normal, widget->displayNameWithoutSuffix(), &ok);
+		if (!ok)
+			return;

-		AsyncDialogs::getText(this, title, label, text, [this, widget = QPointer(widget)](QString name) {
-			if (!widget || !g_debugger_window)
-				return;
+		if (!widget->setCustomDisplayName(new_name))
+		{
+			QMessageBox::warning(this, tr("Invalid Name"), tr("The specified name is too long."));
+			return;
+		}

-			if (!widget->setCustomDisplayName(name))
-			{
-				AsyncDialogs::warning(this, tr("Invalid Name"), tr("The specified name is too long."));
-				return;
-			}
-
-			g_debugger_window->dockManager().updateDockWidgetTitles();
-		});
+		g_debugger_window->dockManager().updateDockWidgetTitles();
 	});

 	QAction* reset_name_action = menu->addAction(tr("Reset Name"));
@@ -3,16 +3,16 @@

 #include "MemorySearchView.h"

-#include "AsyncDialogs.h"
-#include "QtUtils.h"
-
 #include "DebugTools/DebugInterface.h"

+#include "QtUtils.h"
+
 #include "common/Console.h"

 #include <QtGui/QClipboard>
 #include <QtWidgets/QMenu>
 #include <QtWidgets/QScrollBar>
+#include <QtWidgets/QMessageBox>
 #include <QtConcurrent/QtConcurrent>
 #include <QtCore/QFutureWatcher>
 #include <QtGui/QPainter>
@@ -478,7 +478,7 @@ void MemorySearchView::onSearchButtonClicked()

 	if (!ok)
 	{
-		AsyncDialogs::critical(this, tr("Debugger"), tr("Invalid start address"));
+		QMessageBox::critical(this, tr("Debugger"), tr("Invalid start address"));
 		return;
 	}

@@ -486,13 +486,13 @@ void MemorySearchView::onSearchButtonClicked()

 	if (!ok)
 	{
-		AsyncDialogs::critical(this, tr("Debugger"), tr("Invalid end address"));
+		QMessageBox::critical(this, tr("Debugger"), tr("Invalid end address"));
 		return;
 	}

 	if (searchStart >= searchEnd)
 	{
-		AsyncDialogs::critical(this, tr("Debugger"), tr("Start address can't be equal to or greater than the end address"));
+		QMessageBox::critical(this, tr("Debugger"), tr("Start address can't be equal to or greater than the end address"));
 		return;
 	}

@@ -527,7 +527,7 @@ void MemorySearchView::onSearchButtonClicked()

 			if (!ok)
 			{
-				AsyncDialogs::critical(this, tr("Debugger"), tr("Invalid search value"));
+				QMessageBox::critical(this, tr("Debugger"), tr("Invalid search value"));
 				return;
 			}

@@ -551,7 +551,7 @@ void MemorySearchView::onSearchButtonClicked()
 					if (value <= std::numeric_limits<unsigned char>::max())
 						break;
 				default:
-					AsyncDialogs::critical(this, tr("Debugger"), tr("Value is larger than type"));
+					QMessageBox::critical(this, tr("Debugger"), tr("Value is larger than type"));
 					return;
 			}
 		}
@@ -565,7 +565,7 @@ void MemorySearchView::onSearchButtonClicked()
 				searchComparison == SearchComparison::IncreasedBy ||
 				searchComparison == SearchComparison::NotChanged))
 		{
-			AsyncDialogs::critical(this, tr("Debugger"), tr("This search comparison can only be used with filter searches."));
+			QMessageBox::critical(this, tr("Debugger"), tr("This search comparison can only be used with filter searches."));
 			return;
 		}
 	}
@@ -578,7 +578,7 @@ void MemorySearchView::onSearchButtonClicked()
 							   searchComparison == SearchComparison::IncreasedBy ||
 							   searchComparison == SearchComparison::NotChanged))
 	{
-		AsyncDialogs::critical(this, tr("Debugger"), tr("This search comparison can only be used with filter searches."));
+		QMessageBox::critical(this, tr("Debugger"), tr("This search comparison can only be used with filter searches."));
 		return;
 	}

@@ -3,7 +3,6 @@

 #include "MemoryView.h"

-#include "AsyncDialogs.h"
 #include "Debugger/JsonValueWrapper.h"

 #include "QtHost.h"
@@ -13,6 +12,8 @@
 #include <QtGui/QActionGroup>
 #include <QtGui/QClipboard>
 #include <QtGui/QMouseEvent>
+#include <QtWidgets/QInputDialog>
+#include <QtWidgets/QMessageBox>

 using namespace QtUtils;

@@ -304,33 +305,36 @@ bool MemoryViewTable::InsertFloatIntoSelectedHexView(DebugInterface& cpu)
 	std::memcpy(&currentFloatVal, &currentIntVal, sizeof(currentFloatVal));
 	const QString currentfloatStr = QString("%1").arg(QString::number(currentFloatVal, 'g'), 14).trimmed();

-	const QString title = tr("Input New Float");
+	// Prompt user to enter a new float value
+	bool isValidInput = false;
+	QString newFloatStr = QInputDialog::getText(parent, tr("Input New Float"), "",
+		QLineEdit::Normal, currentfloatStr, &isValidInput);
+	if (!isValidInput)
+		return false;

-	AsyncDialogs::getText(parent, title, "", currentfloatStr, [this, &cpu](QString newFloatStr) {
-		// Convert string into float value
-		bool isValidFloat = false;
-		const float newFloatVal = newFloatStr.toFloat(&isValidFloat);
-		if (!isValidFloat)
-		{
-			AsyncDialogs::warning(parent, tr("Input Error"), tr("Invalid float value"));
-			return;
-		}
+	// Convert string into float value
+	bool isValidFloat = false;
+	const float newFloatVal = newFloatStr.toFloat(&isValidFloat);
+	if (!isValidFloat)
+	{
+		QMessageBox::warning(parent, tr("Input Error"), tr("Invalid float value"));
+		return false;
+	}

-		// Write new float value back to memory
-		u32 newIntVal = 0;
-		std::memcpy(&newIntVal, &newFloatVal, sizeof(newIntVal));
-		newIntVal = convertEndian(newIntVal);
+	// Write new float value back to memory
+	u32 newIntVal = 0;
+	std::memcpy(&newIntVal, &newFloatVal, sizeof(newIntVal));
+	newIntVal = convertEndian(newIntVal);

-		const QPointer<MemoryViewTable> table(this);
-		Host::RunOnCPUThread([table, address = selectedAddress, &cpu, val = newIntVal] {
-			cpu.write32(address, val);
+	const QPointer<MemoryViewTable> table(this);
+	Host::RunOnCPUThread([table, address = selectedAddress, &cpu, val = newIntVal] {
+		cpu.write32(address, val);

-			QtHost::RunOnUIThread([table] {
-				if (!table)
-					return;
+		QtHost::RunOnUIThread([table] {
+			if (!table)
+				return;

-				table->parent->update();
-			});
+			table->parent->update();
 		});
 	});

@@ -349,7 +353,7 @@ void MemoryViewTable::InsertAtCurrentSelection(const QString& text, DebugInterfa
 		const float newFloatVal = text.toFloat(&isValidFloat);
 		if (!isValidFloat)
 		{
-			AsyncDialogs::warning(parent, tr("Input Error"), tr("Invalid float value"));
+			QMessageBox::warning(parent, tr("Input Error"), tr("Invalid float value"));
 			return;
 		}

@@ -895,19 +899,22 @@ void MemoryView::contextPaste()

 void MemoryView::contextGoToAddress()
 {
-	const QString title = tr("Go To In Memory View");
+	bool ok;
+	QString targetString = QInputDialog::getText(this, tr("Go To In Memory View"), "",
+		QLineEdit::Normal, "", &ok);

-	AsyncDialogs::getText(this, title, "", "", [this](QString expression) {
-		u64 address = 0;
-		std::string error;
-		if (!cpu().evaluateExpression(expression.toStdString().c_str(), address, error))
-		{
-			AsyncDialogs::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
-			return;
-		}
+	if (!ok)
+		return;

-		gotoAddress(static_cast<u32>(address));
-	});
+	u64 address = 0;
+	std::string error;
+	if (!cpu().evaluateExpression(targetString.toStdString().c_str(), address, error))
+	{
+		QMessageBox::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
+		return;
+	}
+
+	gotoAddress(static_cast<u32>(address));
 }

 void MemoryView::contextFollowAddress()
@@ -3,16 +3,17 @@

 #include "RegisterView.h"

-#include "AsyncDialogs.h"
-#include "QtUtils.h"
 #include "Debugger/JsonValueWrapper.h"

+#include "QtUtils.h"
 #include <QtGui/QMouseEvent>
 #include <QtWidgets/QTabBar>
 #include <QtWidgets/QStylePainter>
 #include <QtWidgets/QStyleOptionTab>
 #include <QtGui/QClipboard>
+#include <QtWidgets/QInputDialog>
 #include <QtWidgets/QProxyStyle>
+#include <QtWidgets/QMessageBox>

 #include <bit>

@@ -350,11 +351,12 @@ void RegisterView::contextCopySegment()
 		QApplication::clipboard()->setText(FilledQStringFromValue(val._u32[3 - m_selected128Field], 16));
 }

-void RegisterView::fetchNewValue(u64 currentValue, bool segment, std::function<void(u64)> callback)
+bool RegisterView::contextFetchNewValue(u64& out, u64 currentValue, bool segment)
 {
 	const int categoryIndex = ui.registerTabs->currentIndex();
 	const bool floatingPoint = CAT_SHOW_FLOAT && segment;
 	const int regSize = cpu().getRegisterSize(categoryIndex);
+	bool ok = false;

 	QString existingValue("%1");

@@ -364,89 +366,79 @@ void RegisterView::fetchNewValue(u64 currentValue, bool segment, std::function<v
 		existingValue = existingValue.arg(std::bit_cast<float>((u32)currentValue));

 	//: Changing the value in a CPU register (e.g. "Change t0")
-	const QString title = tr("Change %1").arg(cpu().getRegisterName(categoryIndex, m_selectedRow));
+	QString input = QInputDialog::getText(this, tr("Change %1").arg(cpu().getRegisterName(categoryIndex, m_selectedRow)), "",
+		QLineEdit::Normal, existingValue, &ok);

-	AsyncDialogs::getText(this, title, "", existingValue, [this, callback, floatingPoint](QString input) {
-		u64 value;
-		if (!floatingPoint) // Get input as hexadecimal
-		{
-			bool ok;
-			value = input.toULongLong(&ok, 16);
-			if (!ok)
-			{
-				AsyncDialogs::warning(this, tr("Invalid register value"), tr("Invalid hexadecimal register value."));
-				return;
-			}
-		}
-		else
-		{
-			bool ok;
-			value = std::bit_cast<u32>(input.toFloat(&ok));
-			if (!ok)
-			{
-				AsyncDialogs::warning(this, tr("Invalid register value"), tr("Invalid floating-point register value."));
-				return;
-			}
-		}
+	if (!ok)
+		return false;

-		callback(value);
-	});
+	if (!floatingPoint) // Get input as hexadecimal
+	{
+		out = input.toULongLong(&ok, 16);
+		if (!ok)
+		{
+			QMessageBox::warning(this, tr("Invalid register value"), tr("Invalid hexadecimal register value."));
+			return false;
+		}
+	}
+	else
+	{
+		out = std::bit_cast<u32>(input.toFloat(&ok));
+		if (!ok)
+		{
+			QMessageBox::warning(this, tr("Invalid register value"), tr("Invalid floating-point register value."));
+			return false;
+		}
+	}
+
+	return true;
 }

 void RegisterView::contextChangeValue()
 {
-	const int category_index = ui.registerTabs->currentIndex();
-	const s32 row = m_selectedRow;
-	const u32 old_value = cpu().getRegister(category_index, row).lo;
-
-	fetchNewValue(old_value, false, [this, category_index, row](u64 input) {
-		cpu().setRegister(category_index, row, u128::From64(input));
+	const int categoryIndex = ui.registerTabs->currentIndex();
+	u64 newVal;
+	if (contextFetchNewValue(newVal, cpu().getRegister(categoryIndex, m_selectedRow).lo))
+	{
+		cpu().setRegister(categoryIndex, m_selectedRow, u128::From64(newVal));
 		DebuggerView::broadcastEvent(DebuggerEvents::VMUpdate());
-	});
+	}
 }

 void RegisterView::contextChangeTop()
 {
-	const int category_index = ui.registerTabs->currentIndex();
-	const s32 row = m_selectedRow;
-	const u128 old_value = cpu().getRegister(category_index, row);
-
-	fetchNewValue(old_value.hi, false, [this, category_index, row, old_value](u32 input) {
-		u128 new_value = old_value;
-		new_value.hi = input;
-		cpu().setRegister(category_index, row, new_value);
+	u64 newVal;
+	u128 oldVal = cpu().getRegister(ui.registerTabs->currentIndex(), m_selectedRow);
+	if (contextFetchNewValue(newVal, oldVal.hi))
+	{
+		oldVal.hi = newVal;
+		cpu().setRegister(ui.registerTabs->currentIndex(), m_selectedRow, oldVal);
 		DebuggerView::broadcastEvent(DebuggerEvents::VMUpdate());
-	});
+	}
 }

 void RegisterView::contextChangeBottom()
 {
-	const int category_index = ui.registerTabs->currentIndex();
-	const s32 row = m_selectedRow;
-	const u128 old_value = cpu().getRegister(category_index, row);
-
-	fetchNewValue(old_value.lo, false, [this, category_index, row, old_value](u32 input) {
-		u128 new_value = old_value;
-		new_value.lo = input;
-		cpu().setRegister(category_index, row, new_value);
+	u64 newVal;
+	u128 oldVal = cpu().getRegister(ui.registerTabs->currentIndex(), m_selectedRow);
+	if (contextFetchNewValue(newVal, oldVal.lo))
+	{
+		oldVal.lo = newVal;
+		cpu().setRegister(ui.registerTabs->currentIndex(), m_selectedRow, oldVal);
 		DebuggerView::broadcastEvent(DebuggerEvents::VMUpdate());
-	});
+	}
 }

 void RegisterView::contextChangeSegment()
 {
-	const int category_index = ui.registerTabs->currentIndex();
-	const s32 row = m_selectedRow;
-	const s32 field = m_selected128Field;
-	const u128 old_value = cpu().getRegister(category_index, row);
-	const u32 segment = old_value._u32[3 - field];
-
-	fetchNewValue(segment, false, [this, category_index, row, field, old_value](u32 input) {
-		u128 new_value = old_value;
-		new_value._u32[3 - field] = input;
-		cpu().setRegister(category_index, row, new_value);
+	u64 newVal;
+	u128 oldVal = cpu().getRegister(ui.registerTabs->currentIndex(), m_selectedRow);
+	if (contextFetchNewValue(newVal, oldVal._u32[3 - m_selected128Field], true))
+	{
+		oldVal._u32[3 - m_selected128Field] = (u32)newVal;
+		cpu().setRegister(ui.registerTabs->currentIndex(), m_selectedRow, oldVal);
 		DebuggerView::broadcastEvent(DebuggerEvents::VMUpdate());
-	});
+	}
 }

 std::optional<DebuggerEvents::GoToAddress> RegisterView::contextCreateGotoEvent()
@@ -462,7 +454,7 @@ std::optional<DebuggerEvents::GoToAddress> RegisterView::contextCreateGotoEvent(

 	if (!cpu().isValidAddress(addr))
 	{
-		AsyncDialogs::warning(
+		QMessageBox::warning(
 			this,
 			tr("Invalid target address"),
 			tr("This register holds an invalid address."));
@@ -49,7 +49,8 @@ public slots:
 private:
 	Ui::RegisterView ui;

-	void fetchNewValue(u64 currentValue, bool segment, std::function<void(u64)> callback);
+	// Returns true on success
+	bool contextFetchNewValue(u64& out, u64 currentValue, bool segment = false);

 	// Used for the height offset the tab bar creates
 	// because we share a widget
@@ -3,14 +3,13 @@

 #include "NewSymbolDialogs.h"

-#include "AsyncDialogs.h"
-#include "Debugger/DebuggerWindow.h"
-#include "Debugger/SymbolTree/TypeString.h"
-
 #include <QtCore/QTimer>
 #include <QtCore/QMetaMethod>
+#include <QtWidgets/QMessageBox>
 #include <QtWidgets/QPushButton>

+#include "TypeString.h"
+
 NewSymbolDialog::NewSymbolDialog(u32 flags, u32 alignment, DebugInterface& cpu, QWidget* parent)
 	: QDialog(parent)
 	, m_cpu(cpu)
@@ -360,7 +359,7 @@ void NewFunctionDialog::createSymbol()
 	});

 	if (!error_message.isEmpty())
-		AsyncDialogs::warning(g_debugger_window, tr("Cannot Create Function"), error_message);
+		QMessageBox::warning(this, tr("Cannot Create Function"), error_message);
 }

 // *****************************************************************************
@@ -417,7 +416,7 @@ void NewGlobalVariableDialog::createSymbol()
 	});

 	if (!error_message.isEmpty())
-		AsyncDialogs::warning(g_debugger_window, tr("Cannot Create Global Variable"), error_message);
+		QMessageBox::warning(this, tr("Cannot Create Global Variable"), error_message);
 }

 // *****************************************************************************
@@ -535,7 +534,7 @@ void NewLocalVariableDialog::createSymbol()
 	});

 	if (!error_message.isEmpty())
-		AsyncDialogs::warning(g_debugger_window, tr("Cannot Create Local Variable"), error_message);
+		QMessageBox::warning(this, tr("Cannot Create Local Variable"), error_message);
 }

 // *****************************************************************************
@@ -649,5 +648,5 @@ void NewParameterVariableDialog::createSymbol()
 	});

 	if (!error_message.isEmpty())
-		AsyncDialogs::warning(g_debugger_window, tr("Cannot Create Parameter Variable"), error_message);
+		QMessageBox::warning(this, tr("Cannot Create Parameter Variable"), error_message);
 }
@@ -3,7 +3,6 @@

 #include "SymbolTreeDelegates.h"

-#include "AsyncDialogs.h"
 #include "Debugger/SymbolTree/SymbolTreeModel.h"
 #include "Debugger/SymbolTree/TypeString.h"

@@ -11,6 +10,7 @@
 #include <QtWidgets/QComboBox>
 #include <QtWidgets/QDoubleSpinBox>
 #include <QtWidgets/QLineEdit>
+#include <QtWidgets/QMessageBox>

 SymbolTreeValueDelegate::SymbolTreeValueDelegate(
 	DebugInterface& cpu,
@@ -495,7 +495,7 @@ void SymbolTreeTypeDelegate::setModelData(QWidget* editor, QAbstractItemModel* m
 		symbol_tree_model->resetChildren(index);
 	}
 	else
-		AsyncDialogs::warning(editor, tr("Cannot Change Type"), error_message);
+		QMessageBox::warning(editor, tr("Cannot Change Type"), error_message);
 }

 // *****************************************************************************
@@ -3,14 +3,15 @@

 #include "SymbolTreeViews.h"

-#include "AsyncDialogs.h"
 #include "Debugger/JsonValueWrapper.h"
 #include "Debugger/SymbolTree/NewSymbolDialogs.h"
 #include "Debugger/SymbolTree/SymbolTreeDelegates.h"

 #include <QtGui/QActionGroup>
 #include <QtGui/QClipboard>
+#include <QtWidgets/QInputDialog>
 #include <QtWidgets/QMenu>
+#include <QtWidgets/QMessageBox>
 #include <QtWidgets/QScrollBar>

 static bool testName(const QString& name, const QString& filter);
@@ -642,16 +643,14 @@ void SymbolTreeView::onDeleteButtonPressed()
 	if (!node->symbol.valid())
 		return;

-	const QString title = tr("Confirm Deletion");
-	const QString text = tr("Delete '%1'?").arg(node->name);
+	if (QMessageBox::question(this, tr("Confirm Deletion"), tr("Delete '%1'?").arg(node->name)) != QMessageBox::Yes)
+		return;

-	AsyncDialogs::question(this, title, text, [this, handle = node->symbol]() {
-		cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
-			handle.destroy_symbol(database, true);
-		});
-
-		reset();
+	cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
+		node->symbol.destroy_symbol(database, true);
 	});
+
+	reset();
 }

 void SymbolTreeView::onCopyName()
@@ -702,10 +701,13 @@ void SymbolTreeView::onRenameSymbol()
 		text = QString::fromStdString(symbol->name());
 	});

-	AsyncDialogs::getText(this, title, label, text, [this, handle = node->symbol](QString new_name) {
-		cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
-			handle.rename_symbol(new_name.toStdString(), database);
-		});
+	bool ok;
+	std::string name = QInputDialog::getText(this, title, label, QLineEdit::Normal, text, &ok).toStdString();
+	if (!ok)
+		return;
+
+	cpu().GetSymbolGuardian().ReadWrite([&](ccc::SymbolDatabase& database) {
+		node->symbol.rename_symbol(name, database);
 	});
 }

@@ -735,15 +737,18 @@ void SymbolTreeView::onChangeTypeTemporarily()
 	std::optional<QString> old_type = m_model->typeFromModelIndexToString(index);
 	if (!old_type.has_value())
 	{
-		AsyncDialogs::warning(this, tr("Cannot Change Type"), tr("That node cannot have a type."));
+		QMessageBox::warning(this, tr("Cannot Change Type"), tr("That node cannot have a type."));
 		return;
 	}

-	AsyncDialogs::getText(this, title, label, *old_type, [this, index](QString type_string) {
-		std::optional<QString> error_message = m_model->changeTypeTemporarily(index, type_string.toStdString());
-		if (error_message.has_value() && !error_message->isEmpty())
-			AsyncDialogs::warning(this, tr("Cannot Change Type"), *error_message);
-	});
+	bool ok;
+	QString type_string = QInputDialog::getText(this, title, label, QLineEdit::Normal, *old_type, &ok);
+	if (!ok)
+		return;
+
+	std::optional<QString> error_message = m_model->changeTypeTemporarily(index, type_string.toStdString());
+	if (error_message.has_value() && !error_message->isEmpty())
+		QMessageBox::warning(this, tr("Cannot Change Type"), *error_message);
 }

 void SymbolTreeView::onTreeViewClicked(const QModelIndex& index)
@@ -857,10 +862,8 @@ void FunctionTreeView::onNewButtonPressed()
 {
 	NewFunctionDialog* dialog = new NewFunctionDialog(cpu(), this);
 	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	connect(dialog, &QDialog::accepted, this, &FunctionTreeView::reset);
-
-	dialog->open();
+	if (dialog->exec() == QDialog::Accepted)
+		reset();
 }

 // *****************************************************************************
@@ -1002,10 +1005,8 @@ void GlobalVariableTreeView::onNewButtonPressed()
 {
 	NewGlobalVariableDialog* dialog = new NewGlobalVariableDialog(cpu(), this);
 	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	connect(dialog, &QDialog::accepted, this, &GlobalVariableTreeView::reset);
-
-	dialog->open();
+	if (dialog->exec() == QDialog::Accepted)
+		reset();
 }

 // *****************************************************************************
@@ -1133,10 +1134,8 @@ void LocalVariableTreeView::onNewButtonPressed()
 {
 	NewLocalVariableDialog* dialog = new NewLocalVariableDialog(cpu(), this);
 	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	connect(dialog, &QDialog::accepted, this, &LocalVariableTreeView::reset);
-
-	dialog->open();
+	if (dialog->exec() == QDialog::Accepted)
+		reset();
 }

 // *****************************************************************************
@@ -1262,10 +1261,8 @@ void ParameterVariableTreeView::onNewButtonPressed()
 {
 	NewParameterVariableDialog* dialog = new NewParameterVariableDialog(cpu(), this);
 	dialog->setAttribute(Qt::WA_DeleteOnClose);
-
-	connect(dialog, &QDialog::accepted, this, &ParameterVariableTreeView::reset);
-
-	dialog->open();
+	if (dialog->exec() == QDialog::Accepted)
+		reset();
 }

 static bool testName(const QString& name, const QString& filter)
@@ -89,7 +89,6 @@
    <Manifest Include="..\pcsx2\windows\PCSX2.manifest" />
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="AsyncDialogs.cpp" />
    <ClCompile Include="ColorPickerButton.cpp" />
    <ClCompile Include="Debugger\SymbolTree\NewSymbolDialogs.cpp" />
    <ClCompile Include="Debugger\SymbolTree\SymbolTreeDelegates.cpp" />
@@ -184,7 +183,6 @@
    <ClCompile Include="VCRuntimeChecker.cpp" />
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="AsyncDialogs.h" />
    <QtMoc Include="SetupWizardDialog.h" />
    <QtMoc Include="Settings\InterfaceSettingsWidget.h" />
    <QtMoc Include="Settings\GameListSettingsWidget.h" />
@@ -43,7 +43,6 @@
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="PrecompiledHeader.cpp" />
-    <ClCompile Include="AsyncDialogs.cpp" />
    <ClCompile Include="QtHost.cpp" />
    <ClCompile Include="MainWindow.cpp" />
    <ClCompile Include="$(IntDir)moc_MainWindow.cpp">
@@ -519,7 +518,6 @@
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="PrecompiledHeader.h" />
-    <ClInclude Include="AsyncDialogs.h" />
    <ClInclude Include="QtUtils.h" />
    <ClInclude Include="SettingWidgetBinder.h" />
    <ClInclude Include="Settings\HddCreateQt.h">
@@ -3560,7 +3560,7 @@ __forceinline bool AreTrianglesQuad(const GSVertex* RESTRICT vin, const u16* RES
 	return are_quad;
 }

-__forceinline bool AreTrianglesQuadNonAA(const GSVertex* RESTRICT vin, const u16* RESTRICT index0, const u16* RESTRICT index1)
+bool GSState::AreTrianglesQuadNonAA(const GSVertex* RESTRICT vin, const u16* RESTRICT index0, const u16* RESTRICT index1)
 {
 	u32 v0[3] = {
 		vin[index0[0]].XYZ.U32[0],
@@ -478,6 +478,7 @@ public:
 	
 	template<bool shuffle_check>
 	bool TrianglesAreQuadsImpl();
+	bool AreTrianglesQuadNonAA(const GSVertex* RESTRICT vin, const u16* RESTRICT index0, const u16* RESTRICT index1);
 	bool TrianglesAreQuads(bool shuffle_check = false);
 	template <u32 primclass>
 	PRIM_OVERLAP GetPrimitiveOverlapDrawlistImpl(bool save_drawlist = false, bool save_bbox = false, float bbox_scale = 1.0f);
@@ -4711,31 +4711,260 @@ void GSRendererHW::Draw()
 	// Note: second hack corrects only the texture coordinate
 	// Be careful to not correct downscaled targets, this can get messy and break post processing
 	// but it still needs to adjust native stuff from memory as it's not been compensated for upscaling (Dragon Quest 8 font for example).
-	if (CanUpscale() && (m_vt.m_primclass == GS_SPRITE_CLASS) && rt && rt->GetScale() > 1.0f)
+	if (CanUpscale() && ((m_vt.m_primclass == GS_SPRITE_CLASS) || ((m_index.tail % 6 == 0) && m_vt.m_primclass == GS_TRIANGLE_CLASS && m_vt.m_eq.z)) && rt && rt->GetScale() > 1.0f)
 	{
-		const u32 count = m_vertex.next;
-		GSVertex* v = &m_vertex.buff[0];
+		bool valid_format = true;

-		// Hack to avoid vertical black line in various games (ace combat/tekken)
-		if (GSConfig.UserHacks_AlignSpriteX)
+		if (m_vt.m_primclass == GS_TRIANGLE_CLASS)
 		{
-			// Note for performance reason I do the check only once on the first
-			// primitive
-			const int win_position = v[1].XYZ.X - context->XYOFFSET.OFX;
-			const bool unaligned_position = ((win_position & 0xF) == 8);
-			const bool unaligned_texture = ((v[1].U & 0xF) == 0) && PRIM->FST; // I'm not sure this check is useful
-			const bool hole_in_vertex = (count < 4) || (v[1].XYZ.X != v[2].XYZ.X);
-			if (hole_in_vertex && unaligned_position && (unaligned_texture || !PRIM->FST))
+			const GSVertex* RESTRICT v = m_vertex.buff;
+			const u16* RESTRICT index = m_index.buff;
+			const size_t count = m_index.tail;
+
+			for (int i = 0; i < count; i += 6)
 			{
-				// Normaly vertex are aligned on full pixels and texture in half
-				// pixels. Let's extend the coverage of an half-pixel to avoid
-				// hole after upscaling
-				for (u32 i = 0; i < count; i += 2)
+				// Non-axis aligned check when only two triangles
+				if (!AreTrianglesQuadNonAA(v, &index[i], &index[i + 3]))
 				{
-					v[i + 1].XYZ.X += 8;
-					// I really don't know if it is a good idea. Neither what to do for !PRIM->FST
-					if (unaligned_texture)
-						v[i + 1].U += 8;
+					valid_format = false;
+					break;
+				}
+			}
+		}
+		if (valid_format)
+		{
+			const u32 count = m_vertex.next;
+			GSVertex* v = &m_vertex.buff[0];
+			u16* idx = &m_index.buff[0];
+			const bool indexed_texture = src && src->m_scale == 1.0f && GSLocalMemory::m_psm[src->m_TEX0.PSM].pal > 0;
+
+			// Shortcut for when the sprites are right up against each other.
+			if (GSConfig.UserHacks_AlignSpriteX && m_vt.m_primclass == GS_SPRITE_CLASS && indexed_texture && PRIM->FST && m_index.tail > 2 &&
+				((v[idx[1]].U == v[idx[2]].U && (v[idx[1]].XYZ.X == v[idx[2]].XYZ.X) && v[idx[0]].V == v[idx[2]].V) || 
+				  (v[idx[1]].V == v[idx[2]].V && (v[idx[1]].XYZ.Y == v[idx[2]].XYZ.Y) && v[idx[0]].U == v[idx[2]].U)))
+			{
+				for (int i = 0; i < m_index.tail; i += 2)
+				{
+					if (!((v[idx[i + 1]].U == v[idx[i + 2]].U && (v[idx[i + 1]].XYZ.X == v[idx[i + 2]].XYZ.X) && v[idx[i]].V == v[idx[i + 2]].V)))
+					{
+						if (v[idx[i + 1]].U & 0x8)
+							v[idx[i + 1]].U -= 8;
+					}
+					if (!((v[idx[i + 1]].V == v[idx[i + 2]].V && (v[idx[i + 1]].XYZ.Y == v[idx[i + 2]].XYZ.Y) && v[idx[i]].U == v[idx[i + 2]].U)))
+					{
+						if (v[idx[i + 1]].V & 0x8)
+							v[idx[i + 11]].V -= 8;
+					}
+				}
+				if (v[idx[m_index.tail - 1]].U & 0x8)
+					v[idx[m_index.tail - 1]].U -= 8;
+
+				if (v[idx[m_index.tail - 1]].V & 0x8)
+					v[idx[m_index.tail - 1]].V -= 8;
+			}
+			else
+			// Hack to avoid vertical black line in various games (ace combat/tekken)
+			if (GSConfig.UserHacks_AlignSpriteX)
+			{
+				// Note for performance reason I do the check only once on the first
+				// primitive
+				const int win_position0 = v[idx[0]].XYZ.X - context->XYOFFSET.OFX;
+				const int win_position1 = v[idx[1]].XYZ.X - context->XYOFFSET.OFX;
+				const bool unaligned_position = ((win_position0 & 0xf) != 0) || ((win_position1 & 0xF) != 0);
+				const int first_s = (v[idx[0]].ST.S / v[idx[0]].RGBAQ.Q) * static_cast<int>(1 << m_cached_ctx.TEX0.TW);
+				const bool unaligned_texture = (PRIM->FST && ((v[1].U & 0xF) == 0)) || (!PRIM->FST && (first_s & 0xF) == 0); // I'm not sure this check is useful
+				const int gap = std::min(static_cast<int>(v[2].XYZ.X), static_cast<int>(v[3].XYZ.X)) - std::max(static_cast<int>(v[0].XYZ.X), static_cast<int>(v[1].XYZ.X));
+				bool hole_in_vertex = (count < 4) || (v[1].XYZ.X != v[2].XYZ.X && ((v[1].XYZ.X ^ v[2].XYZ.X) & 0xF) != 0);
+				const bool is_tri = m_vt.m_primclass == GS_TRIANGLE_CLASS;
+				const int skip = is_tri ? 3 : 2;
+
+				GSVector2 gradient = GSVector2(1.0f, 1.0f);
+
+				if (m_lod.y == 0)
+				{
+					bool can_disable_linear = true;
+					for (u32 i = 0; i < m_index.tail; i += skip)
+					{
+						const int x_offset = (is_tri && v[idx[i]].XYZ.X == v[idx[i + 1]].XYZ.X) ? 2 : 1;
+						const int y_offset = (is_tri && v[idx[i]].XYZ.Y == v[idx[i + 1]].XYZ.Y) ? 2 : 1;
+
+						GSVector2 vert = GSVector2(std::abs(static_cast<float>(v[idx[i]].XYZ.X - v[idx[i + x_offset]].XYZ.X)), std::abs(static_cast<float>(v[idx[i]].XYZ.Y - v[idx[i + y_offset]].XYZ.Y)));
+						GSVector2 tex;
+
+						if (!PRIM->FST)
+						{
+							const int s_offset = (is_tri && (v[idx[i]].ST.S / v[idx[i]].RGBAQ.Q) == (v[idx[i + 1]].ST.S / v[idx[i + 1]].RGBAQ.Q)) ? 2 : 1;
+							const int t_offset = (is_tri && (v[idx[i]].ST.T / v[idx[i]].RGBAQ.Q) == (v[idx[i + 1]].ST.T / v[idx[i + 1]].RGBAQ.Q)) ? 2 : 1;
+							GSVector2 v0, v1;
+							float s = std::min((v[idx[i]].ST.S / v[idx[i]].RGBAQ.Q), 1.0f);
+							float t = std::min((v[idx[i]].ST.T / v[idx[i]].RGBAQ.Q), 1.0f);
+							v0.x = static_cast<int>((1 << m_cached_ctx.TEX0.TW) * s * 16.0f);
+							v0.y = static_cast<int>((1 << m_cached_ctx.TEX0.TH) * t * 16.0f);
+
+							s = std::min((v[idx[i + s_offset]].ST.S / v[idx[i + s_offset]].RGBAQ.Q), 1.0f);
+							t = std::min((v[idx[i + t_offset]].ST.T / v[idx[i + t_offset]].RGBAQ.Q), 1.0f);
+							v1.x = static_cast<int>((1 << m_cached_ctx.TEX0.TW) * s * 16.0f);
+							v1.y = static_cast<int>((1 << m_cached_ctx.TEX0.TH) * t * 16.0f);
+
+							tex = GSVector2(std::abs(v1.x - v0.x), std::abs(v1.y - v0.y));
+						}
+						else
+						{
+							const int u_offset = (is_tri && v[idx[i]].U == v[idx[i + 1]].U) ? 2 : 1;
+							const int v_offset = (is_tri && v[idx[i]].V == v[idx[i + 1]].V) ? 2 : 1;
+							tex = GSVector2(std::abs(static_cast<float>(v[idx[i]].U - v[idx[i + u_offset]].U)), std::abs(static_cast<float>(v[idx[i]].V - v[idx[i + v_offset]].V)));
+						}
+
+						GSVector2 grad = tex / vert;
+						if ((grad.x != gradient.x && grad.x != floor(grad.x)) || (grad.y != gradient.y && grad.y != floor(grad.y)))
+						{
+							can_disable_linear = false;
+							gradient = grad;
+							break;
+						}
+					}
+					if (can_disable_linear)
+					{
+						m_vt.m_filter.linear = 0;
+						m_vt.m_filter.opt_linear = 0;
+					}
+				}
+
+				/*if ((m_vt.m_primclass == GS_SPRITE_CLASS) && hole_in_vertex && unaligned_position && (unaligned_texture || !PRIM->FST))
+				{
+					// Normaly vertex are aligned on full pixels and texture in half
+					// pixels. Let's extend the coverage of an half-pixel to avoid
+					// hole after upscaling
+					for (u32 i = 0; i < count; i += 2)
+					{
+						v[i + 1].XYZ.X += 8;
+						// I really don't know if it is a good idea. Neither what to do for !PRIM->FST
+						if (unaligned_texture)
+							v[i + 1].U += 8;
+					}
+				}
+				else */if (indexed_texture && (gradient.x > (1.0f / 16.0f) || gradient.y > (1.0f / 16.0f)))
+				{
+					const int comparitor = unaligned_position ? 0 : 8;
+
+					if (!PRIM->FST)
+					{
+						int s_offset = (is_tri && (v[idx[0]].ST.S / v[idx[0]].RGBAQ.Q) == (v[idx[1]].ST.S / v[idx[1]].RGBAQ.Q)) ? 2 : 1;
+						int t_offset = (is_tri && (v[idx[0]].ST.T / v[idx[0]].RGBAQ.Q) == (v[idx[1]].ST.T / v[idx[1]].RGBAQ.Q)) ? 2 : 1;
+						GSVector2i v0, v1;
+						float q = v[idx[0]].RGBAQ.Q == 0 ? FLT_MIN : v[idx[0]].RGBAQ.Q;
+						float s = v[idx[0]].ST.S / q;
+						float t = v[idx[0]].ST.T / q;
+						v0.x = static_cast<int>((1 << m_cached_ctx.TEX0.TW) * s * 16.0f);
+						v0.y = static_cast<int>((1 << m_cached_ctx.TEX0.TH) * t * 16.0f);
+
+						q = v[idx[s_offset]].RGBAQ.Q == 0 ? FLT_MIN : v[idx[s_offset]].RGBAQ.Q;
+						s = v[idx[s_offset]].ST.S / q;
+						t = v[idx[t_offset]].ST.T / q;
+						v1.x = static_cast<int>((1 << m_cached_ctx.TEX0.TW) * s * 16.0f);
+						v1.y = static_cast<int>((1 << m_cached_ctx.TEX0.TH) * t * 16.0f);
+						bool small_texture = std::abs(v1.x - v0.x) <= (64 * 16) || std::abs(v1.y - v0.y) <= (64 * 16);
+						bool offset_texture_x = (m_vt.IsLinear() || ((v0.x & 0xF) && (v1.x & 0xF))) && small_texture; // Keep them relatively small to avoid full screen stuff.
+						bool offset_texture_y = (m_vt.IsLinear() || ((v0.y & 0xF) && (v1.y & 0xF))) && small_texture;
+
+						//if (offset_texture_x && offset_texture_y)
+						{
+							for (u32 i = m_index.buff[0]; i < m_index.tail; i += skip)
+							{
+								GSVector2 st;
+
+								if (gradient.x > (1.0f / 16.0f))
+								{
+									float largest_s = std::max(is_tri ? (v[i + 2].ST.S / v[i + 2].RGBAQ.Q) : static_cast<float>(0), std::max((v[i].ST.S / v[i].RGBAQ.Q), (v[i + 1].ST.S / v[i + 1].RGBAQ.Q)));
+									float smallest_s = std::min(is_tri ? (v[i + 2].ST.S / v[i + 2].RGBAQ.Q) : static_cast<float>(0), std::min((v[i].ST.S / v[i].RGBAQ.Q), (v[i + 1].ST.S / v[i + 1].RGBAQ.Q)));
+
+									for (int j = 0; j < skip; j++)
+									{
+										q = v[i + j].RGBAQ.Q == 0 ? FLT_MIN : v[i + j].RGBAQ.Q;
+										float s = v[i + j].ST.S / q;
+										st.x = static_cast<float>(1 << m_cached_ctx.TEX0.TW) * s;
+										if ((v[i + j].ST.S / q) == largest_s)
+											v[i + j].ST.S = ((st.x - 0.5f) / static_cast<float>(1 << m_cached_ctx.TEX0.TW)) * q;
+										// Check the minimap in Persona 3.
+										if ((static_cast<int>(st.x * 16) & 0x8) == comparitor && (v[i + j].ST.S / q) == smallest_s)
+											v[i + j].ST.S = (std::max(0.0f, (st.x - 0.5f)) / static_cast<float>(1 << m_cached_ctx.TEX0.TW)) * q;
+									}
+								}
+
+								if (gradient.y > (1.0f / 16.0f))
+								{
+									float largest_t = std::max(is_tri ? (v[i + 2].ST.T / v[i + 2].RGBAQ.Q) : static_cast<float>(0), std::max((v[i].ST.T / v[i].RGBAQ.Q), (v[i + 1].ST.T / v[i + 1].RGBAQ.Q)));
+									float smallest_t = std::min(is_tri ? (v[i + 2].ST.T / v[i + 2].RGBAQ.Q) : static_cast<float>(0), std::min((v[i].ST.T / v[i].RGBAQ.Q), (v[i + 1].ST.T / v[i + 1].RGBAQ.Q)));
+									for (int j = 0; j < skip; j++)
+									{
+										q = v[i + j].RGBAQ.Q == 0 ? FLT_MIN : v[i + j].RGBAQ.Q;
+										float t = v[i + j].ST.T / q;
+										st.y = static_cast<float>(1 << m_cached_ctx.TEX0.TH) * t;
+										if ((v[i + j].ST.T / q) == largest_t)
+											v[i + j].ST.T = ((st.y - 0.5f) / static_cast<float>(1 << m_cached_ctx.TEX0.TH)) * q;
+										// Check the minimap in Persona 3.
+										if ((static_cast<int>(st.y * 16) & 0x8) == comparitor && (v[i + j].ST.T / q) == smallest_t)
+											v[i + j].ST.T = (std::max(0.0f, (st.y - 0.5f)) / static_cast<float>(1 << m_cached_ctx.TEX0.TH)) * q;
+									}
+								}
+							}
+						}
+					}
+					else
+					{
+						int u_offset = (is_tri && (v[0].U == v[1].U)) ? 2 : 1;
+						int v_offset = (is_tri && (v[0].V == v[1].V)) ? 2 : 1;
+						bool small_texture = std::abs(static_cast<int>(v[idx[u_offset]].U) - static_cast<int>(v[idx[0]].U)) <= (64 * 16) || std::abs(static_cast<int>(v[idx[v_offset]].V) - static_cast<int>(v[idx[0]].V)) <= (64 * 16);
+						bool offset_texture_x = (m_vt.IsLinear() || ((v[0].U & 0xF) && (v[idx[u_offset]].U & 0xF))) && small_texture;
+						bool offset_texture_y = (m_vt.IsLinear() || ((v[0].V & 0xF) && (v[idx[v_offset]].V & 0xF))) && small_texture;
+
+						if (offset_texture_x && offset_texture_y)
+						{
+							for (u32 i = m_index.buff[0]; i < m_index.tail; i += skip)
+							{
+								if (gradient.x > (1.0f / 16.0f))
+								{
+									const u16 largest_u = std::max(is_tri ? v[idx[i + 2]].U : static_cast<u16>(0), std::max(v[idx[i]].U, v[idx[i + 1]].U));
+
+									if ((v[idx[i]].U & 0x8) == comparitor && v[idx[i]].U == largest_u)
+										v[idx[i]].U = std::max(static_cast<int>(v[idx[i]].U) - 8, 0);
+
+									if ((v[idx[i + 1]].U & 0x8) == comparitor && v[idx[i + 1]].U == largest_u)
+										v[idx[i + 1]].U = std::max(static_cast<int>(v[idx[i + 1]].U) - 8, 0);
+
+									if (is_tri && (v[idx[i + 2]].U & 0x8) == comparitor && v[idx[i + 2]].U == largest_u)
+										v[idx[i + 2]].U = std::max(static_cast<int>(v[idx[i + 2]].U) - 8, 0);
+								}
+
+								if (gradient.y > (1.0f / 16.0f))
+								{
+									const u16 largest_v = std::max(is_tri ? v[idx[i + 2]].V : static_cast<u16>(0), std::max(v[idx[i]].V, v[idx[i + 1]].V));
+
+									if ((v[idx[i]].V & 0x8) == comparitor && v[idx[i]].V == largest_v)
+										v[idx[i]].V = std::max(static_cast<int>(v[idx[i]].V) - 8, 0);
+
+									if ((v[idx[i + 1]].V & 0x8) == comparitor && v[idx[i + 1]].V == largest_v)
+										v[idx[i + 1]].V = std::max(static_cast<int>(v[idx[i + 1]].V) - 8, 0);
+
+									if (is_tri && (v[idx[i + 2]].V & 0x8) == comparitor && v[idx[i + 2]].V == largest_v)
+										v[idx[i + 2]].V = std::max(static_cast<int>(v[idx[i + 2]].V) - 8, 0);
+								}
+							}
+						}
+					}
+				}
+				else if ((m_vt.m_primclass == GS_SPRITE_CLASS) && hole_in_vertex && unaligned_position && (unaligned_texture || !PRIM->FST))
+				{
+					// Normaly vertex are aligned on full pixels and texture in half
+					// pixels. Let's extend the coverage of an half-pixel to avoid
+					// hole after upscaling
+					for (u32 i = 0; i < count; i += 2)
+					{
+						v[i + 1].XYZ.X += 8;
+						// I really don't know if it is a good idea. Neither what to do for !PRIM->FST
+						if (unaligned_texture)
+							v[i + 1].U += 8;
+					}
 				}
 			}
 		}