GS/HW: Refactor StretchRect() to have single entry to renderer/reduce duplication.

We currently have a barrier so let's do date_one in a single pass, plus this avoids any issues with copies and stencil issues.
On dx copies are slower so we can only use the optimization if we have barriers already present.

.github/workflows/lint_gamedb.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Install Packages
         run: |
           npm install -g ajv-cli prettier
-          sudo apt-get -y install yamllint
+          pip install yamllint
 
       - name: Validate YAML
         run: |

.github/workflows/scripts/linux/build-dependencies-qt.sh

@@ -21,7 +21,7 @@ LIBJPEGTURBO=3.1.2
 LIBPNG=1.6.50
 LIBWEBP=1.6.0
 SDL=SDL3-3.2.26
-QT=6.10.0
+QT=6.10.1
 QTAPNG=1.3.0
 LZ4=1.10.0
 ZSTD=1.5.7
@@ -48,12 +48,12 @@ dad488474a51a0b01d547cd2834893d6299328d2e30f479a3564088b5476bae2  $SDL.tar.gz
 687ddc0c7cb128a3ea58e159b5129252537c27ede0c32a93f11f03127f0c0165  libpng-$LIBPNG-apng.patch.gz
 537512904744b35e232912055ccf8ec66d768639ff3abe5788d90d792ec5f48b  lz4-$LZ4.tar.gz
 eb33e51f49a15e023950cd7825ca74a4a2b43db8354825ac24fc1b7ee09e6fa3  zstd-$ZSTD.tar.gz
-ead4623bcb54a32257c5b3e3a5aec6d16ec96f4cda58d2e003f5a0c16f72046d  qtbase-everywhere-src-$QT.tar.xz
-64450a52507c540de53616ed5e516df0e0905a99d3035ddfaa690f2b3f7c0cea  qtimageformats-everywhere-src-$QT.tar.xz
-5ed2c0e04d5e73ff75c2a2ed92db5dc1788ba70f704fc2b71bc21644beda2533  qtsvg-everywhere-src-$QT.tar.xz
-d86d5098cf3e3e599f37e18df477e65908fc8f036e10ea731b3469ec4fdbd02a  qttools-everywhere-src-$QT.tar.xz
-326e8253cfd0cb5745238117f297da80e30ce8f4c1db81990497bd388b026cde  qttranslations-everywhere-src-$QT.tar.xz
-603f2b0a259b24bd0fb14f880d7761b1d248118a42a6870cdbe8fdda4173761f  qtwayland-everywhere-src-$QT.tar.xz
+5a6226f7e23db51fdc3223121eba53f3f5447cf0cc4d6cb82a3a2df7a65d265d  qtbase-everywhere-src-$QT.tar.xz
+498eabdf2381db96f808942b3e3c765f6360fe6c0e9961f0a45ff7a4c68d7a72  qtimageformats-everywhere-src-$QT.tar.xz
+c02f355a58f3bbcf404a628bf488b6aeb2d84a94c269afdb86f6e529343ab01f  qtsvg-everywhere-src-$QT.tar.xz
+8148408380ffea03101a26305c812b612ea30dbc07121e58707601522404d49b  qttools-everywhere-src-$QT.tar.xz
+8e49a2df88a12c376a479ae7bd272a91cf57ebb4e7c0cf7341b3565df99d2314  qttranslations-everywhere-src-$QT.tar.xz
+49bf6db800227a6b2c971f4c5d03dd1e81297e7ffb296ce4a96437304f27cb13  qtwayland-everywhere-src-$QT.tar.xz
 f1d3be3489f758efe1a8f12118a212febbe611aa670af32e0159fa3c1feab2a6  QtApng-$QTAPNG.tar.gz
 a8e4a25e5c2686fd36981e527ed05e451fcfc226bddf350f4e76181371190937  shaderc-$SHADERC.tar.gz
 9427deccbdf4bde6a269938df38c6bd75247493786a310d8d733a2c82065ef47  shaderc-glslang-$SHADERC_GLSLANG.tar.gz

.github/workflows/scripts/macos/build-dependencies-universal.sh

@@ -48,7 +48,7 @@ LIBJPEGTURBO=3.1.2
 LIBWEBP=1.6.0
 FFMPEG=8.0
 MOLTENVK=1.2.9
-QT=6.10.0
+QT=6.10.1
 QTAPNG=1.3.0
 KDDOCKWIDGETS=2.4.0
 PLUTOVG=1.3.1
@@ -89,11 +89,11 @@ e4ab7009bf0629fd11982d4c2aa83964cf244cffba7347ecd39019a9e38c4564  libwebp-$LIBWE
 8f0012234b464ce50890c490f18194f913a7b1f4e6a03d6644179fa0f867d0cf  libjpeg-turbo-$LIBJPEGTURBO.tar.gz
 b2751fccb6cc4c77708113cd78b561059b6fa904b24162fa0be2d60273d27b8e  ffmpeg-$FFMPEG.tar.xz
 f415a09385030c6510a936155ce211f617c31506db5fbc563e804345f1ecf56e  v$MOLTENVK.tar.gz
-ead4623bcb54a32257c5b3e3a5aec6d16ec96f4cda58d2e003f5a0c16f72046d  qtbase-everywhere-src-$QT.tar.xz
-64450a52507c540de53616ed5e516df0e0905a99d3035ddfaa690f2b3f7c0cea  qtimageformats-everywhere-src-$QT.tar.xz
-5ed2c0e04d5e73ff75c2a2ed92db5dc1788ba70f704fc2b71bc21644beda2533  qtsvg-everywhere-src-$QT.tar.xz
-d86d5098cf3e3e599f37e18df477e65908fc8f036e10ea731b3469ec4fdbd02a  qttools-everywhere-src-$QT.tar.xz
-326e8253cfd0cb5745238117f297da80e30ce8f4c1db81990497bd388b026cde  qttranslations-everywhere-src-$QT.tar.xz
+5a6226f7e23db51fdc3223121eba53f3f5447cf0cc4d6cb82a3a2df7a65d265d  qtbase-everywhere-src-$QT.tar.xz
+498eabdf2381db96f808942b3e3c765f6360fe6c0e9961f0a45ff7a4c68d7a72  qtimageformats-everywhere-src-$QT.tar.xz
+c02f355a58f3bbcf404a628bf488b6aeb2d84a94c269afdb86f6e529343ab01f  qtsvg-everywhere-src-$QT.tar.xz
+8148408380ffea03101a26305c812b612ea30dbc07121e58707601522404d49b  qttools-everywhere-src-$QT.tar.xz
+8e49a2df88a12c376a479ae7bd272a91cf57ebb4e7c0cf7341b3565df99d2314  qttranslations-everywhere-src-$QT.tar.xz
 f1d3be3489f758efe1a8f12118a212febbe611aa670af32e0159fa3c1feab2a6  QtApng-$QTAPNG.tar.gz
 a8e4a25e5c2686fd36981e527ed05e451fcfc226bddf350f4e76181371190937  shaderc-$SHADERC.tar.gz
 9427deccbdf4bde6a269938df38c6bd75247493786a310d8d733a2c82065ef47  shaderc-glslang-$SHADERC_GLSLANG.tar.gz

.github/workflows/scripts/macos/build-dependencies.sh

@@ -30,7 +30,7 @@ LIBJPEGTURBO=3.1.2
 LIBWEBP=1.6.0
 FFMPEG=8.0
 MOLTENVK=1.2.9
-QT=6.10.0
+QT=6.10.1
 QTAPNG=1.3.0
 KDDOCKWIDGETS=2.4.0
 PLUTOVG=1.3.1
@@ -70,11 +70,11 @@ e4ab7009bf0629fd11982d4c2aa83964cf244cffba7347ecd39019a9e38c4564  libwebp-$LIBWE
 8f0012234b464ce50890c490f18194f913a7b1f4e6a03d6644179fa0f867d0cf  libjpeg-turbo-$LIBJPEGTURBO.tar.gz
 b2751fccb6cc4c77708113cd78b561059b6fa904b24162fa0be2d60273d27b8e  ffmpeg-$FFMPEG.tar.xz
 f415a09385030c6510a936155ce211f617c31506db5fbc563e804345f1ecf56e  v$MOLTENVK.tar.gz
-ead4623bcb54a32257c5b3e3a5aec6d16ec96f4cda58d2e003f5a0c16f72046d  qtbase-everywhere-src-$QT.tar.xz
-64450a52507c540de53616ed5e516df0e0905a99d3035ddfaa690f2b3f7c0cea  qtimageformats-everywhere-src-$QT.tar.xz
-5ed2c0e04d5e73ff75c2a2ed92db5dc1788ba70f704fc2b71bc21644beda2533  qtsvg-everywhere-src-$QT.tar.xz
-d86d5098cf3e3e599f37e18df477e65908fc8f036e10ea731b3469ec4fdbd02a  qttools-everywhere-src-$QT.tar.xz
-326e8253cfd0cb5745238117f297da80e30ce8f4c1db81990497bd388b026cde  qttranslations-everywhere-src-$QT.tar.xz
+5a6226f7e23db51fdc3223121eba53f3f5447cf0cc4d6cb82a3a2df7a65d265d  qtbase-everywhere-src-$QT.tar.xz
+498eabdf2381db96f808942b3e3c765f6360fe6c0e9961f0a45ff7a4c68d7a72  qtimageformats-everywhere-src-$QT.tar.xz
+c02f355a58f3bbcf404a628bf488b6aeb2d84a94c269afdb86f6e529343ab01f  qtsvg-everywhere-src-$QT.tar.xz
+8148408380ffea03101a26305c812b612ea30dbc07121e58707601522404d49b  qttools-everywhere-src-$QT.tar.xz
+8e49a2df88a12c376a479ae7bd272a91cf57ebb4e7c0cf7341b3565df99d2314  qttranslations-everywhere-src-$QT.tar.xz
 f1d3be3489f758efe1a8f12118a212febbe611aa670af32e0159fa3c1feab2a6  QtApng-$QTAPNG.tar.gz
 a8e4a25e5c2686fd36981e527ed05e451fcfc226bddf350f4e76181371190937  shaderc-$SHADERC.tar.gz
 9427deccbdf4bde6a269938df38c6bd75247493786a310d8d733a2c82065ef47  shaderc-glslang-$SHADERC_GLSLANG.tar.gz
@@ -237,9 +237,6 @@ cd "qtbase-everywhere-src-$QT"
 # Patch Qt to support macOS 11
 patch -p1 < "$SCRIPTDIR/qt-macos11compat.patch"
 
-# Patch Qt to fix a bug with message boxes on Tahoe
-patch -p1 < "$SCRIPTDIR/clickbutton.patch"
-
 # since we don't have a direct reference to QtSvg, it doesn't deployed directly from the main binary
 # (only indirectly from iconengines), and the libqsvg.dylib imageformat plugin does not get deployed.
 # We could run macdeployqt twice, but that's even more janky than patching it.

.github/workflows/scripts/macos/clickbutton.patch

@@ -1,16 +0,0 @@
---- a/src/plugins/platforms/cocoa/qcocoamessagedialog.mm
-+++ b/src/plugins/platforms/cocoa/qcocoamessagedialog.mm
-@@ -88,6 +88,11 @@ bool QCocoaMessageDialog::show(Qt::WindowModality windowModality)
-         qCWarning(lcQpaDialogs, "Cannot run window modal dialog without parent window");
-         return false;
-     }
-+
-+    // Tahoe has issues with window-modal alert buttons not responding to mouse
-+    if (windowModality == Qt::WindowModal
-+        && QOperatingSystemVersion::current() >= QOperatingSystemVersion::MacOSTahoe)
-+        return false;
-
-     // And without options we don't know what to show
-     if (!options())
-
-# Source https://codereview.qt-project.org/c/qt/qtbase/+/689796

.github/workflows/scripts/macos/qt-macos11compat.patch

@@ -1,5 +1,4 @@
 diff --git a/.cmake.conf b/.cmake.conf
-index 9a21ff42a74..d6707ba7dff 100644
 --- a/.cmake.conf
 +++ b/.cmake.conf
 @@ -51,7 +51,7 @@ set(QT_MAX_NEW_POLICY_CMAKE_VERSION_QT_APPLE "3.21")
@@ -12,7 +11,6 @@ index 9a21ff42a74..d6707ba7dff 100644
  
  set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "17")
 diff --git a/CMakeLists.txt b/CMakeLists.txt
-index d3a14fc67eb..1553b956fe3 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
 @@ -12,6 +12,10 @@ cmake_minimum_required(VERSION 3.16)
@@ -27,7 +25,6 @@ index d3a14fc67eb..1553b956fe3 100644
  
  qt_internal_check_if_path_has_symlinks("${CMAKE_BINARY_DIR}")
 diff --git a/src/corelib/global/qsysinfo.cpp b/src/corelib/global/qsysinfo.cpp
-index ae762c0cc6d..9171a5736b4 100644
 --- a/src/corelib/global/qsysinfo.cpp
 +++ b/src/corelib/global/qsysinfo.cpp
 @@ -1027,7 +1027,7 @@ QByteArray QSysInfo::machineUniqueId()
@@ -40,10 +37,9 @@ index ae762c0cc6d..9171a5736b4 100644
      CFStringGetCString(stringRef, uuid, sizeof(uuid), kCFStringEncodingMacRoman);
      return QByteArray(uuid);
 diff --git a/src/corelib/kernel/qcore_mac.mm b/src/corelib/kernel/qcore_mac.mm
-index 9f27dbe694e..c023a48cad3 100644
 --- a/src/corelib/kernel/qcore_mac.mm
 +++ b/src/corelib/kernel/qcore_mac.mm
-@@ -372,7 +372,7 @@ bool qt_apple_runningWithLiquidGlass()
+@@ -367,7 +367,7 @@ bool qt_apple_runningWithLiquidGlass()
              return config;
  #endif
  
@@ -52,8 +48,50 @@ index 9f27dbe694e..c023a48cad3 100644
          if (!nvram) {
              qWarning("Failed to locate NVRAM entry in IO registry");
              return {};
+diff --git a/src/gui/platform/darwin/qappleiconengine.mm b/src/gui/platform/darwin/qappleiconengine.mm
+--- a/src/gui/platform/darwin/qappleiconengine.mm
++++ b/src/gui/platform/darwin/qappleiconengine.mm
+@@ -366,12 +366,16 @@
+                                                weight:NSFontWeightRegular
+                                                scale:NSImageSymbolScaleLarge];
+ 
++    auto *primaryColor = [NSColor colorWithSRGBRed:color.redF()
++                                             green:color.greenF()
++                                              blue:color.blueF()
++                                             alpha:color.alphaF()];
++
++    if (@available(macOS 13, *)) {
++
+     // Apply tint color first, which switches the configuration to palette mode
+     config = [config configurationByApplyingConfiguration:
+-        [NSImageSymbolConfiguration configurationWithPaletteColors:@[
+-            [NSColor colorWithSRGBRed:color.redF() green:color.greenF()
+-                blue:color.blueF() alpha:color.alphaF()]
+-        ]]];
++        [NSImageSymbolConfiguration configurationWithPaletteColors:@[primaryColor]]];
+ 
+     // Then switch back to monochrome, as palette mode gives a different look
+     // than monochrome, even with a single color.
+@@ -379,6 +383,18 @@
+         [NSImageSymbolConfiguration configurationPreferringMonochrome]];
+ 
+     return [image imageWithSymbolConfiguration:config];
++
++    } else {
++    NSImage *configuredImage = [image imageWithSymbolConfiguration:config];
++    return [NSImage imageWithSize:configuredImage.size flipped:NO
++        drawingHandler:^BOOL(NSRect) {
++            [primaryColor set];
++            NSRect imageRect = {NSZeroPoint, configuredImage.size};
++            [configuredImage drawInRect:imageRect];
++            NSRectFillUsingOperation(imageRect, NSCompositingOperationSourceIn);
++            return YES;
++        }];
++    }
+ }
+ #elif defined(QT_PLATFORM_UIKIT)
+ auto *configuredImage(const UIImage *image, const QColor &color)
 diff --git a/src/plugins/platforms/cocoa/qcocoawindow.mm b/src/plugins/platforms/cocoa/qcocoawindow.mm
-index 6b33d94d58c..867389e4c93 100644
 --- a/src/plugins/platforms/cocoa/qcocoawindow.mm
 +++ b/src/plugins/platforms/cocoa/qcocoawindow.mm
 @@ -323,6 +323,8 @@ a normal (not maximized or full screen) top-level window.

.github/workflows/scripts/windows/build-dependencies-arm64.bat

@@ -48,7 +48,7 @@ set LIBJPEGTURBO=3.1.2
 set LIBPNG=1650
 set LIBPNGLONG=1.6.50
 set SDL=SDL3-3.2.26
-set QT=6.10.0
+set QT=6.10.1
 set QTMINOR=6.10
 set QTAPNG=1.3.0
 set LZ4=1.10.0
@@ -72,11 +72,11 @@ call :downloadfile "lpng%LIBPNG%-apng.patch.gz" https://download.sourceforge.net
 call :downloadfile "libjpeg-turbo-%LIBJPEGTURBO%.tar.gz" "https://github.com/libjpeg-turbo/libjpeg-turbo/releases/download/%LIBJPEGTURBO%/libjpeg-turbo-%LIBJPEGTURBO%.tar.gz" 8f0012234b464ce50890c490f18194f913a7b1f4e6a03d6644179fa0f867d0cf || goto error
 call :downloadfile "libwebp-%WEBP%.tar.gz" "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-%WEBP%.tar.gz" e4ab7009bf0629fd11982d4c2aa83964cf244cffba7347ecd39019a9e38c4564 || goto error
 call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" 739356eef1192fff9d641c320a8f5ef4a10506b8927def4b9ceb764c7e947369 || goto error
-call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" d3b5379edcace266273d789249b6d68ae9495ec1b0b562ba6d039034cd315d8e || goto error
-call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" ac2fe34a9f1c1451b6785474e9b1b64eb59edef6553be3d630240f16a730456d || goto error
-call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" c12f8bfb617e4a03da104be36f6966ba7f64bee331f0095da1a649a1149796d2 || goto error
-call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" c6d0f0a512304ad87b20f5ff604442dd8d55769d659576ecfe5462fcd7bb9b7d || goto error
-call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" e6cc1ebf62cf37d81f3b86990086108518037bb383e75da327f297cc4fc1ae36 || goto error
+call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" c43f471a808b07fc541528410e94ce89c6745bdc1d744492e19911d35fbf7d33 || goto error
+call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 2d828d8c999fdd18167937c071781c22321c643b04a106c714411c2356cdb26d || goto error
+call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" ddd74a417d2397eb085d047a9b6ba52b76e748055817f728fe691f8456035d23 || goto error
+call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" db8e49ed50912c3c064a4f9ada7791c09eccec5a8d53463a19608eaab17679f0 || goto error
+call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 868eb651e395d48ade5932ef2c386e606e054eb5888ebe5284fbd8cb63ed935a || goto error
 call :downloadfile "QtApng-%QTAPNG%.zip" "https://github.com/jurplel/QtApng/archive/refs/tags/%QTAPNG%.zip" 5176082cdd468047a7eb1ec1f106b032f57df207aa318d559b29606b00d159ac || goto error
 call :downloadfile "lz4-%LZ4%.zip" "https://github.com/lz4/lz4/archive/refs/tags/v%LZ4%.zip" 3224b4c80f351f194984526ef396f6079bd6332dd9825c72ac0d7a37b3cdc565 || goto error
 call :downloadfile "zlib%ZLIBSHORT%.zip" "https://zlib.net/zlib%ZLIBSHORT%.zip" 72af66d44fcc14c22013b46b814d5d2514673dda3d115e64b690c1ad636e7b17 || goto error

.github/workflows/scripts/windows/build-dependencies.bat

@@ -46,7 +46,7 @@ set LIBJPEGTURBO=3.1.2
 set LIBPNG=1650
 set SDL=SDL3-3.2.26
 set LIBPNGLONG=1.6.50
-set QT=6.10.0
+set QT=6.10.1
 set QTMINOR=6.10
 set QTAPNG=1.3.0
 set LZ4=1.10.0
@@ -70,11 +70,11 @@ call :downloadfile "lpng%LIBPNG%-apng.patch.gz" https://download.sourceforge.net
 call :downloadfile "libjpeg-turbo-%LIBJPEGTURBO%.tar.gz" "https://github.com/libjpeg-turbo/libjpeg-turbo/releases/download/%LIBJPEGTURBO%/libjpeg-turbo-%LIBJPEGTURBO%.tar.gz" 8f0012234b464ce50890c490f18194f913a7b1f4e6a03d6644179fa0f867d0cf || goto error
 call :downloadfile "libwebp-%WEBP%.tar.gz" "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-%WEBP%.tar.gz" e4ab7009bf0629fd11982d4c2aa83964cf244cffba7347ecd39019a9e38c4564 || goto error
 call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" 739356eef1192fff9d641c320a8f5ef4a10506b8927def4b9ceb764c7e947369 || goto error
-call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" d3b5379edcace266273d789249b6d68ae9495ec1b0b562ba6d039034cd315d8e || goto error
-call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" ac2fe34a9f1c1451b6785474e9b1b64eb59edef6553be3d630240f16a730456d || goto error
-call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" c12f8bfb617e4a03da104be36f6966ba7f64bee331f0095da1a649a1149796d2 || goto error
-call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" c6d0f0a512304ad87b20f5ff604442dd8d55769d659576ecfe5462fcd7bb9b7d || goto error
-call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" e6cc1ebf62cf37d81f3b86990086108518037bb383e75da327f297cc4fc1ae36 || goto error
+call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" c43f471a808b07fc541528410e94ce89c6745bdc1d744492e19911d35fbf7d33 || goto error
+call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 2d828d8c999fdd18167937c071781c22321c643b04a106c714411c2356cdb26d || goto error
+call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" ddd74a417d2397eb085d047a9b6ba52b76e748055817f728fe691f8456035d23 || goto error
+call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" db8e49ed50912c3c064a4f9ada7791c09eccec5a8d53463a19608eaab17679f0 || goto error
+call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 868eb651e395d48ade5932ef2c386e606e054eb5888ebe5284fbd8cb63ed935a || goto error
 call :downloadfile "QtApng-%QTAPNG%.zip" "https://github.com/jurplel/QtApng/archive/refs/tags/%QTAPNG%.zip" 5176082cdd468047a7eb1ec1f106b032f57df207aa318d559b29606b00d159ac || goto error
 call :downloadfile "lz4-%LZ4%.zip" "https://github.com/lz4/lz4/archive/refs/tags/v%LZ4%.zip" 3224b4c80f351f194984526ef396f6079bd6332dd9825c72ac0d7a37b3cdc565 || goto error
 call :downloadfile "zlib%ZLIBSHORT%.zip" "https://zlib.net/zlib%ZLIBSHORT%.zip" 72af66d44fcc14c22013b46b814d5d2514673dda3d115e64b690c1ad636e7b17 || goto error

3rdparty/soundtouch/CMakeLists.txt

@@ -38,7 +38,7 @@ if(NOT "${CMAKE_BUILD_TYPE}" MATCHES "Debug")
 	if(MSVC)
 		target_compile_options(pcsx2-soundtouch PRIVATE /O2 /fp:fast)
 	else()
-		target_compile_options(pcsx2-soundtouch PRIVATE -Ofast)
+		target_compile_options(pcsx2-soundtouch PRIVATE -O3 -ffast-math)
 	endif()
 endif()
 

bin/docs/debugger.txt

@@ -1,58 +0,0 @@
-
-†---------------------†
-
-Disassembly view:
-
-†---------------------†
-
-  Ctrl + G             Goto
-  Ctrl + E             Edit Breakpoint
-  Ctrl + D             Enable/disable breakpoint
-  Ctrl + B             Add breakpoint
-  Left                 Go back one branch level/goto pc
-  Right                Follow branch/position memory view to accessed address
-  Up                   Move cursor up one line
-  Down                 Move cursor down one line
-  Page Up              Move visible area up one page
-  Page Down            Move visible area down one page
-  F10                  Step over
-  F11                  Step into
-  Tab                  Toggle display symbols
-  Left Click           Select line/toggle breakpoint if line is already highlighted
-  Right Click          Open context menu
-
-†---------------------†
-
-Memory View:
-
-†---------------------†
-
-  Ctrl + G             Goto
-  Ctrl + B             Add breakpoint
-  Left                 Move cursor back one byte/nibble
-  Right                Move cursor ahead one byte/nibble
-  Up                   Move cursor up one line
-  Down                 Move cursor down one line
-  Page Up              Move cursor up one page
-  Page Down            Move cursor down one page
-  0-9,A-F              Overwrite hex nibble
-  Any                  Overwrite ansi byte
-  Left Click           Select byte/nibble
-  Right Click          Open context menu
-  Ctrl+Wheel           Zoom memory view
-  Esc                  Return to previous goto address
-  Ctrl+V               Paste a hex string into memory
-
-†---------------------†
-
-Breakpoint List:
-
-†---------------------†
-
-    Up                Select previous item
-    Down              Select next item
-    Delete            Remove selected breakpoint
-    Return            Edit selected breakpoint
-    Space             Toggle enable state of selected breakpoint
-
-†---------------------†

bin/resources/game_controller_db.txt

@@ -175,7 +175,6 @@
 030000001a1c00000001000000000000,Datel Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
 03000000451300000830000000000000,Defender Game Racer X7,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,
 03000000791d00000103000000000000,Dual Box Wii,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,
-03000000c0160000e105000000000000,Dual 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:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,
 030000004f040000070f000000000000,Dual Power,a:b8,b:b9,back:b4,dpdown:b1,dpleft:b2,dpright:b3,dpup:b0,leftshoulder:b13,leftstick:b6,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b12,rightstick:b7,righttrigger:b15,start:b5,x:b10,y:b11,platform:Windows,
 030000004f04000012b3000000000000,Dual Power 3,a:b0,b:b2,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:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,
 030000004f04000020b3000000000000,Dual Trigger,a:b0,b:b2,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:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,
@@ -839,6 +838,7 @@
 03000000172700004431000000000000,Xiaomi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a7,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,
 03000000172700003350000000000000,Xiaomi XMGP01YM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000bc2000005060000000000000,Xiaomi XMGP01YM,+lefty:+a2,+righty:+a5,-lefty:-a1,-righty:-a4,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,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,start:b11,x:b3,y:b4,platform:Windows,
+03000000c0160000e105000000000000,XinMo Dual Arcade,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
 xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 030000007d0400000340000000000000,Xterminator Digital Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:-a4,lefttrigger:+a4,leftx:a0,lefty:a1,paddle1:b7,paddle2:b6,rightshoulder:b5,rightstick:b9,righttrigger:b2,rightx:a3,righty:a5,start:b8,x:b3,y:b4,platform:Windows,
 030000002c3600000100000000000000,Yawman Arrow,+rightx:h0.2,+righty:h0.4,-rightx:h0.8,-righty:h0.1,a:b4,b:b5,back:b6,dpdown:b15,dpleft:b14,dpright:b16,dpup:b13,leftshoulder:b10,leftstick:b0,lefttrigger:-a4,leftx:a0,lefty:a1,paddle1:b11,paddle2:b12,rightshoulder:b8,rightstick:b9,righttrigger:+a4,start:b3,x:b1,y:b2,platform:Windows,
@@ -1119,6 +1119,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005f140000c501000000020000,Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,
 03000000100800000100000000000000,Twin USB Joystick,a:b4,b:b2,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b12,leftstick:b20,lefttrigger:b8,leftx:a0,lefty:a2,rightshoulder:b14,rightstick:b22,righttrigger:b10,rightx:a6,righty:a4,start:b18,x:b6,y:b0,platform:Mac OS X,
 03000000632500002605000000010000,Uberwith Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
+03000000c0160000e105000000040000,Ultimate Atari Fight Stick,a:b2,b:b4,back:b18,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,rightshoulder:b8,righttrigger:b10,start:b16,x:b0,y:b6,platform:Mac OS X,
 03000000151900005678000010010000,Uniplay U6,a:b3,b:b6,back:b25,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b17,leftstick:b31,lefttrigger:b21,leftx:a1,lefty:a3,rightshoulder:b19,rightstick:b33,righttrigger:b23,rightx:a4,righty:a5,start:b27,x:b11,y:b13,platform:Mac OS X,
 030000006f0e00000302000025040000,Victrix PS4 Pro Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,
 030000006f0e00000702000003060000,Victrix PS4 Pro Fightstick,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,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,
@@ -1774,6 +1775,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005f140000c501000010010000,Trust Gamepad,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,
 06000000f51000000870000003010000,Turtle Beach Recon,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,
 03000000100800000100000010010000,Twin PS2 Adapter,a:b2,b:b1,back:b8,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:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
+03000000c0160000e105000010010000,Ultimate Atari Fight Stick,a:b1,b:b2,back:b9,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,rightshoulder:b4,righttrigger:b5,start:b8,x:b0,y:b3,platform:Linux,
 03000000151900005678000010010000,Uniplay U6,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000100800000300000010010000,USB Gamepad,a:b2,b:b1,back:b8,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:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
 03000000790000000600000007010000,USB gamepad,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:a3,righty:a4,start:b9,x:b3,y:b0,platform:Linux,

common/Console.cpp

@@ -99,7 +99,7 @@ __ri void Log::WriteToConsole(LOGLEVEL level, ConsoleColors color, std::string_v
 	static constexpr size_t BUFFER_SIZE = 512;
 
 	SmallStackString<BUFFER_SIZE> buffer;
-	buffer.reserve(32 + message.length());
+	buffer.reserve(static_cast<u32>(32 + message.length()));
 	buffer.append(s_ansi_color_codes[color]);
 
 	if (s_log_timestamps)

common/Image.cpp

@@ -14,9 +14,6 @@
 #include <webp/decode.h>
 #include <webp/encode.h>
 
-// Compute the address of a base type given a field offset.
-#define BASE_FROM_RECORD_FIELD(ptr, base_type, field) ((base_type*)(((char*)ptr) - offsetof(base_type, field)))
-
 static bool PNGBufferLoader(RGBA8Image* image, const void* buffer, size_t buffer_size);
 static bool PNGBufferSaver(const RGBA8Image& image, std::vector<u8>* buffer, u8 quality);
 static bool PNGFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp);
@@ -32,6 +29,11 @@ static bool WebPBufferSaver(const RGBA8Image& image, std::vector<u8>* buffer, u8
 static bool WebPFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp);
 static bool WebPFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp, u8 quality);
 
+static bool BMPBufferLoader(RGBA8Image* image, const void* buffer, size_t buffer_size);
+static bool BMPBufferSaver(const RGBA8Image& image, std::vector<u8>* buffer, u8 quality);
+static bool BMPFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp);
+static bool BMPFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp, u8 quality);
+
 struct FormatHandler
 {
 	const char* extension;
@@ -46,6 +48,7 @@ static constexpr FormatHandler s_format_handlers[] = {
 	{"jpg", JPEGBufferLoader, JPEGBufferSaver, JPEGFileLoader, JPEGFileSaver},
 	{"jpeg", JPEGBufferLoader, JPEGBufferSaver, JPEGFileLoader, JPEGFileSaver},
 	{"webp", WebPBufferLoader, WebPBufferSaver, WebPFileLoader, WebPFileSaver},
+	{"bmp", BMPBufferLoader, BMPBufferSaver, BMPFileLoader, BMPFileSaver},
 };
 
 static const FormatHandler* GetFormatHandler(const std::string_view extension)
@@ -485,6 +488,8 @@ bool JPEGFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp)
 
 	struct FileCallback
 	{
+		// Must be the first member (&this == &mgr)
+		// We pass a pointer of mgr to libjpeg, and we need to be able to cast it back to FileCallback.
 		jpeg_source_mgr mgr;
 
 		std::FILE* fp;
@@ -496,7 +501,7 @@ bool JPEGFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp)
 		.mgr = {
 			.init_source = [](j_decompress_ptr cinfo) {},
 			.fill_input_buffer = [](j_decompress_ptr cinfo) -> boolean {
-				FileCallback* cb = BASE_FROM_RECORD_FIELD(cinfo->src, FileCallback, mgr);
+				FileCallback* cb = reinterpret_cast<FileCallback*>(cinfo->src);
 				cb->mgr.next_input_byte = cb->buffer.get();
 				if (cb->end_of_file)
 				{
@@ -513,7 +518,7 @@ bool JPEGFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp)
 			},
 			.skip_input_data =
 				[](j_decompress_ptr cinfo, long num_bytes) {
-					FileCallback* cb = BASE_FROM_RECORD_FIELD(cinfo->src, FileCallback, mgr);
+					FileCallback* cb = reinterpret_cast<FileCallback*>(cinfo->src);
 					const size_t skip_in_buffer = std::min<size_t>(cb->mgr.bytes_in_buffer, static_cast<size_t>(num_bytes));
 					cb->mgr.next_input_byte += skip_in_buffer;
 					cb->mgr.bytes_in_buffer -= skip_in_buffer;
@@ -650,12 +655,12 @@ bool JPEGFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp,
 		.mgr = {
 			.init_destination =
 				[](j_compress_ptr cinfo) {
-					FileCallback* cb = BASE_FROM_RECORD_FIELD(cinfo->dest, FileCallback, mgr);
+					FileCallback* cb = reinterpret_cast<FileCallback*>(cinfo->dest);
 					cb->mgr.next_output_byte = cb->buffer.get();
 					cb->mgr.free_in_buffer = BUFFER_SIZE;
 				},
 			.empty_output_buffer = [](j_compress_ptr cinfo) -> boolean {
-				FileCallback* cb = BASE_FROM_RECORD_FIELD(cinfo->dest, FileCallback, mgr);
+				FileCallback* cb = reinterpret_cast<FileCallback*>(cinfo->dest);
 				if (!cb->write_error)
 					cb->write_error |= (std::fwrite(cb->buffer.get(), 1, BUFFER_SIZE, cb->fp) != BUFFER_SIZE);
 
@@ -665,7 +670,7 @@ bool JPEGFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp,
 			},
 			.term_destination =
 				[](j_compress_ptr cinfo) {
-					FileCallback* cb = BASE_FROM_RECORD_FIELD(cinfo->dest, FileCallback, mgr);
+					FileCallback* cb = reinterpret_cast<FileCallback*>(cinfo->dest);
 					const size_t left = BUFFER_SIZE - cb->mgr.free_in_buffer;
 					if (left > 0 && !cb->write_error)
 						cb->write_error |= (std::fwrite(cb->buffer.get(), 1, left, cb->fp) != left);
@@ -734,3 +739,617 @@ bool WebPFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp,
 
 	return (std::fwrite(buffer.data(), buffer.size(), 1, fp) == 1);
 }
+
+// Some of this code is adapted from Qt's BMP handler (https://github.com/qt/qtbase/blob/dev/src/gui/image/qbmphandler.cpp)
+#pragma pack(push, 1)
+struct BMPFileHeader
+{
+	u16 type;
+	u32 size;
+	u16 reserved1;
+	u16 reserved2;
+	u32 offset;
+};
+
+struct BMPInfoHeader
+{
+	u32 size;
+	s32 width;
+	s32 height;
+	u16 planes;
+	u16 bit_count;
+	u32 compression;
+	u32 size_image;
+	s32 x_pels_per_meter;
+	s32 y_pels_per_meter;
+	u32 clr_used;
+	u32 clr_important;
+};
+#pragma pack(pop)
+
+bool IsSupportedBMPFormat(u32 compression, u16 bit_count)
+{
+	if (compression == 0)
+		return (bit_count == 1 || bit_count == 4 || bit_count == 8 || bit_count == 16 || bit_count == 24 || bit_count == 32);
+
+	if (compression == 1)
+		return (bit_count == 8);
+
+	if (compression == 2)
+		return (bit_count == 4);
+
+	if (compression == 3 || compression == 4) // BMP_BITFIELDS or BMP_ALPHABITFIELDS
+		return (bit_count == 16 || bit_count == 32);
+
+	return false;
+}
+
+bool LoadBMPPalette(std::vector<u32>& palette, const u8* data, u32 palette_offset, const BMPInfoHeader& info_header)
+{
+	// 1 bit format doesn't use a palette in the traditional sense
+	if (info_header.bit_count == 1)
+	{
+		palette = {0xFFFFFFFF, 0xFF000000};
+		return true;
+	}
+
+	const u32 num_colors = (info_header.clr_used > 0) ? info_header.clr_used : (1u << info_header.bit_count);
+
+	// Make sure that we don't have an unreasonably large palette
+	if (num_colors > 256)
+	{
+		Console.Error("Invalid palette size: %u", num_colors);
+		return false;
+	}
+
+	palette.clear();
+	palette.reserve(num_colors);
+
+	const u8* palette_data = data + sizeof(BMPFileHeader) + info_header.size;
+
+	for (u32 i = 0; i < num_colors; i++)
+	{
+		const u8* color = palette_data + (i * 4);
+		const u8 b = color[0];
+		const u8 g = color[1];
+		const u8 r = color[2];
+		palette.push_back(r | (g << 8) | (b << 16) | 0xFF000000u);
+	}
+
+	return true;
+}
+
+bool LoadUncompressedBMP(u32* pixels, const u8* src, const u8* data, u32 width, u32 height, const BMPInfoHeader& info_header, const std::vector<u32>& palette, bool flip_vertical, u32 red_mask = 0, u32 green_mask = 0, u32 blue_mask = 0, u32 alpha_mask = 0, bool use_alpha = false)
+{
+	const u32 row_size = ((width * info_header.bit_count + 31) / 32) * 4;
+
+	for (u32 y = 0; y < height; y++)
+	{
+		u32 dst_y = flip_vertical ? (height - 1 - y) : y;
+		const u8* row_src = src + (y * row_size);
+		u32* row_dst = pixels + (dst_y * width);
+
+		u32 bit_offset = 0;
+
+		for (u32 x = 0; x < width; x++)
+		{
+			u32 pixel_value = 0;
+
+			switch (info_header.bit_count)
+			{
+				case 1:
+				{
+					const u32 byte_index = bit_offset / 8;
+					const u32 bit_index = 7 - (bit_offset % 8);
+					pixel_value = (row_src[byte_index] >> bit_index) & 1;
+					bit_offset += 1;
+					break;
+				}
+				case 4:
+				{
+					const u32 byte_index = bit_offset / 8;
+					const u32 nibble_index = (bit_offset % 8) / 4;
+					pixel_value = (row_src[byte_index] >> (nibble_index * 4)) & 0xF;
+					bit_offset += 4;
+					break;
+				}
+				case 8:
+				{
+					pixel_value = row_src[bit_offset / 8];
+					bit_offset += 8;
+					break;
+				}
+				case 16:
+				{
+					const u32 byte_index = bit_offset / 8;
+					pixel_value = row_src[byte_index] | (row_src[byte_index + 1] << 8);
+					bit_offset += 16;
+
+					if (info_header.compression == 3)
+					{
+						const u8* bitfields = data + sizeof(BMPFileHeader) + info_header.size;
+						const u32 r_mask = *reinterpret_cast<const u32*>(bitfields);
+						const u32 g_mask = *reinterpret_cast<const u32*>(bitfields + 4);
+						const u32 b_mask = *reinterpret_cast<const u32*>(bitfields + 8);
+
+						u32 r_shift = 0, g_shift = 0, b_shift = 0;
+						u32 temp = r_mask;
+						while (temp >>= 1)
+							r_shift++;
+						temp = g_mask;
+						while (temp >>= 1)
+							g_shift++;
+						temp = b_mask;
+						while (temp >>= 1)
+							b_shift++;
+
+						const u8 r = static_cast<u8>((pixel_value & r_mask) >> r_shift);
+						const u8 g = static_cast<u8>((pixel_value & g_mask) >> g_shift);
+						const u8 b = static_cast<u8>((pixel_value & b_mask) >> b_shift);
+
+						const u8 r_max = static_cast<u8>(r_mask >> r_shift);
+						const u8 g_max = static_cast<u8>(g_mask >> g_shift);
+						const u8 b_max = static_cast<u8>(b_mask >> b_shift);
+
+						const u8 r_scaled = (r_max > 0) ? static_cast<u8>((r * 255) / r_max) : 0;
+						const u8 g_scaled = (g_max > 0) ? static_cast<u8>((g * 255) / g_max) : 0;
+						const u8 b_scaled = (b_max > 0) ? static_cast<u8>((b * 255) / b_max) : 0;
+
+						row_dst[x] = r_scaled | (g_scaled << 8) | (b_scaled << 16) | 0xFF000000u;
+					}
+					else
+					{
+						const u8 r = (pixel_value >> 10) & 0x1F;
+						const u8 g = (pixel_value >> 5) & 0x1F;
+						const u8 b = pixel_value & 0x1F;
+						row_dst[x] = (r << 3) | (g << 11) | (b << 19) | 0xFF000000u;
+					}
+					continue;
+				}
+				case 24:
+				{
+					const u32 byte_index = bit_offset / 8;
+					const u8 b = row_src[byte_index + 0];
+					const u8 g = row_src[byte_index + 1];
+					const u8 r = row_src[byte_index + 2];
+					row_dst[x] = r | (g << 8) | (b << 16) | 0xFF000000u;
+					bit_offset += 24;
+					continue;
+				}
+				case 32:
+				{
+					const u32 byte_index = bit_offset / 8;
+					u32 pixel_value = row_src[byte_index] | (row_src[byte_index + 1] << 8) | (row_src[byte_index + 2] << 16) | (row_src[byte_index + 3] << 24);
+					bit_offset += 32;
+
+					if (info_header.compression == 3 || info_header.compression == 4) // BITFIELDS or ALPHABITFIELDS
+					{
+						// Calculate shifts
+						auto calc_shift = [](u32 mask) -> u32 {
+							u32 result = 0;
+							while ((mask >= 0x100) || (!(mask & 1) && mask))
+							{
+								result++;
+								mask >>= 1;
+							}
+							return result;
+						};
+
+						// Calculate scales
+						auto calc_scale = [](u32 low_mask) -> u32 {
+							u32 result = 8;
+							while (low_mask && result)
+							{
+								result--;
+								low_mask >>= 1;
+							}
+							return result;
+						};
+
+						// Apply scale
+						auto apply_scale = [](u32 value, u32 scale) -> u8 {
+							if (!(scale & 0x07)) // scale == 8 or 0
+								return static_cast<u8>(value);
+							u32 filled = 8 - scale;
+							u32 result = value << scale;
+							do
+							{
+								result |= result >> filled;
+								filled <<= 1;
+							} while (filled < 8);
+							return static_cast<u8>(result);
+						};
+
+						const u32 r_shift = calc_shift(red_mask);
+						const u32 g_shift = calc_shift(green_mask);
+						const u32 b_shift = calc_shift(blue_mask);
+						const u32 a_shift = (alpha_mask != 0) ? calc_shift(alpha_mask) : 0;
+
+						const u32 r_scale = calc_scale(red_mask >> r_shift);
+						const u32 g_scale = calc_scale(green_mask >> g_shift);
+						const u32 b_scale = calc_scale(blue_mask >> b_shift);
+						const u32 a_scale = (alpha_mask != 0) ? calc_scale(alpha_mask >> a_shift) : 0;
+
+						const u8 r = apply_scale((pixel_value & red_mask) >> r_shift, r_scale);
+						const u8 g = apply_scale((pixel_value & green_mask) >> g_shift, g_scale);
+						const u8 b = apply_scale((pixel_value & blue_mask) >> b_shift, b_scale);
+						const u8 a = (use_alpha && alpha_mask != 0) ? apply_scale((pixel_value & alpha_mask) >> a_shift, a_scale) : 0xFF;
+
+						row_dst[x] = r | (g << 8) | (b << 16) | (a << 24);
+					}
+					else
+					{
+						// Uncompressed 32-bit BGRA order
+						const u8 b = row_src[byte_index + 0];
+						const u8 g = row_src[byte_index + 1];
+						const u8 r = row_src[byte_index + 2];
+						const u8 a = row_src[byte_index + 3];
+						row_dst[x] = r | (g << 8) | (b << 16) | (a << 24);
+					}
+					continue;
+				}
+			}
+			if (info_header.bit_count <= 8)
+			{
+				if (pixel_value < palette.size())
+					row_dst[x] = palette[pixel_value];
+				else
+				{
+					Console.Error("Invalid palette index: %u (palette size: %zu)", pixel_value, palette.size());
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+}
+
+bool LoadCompressedBMP(u32* pixels, const u8* src, u32 src_size, u32 width, u32 height, const BMPInfoHeader& info_header, const std::vector<u32>& palette, bool flip_vertical)
+{
+	u32 src_pos = 0;
+	const u32 pixel_size = (info_header.bit_count == 8) ? 1 : 2;
+
+	for (u32 y = 0; y < height; y++)
+	{
+		u32 dst_y = flip_vertical ? (height - 1 - y) : y;
+		u32* row_dst = pixels + (dst_y * width);
+		u32 x = 0;
+
+		while (x < width)
+		{
+			// Check bounds before reading
+			if (src_pos + 2 > src_size)
+				return false;
+
+			const u8 count = src[src_pos++];
+			const u8 value = src[src_pos++];
+
+			if (count == 0)
+			{
+				if (value == 0)
+				{
+					break;
+				}
+				else if (value == 1)
+				{
+					return true;
+				}
+				else if (value == 2)
+				{
+					// Delta (jump) need 2 more bytes
+					if (src_pos + 2 > src_size)
+						return false;
+					const u8 dx = src[src_pos++];
+					const u8 dy = src[src_pos++];
+					x += dx;
+					y += dy;
+					if (y >= height || x >= width)
+						return false;
+					const u32 new_dst_y = flip_vertical ? (height - 1 - y) : y;
+					row_dst = pixels + (new_dst_y * width);
+				}
+				else
+				{
+					// Absolute mode need "value" bytes of pixel data
+					const u32 run_length = value;
+					const u32 bytes_needed = run_length * pixel_size;
+					if (src_pos + bytes_needed > src_size)
+						return false;
+
+					for (u32 i = 0; i < run_length; i++)
+					{
+						if (x >= width)
+							break;
+
+						u8 pixel_value = 0;
+						if (info_header.bit_count == 8)
+						{
+							pixel_value = src[src_pos++];
+						}
+						else
+						{
+							const u8 byte_val = src[src_pos++];
+							pixel_value = (i % 2 == 0) ? (byte_val >> 4) : (byte_val & 0x0F);
+						}
+
+						row_dst[x++] = (pixel_value < palette.size()) ? palette[pixel_value] : 0;
+					}
+
+					if ((run_length * pixel_size) % 2 == 1)
+						src_pos++;
+				}
+			}
+			else
+			{
+				u8 pixel_value = value;
+
+				for (u32 i = 0; i < count; i++)
+				{
+					if (x >= width)
+						break;
+					row_dst[x++] = (pixel_value < palette.size()) ? palette[pixel_value] : 0;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+bool BMPBufferLoader(RGBA8Image* image, const void* buffer, size_t buffer_size)
+{
+	if (buffer_size < sizeof(BMPFileHeader) + sizeof(BMPInfoHeader))
+	{
+		Console.Error("BMP file too small");
+		return false;
+	}
+
+	const u8* data = static_cast<const u8*>(buffer);
+	BMPFileHeader file_header;
+	BMPInfoHeader info_header;
+
+	std::memcpy(&file_header, data, sizeof(BMPFileHeader));
+	std::memcpy(&info_header, data + sizeof(BMPFileHeader), sizeof(BMPInfoHeader));
+
+	if (file_header.type != 0x4D42)
+	{
+		Console.Error("Invalid BMP signature");
+		return false;
+	}
+
+	// Check for extended header versions (V4=108 bytes, V5=124 bytes)
+	// We read as BITMAPINFOHEADER (40 bytes) regardless, since extended headers just add fields at the end
+	if (info_header.size == 108)
+	{
+		Console.Warning("BITMAPV4HEADER detected, reading as BITMAPINFOHEADER");
+	}
+	else if (info_header.size == 124)
+	{
+		Console.Warning("BITMAPV5HEADER detected, reading as BITMAPINFOHEADER");
+	}
+	else if (info_header.size != 40)
+	{
+		Console.Warning("Unknown BMP header size: %u, attempting to read as BITMAPINFOHEADER", info_header.size);
+	}
+
+	if (!IsSupportedBMPFormat(info_header.compression, info_header.bit_count))
+	{
+		Console.Error("Unsupported BMP format: compression=%u, bit_count=%u", info_header.compression, info_header.bit_count);
+		return false;
+	}
+
+	const u32 width = static_cast<u32>(std::abs(info_header.width));
+	const u32 height = static_cast<u32>(std::abs(info_header.height));
+	const bool flip_vertical = (info_header.height > 0);
+
+	if (width == 0 || height == 0)
+	{
+		Console.Error("Invalid BMP dimensions: %ux%u", width, height);
+		return false;
+	}
+
+	if (width > 65536 || height > 65536)
+	{
+		Console.Error("BMP dimensions too large: %ux%u", width, height);
+		return false;
+	}
+
+	Console.WriteLn("BMP: %ux%u, %u-bit, compression=%u", width, height, info_header.bit_count, info_header.compression);
+
+	// Read color masks from header or bitfields
+	u32 red_mask = 0;
+	u32 green_mask = 0;
+	u32 blue_mask = 0;
+	u32 alpha_mask = 0;
+	const bool bitfields = (info_header.compression == 3 || info_header.compression == 4); // BMP_BITFIELDS or BMP_ALPHABITFIELDS
+	const u8* header_start = data + sizeof(BMPFileHeader);
+	const u32 header_base_offset = sizeof(BMPFileHeader) + 40; // Base header is 40 bytes
+
+	if (info_header.size >= 108) // BMP_WIN4 (108) or BMP_WIN5 (124)
+	{
+		// V4/V5 headers masks come right after the 40-byte base header
+		// Masks are at offsets from header_start: red=40, green=44, blue=48, alpha=52
+		if (buffer_size >= header_base_offset + 16) // Need space for 4 masks
+		{
+			red_mask = *reinterpret_cast<const u32*>(header_start + 40);
+			green_mask = *reinterpret_cast<const u32*>(header_start + 44);
+			blue_mask = *reinterpret_cast<const u32*>(header_start + 48);
+			alpha_mask = *reinterpret_cast<const u32*>(header_start + 52);
+		}
+	}
+	else if (bitfields && (info_header.bit_count == 16 || info_header.bit_count == 32))
+	{
+		const u32 bitfields_offset = sizeof(BMPFileHeader) + info_header.size;
+		if (buffer_size >= bitfields_offset + 12) // Need space for at least r/g/b masks
+		{
+			red_mask = *reinterpret_cast<const u32*>(data + bitfields_offset);
+			green_mask = *reinterpret_cast<const u32*>(data + bitfields_offset + 4);
+			blue_mask = *reinterpret_cast<const u32*>(data + bitfields_offset + 8);
+			if (info_header.compression == 4) // BMP_ALPHABITFIELDS
+			{
+				// Read alpha mask: r, g, b, a
+				if (buffer_size >= bitfields_offset + 16)
+					alpha_mask = *reinterpret_cast<const u32*>(data + bitfields_offset + 12);
+			}
+			// For BMP_BITFIELDS (3), alpha_mask stays 0
+		}
+	}
+
+	bool use_alpha = bitfields || (info_header.compression == 0 && info_header.bit_count == 32 && alpha_mask == 0xff000000);
+	use_alpha = use_alpha && (alpha_mask != 0);
+
+	const u32 bytes_per_pixel = info_header.bit_count / 8;
+	const u32 row_size = ((width * bytes_per_pixel + 3) / 4) * 4;
+
+	// For uncompressed BMPs, verify we have enough data
+	// For RLE-compressed BMPs, size is variable so we check differently
+	if (info_header.compression == 0)
+	{
+		if (file_header.offset + (row_size * height) > buffer_size)
+		{
+			Console.Error("BMP file data incomplete");
+			return false;
+		}
+	}
+	else
+	{
+		// For RLE-compressed BMPs, check that we have at least the offset and some data
+		// Use biSizeImage if available, otherwise just verify offset is valid
+		if (file_header.offset >= buffer_size)
+		{
+			Console.Error("BMP file data incomplete");
+			return false;
+		}
+		if (info_header.size_image > 0)
+		{
+			if (file_header.offset + info_header.size_image > buffer_size)
+			{
+				Console.Error("BMP file data incomplete");
+				return false;
+			}
+		}
+	}
+
+	std::vector<u32> pixels;
+	pixels.resize(width * height);
+
+	const u8* src = data + file_header.offset;
+	const u32 src_size = buffer_size - file_header.offset;
+
+	std::vector<u32> palette;
+	if (info_header.bit_count <= 8)
+	{
+		if (!LoadBMPPalette(palette, data, file_header.offset, info_header))
+		{
+			Console.Error("Failed to load BMP palette");
+			return false;
+		}
+	}
+
+	if (info_header.compression == 0 || info_header.compression == 3 || info_header.compression == 4)
+	{
+		if (!LoadUncompressedBMP(pixels.data(), src, data, width, height, info_header, palette, flip_vertical, red_mask, green_mask, blue_mask, alpha_mask, use_alpha))
+		{
+			Console.Error("Failed to load uncompressed BMP data");
+			return false;
+		}
+	}
+	else
+	{
+		if (!LoadCompressedBMP(pixels.data(), src, src_size, width, height, info_header, palette, flip_vertical))
+		{
+			Console.Error("Failed to load compressed BMP data");
+			return false;
+		}
+	}
+
+	// Handle alpha channel for 32-bit BMPs
+	// Only use alpha if alpha_mask is explicitly set in header/bitfields
+	if (info_header.bit_count == 32 && !use_alpha)
+	{
+		// Alpha mask not set or zero - set all pixels to fully opaque
+		for (u32& pixel : pixels)
+			pixel |= 0xFF000000u;
+	}
+
+	image->SetPixels(width, height, std::move(pixels));
+	return true;
+}
+
+bool BMPFileLoader(RGBA8Image* image, const char* filename, std::FILE* fp)
+{
+	std::optional<std::vector<u8>> data = FileSystem::ReadBinaryFile(fp);
+	if (!data.has_value())
+		return false;
+
+	return BMPBufferLoader(image, data->data(), data->size());
+}
+
+bool BMPBufferSaver(const RGBA8Image& image, std::vector<u8>* buffer, u8 quality)
+{
+	const u32 width = image.GetWidth();
+	const u32 height = image.GetHeight();
+
+	// Check dimensions
+	if (width == 0 || height == 0)
+	{
+		Console.Error("Invalid BMP dimensions: %ux%u", width, height);
+		return false;
+	}
+
+	const u32 row_size = ((width * 3 + 3) / 4) * 4;
+	const u32 image_size = row_size * height;
+	const u32 file_size = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + image_size;
+
+	buffer->resize(file_size);
+	u8* data = buffer->data();
+
+	BMPFileHeader file_header = {};
+	file_header.type = 0x4D42;
+	file_header.size = file_size;
+	file_header.reserved1 = 0;
+	file_header.reserved2 = 0;
+	file_header.offset = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
+	std::memcpy(data, &file_header, sizeof(BMPFileHeader));
+
+	BMPInfoHeader info_header = {};
+	info_header.size = sizeof(BMPInfoHeader);
+	info_header.width = static_cast<s32>(width);
+	info_header.height = static_cast<s32>(height);
+	info_header.planes = 1;
+	info_header.bit_count = 24;
+	info_header.compression = 0;
+	info_header.size_image = image_size;
+	info_header.x_pels_per_meter = 0;
+	info_header.y_pels_per_meter = 0;
+	info_header.clr_used = 0;
+	info_header.clr_important = 0;
+	std::memcpy(data + sizeof(BMPFileHeader), &info_header, sizeof(BMPInfoHeader));
+
+	u8* pixel_data = data + file_header.offset;
+	for (u32 y = 0; y < height; y++)
+	{
+		const u32 src_y = height - 1 - y;
+		const u32* row_src = image.GetRowPixels(src_y);
+		u8* row_dst = pixel_data + (y * row_size);
+
+		for (u32 x = 0; x < width; x++)
+		{
+			const u32 rgba = row_src[x];
+			row_dst[x * 3 + 0] = static_cast<u8>((rgba >> 16) & 0xFF);
+			row_dst[x * 3 + 1] = static_cast<u8>((rgba >> 8) & 0xFF);
+			row_dst[x * 3 + 2] = static_cast<u8>(rgba & 0xFF);
+		}
+	}
+
+	return true;
+}
+
+bool BMPFileSaver(const RGBA8Image& image, const char* filename, std::FILE* fp, u8 quality)
+{
+	std::vector<u8> buffer;
+	if (!BMPBufferSaver(image, &buffer, quality))
+		return false;
+
+	return (std::fwrite(buffer.data(), buffer.size(), 1, fp) == 1);
+}

common/Timer.cpp

@@ -106,6 +106,11 @@ namespace Common
 		Reset();
 	}
 
+	Timer::Timer(Value start_value)
+	{
+		m_tvStartValue = start_value;
+	}
+
 	void Timer::Reset()
 	{
 		m_tvStartValue = GetCurrentValue();

common/Timer.h

@@ -12,6 +12,7 @@ namespace Common
 		using Value = std::uint64_t;
 
 		Timer();
+		Timer (Value start_value);
 
 		static Value GetCurrentValue();
 		static double ConvertValueToSeconds(Value value);

pcsx2-gsrunner/Main.cpp

@@ -446,8 +446,8 @@ static void PrintCommandLineHelp(const char* progname)
 	std::fprintf(stderr, "  -help: Displays this information and exits.\n");
 	std::fprintf(stderr, "  -version: Displays version information and exits.\n");
 	std::fprintf(stderr, "  -dumpdir <dir>: Frame dump directory (will be dumped as filename_frameN.png).\n");
-	std::fprintf(stderr, "  -dump [rt|tex|z|f|a|i|tr]: Enabling dumping of render target, texture, z buffer, frame, "
-		"alphas, and info (context, vertices, transfers (list)), transfers (images), respectively, per draw. Generates lots of data.\n");
+	std::fprintf(stderr, "  -dump [rt|tex|z|f|a|i|tr|ds|fs]: Enabling dumping of render target, texture, z buffer, frame, "
+		"alphas, and info (context, vertices, list of transfers), transfers images, draw stats, frame stats, respectively, per draw. Generates lots of data.\n");
 	std::fprintf(stderr, "  -dumprange N[,L,B]: Start dumping from draw N (base 0), stops after L draws, and only "
 		"those draws that are multiples of B (intersection of -dumprange and -dumprangef used)."
 		"Defaults to 0,-1,1 (all draws). Only used if -dump used.\n");
@@ -533,6 +533,10 @@ bool GSRunner::ParseCommandLineArgs(int argc, char* argv[], VMBootParameters& pa
 					s_settings_interface.SetBoolValue("EmuCore/GS", "SaveInfo", true);
 				if (str.find("tr") != std::string::npos)
 					s_settings_interface.SetBoolValue("EmuCore/GS", "SaveTransferImages", true);
+				if (str.find("ds") != std::string::npos)
+					s_settings_interface.SetBoolValue("EmuCore/GS", "SaveDrawStats", true);
+				if (str.find("fs") != std::string::npos)
+					s_settings_interface.SetBoolValue("EmuCore/GS", "SaveFrameStats", true);
 				continue;
 			}
 			else if (CHECK_ARG_PARAM("-dumprange"))
@@ -726,7 +730,7 @@ bool GSRunner::ParseCommandLineArgs(int argc, char* argv[], VMBootParameters& pa
 			else if (CHECK_ARG("-noshadercache"))
 			{
 				Console.WriteLn("Disabling shader cache");
-				s_settings_interface.SetBoolValue("EmuCore/GS", "disable_shader_cache", true);
+				s_settings_interface.SetBoolValue("EmuCore/GS", "DisableShaderCache", true);
 				continue;
 			}
 			else if (CHECK_ARG("-window"))
@@ -857,16 +861,27 @@ void GSRunner::DumpStats()
 #define main real_main
 #endif
 
-static void CPUThreadMain(VMBootParameters* params) {
-	if (VMManager::Initialize(*params))
+static void CPUThreadMain(VMBootParameters* params, std::atomic<int>* ret)
+{
+	ret->store(EXIT_FAILURE);
+
+	if (VMManager::Internal::CPUThreadInitialize())
 	{
-		// run until end
-		GSDumpReplayer::SetLoopCount(s_loop_count);
-		VMManager::SetState(VMState::Running);
-		while (VMManager::GetState() == VMState::Running)
-			VMManager::Execute();
-		VMManager::Shutdown(false);
-		GSRunner::DumpStats();
+		// apply new settings (e.g. pick up renderer change)
+		VMManager::ApplySettings();
+		GSDumpReplayer::SetIsDumpRunner(true);
+
+		if (VMManager::Initialize(*params))
+		{
+			// run until end
+			GSDumpReplayer::SetLoopCount(s_loop_count);
+			VMManager::SetState(VMState::Running);
+			while (VMManager::GetState() == VMState::Running)
+				VMManager::Execute();
+			VMManager::Shutdown(false);
+			GSRunner::DumpStats();
+			ret->store(EXIT_SUCCESS);
+		}
 	}
 
 	VMManager::Internal::CPUThreadShutdown();
@@ -888,9 +903,6 @@ int main(int argc, char* argv[])
 	if (!GSRunner::ParseCommandLineArgs(argc, argv, params))
 		return EXIT_FAILURE;
 
-	if (!VMManager::Internal::CPUThreadInitialize())
-		return EXIT_FAILURE;
-
 	if (s_use_window.value_or(true) && !GSRunner::CreatePlatformWindow())
 	{
 		Console.Error("Failed to create window.");
@@ -900,18 +912,14 @@ int main(int argc, char* argv[])
 	// Override settings that shouldn't be picked up from defaults or INIs.
 	GSRunner::SettingsOverride();
 
-	// apply new settings (e.g. pick up renderer change)
-	VMManager::ApplySettings();
-	GSDumpReplayer::SetIsDumpRunner(true);
-
-	std::thread cputhread(CPUThreadMain, &params);
+	std::atomic<int> thread_ret;
+	std::thread cputhread(CPUThreadMain, &params, &thread_ret);
 	GSRunner::PumpPlatformMessages(/*forever=*/true);
 	cputhread.join();
 
-	VMManager::Internal::CPUThreadShutdown();
 	GSRunner::DestroyPlatformWindow();
 
-	return EXIT_SUCCESS;
+	return thread_ret.load();
 }
 
 void Host::PumpMessagesOnCPUThread()

pcsx2-qt/AboutDialog.cpp

@@ -12,6 +12,7 @@
 #include "common/SmallString.h"
 
 #include <QtCore/QFile>
+#include <QtCore/QFileInfo>
 #include <QtCore/QString>
 #include <QtGui/QDesktopServices>
 #include <QtWidgets/QDialog>
@@ -134,12 +135,16 @@ void AboutDialog::showHTMLDialog(QWidget* parent, const QString& title, const QS
 	tb->setOpenExternalLinks(true);
 
 	QFile file(path);
-	file.open(QIODevice::ReadOnly);
-	if (const QByteArray data = file.readAll(); !data.isEmpty())
-		tb->setText(QString::fromUtf8(data));
-	else
+	QFileInfo fi(path);
+	if (!fi.exists() || !fi.isReadable())
+	{
 		tb->setText(tr("File not found: %1").arg(path));
-
+	}
+	else
+	{
+		tb->setSource(QUrl::fromLocalFile(path));
+	}
+	
 	layout->addWidget(tb, 1);
 
 	QDialogButtonBox* bb = new QDialogButtonBox(QDialogButtonBox::Close, &dialog);

pcsx2-qt/Debugger/DebuggerSettingsManager.cpp

@@ -153,7 +153,7 @@ void DebuggerSettingsManager::saveGameSettings(QAbstractTableModel* abstractTabl
 	if (path.empty())
 		return;
 
-	const std::lock_guard<std::mutex> lock(writeLock);
+	std::lock_guard<std::mutex> lock(writeLock);
 	QJsonObject loadedSettings = loadGameSettingsJSON();
 	QJsonArray rowsArray;
 	QStringList keys;

pcsx2-qt/Debugger/DisassemblyView.cpp

@@ -118,11 +118,11 @@ void DisassemblyView::contextPasteInstructionText()
 	// split text in clipboard by new lines
 	QString clipboardText = QApplication::clipboard()->text();
 	std::vector<std::string> newInstructions = StringUtil::splitOnNewLine(clipboardText.toLocal8Bit().constData());
-	int newInstructionsSize = newInstructions.size();
+	u32 newInstructionsSize = static_cast<u32>(newInstructions.size());
 
 	// validate new instructions before pasting them
 	std::vector<u32> encodedInstructions;
-	for (int instructionIdx = 0; instructionIdx < newInstructionsSize; instructionIdx++)
+	for (u32 instructionIdx = 0; instructionIdx < newInstructionsSize; instructionIdx++)
 	{
 		u32 replaceAddress = m_selectedAddressStart + instructionIdx * 4;
 		u32 encodedInstruction;
@@ -137,7 +137,7 @@ void DisassemblyView::contextPasteInstructionText()
 	}
 
 	// paste validated instructions
-	for (int instructionIdx = 0; instructionIdx < newInstructionsSize; instructionIdx++)
+	for (u32 instructionIdx = 0; instructionIdx < newInstructionsSize; instructionIdx++)
 	{
 		u32 replaceAddress = m_selectedAddressStart + instructionIdx * 4;
 		setInstructions(replaceAddress, replaceAddress, encodedInstructions[instructionIdx]);
@@ -424,7 +424,7 @@ void DisassemblyView::paintEvent(QPaintEvent* event)
 	bool alternate = m_visibleStart % 8;
 
 	// Draw visible disassembly rows
-	for (u32 i = 0; i <= m_visibleRows; i++)
+	for (u32 i = 0; i < m_visibleRows + 1; i++)
 	{
 		// Address of instruction being displayed on row
 		const u32 rowAddress = (i * 4) + m_visibleStart;
@@ -977,18 +977,18 @@ QColor DisassemblyView::GetAddressFunctionColor(u32 address)
 QString DisassemblyView::FetchSelectionInfo(SelectionInfo selInfo)
 {
 	QString infoBlock;
-	for (u32 i = m_selectedAddressStart; i <= m_selectedAddressEnd; i += 4)
+	for (u64 i = m_selectedAddressStart; i <= m_selectedAddressEnd; i += 4)
 	{
 		if (i != m_selectedAddressStart)
 			infoBlock += '\n';
 		if (selInfo == SelectionInfo::ADDRESS)
 		{
-			infoBlock += FilledQStringFromValue(i, 16);
+			infoBlock += FilledQStringFromValue(static_cast<u32>(i), 16);
 		}
 		else if (selInfo == SelectionInfo::INSTRUCTIONTEXT)
 		{
 			DisassemblyLineInfo line;
-			m_disassemblyManager.getLine(i, true, line);
+			m_disassemblyManager.getLine(static_cast<u32>(i), true, line);
 			infoBlock += QString("%1 %2").arg(line.name.c_str()).arg(line.params.c_str());
 		}
 		else // INSTRUCTIONHEX
@@ -1075,9 +1075,9 @@ void DisassemblyView::setInstructions(u32 start, u32 end, u32 value)
 
 bool DisassemblyView::AddressCanRestore(u32 start, u32 end)
 {
-	for (u32 i = start; i <= end; i += 4)
+	for (u64 i = start; i <= end; i += 4)
 	{
-		if (this->m_nopedInstructions.find(i) != this->m_nopedInstructions.end())
+		if (this->m_nopedInstructions.find(static_cast<u32>(i)) != this->m_nopedInstructions.end())
 		{
 			return true;
 		}

pcsx2-qt/Debugger/Docking/DockMenuBar.cpp

@@ -6,39 +6,36 @@
 #include <QtCore/QTimer>
 #include <QtGui/QPainter>
 #include <QtGui/QPaintEvent>
-#include <QtWidgets/QBoxLayout>
 #include <QtWidgets/QStyleFactory>
 #include <QtWidgets/QStyleOption>
 
-static const int OUTER_MENU_MARGIN = 2;
-static const int INNER_MENU_MARGIN = 4;
+static constexpr int TAB_BAR_TOP_MARGIN = 2;
+static constexpr int RIGHT_MARGIN = 2;
 
 DockMenuBar::DockMenuBar(QWidget* original_menu_bar, QWidget* parent)
 	: QWidget(parent)
 	, m_original_menu_bar(original_menu_bar)
 {
-	QHBoxLayout* layout = new QHBoxLayout;
-	layout->setContentsMargins(0, OUTER_MENU_MARGIN, OUTER_MENU_MARGIN, 0);
-	setLayout(layout);
+	QHBoxLayout* layout = new QHBoxLayout(this);
+	layout->setContentsMargins(0, 0, RIGHT_MARGIN, 0);
 
-	QWidget* menu_wrapper = new QWidget;
-	menu_wrapper->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
-	layout->addWidget(menu_wrapper);
+	QWidget* menu_bar_wrapper = new QWidget;
+	layout->addWidget(menu_bar_wrapper);
 
-	QHBoxLayout* menu_layout = new QHBoxLayout;
-	menu_layout->setContentsMargins(0, INNER_MENU_MARGIN, 0, INNER_MENU_MARGIN);
-	menu_wrapper->setLayout(menu_layout);
+	QVBoxLayout* menu_bar_layout = new QVBoxLayout(menu_bar_wrapper);
+	menu_bar_layout->setContentsMargins(0, 0, 0, 0);
+	menu_bar_layout->addWidget(original_menu_bar, 0, Qt::AlignVCenter);
 
-	menu_layout->addWidget(original_menu_bar);
+	QWidget* layout_switcher_wrapper = new QWidget;
+	layout->addWidget(layout_switcher_wrapper);
+
+	m_layout_switcher_layout = new QVBoxLayout(layout_switcher_wrapper);
 
 	m_layout_switcher = new QTabBar;
-	m_layout_switcher->setContentsMargins(0, 0, 0, 0);
-	m_layout_switcher->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 	m_layout_switcher->setContextMenuPolicy(Qt::CustomContextMenu);
 	m_layout_switcher->setDrawBase(false);
 	m_layout_switcher->setExpanding(false);
 	m_layout_switcher->setMovable(true);
-	layout->addWidget(m_layout_switcher);
 
 	connect(m_layout_switcher, &QTabBar::tabMoved, this, [this](int from, int to) {
 		DockLayout::Index from_index = static_cast<DockLayout::Index>(from);
@@ -63,6 +60,10 @@ DockMenuBar::DockMenuBar(QWidget* original_menu_bar, QWidget* parent)
 	});
 	layout->addWidget(m_layout_locked_toggle);
 
+	layout->setStretchFactor(menu_bar_wrapper, 0);
+	layout->setStretchFactor(layout_switcher_wrapper, 1);
+	layout->setStretchFactor(m_layout_locked_toggle, 0);
+
 	updateTheme();
 }
 
@@ -75,6 +76,19 @@ void DockMenuBar::updateTheme()
 
 	delete m_style;
 	m_style = style;
+
+	// Vertically centre the layout switcher tabs for the Windows 11 style
+	// because I think it looks better. Do the same for macOS too.
+	if (style->baseStyle()->name() == "windows11" || style->baseStyle()->name() == "macOS")
+	{
+		m_layout_switcher_layout->setContentsMargins(0, 0, 0, 0);
+		m_layout_switcher_layout->addWidget(m_layout_switcher, 0, Qt::AlignVCenter);
+	}
+	else
+	{
+		m_layout_switcher_layout->setContentsMargins(0, TAB_BAR_TOP_MARGIN, 0, 0);
+		m_layout_switcher_layout->addWidget(m_layout_switcher, 0, Qt::AlignBottom);
+	}
 }
 
 void DockMenuBar::updateLayoutSwitcher(DockLayout::Index current_index, const std::vector<DockLayout>& layouts)
@@ -182,11 +196,6 @@ void DockMenuBar::stopBlink()
 	}
 }
 
-int DockMenuBar::innerHeight() const
-{
-	return m_original_menu_bar->sizeHint().height() + INNER_MENU_MARGIN * 2;
-}
-
 void DockMenuBar::paintEvent(QPaintEvent* event)
 {
 	QPainter painter(this);
@@ -236,39 +245,6 @@ void DockMenuBarStyle::drawControl(
 {
 	switch (element)
 	{
-		case CE_MenuBarItem:
-		{
-			const QStyleOptionMenuItem* opt = qstyleoption_cast<const QStyleOptionMenuItem*>(option);
-			if (!opt)
-				break;
-
-			QWidget* menu_wrapper = widget->parentWidget();
-			if (!menu_wrapper)
-				break;
-
-			const DockMenuBar* menu_bar = qobject_cast<const DockMenuBar*>(menu_wrapper->parentWidget());
-			if (!menu_bar)
-				break;
-
-			if (baseStyle()->name() != "fusion")
-				break;
-
-			// This mirrors a check in QFusionStyle::drawControl. If act is
-			// false, QFusionStyle will try to draw a border along the bottom.
-			bool act = opt->state & State_Selected && opt->state & State_Sunken;
-			if (act)
-				break;
-
-			// Extend the menu item to the bottom of the menu bar to fix the
-			// position in which it draws its bottom border. We also need to
-			// extend it up by the same amount so that the text isn't moved.
-			QStyleOptionMenuItem menu_opt = *opt;
-			int difference = (menu_bar->innerHeight() - option->rect.top()) - menu_opt.rect.height();
-			menu_opt.rect.adjust(0, -difference, 0, difference);
-			QProxyStyle::drawControl(element, &menu_opt, painter, widget);
-
-			return;
-		}
 		case CE_TabBarTab:
 		{
 			QProxyStyle::drawControl(element, option, painter, widget);
@@ -286,6 +262,25 @@ void DockMenuBarStyle::drawControl(
 
 			return;
 		}
+		case CE_MenuBarItem:
+		{
+			const QStyleOptionMenuItem* opt = qstyleoption_cast<const QStyleOptionMenuItem*>(option);
+			if (!opt)
+				break;
+
+			if (baseStyle()->name() != "fusion")
+				break;
+
+			// This mirrors a check in QFusionStyle::drawControl. If act is
+			// false, QFusionStyle will try to draw a border along the bottom.
+			bool act = opt->state & State_Selected && opt->state & State_Sunken;
+			if (act)
+				break;
+
+			QCommonStyle::drawControl(element, option, painter, widget);
+
+			return;
+		}
 		case CE_MenuBarEmptyArea:
 		{
 			// Prevent it from drawing a border in the wrong position.
@@ -301,7 +296,10 @@ void DockMenuBarStyle::drawControl(
 }
 
 QSize DockMenuBarStyle::sizeFromContents(
-	QStyle::ContentsType type, const QStyleOption* option, const QSize& contents_size, const QWidget* widget) const
+	QStyle::ContentsType type,
+	const QStyleOption* option,
+	const QSize& contents_size,
+	const QWidget* widget) const
 {
 	QSize size = QProxyStyle::sizeFromContents(type, option, contents_size, widget);
 
@@ -312,27 +310,10 @@ QSize DockMenuBarStyle::sizeFromContents(
 		if (!opt)
 			return size;
 
-		const QTabBar* tab_bar = qobject_cast<const QTabBar*>(widget);
-		if (!tab_bar)
-			return size;
-
-		const DockMenuBar* menu_bar = qobject_cast<const DockMenuBar*>(tab_bar->parentWidget());
-		if (!menu_bar)
-			return size;
-
-		if (baseStyle()->name() == "fusion" || baseStyle()->name() == "windowsvista")
+		if (baseStyle()->name() == "windows11")
 		{
-			// Make sure the tab extends to the bottom of the widget.
-			size.setHeight(menu_bar->innerHeight() - opt->rect.top());
-		}
-		else if (baseStyle()->name() == "windows11")
-		{
-			// Adjust the size of the tab such that it is vertically centred.
-			size.setHeight(menu_bar->innerHeight() - opt->rect.top() * 2 - OUTER_MENU_MARGIN);
-
-			// Make the plus button square.
-			if (opt->tabIndex + 1 == tab_bar->count())
-				size.setWidth(size.height());
+			// Make the tabs a bit taller, otherwise there's an awkward margin.
+			size.setHeight(size.height() + 4);
 		}
 	}
 

pcsx2-qt/Debugger/Docking/DockMenuBar.h

@@ -9,6 +9,7 @@
 #include <QtWidgets/QProxyStyle>
 #include <QtWidgets/QPushButton>
 #include <QtWidgets/QTabBar>
+#include <QtWidgets/QBoxLayout>
 #include <QtWidgets/QWidget>
 
 class DockMenuBarStyle;
@@ -36,8 +37,6 @@ public:
 	void updateBlink();
 	void stopBlink();
 
-	int innerHeight() const;
-
 Q_SIGNALS:
 	void currentLayoutChanged(DockLayout::Index layout_index);
 	void newButtonClicked();
@@ -54,6 +53,7 @@ private:
 
 	QWidget* m_original_menu_bar;
 
+	QVBoxLayout* m_layout_switcher_layout;
 	QTabBar* m_layout_switcher;
 	QMetaObject::Connection m_tab_connection;
 	int m_plus_tab_index = -1;
@@ -70,8 +70,7 @@ private:
 	DockMenuBarStyle* m_style = nullptr;
 };
 
-// Fixes some theming issues relating to the menu bar, the layout switcher and
-// the layout locked/unlocked toggle button.
+// Fixes some theming issues relating to the menu bar and the layout switcher.
 class DockMenuBarStyle : public QProxyStyle
 {
 	Q_OBJECT
@@ -83,11 +82,11 @@ public:
 		ControlElement element,
 		const QStyleOption* option,
 		QPainter* painter,
-		const QWidget* widget = nullptr) const override;
+		const QWidget* widget) const override;
 
 	QSize sizeFromContents(
 		QStyle::ContentsType type,
 		const QStyleOption* option,
 		const QSize& contents_size,
-		const QWidget* widget = nullptr) const override;
+		const QWidget* widget) const override;
 };

pcsx2-qt/Debugger/SymbolTree/SymbolTreeDelegates.cpp

@@ -114,12 +114,30 @@ QWidget* SymbolTreeValueDelegate::createEditor(QWidget* parent, const QStyleOpti
 				const ccc::ast::Enum& enumeration = type.as<ccc::ast::Enum>();
 
 				QComboBox* combo_box = new QComboBox(parent);
-				for (s32 i = 0; i < (s32)enumeration.constants.size(); i++)
+				bool named = false;
+
+				for (size_t i = 0; i < enumeration.constants.size(); i++)
 				{
-					combo_box->addItem(QString::fromStdString(enumeration.constants[i].second));
+					QString text = QString::fromStdString(enumeration.constants[i].second);
+					combo_box->addItem(text, enumeration.constants[i].first);
 					if (enumeration.constants[i].first == value.toInt())
-						combo_box->setCurrentIndex(i);
+					{
+						combo_box->setCurrentIndex(static_cast<int>(i));
+						named = true;
+					}
 				}
+
+				if (!named)
+				{
+					// The value isn't equal to any of the named constants, so
+					// add an extra item to the combo box representing the
+					// current value so that the first named constant isn't
+					// written back to VM memory accidentally.
+					QString text = display_options.signedIntegerToString(value.toInt(), 32);
+					combo_box->insertItem(0, text, value.toInt());
+					combo_box->setCurrentIndex(0);
+				}
+
 				connect(combo_box, &QComboBox::currentIndexChanged, this, &SymbolTreeValueDelegate::onComboBoxIndexChanged);
 				result = combo_box;
 
@@ -245,15 +263,10 @@ void SymbolTreeValueDelegate::setModelData(QWidget* editor, QAbstractItemModel*
 			}
 			case ccc::ast::ENUM:
 			{
-				const ccc::ast::Enum& enumeration = type.as<ccc::ast::Enum>();
 				QComboBox* combo_box = qobject_cast<QComboBox*>(editor);
 				Q_ASSERT(combo_box);
 
-				s32 comboIndex = combo_box->currentIndex();
-				if (comboIndex < 0 || comboIndex >= (s32)enumeration.constants.size())
-					break;
-
-				value = enumeration.constants[comboIndex].first;
+				value = combo_box->currentData().toInt();
 
 				break;
 			}

pcsx2-qt/Debugger/SymbolTree/SymbolTreeNode.cpp

@@ -390,15 +390,13 @@ QString SymbolTreeNode::generateDisplayString(
 		}
 		case ccc::ast::ENUM:
 		{
-			s32 value = (s32)location.read32(cpu);
+			s32 value = static_cast<s32>(location.read32(cpu));
 			const auto& enum_type = physical_type.as<ccc::ast::Enum>();
-			for (auto [test_value, name] : enum_type.constants)
-			{
+			for (const auto& [test_value, name] : enum_type.constants)
 				if (test_value == value)
 					return QString::fromStdString(name);
-			}
 
-			break;
+			return display_options.signedIntegerToString(value, 32);
 		}
 		case ccc::ast::POINTER_OR_REFERENCE:
 		{

pcsx2-qt/Debugger/ThreadModel.cpp

@@ -13,7 +13,7 @@ ThreadModel::ThreadModel(DebugInterface& cpu, QObject* parent)
 
 int ThreadModel::rowCount(const QModelIndex&) const
 {
-	return m_cpu.GetThreadList().size();
+	return static_cast<int>(m_threads.size());
 }
 
 int ThreadModel::columnCount(const QModelIndex&) const

pcsx2-qt/DisplayWidget.cpp

@@ -29,20 +29,12 @@
 #include <qpa/qplatformnativeinterface.h>
 #endif
 
-DisplayWidget::DisplayWidget(QWidget* parent)
-	: QWidget(parent)
+DisplaySurface::DisplaySurface()
+	: QWindow()
 {
-	// We want a native window for both D3D and OpenGL.
-	setAutoFillBackground(false);
-	setAttribute(Qt::WA_NativeWindow, true);
-	setAttribute(Qt::WA_NoSystemBackground, true);
-	setAttribute(Qt::WA_PaintOnScreen, true);
-	setAttribute(Qt::WA_KeyCompression, false);
-	setFocusPolicy(Qt::StrongFocus);
-	setMouseTracking(true);
 }
 
-DisplayWidget::~DisplayWidget()
+DisplaySurface::~DisplaySurface()
 {
 #ifdef _WIN32
 	if (m_clip_mouse_enabled)
@@ -50,19 +42,17 @@ DisplayWidget::~DisplayWidget()
 #endif
 }
 
-int DisplayWidget::scaledWindowWidth() const
+QWidget* DisplaySurface::createWindowContainer(QWidget* parent)
 {
-	return std::max(static_cast<int>(std::ceil(static_cast<qreal>(width()) * devicePixelRatioF())), 1);
+	m_container = QWidget::createWindowContainer(this, parent);
+	m_container->installEventFilter(this);
+	m_container->setFocusPolicy(Qt::StrongFocus);
+	return m_container;
 }
 
-int DisplayWidget::scaledWindowHeight() const
+std::optional<WindowInfo> DisplaySurface::getWindowInfo()
 {
-	return std::max(static_cast<int>(std::ceil(static_cast<qreal>(height()) * devicePixelRatioF())), 1);
-}
-
-std::optional<WindowInfo> DisplayWidget::getWindowInfo()
-{
-	std::optional<WindowInfo> ret(QtUtils::GetWindowInfoForWidget(this));
+	std::optional<WindowInfo> ret(QtUtils::GetWindowInfoForWindow(this));
 	if (ret.has_value())
 	{
 		m_last_window_width = ret->surface_width;
@@ -72,7 +62,7 @@ std::optional<WindowInfo> DisplayWidget::getWindowInfo()
 	return ret;
 }
 
-void DisplayWidget::updateRelativeMode(bool enabled)
+void DisplaySurface::updateRelativeMode(bool enabled)
 {
 #ifdef _WIN32
 	// prefer ClipCursor() over warping movement when we're using raw input
@@ -104,17 +94,17 @@ void DisplayWidget::updateRelativeMode(bool enabled)
 #endif
 		m_relative_mouse_start_pos = QCursor::pos();
 		updateCenterPos();
-		grabMouse();
+		setMouseGrabEnabled(true);
 	}
 	else if (m_relative_mouse_enabled)
 	{
 		m_relative_mouse_enabled = false;
 		QCursor::setPos(m_relative_mouse_start_pos);
-		releaseMouse();
+		setMouseGrabEnabled(false);
 	}
 }
 
-void DisplayWidget::updateCursor(bool hidden)
+void DisplaySurface::updateCursor(bool hidden)
 {
 	if (m_cursor_hidden == hidden)
 		return;
@@ -132,7 +122,7 @@ void DisplayWidget::updateCursor(bool hidden)
 	}
 }
 
-void DisplayWidget::handleCloseEvent(QCloseEvent* event)
+void DisplaySurface::handleCloseEvent(QCloseEvent* event)
 {
 	// Closing the separate widget will either cancel the close, or trigger shutdown.
 	// In the latter case, it's going to destroy us, so don't let Qt do it first.
@@ -152,28 +142,13 @@ void DisplayWidget::handleCloseEvent(QCloseEvent* event)
 	event->ignore();
 }
 
-void DisplayWidget::destroy()
+bool DisplaySurface::isActuallyFullscreen() const
 {
-	m_destroying = true;
-
-#ifdef __APPLE__
-	// See Qt documentation, entire application is in full screen state, and the main
-	// window will get reopened fullscreen instead of windowed if we don't close the
-	// fullscreen window first.
-	if (isActuallyFullscreen())
-		close();
-#endif
-	deleteLater();
+	// DisplaySurface is always in a container, so we need to check parent window
+	return parent()->windowState() & Qt::WindowFullScreen;
 }
 
-bool DisplayWidget::isActuallyFullscreen() const
-{
-	// I hate you QtWayland... have to check the parent, not ourselves.
-	QWidget* container = qobject_cast<QWidget*>(parent());
-	return container ? container->isFullScreen() : isFullScreen();
-}
-
-void DisplayWidget::updateCenterPos()
+void DisplaySurface::updateCenterPos()
 {
 #ifdef _WIN32
 	if (m_clip_mouse_enabled)
@@ -203,12 +178,14 @@ void DisplayWidget::updateCenterPos()
 #endif
 }
 
-QPaintEngine* DisplayWidget::paintEngine() const
-{
-	return nullptr;
-}
-
-bool DisplayWidget::event(QEvent* event)
+// Keyboard focus and child windows are inconsistant across platforms;
+// Windows: Can programmatically focus the child window, NVidia overlay can defocus it.
+// X11: Can programmatically focus the child window.
+// Wayland: Child window cannot be focused at all on most(?) DE.
+// Mac: Can programmatically focus the child window.
+// Thus for KB inputs we need to sometimes use the event filter.
+// Mouse events are always delivered to the child window, so that seems consistant.
+void DisplaySurface::handleKeyInputEvent(QEvent* event)
 {
 	switch (event->type())
 	{
@@ -229,7 +206,7 @@ bool DisplayWidget::event(QEvent* event)
 			}
 
 			if (key_event->isAutoRepeat())
-				return true;
+				return;
 
 			// For some reason, Windows sends "fake" key events.
 			// Scenario: Press shift, press F1, release shift, release F1.
@@ -246,7 +223,7 @@ bool DisplayWidget::event(QEvent* event)
 			if (it != m_keys_pressed_with_modifiers.end())
 			{
 				if (pressed)
-					return true;
+					return;
 				else
 					m_keys_pressed_with_modifiers.erase(it);
 			}
@@ -259,6 +236,23 @@ bool DisplayWidget::event(QEvent* event)
 				InputManager::InvokeEvents(InputManager::MakeHostKeyboardKey(key), static_cast<float>(pressed));
 			});
 
+			return;
+		}
+
+		default:
+			pxAssert(false);
+			return;
+	}
+}
+
+bool DisplaySurface::event(QEvent* event)
+{
+	switch (event->type())
+	{
+		case QEvent::KeyPress:
+		case QEvent::KeyRelease:
+		{
+			handleKeyInputEvent(event);
 			return true;
 		}
 
@@ -268,7 +262,7 @@ bool DisplayWidget::event(QEvent* event)
 
 			if (!m_relative_mouse_enabled)
 			{
-				const qreal dpr = devicePixelRatioF();
+				const qreal dpr = devicePixelRatio();
 				const QPoint mouse_pos = mouse_event->pos();
 
 				const float scaled_x = static_cast<float>(static_cast<qreal>(mouse_pos.x()) * dpr);
@@ -352,11 +346,11 @@ bool DisplayWidget::event(QEvent* event)
 		case QEvent::DevicePixelRatioChange:
 		case QEvent::Resize:
 		{
-			QWidget::event(event);
+			QWindow::event(event);
 
-			const float dpr = devicePixelRatioF();
-			const u32 scaled_width = static_cast<u32>(std::max(static_cast<int>(std::ceil(static_cast<qreal>(width()) * dpr)), 1));
-			const u32 scaled_height = static_cast<u32>(std::max(static_cast<int>(std::ceil(static_cast<qreal>(height()) * dpr)), 1));
+			const float dpr = devicePixelRatio();
+			const u32 scaled_width = static_cast<u32>(std::max(static_cast<int>(std::round(static_cast<qreal>(width()) * dpr)), 1));
+			const u32 scaled_height = static_cast<u32>(std::max(static_cast<int>(std::round(static_cast<qreal>(height()) * dpr)), 1));
 
 			// avoid spamming resize events for paint events (sent on move on windows)
 			if (m_last_window_width != scaled_width || m_last_window_height != scaled_height || m_last_window_scale != dpr)
@@ -371,106 +365,60 @@ bool DisplayWidget::event(QEvent* event)
 			return true;
 		}
 
+		case QEvent::DragEnter:
+			QWindow::event(event);
+			emit dragEnterEvent(static_cast<QDragEnterEvent*>(event));
+			return event->isAccepted();
+
+		case QEvent::Drop:
+			QWindow::event(event);
+			emit dropEvent(static_cast<QDropEvent*>(event));
+			return event->isAccepted();
+
 		case QEvent::Move:
 		{
 			updateCenterPos();
 			return true;
 		}
 
-		case QEvent::Close:
-		{
-			if (m_destroying)
-				return QWidget::event(event);
-
-			handleCloseEvent(static_cast<QCloseEvent*>(event));
-			return true;
-		}
-
-		case QEvent::WindowStateChange:
-		{
-			QWidget::event(event);
-
-			if (static_cast<QWindowStateChangeEvent*>(event)->oldState() & Qt::WindowMinimized)
-				emit windowRestoredEvent();
-
-			return true;
-		}
-
 		default:
-			return QWidget::event(event);
+			return QWindow::event(event);
 	}
 }
 
-DisplayContainer::DisplayContainer()
-	: QStackedWidget(nullptr)
+bool DisplaySurface::eventFilter(QObject* object, QEvent* event)
 {
-}
-
-DisplayContainer::~DisplayContainer() = default;
-
-bool DisplayContainer::isNeeded(bool fullscreen, bool render_to_main)
-{
-#if defined(_WIN32) || defined(__APPLE__)
-	return false;
-#else
-	if (!isRunningOnWayland())
-		return false;
-
-	// We only need this on Wayland because of client-side decorations...
-	return (fullscreen || !render_to_main);
-#endif
-}
-
-bool DisplayContainer::isRunningOnWayland()
-{
-#if defined(_WIN32) || defined(__APPLE__)
-	return false;
-#else
-	const QString platform_name = QGuiApplication::platformName();
-	return (platform_name == QStringLiteral("wayland"));
-#endif
-}
-
-void DisplayContainer::setDisplayWidget(DisplayWidget* widget)
-{
-	pxAssert(!m_display_widget);
-	m_display_widget = widget;
-	addWidget(widget);
-}
-
-DisplayWidget* DisplayContainer::removeDisplayWidget()
-{
-	DisplayWidget* widget = m_display_widget;
-	pxAssert(widget);
-	m_display_widget = nullptr;
-	removeWidget(widget);
-	return widget;
-}
-
-bool DisplayContainer::event(QEvent* event)
-{
-	if (event->type() == QEvent::Close && m_display_widget)
-	{
-		m_display_widget->handleCloseEvent(static_cast<QCloseEvent*>(event));
-		return true;
-	}
-
-	const bool res = QStackedWidget::event(event);
-	if (!m_display_widget)
-		return res;
-
 	switch (event->type())
 	{
+		case QEvent::KeyPress:
+		case QEvent::KeyRelease:
+#ifdef _WIN32
+			// Nvidia overlay causes the child window to lose focus, but not its parent.
+			// Refocus the child window.
+			requestActivate();
+#endif
+			handleKeyInputEvent(event);
+			return true;
+
+		// These events only work on the top level control.
+		// Which is this container when render to seperate or fullscreen is active.
+		case QEvent::Close:
+			handleCloseEvent(static_cast<QCloseEvent*>(event));
+			return true;
 		case QEvent::WindowStateChange:
-		{
 			if (static_cast<QWindowStateChangeEvent*>(event)->oldState() & Qt::WindowMinimized)
-				emit m_display_widget->windowRestoredEvent();
-		}
-		break;
+				emit windowRestoredEvent();
+			return false;
+
+		case QEvent::ChildRemoved:
+			if (static_cast<QChildEvent*>(event)->child() == m_container)
+			{
+				object->removeEventFilter(this);
+				m_container = nullptr;
+			}
+			return false;
 
 		default:
-			break;
+			return false;
 	}
-
-	return res;
 }

pcsx2-qt/DisplayWidget.h

@@ -3,40 +3,44 @@
 
 #pragma once
 #include "common/WindowInfo.h"
-#include <QtWidgets/QStackedWidget>
-#include <QtWidgets/QWidget>
+#include <QtGui/QDragMoveEvent>
+#include <QtGui/QWindow>
 #include <optional>
 #include <vector>
 
 class QCloseEvent;
 
-class DisplayWidget final : public QWidget
+class DisplaySurface final : public QWindow
 {
 	Q_OBJECT
 
 public:
-	explicit DisplayWidget(QWidget* parent);
-	~DisplayWidget();
+	explicit DisplaySurface();
+	~DisplaySurface();
 
-	QPaintEngine* paintEngine() const override;
-
-	int scaledWindowWidth() const;
-	int scaledWindowHeight() const;
+	// while QWindow can be used directly as a window, Popups requre a QWidget parent.
+	// Additionally, we use saveGeometry/restoreGeometry for render to seperate window mode
+	// but those functions only exist on QWidget.
+	// Thus, we always need a container widget.
+	QWidget* createWindowContainer(QWidget* parent = nullptr);
 
 	std::optional<WindowInfo> getWindowInfo();
 
 	void updateRelativeMode(bool enabled);
 	void updateCursor(bool hidden);
 
-	void handleCloseEvent(QCloseEvent* event);
-	void destroy();
-
 Q_SIGNALS:
 	void windowResizedEvent(int width, int height, float scale);
 	void windowRestoredEvent();
 
+	void dragEnterEvent(QDragEnterEvent* event);
+	void dropEvent(QDropEvent* event);
+
 protected:
+	void handleCloseEvent(QCloseEvent* event);
+	void handleKeyInputEvent(QEvent* event);
 	bool event(QEvent* event) override;
+	bool eventFilter(QObject* object, QEvent* event) override;
 
 private:
 	bool isActuallyFullscreen() const;
@@ -49,34 +53,12 @@ private:
 	bool m_clip_mouse_enabled = false;
 #endif
 	bool m_cursor_hidden = false;
-	bool m_destroying = false;
 
 	std::vector<int> m_keys_pressed_with_modifiers;
 
 	u32 m_last_window_width = 0;
 	u32 m_last_window_height = 0;
 	float m_last_window_scale = 1.0f;
-};
-
-class DisplayContainer final : public QStackedWidget
-{
-	Q_OBJECT
-
-public:
-	DisplayContainer();
-	~DisplayContainer();
-
-	// Wayland is broken in lots of ways, so we need to check for it.
-	static bool isRunningOnWayland();
-
-	static bool isNeeded(bool fullscreen, bool render_to_main);
-
-	void setDisplayWidget(DisplayWidget* widget);
-	DisplayWidget* removeDisplayWidget();
-
-protected:
-	bool event(QEvent* event) override;
-
-private:
-	DisplayWidget* m_display_widget = nullptr;
+
+	QWidget* m_container = nullptr;
 };

pcsx2-qt/GameList/GameListModel.cpp

@@ -31,60 +31,15 @@ static constexpr int SIZE_HINT_HEIGHT_TITLES = SIZE_HINT_HEIGHT + COVER_ART_SPAC
 
 static constexpr int MIN_COVER_CACHE_SIZE = 256;
 
-static int DPRScale(const int size, const qreal dpr)
-{
-	return static_cast<int>(static_cast<qreal>(size) * dpr);
-}
-
-static int DPRUnscale(const int size, const qreal dpr)
-{
-	return static_cast<int>(static_cast<qreal>(size) / dpr);
-}
-
-static void resizeAndPadPixmap(QPixmap* pm, const int expected_width, const int expected_height, const qreal dpr)
-{
-	const int dpr_expected_width = DPRScale(expected_width, dpr);
-	const int dpr_expected_height = DPRScale(expected_height, dpr);
-	if (pm->width() == dpr_expected_width && pm->height() == dpr_expected_height)
-		return;
-
-	*pm = pm->scaled(dpr_expected_width, dpr_expected_height, Qt::KeepAspectRatio, Qt::SmoothTransformation);
-	if (pm->width() == dpr_expected_width && pm->height() == dpr_expected_height)
-		return;
-
-	// QPainter works in unscaled coordinates.
-	int xoffs = 0;
-	int yoffs = 0;
-	if (pm->width() < dpr_expected_width)
-		xoffs = DPRUnscale((dpr_expected_width - pm->width()) / 2, dpr);
-	if (pm->height() < dpr_expected_height)
-		yoffs = DPRUnscale((dpr_expected_height - pm->height()) / 2, dpr);
-
-	QPixmap padded_image(dpr_expected_width, dpr_expected_height);
-	padded_image.setDevicePixelRatio(dpr);
-	padded_image.fill(Qt::transparent);
-	QPainter painter;
-	if (painter.begin(&padded_image))
-	{
-		painter.setCompositionMode(QPainter::CompositionMode_Source);
-		painter.drawPixmap(xoffs, yoffs, *pm);
-		painter.setCompositionMode(QPainter::CompositionMode_Destination);
-		painter.fillRect(padded_image.rect(), QColor(0, 0, 0, 0));
-		painter.end();
-	}
-
-	*pm = padded_image;
-}
-
-static QPixmap createPlaceholderImage(const QPixmap& placeholder_pixmap, const int width, const int height,
-	const float scale, const qreal dpr, const std::string& title)
+static QPixmap createPlaceholderImage(const QPixmap& placeholder_pixmap, int width, int height, float scale,
+	qreal dpr, const std::string& title)
 {
 	QPixmap pm(placeholder_pixmap.copy());
 	pm.setDevicePixelRatio(dpr);
 	if (pm.isNull())
 		return QPixmap();
 
-	resizeAndPadPixmap(&pm, width, height, dpr);
+	QtUtils::resizeAndScalePixmap(&pm, width, height, dpr, QtUtils::ScalingMode::Fit, 100);
 	QPainter painter;
 	if (painter.begin(&pm))
 	{
@@ -199,7 +154,7 @@ void GameListModel::loadOrGenerateCover(const GameList::Entry* ge)
 			else
 			{
 				image.setDevicePixelRatio(m_dpr);
-				resizeAndPadPixmap(&image, getCoverArtWidth(), getCoverArtHeight(), m_dpr);
+				QtUtils::resizeAndScalePixmap(&image, getCoverArtWidth(), getCoverArtHeight(), m_dpr, QtUtils::ScalingMode::Fit, 100);
 			}
 		}
 

pcsx2-qt/GameList/GameListWidget.cpp

@@ -7,6 +7,7 @@
 #include "QtHost.h"
 #include "QtUtils.h"
 
+#include "Settings/InterfaceSettingsWidget.h"
 #include "pcsx2/GameList.h"
 #include "pcsx2/Host.h"
 
@@ -44,6 +45,25 @@ static const char* SUPPORTED_FORMATS_STRING = QT_TRANSLATE_NOOP(GameListWidget,
 static constexpr float MIN_SCALE = 0.1f;
 static constexpr float MAX_SCALE = 2.0f;
 
+static constexpr GameListModel::Column DEFAULT_SORT_COLUMN = GameListModel::Column_Title;
+static constexpr int DEFAULT_SORT_INDEX = static_cast<int>(DEFAULT_SORT_COLUMN);
+static constexpr Qt::SortOrder DEFAULT_SORT_ORDER = Qt::AscendingOrder;
+
+static constexpr std::array<int, GameListModel::Column_Count> DEFAULT_COLUMN_WIDTHS = {{
+	55, // type
+	85, // code
+	-1, // title
+	-1, // file title
+	75, // crc
+	95, // time played
+	90, // last played
+	80, // size
+	60, // region
+	120 // compatibility
+}};
+static_assert(static_cast<int>(DEFAULT_COLUMN_WIDTHS.size()) <= GameListModel::Column_Count,
+	"Game List: More default column widths than column types.");
+
 class GameListSortModel final : public QSortFilterProxyModel
 {
 public:
@@ -55,18 +75,21 @@ public:
 
 	void setFilterType(GameList::EntryType type)
 	{
+		beginFilterChange();
 		m_filter_type = type;
-		invalidateRowsFilter();
+		endFilterChange(Direction::Rows);
 	}
 	void setFilterRegion(GameList::Region region)
 	{
+		beginFilterChange();
 		m_filter_region = region;
-		invalidateRowsFilter();
+		endFilterChange(Direction::Rows);
 	}
 	void setFilterName(const QString& name)
 	{
+		beginFilterChange();
 		m_filter_name = name;
-		invalidateRowsFilter();
+		endFilterChange(Direction::Rows);
 	}
 
 	bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override
@@ -234,6 +257,7 @@ void GameListWidget::initialize()
 	m_table_view = new QTableView(m_ui.stack);
 	m_table_view->setModel(m_sort_model);
 	m_table_view->setSortingEnabled(true);
+	m_table_view->horizontalHeader()->setSectionsMovable(true);
 	m_table_view->setSelectionMode(QAbstractItemView::SingleSelection);
 	m_table_view->setSelectionBehavior(QAbstractItemView::SelectRows);
 	m_table_view->setContextMenuPolicy(Qt::CustomContextMenu);
@@ -251,18 +275,28 @@ void GameListWidget::initialize()
 	m_table_view->setItemDelegateForColumn(8, new GameListIconStyleDelegate(this));
 	m_table_view->setItemDelegateForColumn(9, new GameListIconStyleDelegate(this));
 
-	loadTableViewColumnVisibilitySettings();
-	loadTableViewColumnSortSettings();
-
 	connect(m_table_view->selectionModel(), &QItemSelectionModel::currentChanged, this,
 		&GameListWidget::onSelectionModelCurrentChanged);
 	connect(m_table_view, &QTableView::activated, this, &GameListWidget::onTableViewItemActivated);
 	connect(m_table_view, &QTableView::customContextMenuRequested, this,
 		&GameListWidget::onTableViewContextMenuRequested);
 	connect(m_table_view->horizontalHeader(), &QHeaderView::customContextMenuRequested, this,
-		&GameListWidget::onTableViewHeaderContextMenuRequested);
+			&GameListWidget::onTableViewHeaderContextMenuRequested);
+
+	// Save state when header state changes (hiding and showing handled within onTableViewHeaderContextMenuRequested).
+	connect(m_table_view->horizontalHeader(), &QHeaderView::sectionMoved, this, &GameListWidget::onTableHeaderStateChanged);
+	connect(m_table_view->horizontalHeader(), &QHeaderView::sectionResized, this, &GameListWidget::onTableHeaderStateChanged);
 	connect(m_table_view->horizontalHeader(), &QHeaderView::sortIndicatorChanged, this,
-		&GameListWidget::saveTableViewColumnSortSettings);
+		[this](const int column, const Qt::SortOrder sort_order) { GameListWidget::saveSortSettings(column, sort_order); GameListWidget::onTableHeaderStateChanged(); });
+
+	// Load the last session's header state or create a new one.
+	if (Host::ContainsBaseSettingValue("GameListTableView", "HeaderState"))
+		loadTableHeaderState();
+	else
+		applyTableHeaderDefaults();
+
+	// After header state load to account for user-specified sort.
+	m_table_view->setSortingEnabled(true);
 
 	m_ui.stack->insertWidget(0, m_table_view);
 
@@ -310,84 +344,30 @@ void GameListWidget::initialize()
 	setCustomBackground();
 }
 
-static void resizeAndPadImage(QImage* image, int expected_width, int expected_height, bool fill_with_top_left, bool expand_to_fill)
+void GameListWidget::setCustomBackground()
 {
-	const qreal dpr = image->devicePixelRatio();
-	const int dpr_expected_width = static_cast<int>(static_cast<qreal>(expected_width) * dpr);
-	const int dpr_expected_height = static_cast<int>(static_cast<qreal>(expected_height) * dpr);
-	if (image->width() == dpr_expected_width && image->height() == dpr_expected_height)
-		return;
-
-	// Resize
-	if (((static_cast<float>(image->width()) / static_cast<float>(image->height())) >=
-		(static_cast<float>(dpr_expected_width) / static_cast<float>(dpr_expected_height))) != expand_to_fill)
-	{
-		*image = image->scaledToWidth(dpr_expected_width, Qt::SmoothTransformation);
-	}
-	else
-	{
-		*image = image->scaledToHeight(dpr_expected_height, Qt::SmoothTransformation);
-	}
-
-	if (image->width() == dpr_expected_width && image->height() == dpr_expected_height)
-		return;
-
-	// Padding
-	int xoffs = 0;
-	int yoffs = 0;
-	const int image_width = image->width();
-	const int image_height = image->height();
-	if ((image_width < dpr_expected_width) != expand_to_fill)
-		xoffs = static_cast<int>(static_cast<qreal>((dpr_expected_width - image_width) / 2) / dpr);
-	if ((image_height < dpr_expected_height) != expand_to_fill)
-		yoffs = static_cast<int>(static_cast<qreal>((dpr_expected_height - image_height) / 2) / dpr);
-
-	QImage padded_image(dpr_expected_width, dpr_expected_height, QImage::Format_ARGB32);
-	padded_image.setDevicePixelRatio(dpr);
-	if (fill_with_top_left)
-		padded_image.fill(image->pixel(0, 0));
-	else
-		padded_image.fill(Qt::transparent);
-
-	// Painting
-	QPainter painter;
-	const float opacity = Host::GetBaseFloatSettingValue("UI", "GameListBackgroundOpacity");
-	if (painter.begin(&padded_image))
-	{
-		painter.setOpacity((static_cast<float>(opacity / 100.0f))); // Qt expects the range to be from 0.0 to 1.0
-		painter.setCompositionMode(QPainter::CompositionMode_Source);
-		painter.drawImage(xoffs, yoffs, *image);
-		painter.end();
-	}
-
-	*image = std::move(padded_image);
-}
-
-void GameListWidget::setCustomBackground(bool force_refresh)
-{
-	std::string path = Host::GetBaseStringSettingValue("UI", "GameListBackgroundPath");
-	bool enabled = Host::GetBaseBoolSettingValue("UI", "GameListBackgroundEnabled");
-	bool fill = Host::GetBaseBoolSettingValue("UI", "GameListBackgroundFill");
-
 	// Cleanup old animation if it still exists on gamelist
 	if (m_background_movie != nullptr)
 	{
+		m_background_movie->disconnect(this);
 		delete m_background_movie;
 		m_background_movie = nullptr;
 	}
 
+	std::string path = Host::GetBaseStringSettingValue("UI", "GameListBackgroundPath");
 	if (!Path::IsAbsolute(path))
 		path = Path::Combine(EmuFolders::DataRoot, path);
 
-	// Only try to create background both if path are valid and custom background are enabled
-	if ((!path.empty() && FileSystem::FileExists(path.c_str())) && enabled)
+	// Only try to create background if path are valid
+	if (!path.empty() && FileSystem::FileExists(path.c_str()))
 	{
 		QMovie* new_movie;
-		if (Path::GetExtension(path) == "png")
+		QString img_path = QString::fromStdString(path);
+		if (img_path.endsWith(".png", Qt::CaseInsensitive))
 			// Use apng plugin
-			new_movie = new QMovie(QString::fromStdString(path), "apng", this);
+			new_movie = new QMovie(img_path, "apng", this);
 		else
-			new_movie = new QMovie(QString::fromStdString(path), QByteArray(), this);
+			new_movie = new QMovie(img_path, QByteArray(), this);
 
 		if (new_movie->isValid())
 			m_background_movie = new_movie;
@@ -398,7 +378,7 @@ void GameListWidget::setCustomBackground(bool force_refresh)
 		}
 	}
 
-	// If there is no valid background then reset fallback to UI state
+	// If there is no valid background then reset fallback to default UI state
 	if (!m_background_movie)
 	{
 		m_ui.stack->setPalette(QApplication::palette());
@@ -406,36 +386,60 @@ void GameListWidget::setCustomBackground(bool force_refresh)
 		return;
 	}
 
-	// Background is valid, connect the signals and start animation in gamelist
-	connect(m_background_movie, &QMovie::frameChanged, this, [this, fill]() { processBackgroundFrames(fill); });
-	updateCustomBackgroundState(force_refresh);
+	// Retrieve scaling setting
+	m_background_scaling = QtUtils::ScalingMode::Fit;
+	const std::string ar_value = Host::GetBaseStringSettingValue("UI", "GameListBackgroundMode", InterfaceSettingsWidget::BACKGROUND_SCALE_NAMES[static_cast<u8>(QtUtils::ScalingMode::Fit)]);
+	for (u8 i = 0; i < static_cast<u8>(QtUtils::ScalingMode::MaxCount); i++)
+	{
+		if (!(InterfaceSettingsWidget::BACKGROUND_SCALE_NAMES[i] == nullptr))
+		{
+			if (ar_value == InterfaceSettingsWidget::BACKGROUND_SCALE_NAMES[i])
+			{
+				m_background_scaling = static_cast<QtUtils::ScalingMode>(i);
+				break;
+			}
+		}
+	}
 
+	// Retrieve opacity setting
+	m_background_opacity = Host::GetBaseFloatSettingValue("UI", "GameListBackgroundOpacity", 100.0f);
+
+	// Selected Custom background is valid, connect the signals and start animation in gamelist
+	connect(m_background_movie, &QMovie::frameChanged, this, &GameListWidget::processBackgroundFrames, Qt::UniqueConnection);
+	updateCustomBackgroundState(true);
 	m_table_view->setAlternatingRowColors(false);
 }
 
-void GameListWidget::updateCustomBackgroundState(bool force_start)
+void GameListWidget::updateCustomBackgroundState(const bool force_start)
 {
-	if (m_background_movie)
+	if (m_background_movie && m_background_movie->isValid())
 	{
 		if ((isVisible() && (isActiveWindow() || force_start)) && qGuiApp->applicationState() == Qt::ApplicationActive)
-			m_background_movie->start();
+			m_background_movie->setPaused(false);
 		else
-			m_background_movie->stop();
+			m_background_movie->setPaused(true);
 	}
 }
 
-void GameListWidget::processBackgroundFrames(bool fill_area)
+void GameListWidget::processBackgroundFrames()
 {
-	QImage img = m_background_movie->currentImage();
-	img.setDevicePixelRatio(devicePixelRatioF());
-	const int widget_width = m_ui.stack->width();
-	const int widget_height = m_ui.stack->height();
+	if (m_background_movie && m_background_movie->isValid())
+	{
+		const int widget_width = m_ui.stack->width();
+		const int widget_height = m_ui.stack->height();
 
-	resizeAndPadImage(&img, widget_width, widget_height, false, fill_area);
+		if (widget_width <= 0 || widget_height <= 0)
+			return;
 
-	QPalette new_palette(m_ui.stack->palette());
-	new_palette.setBrush(QPalette::Base, img);
-	m_ui.stack->setPalette(new_palette);
+		QPixmap pm = m_background_movie->currentPixmap();
+		const qreal dpr = devicePixelRatioF();
+
+		QtUtils::resizeAndScalePixmap(&pm, widget_width, widget_height, dpr, m_background_scaling, m_background_opacity);
+
+		QPalette bg_palette(m_ui.stack->palette());
+		bg_palette.setBrush(QPalette::Base, pm);
+		m_ui.stack->setPalette(bg_palette);
+	}
 }
 
 bool GameListWidget::isShowingGameList() const
@@ -554,18 +558,24 @@ void GameListWidget::onListViewContextMenuRequested(const QPoint& point)
 void GameListWidget::onTableViewHeaderContextMenuRequested(const QPoint& point)
 {
 	QMenu menu;
+	QHeaderView* header = m_table_view->horizontalHeader();
+	if (!header)
+		return;
 
+	int column_visual = 0;
 	for (int column = 0; column < GameListModel::Column_Count; column++)
 	{
+		// The "cover" column is the game grid and cannot be hidden.
 		if (column == GameListModel::Column_Cover)
 			continue;
 
-		QAction* action = menu.addAction(m_model->getColumnDisplayName(column));
+		column_visual = header->visualIndex(column);
+		QAction* action = menu.addAction(m_model->getColumnDisplayName(column_visual));
 		action->setCheckable(true);
-		action->setChecked(!m_table_view->isColumnHidden(column));
-		connect(action, &QAction::toggled, [this, column](bool enabled) {
-			m_table_view->setColumnHidden(column, !enabled);
-			saveTableViewColumnVisibilitySettings(column);
+		action->setChecked(!m_table_view->isColumnHidden(column_visual));
+		connect(action, &QAction::toggled, [this, column_visual](bool enabled) {
+			m_table_view->setColumnHidden(column_visual, !enabled);
+			onTableHeaderStateChanged();
 			resizeTableViewColumnsToFit();
 		});
 	}
@@ -708,7 +718,7 @@ void GameListWidget::resizeEvent(QResizeEvent* event)
 	QWidget::resizeEvent(event);
 	resizeTableViewColumnsToFit();
 	m_model->updateCacheSize(width(), height());
-	setCustomBackground();
+	processBackgroundFrames();
 }
 
 bool GameListWidget::event(QEvent* event)
@@ -726,123 +736,141 @@ bool GameListWidget::event(QEvent* event)
 void GameListWidget::resizeTableViewColumnsToFit()
 {
 	QtUtils::ResizeColumnsForTableView(m_table_view, {
-														 55, // type
-														 85, // code
-														 -1, // title
-														 -1, // file title
-														 75, // crc
-														 95, // time played
-														 90, // last played
-														 80, // size
-														 60, // region
-														 120, // compatibility
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Type],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Serial],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_FileTitle],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Type],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_CRC],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_TimePlayed],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_LastPlayed],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Size],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Region],
+														 DEFAULT_COLUMN_WIDTHS[GameListModel::Column_Compatibility],
 													 });
 }
 
-static std::string getColumnVisibilitySettingsKeyName(int column)
+void GameListWidget::loadTableHeaderState()
 {
-	return StringUtil::StdStringFromFormat("Show%s",
+	QHeaderView* header = m_table_view->horizontalHeader();
+	if (!header)
+		return;
+
+	// Decode Base64 string from settings to QByteArray state.
+	const std::string state_setting = Host::GetBaseStringSettingValue("GameListTableView", "HeaderState");
+	if (state_setting.empty())
+		return;
+
+	QSignalBlocker blocker(header);
+	header->restoreState(QByteArray::fromBase64(QByteArray::fromStdString(state_setting)));
+}
+
+void GameListWidget::onTableHeaderStateChanged()
+{
+	QHeaderView* header = m_table_view->horizontalHeader();
+	if (!header)
+		return;
+
+	// Encode QByteArray state as Base64 string for storage.
+	Host::SetBaseStringSettingValue("GameListTableView", "HeaderState", header->saveState().toBase64());
+}
+
+void GameListWidget::applyTableHeaderDefaults()
+{
+	QHeaderView* header = m_table_view->horizontalHeader();
+	if (!header)
+		return;
+
+	{
+		QSignalBlocker blocker(header);
+		header->hideSection(GameListModel::Column_FileTitle);
+		header->hideSection(GameListModel::Column_CRC);
+		header->hideSection(GameListModel::Column_Cover);
+		for (int column = 0; column < GameListModel::Column_Count; column++)
+		{
+			if (column == GameListModel::Column_Cover)
+				continue;
+
+			header->resizeSection(column, DEFAULT_COLUMN_WIDTHS[column]);
+		}
+		header->setSortIndicator(DEFAULT_SORT_INDEX, DEFAULT_SORT_ORDER);
+	}
+
+	Host::SetBaseStringSettingValue("GameListTableView", "HeaderState", header->saveState().toBase64());
+}
+
+// TODO (Tech): Create a button for this in the minibar. Currently unused.
+void GameListWidget::resetTableHeaderToDefault()
+{
+	QHeaderView* header = m_table_view->horizontalHeader();
+	if (!header)
+		return;
+
+	{
+		QSignalBlocker blocker(header);
+		for (int column = 0; column < GameListModel::Column_Count; column++)
+		{
+			if (column == GameListModel::Column_Cover)
+				continue;
+
+			// Reset size, position, and visibility.
+			header->resizeSection(column, DEFAULT_COLUMN_WIDTHS[column]);
+			header->moveSection(header->visualIndex(column), column);
+			header->setSectionHidden(column,
+				column == GameListModel::Column_CRC || column == GameListModel::Column_FileTitle);
+		}
+		header->hideSection(GameListModel::Column_Cover);
+		header->setSortIndicator(DEFAULT_SORT_INDEX, DEFAULT_SORT_ORDER);
+	}
+
+	Host::SetBaseStringSettingValue("GameListTableView", "HeaderState", header->saveState().toBase64());
+}
+
+void GameListWidget::saveSortSettings(const int column, const Qt::SortOrder sort_order)
+{
+	Host::SetBaseStringSettingValue("GameListTableView", "SortColumn",
 		GameListModel::getColumnName(static_cast<GameListModel::Column>(column)));
+	Host::SetBaseBoolSettingValue("GameListTableView", "SortDescending", static_cast<bool>(sort_order));
 }
 
-void GameListWidget::loadTableViewColumnVisibilitySettings()
+std::optional<GameList::Entry> GameListWidget::getSelectedEntry() const
 {
-	static constexpr std::array<bool, GameListModel::Column_Count> DEFAULT_VISIBILITY = {{
-		true, // type
-		true, // code
-		true, // title
-		false, // file title
-		false, // crc
-		true, // time played
-		true, // last played
-		true, // size
-		true, // region
-		true // compatibility
-	}};
+	auto lock = GameList::GetLock();
 
-	for (int column = 0; column < GameListModel::Column_Count; column++)
-	{
-		const bool visible = Host::GetBaseBoolSettingValue(
-			"GameListTableView", getColumnVisibilitySettingsKeyName(column).c_str(), DEFAULT_VISIBILITY[column]);
-		m_table_view->setColumnHidden(column, !visible);
-	}
-}
-
-void GameListWidget::saveTableViewColumnVisibilitySettings()
-{
-	for (int column = 0; column < GameListModel::Column_Count; column++)
-	{
-		const bool visible = !m_table_view->isColumnHidden(column);
-		Host::SetBaseBoolSettingValue("GameListTableView", getColumnVisibilitySettingsKeyName(column).c_str(), visible);
-		Host::CommitBaseSettingChanges();
-	}
-}
-
-void GameListWidget::saveTableViewColumnVisibilitySettings(int column)
-{
-	const bool visible = !m_table_view->isColumnHidden(column);
-	Host::SetBaseBoolSettingValue("GameListTableView", getColumnVisibilitySettingsKeyName(column).c_str(), visible);
-	Host::CommitBaseSettingChanges();
-}
-
-void GameListWidget::loadTableViewColumnSortSettings()
-{
-	const GameListModel::Column DEFAULT_SORT_COLUMN = GameListModel::Column_Type;
-	const bool DEFAULT_SORT_DESCENDING = false;
-
-	const GameListModel::Column sort_column =
-		GameListModel::getColumnIdForName(Host::GetBaseStringSettingValue("GameListTableView", "SortColumn"))
-			.value_or(DEFAULT_SORT_COLUMN);
-	const bool sort_descending =
-		Host::GetBaseBoolSettingValue("GameListTableView", "SortDescending", DEFAULT_SORT_DESCENDING);
-	const Qt::SortOrder sort_order = sort_descending ? Qt::DescendingOrder : Qt::AscendingOrder;
-	m_sort_model->sort(sort_column, sort_order);
-	if (QHeaderView* hv = m_table_view->horizontalHeader())
-		hv->setSortIndicator(sort_column, sort_order);
-}
-
-void GameListWidget::saveTableViewColumnSortSettings(const int sort_column, const Qt::SortOrder sort_order)
-{
-	if (sort_column >= 0 && sort_column < GameListModel::Column_Count)
-	{
-		Host::SetBaseStringSettingValue(
-			"GameListTableView", "SortColumn", GameListModel::getColumnName(static_cast<GameListModel::Column>(sort_column)));
-	}
-
-	Host::SetBaseBoolSettingValue("GameListTableView", "SortDescending", sort_order == Qt::DescendingOrder);
-	Host::CommitBaseSettingChanges();
-}
-
-const GameList::Entry* GameListWidget::getSelectedEntry() const
-{
+	const GameList::Entry* entry;
 	if (m_ui.stack->currentIndex() == 0)
 	{
 		const QItemSelectionModel* selection_model = m_table_view->selectionModel();
 		if (!selection_model->hasSelection())
-			return nullptr;
+			return std::nullopt;
 
 		const QModelIndexList selected_rows = selection_model->selectedRows();
 		if (selected_rows.empty())
-			return nullptr;
+			return std::nullopt;
 
 		const QModelIndex source_index = m_sort_model->mapToSource(selected_rows[0]);
 		if (!source_index.isValid())
-			return nullptr;
+			return std::nullopt;
 
-		return GameList::GetEntryByIndex(source_index.row());
+		entry = GameList::GetEntryByIndex(source_index.row());
 	}
 	else
 	{
 		const QItemSelectionModel* selection_model = m_list_view->selectionModel();
 		if (!selection_model->hasSelection())
-			return nullptr;
+			return std::nullopt;
 
 		const QModelIndex source_index = m_sort_model->mapToSource(selection_model->currentIndex());
 		if (!source_index.isValid())
-			return nullptr;
+			return std::nullopt;
 
-		return GameList::GetEntryByIndex(source_index.row());
+		entry = GameList::GetEntryByIndex(source_index.row());
 	}
+
+	if (!entry)
+		return std::nullopt;
+
+	// Copy the entry here instead of keeping the lock held to avoid deadlocks.
+	return *entry;
 }
 
 void GameListWidget::rescanFile(const std::string& path)

pcsx2-qt/GameList/GameListWidget.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "QtUtils.h"
 #include "ui_EmptyGameListWidget.h"
 #include "ui_GameListWidget.h"
 
@@ -49,15 +50,15 @@ public:
 	void refresh(bool invalidate_cache, bool popup_on_error);
 	void cancelRefresh();
 	void reloadThemeSpecificImages();
-	void setCustomBackground(bool force = false);
-	void updateCustomBackgroundState(bool force_start = false);
-	void processBackgroundFrames(bool fill_area);
+	void setCustomBackground();
+	void updateCustomBackgroundState(const bool force_start = false);
+	void processBackgroundFrames();
 
 	bool isShowingGameList() const;
 	bool isShowingGameGrid() const;
 	bool getShowGridCoverTitles() const;
 
-	const GameList::Entry* getSelectedEntry() const;
+	std::optional<GameList::Entry> getSelectedEntry() const;
 
 	/// Rescans a single file. NOTE: Happens on UI thread.
 	void rescanFile(const std::string& path);
@@ -84,6 +85,7 @@ private Q_SLOTS:
 	void onListViewItemActivated(const QModelIndex& index);
 	void onListViewContextMenuRequested(const QPoint& point);
 	void onCoverScaleChanged();
+	void onTableHeaderStateChanged();
 
 public Q_SLOTS:
 	void showGameList();
@@ -101,11 +103,10 @@ protected:
 	bool event(QEvent* event) override;
 
 private:
-	void loadTableViewColumnVisibilitySettings();
-	void saveTableViewColumnVisibilitySettings();
-	void saveTableViewColumnVisibilitySettings(int column);
-	void loadTableViewColumnSortSettings();
-	void saveTableViewColumnSortSettings(const int sort_column, const Qt::SortOrder sort_order);
+	void loadTableHeaderState();
+	void applyTableHeaderDefaults();
+	void resetTableHeaderToDefault();
+	void saveSortSettings(int column, Qt::SortOrder sort_order);
 	void listZoom(float delta);
 	void updateToolbar();
 
@@ -122,4 +123,6 @@ private:
 	GameListRefreshThread* m_refresh_thread = nullptr;
 
 	QMovie* m_background_movie = nullptr;
+	QtUtils::ScalingMode m_background_scaling = QtUtils::ScalingMode::Fit;
+	float m_background_opacity = 100.0f;
 };

pcsx2-qt/MainWindow.cpp

@@ -86,16 +86,6 @@ const char* MainWindow::DISC_IMAGE_FILTER = QT_TRANSLATE_NOOP("MainWindow", "All
 
 MainWindow* g_main_window = nullptr;
 
-#if defined(_WIN32) || defined(__APPLE__)
-static const bool s_use_central_widget = false;
-#else
-// Qt Wayland is broken. Any sort of stacked widget usage fails to update,
-// leading to broken window resizes, no display rendering, etc. So, we mess
-// with the central widget instead. Which we can't do on xorg, because it
-// breaks window resizing there...
-static bool s_use_central_widget = false;
-#endif
-
 // UI thread VM validity.
 static bool s_vm_valid = false;
 static bool s_vm_paused = false;
@@ -113,19 +103,6 @@ MainWindow::MainWindow()
 {
 	pxAssert(!g_main_window);
 	g_main_window = this;
-
-	//  Native window rendering is broken in wayland.
-	//  Let's work around it by disabling it for every widget besides
-	//  DisplayWidget.
-	//  Additionally, alien widget rendering is much more performant, so we
-	//  should have a nice responsiveness boost in our UI :)
-	//  QTBUG-133919, reported upstream by govanify
-	QGuiApplication::setAttribute(Qt::AA_NativeWindows, false);
-	QGuiApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);
-
-#if !defined(_WIN32) && !defined(__APPLE__)
-	s_use_central_widget = DisplayContainer::isRunningOnWayland();
-#endif
 }
 
 MainWindow::~MainWindow()
@@ -192,7 +169,7 @@ static void makeIconsMasks(QWidget* menu)
 
 QWidget* MainWindow::getContentParent()
 {
-	return s_use_central_widget ? static_cast<QWidget*>(this) : static_cast<QWidget*>(m_ui.mainContainer);
+	return static_cast<QWidget*>(m_ui.mainContainer);
 }
 
 void MainWindow::setupAdditionalUi()
@@ -219,15 +196,7 @@ void MainWindow::setupAdditionalUi()
 	m_game_list_widget = new GameListWidget(getContentParent());
 	m_game_list_widget->initialize();
 	m_ui.actionGridViewShowTitles->setChecked(m_game_list_widget->getShowGridCoverTitles());
-	if (s_use_central_widget)
-	{
-		m_ui.mainContainer = nullptr; // setCentralWidget() will delete this
-		setCentralWidget(m_game_list_widget);
-	}
-	else
-	{
-		m_ui.mainContainer->addWidget(m_game_list_widget);
-	}
+	m_ui.mainContainer->addWidget(m_game_list_widget);
 
 	m_status_progress_widget = new QProgressBar(m_ui.statusBar);
 	m_status_progress_widget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
@@ -532,7 +501,7 @@ void MainWindow::recreate()
 	if (was_display_created)
 	{
 		g_emu_thread->setSurfaceless(true);
-		while (m_display_widget || !g_emu_thread->isSurfaceless())
+		while (m_display_surface || !g_emu_thread->isSurfaceless())
 			QApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 1);
 
 		m_display_created = false;
@@ -1033,11 +1002,10 @@ void MainWindow::updateWindowTitle()
 	if (windowTitle() != main_title)
 		setWindowTitle(main_title);
 
-	if (m_display_widget && !isRenderingToMain())
+	if (m_display_container && !isRenderingToMain())
 	{
-		QWidget* container = m_display_container ? static_cast<QWidget*>(m_display_container) : static_cast<QWidget*>(m_display_widget);
-		if (container->windowTitle() != display_title)
-			container->setWindowTitle(display_title);
+		if (m_display_container->windowTitle() != display_title)
+			m_display_container->setWindowTitle(display_title);
 	}
 
 	if (g_log_window)
@@ -1052,7 +1020,7 @@ void MainWindow::updateWindowState(bool force_visible)
 
 	const bool hide_window = !isRenderingToMain() && shouldHideMainWindow();
 	const bool disable_resize = Host::GetBoolSettingValue("UI", "DisableWindowResize", false);
-	const bool has_window = s_vm_valid || m_display_widget;
+	const bool has_window = s_vm_valid || m_display_surface;
 
 	// Need to test both valid and display widget because of startup (vm invalid while window is created).
 	const bool visible = force_visible || !hide_window || !has_window;
@@ -1065,8 +1033,8 @@ void MainWindow::updateWindowState(bool force_visible)
 		QtUtils::SetWindowResizeable(this, resizeable);
 
 	// Update the display widget too if rendering separately.
-	if (m_display_widget && !isRenderingToMain())
-		QtUtils::SetWindowResizeable(getDisplayContainer(), resizeable);
+	if (m_display_surface && !isRenderingToMain())
+		QtUtils::SetWindowResizeable(m_display_container, resizeable);
 }
 
 void MainWindow::setProgressBar(int current, int total)
@@ -1093,26 +1061,20 @@ void MainWindow::clearProgressBar()
 
 bool MainWindow::isShowingGameList() const
 {
-	if (s_use_central_widget)
-		return (centralWidget() == m_game_list_widget);
-	else
-		return (m_ui.mainContainer->currentIndex() == 0);
+	return (m_ui.mainContainer->currentIndex() == 0);
 }
 
 bool MainWindow::isRenderingFullscreen() const
 {
-	if (!MTGS::IsOpen() || !m_display_widget)
+	if (!MTGS::IsOpen() || !m_display_surface)
 		return false;
 
-	return getDisplayContainer()->isFullScreen();
+	return m_display_container->isFullScreen();
 }
 
 bool MainWindow::isRenderingToMain() const
 {
-	if (s_use_central_widget)
-		return (m_display_widget && centralWidget() == m_display_widget);
-	else
-		return (m_display_widget && m_ui.mainContainer->indexOf(m_display_widget) == 1);
+	return (m_display_surface && m_ui.mainContainer->indexOf(m_display_container) == 1);
 }
 
 bool MainWindow::shouldHideMouseCursor() const
@@ -1137,14 +1099,14 @@ bool MainWindow::shouldMouseLock() const
 	if (!Host::GetBoolSettingValue("EmuCore", "EnableMouseLock", false))
 		return false;
 
-	if (m_display_created == false || m_display_widget == nullptr && !isRenderingToMain())
+	if (m_display_created == false || m_display_surface == nullptr)
 		return false;
 
 	bool windowsHidden = (!g_debugger_window || g_debugger_window->isHidden()) &&
 	                     (!m_controller_settings_window || m_controller_settings_window->isHidden()) &&
 	                     (!m_settings_window || m_settings_window->isHidden());
 
-	auto* displayWindow = isRenderingToMain() ? window() : m_display_widget->window();
+	auto* displayWindow = isRenderingToMain() ? window() : m_display_container->window();
 
 	if (displayWindow == nullptr)
 		return false;
@@ -1194,7 +1156,7 @@ void MainWindow::switchToGameListView()
 
 		// switch to surfaceless. we have to wait until the display widget is gone before we swap over.
 		g_emu_thread->setSurfaceless(true);
-		while (m_display_widget)
+		while (m_display_surface)
 			QApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 1);
 	}
 }
@@ -1211,8 +1173,8 @@ void MainWindow::switchToEmulationView()
 	if (s_vm_paused && !m_was_paused_on_surface_loss)
 		g_emu_thread->setVMPaused(false);
 
-	if (m_display_widget)
-		m_display_widget->setFocus();
+	if (m_display_surface)
+		m_display_container->setFocus();
 }
 
 void MainWindow::refreshGameList(bool invalidate_cache, bool popup_on_error)
@@ -1349,7 +1311,7 @@ void MainWindow::requestExit(bool allow_confirm)
 
 void MainWindow::checkForSettingChanges()
 {
-	if (m_display_widget)
+	if (m_display_surface)
 		updateDisplayWidgetCursor();
 
 	updateWindowState();
@@ -1359,10 +1321,10 @@ void MainWindow::checkForSettingChanges()
 
 std::optional<WindowInfo> MainWindow::getWindowInfo()
 {
-	if (!m_display_widget || isRenderingToMain())
-		return QtUtils::GetWindowInfoForWidget(this);
-	else if (QWidget* widget = getDisplayContainer())
-		return QtUtils::GetWindowInfoForWidget(widget);
+	if (!m_display_surface || isRenderingToMain())
+		return QtUtils::GetWindowInfoForWindow(this);
+	else if (m_display_surface)
+		return QtUtils::GetWindowInfoForWindow(m_display_surface);
 	else
 		return std::nullopt;
 }
@@ -1381,9 +1343,8 @@ void MainWindow::onGameListRefreshComplete()
 
 void MainWindow::onGameListSelectionChanged()
 {
-	auto lock = GameList::GetLock();
-	const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
-	if (!entry)
+	const std::optional<GameList::Entry> entry = m_game_list_widget->getSelectedEntry();
+	if (!entry.has_value())
 		return;
 
 	m_ui.statusBar->showMessage(QString::fromStdString(entry->path));
@@ -1391,9 +1352,8 @@ void MainWindow::onGameListSelectionChanged()
 
 void MainWindow::onGameListEntryActivated()
 {
-	auto lock = GameList::GetLock();
-	const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
-	if (!entry)
+	const std::optional<GameList::Entry> entry = m_game_list_widget->getSelectedEntry();
+	if (!entry.has_value())
 		return;
 
 	if (s_vm_valid)
@@ -1421,24 +1381,23 @@ void MainWindow::onGameListEntryActivated()
 	}
 
 	// only resume if the option is enabled, and we have one for this game
-	startGameListEntry(entry, resume.value() ? std::optional<s32>(-1) : std::optional<s32>(), std::nullopt);
+	startGameListEntry(*entry, resume.value() ? std::optional<s32>(-1) : std::optional<s32>(), std::nullopt);
 }
 
 void MainWindow::onGameListEntryContextMenuRequested(const QPoint& point)
 {
-	auto lock = GameList::GetLock();
-	const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
+	const std::optional<GameList::Entry> entry = m_game_list_widget->getSelectedEntry();
 
 	QMenu menu;
 
-	if (entry)
+	if (entry.has_value())
 	{
 		QAction* action = menu.addAction(tr("Properties..."));
 		action->setEnabled(!entry->serial.empty() || entry->type == GameList::EntryType::ELF);
 		if (action->isEnabled())
 		{
 			connect(action, &QAction::triggered, [entry]() {
-				SettingsWindow::openGamePropertiesDialog(entry,
+				SettingsWindow::openGamePropertiesDialog(&*entry,
 					entry->title, entry->serial, entry->crc, entry->type == GameList::EntryType::ELF, nullptr);
 			});
 		}
@@ -1450,7 +1409,7 @@ void MainWindow::onGameListEntryContextMenuRequested(const QPoint& point)
 		});
 
 		action = menu.addAction(tr("Set Cover Image..."));
-		connect(action, &QAction::triggered, [this, entry]() { setGameListEntryCoverImage(entry); });
+		connect(action, &QAction::triggered, [this, entry]() { setGameListEntryCoverImage(*entry); });
 
 #if !defined(__APPLE__)
 		connect(menu.addAction(tr("Create Game Shortcut...")), &QAction::triggered, [this]() { MainWindow::onCreateGameShortcutTriggered(); });
@@ -1462,37 +1421,37 @@ void MainWindow::onGameListEntryContextMenuRequested(const QPoint& point)
 		const time_t entry_played_time = GameList::GetCachedPlayedTimeForSerial(entry->serial);
 		// Best two options given zero play time are to grey this out or to not show it at all.
 		if (entry_played_time)
-			connect(menu.addAction(tr("Reset Play Time")), &QAction::triggered, [this, entry, entry_played_time]() { clearGameListEntryPlayTime(entry, entry_played_time); });
+			connect(menu.addAction(tr("Reset Play Time")), &QAction::triggered, [this, entry, entry_played_time]() { clearGameListEntryPlayTime(*entry, entry_played_time); });
 
 		// Check Wiki Page functionality is based on a serial redirect.
 		if (!entry->serial.empty())
-			connect(menu.addAction(tr("Check Wiki Page")), &QAction::triggered, [this, entry]() { goToWikiPage(entry); });
+			connect(menu.addAction(tr("Check Wiki Page")), &QAction::triggered, [this, entry]() { goToWikiPage(*entry); });
 
 		action = menu.addAction(tr("Open Snapshots Folder"));
-		connect(action, &QAction::triggered, [this, entry]() { openSnapshotsFolderForGame(entry); });
+		connect(action, &QAction::triggered, [this, entry]() { openSnapshotsFolderForGame(*entry); });
 		menu.addSeparator();
 
 		if (!s_vm_valid)
 		{
 			action = menu.addAction(tr("Default Boot"));
-			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(entry); });
+			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(*entry); });
 
 			// Make bold to indicate it's the default choice when double-clicking
 			if (!VMManager::HasSaveStateInSlot(entry->serial.c_str(), entry->crc, -1))
 				QtUtils::MarkActionAsDefault(action);
 
 			action = menu.addAction(tr("Fast Boot"));
-			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(entry, std::nullopt, true); });
+			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(*entry, std::nullopt, true); });
 
 			action = menu.addAction(tr("Full Boot"));
-			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(entry, std::nullopt, false); });
+			connect(action, &QAction::triggered, [this, entry]() { startGameListEntry(*entry, std::nullopt, false); });
 
 			if (m_ui.menuDebug->menuAction()->isVisible())
 			{
 				action = menu.addAction(tr("Boot and Debug"));
 				connect(action, &QAction::triggered, [this, entry]() {
 					DebugInterface::setPauseOnEntry(true);
-					startGameListEntry(entry);
+					startGameListEntry(*entry);
 					DebuggerWindow::getInstance()->show();
 				});
 			}
@@ -1598,7 +1557,7 @@ void MainWindow::onSaveStateMenuAboutToShow()
 
 void MainWindow::onStartFullscreenUITriggered()
 {
-	if (m_display_widget)
+	if (m_display_surface)
 		g_emu_thread->stopFullscreenUI();
 	else
 		g_emu_thread->startFullscreenUI(Host::GetBaseBoolSettingValue("UI", "StartFullscreen", false));
@@ -1764,7 +1723,10 @@ void MainWindow::onToolsCoverDownloaderTriggered()
 #if !defined(__APPLE__)
 void MainWindow::onCreateGameShortcutTriggered()
 {
-	const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
+	const std::optional<GameList::Entry> entry = m_game_list_widget->getSelectedEntry();
+	if (!entry.has_value())
+		return;
+
 	const QString title = QString::fromStdString(entry->GetTitle());
 	const QString path = QString::fromStdString(entry->path);
 	VMLock lock(pauseAndLockVM());
@@ -2033,7 +1995,7 @@ void MainWindow::onVMPaused()
 	updateStatusBarWidgetVisibility();
 	m_last_fps_status = m_status_verbose_widget->text();
 	m_status_verbose_widget->setText(tr("Paused"));
-	if (m_display_widget)
+	if (m_display_surface)
 		updateDisplayWidgetCursor();
 }
 
@@ -2055,10 +2017,10 @@ void MainWindow::onVMResumed()
 	updateStatusBarWidgetVisibility();
 	m_status_verbose_widget->setText(m_last_fps_status);
 	m_last_fps_status = QString();
-	if (m_display_widget)
+	if (m_display_surface)
 	{
 		updateDisplayWidgetCursor();
-		m_display_widget->setFocus();
+		m_display_container->setFocus();
 	}
 }
 
@@ -2090,7 +2052,7 @@ void MainWindow::onVMStopped()
 		return;
 	}
 
-	if (m_display_widget)
+	if (m_display_surface)
 		updateDisplayWidgetCursor();
 	else
 		switchToGameListView();
@@ -2360,22 +2322,17 @@ std::optional<WindowInfo> MainWindow::acquireRenderWindow(bool recreate_window,
 	DevCon.WriteLn("acquireRenderWindow() recreate=%s fullscreen=%s render_to_main=%s surfaceless=%s", recreate_window ? "true" : "false",
 		fullscreen ? "true" : "false", render_to_main ? "true" : "false", surfaceless ? "true" : "false");
 
-	QWidget* container = m_display_container ? static_cast<QWidget*>(m_display_container) : static_cast<QWidget*>(m_display_widget);
 	const bool is_fullscreen = isRenderingFullscreen();
 	const bool is_rendering_to_main = isRenderingToMain();
-	const bool changing_surfaceless = (!m_display_widget != surfaceless);
+	const bool changing_surfaceless = (!m_display_surface != surfaceless);
 	if (m_display_created && !recreate_window && fullscreen == is_fullscreen && is_rendering_to_main == render_to_main &&
 		!changing_surfaceless)
 	{
-		return m_display_widget ? m_display_widget->getWindowInfo() : WindowInfo();
+		return m_display_surface ? m_display_surface->getWindowInfo() : WindowInfo();
 	}
 
 	// Skip recreating the surface if we're just transitioning between fullscreen and windowed with render-to-main off.
-	// .. except on Wayland, where everything tends to break if you don't recreate.
-	const bool has_container = (m_display_container != nullptr);
-	const bool needs_container = DisplayContainer::isNeeded(fullscreen, render_to_main);
-	if (m_display_created && !recreate_window && !is_rendering_to_main && !render_to_main && has_container == needs_container &&
-		!needs_container && !changing_surfaceless)
+	if (m_display_created && !recreate_window && !is_rendering_to_main && !render_to_main && !changing_surfaceless)
 	{
 		DevCon.WriteLn("Toggling to %s without recreating surface", (fullscreen ? "fullscreen" : "windowed"));
 
@@ -2385,23 +2342,23 @@ std::optional<WindowInfo> MainWindow::acquireRenderWindow(bool recreate_window,
 
 		if (fullscreen)
 		{
-			container->showFullScreen();
+			m_display_container->showFullScreen();
 		}
 		else
 		{
 			if (m_is_temporarily_windowed && g_emu_thread->shouldRenderToMain())
-				container->setGeometry(geometry());
+				m_display_container->setGeometry(geometry());
 			else
 				restoreDisplayWindowGeometryFromConfig();
-			container->showNormal();
+			m_display_container->showNormal();
 		}
 
 		updateDisplayWidgetCursor();
-		m_display_widget->setFocus();
+		m_display_container->setFocus();
 		updateWindowState();
 
 		QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
-		return m_display_widget->getWindowInfo();
+		return m_display_surface->getWindowInfo();
 	}
 
 	destroyDisplayWidget(surfaceless);
@@ -2420,7 +2377,7 @@ std::optional<WindowInfo> MainWindow::acquireRenderWindow(bool recreate_window,
 
 	createDisplayWidget(fullscreen, render_to_main);
 
-	std::optional<WindowInfo> wi = m_display_widget->getWindowInfo();
+	std::optional<WindowInfo> wi = m_display_surface->getWindowInfo();
 	if (!wi.has_value())
 	{
 		QMessageBox::critical(this, tr("Error"), tr("Failed to get window info from widget"));
@@ -2428,14 +2385,13 @@ std::optional<WindowInfo> MainWindow::acquireRenderWindow(bool recreate_window,
 		return std::nullopt;
 	}
 
-	g_emu_thread->connectDisplaySignals(m_display_widget);
+	g_emu_thread->connectDisplaySignals(m_display_surface);
 
 	updateWindowTitle();
 	updateWindowState();
 
 	updateDisplayWidgetCursor();
-	m_display_widget->setFocus();
-
+	m_display_container->setFocus();
 	return wi;
 }
 
@@ -2449,64 +2405,46 @@ void MainWindow::createDisplayWidget(bool fullscreen, bool render_to_main)
 		QGuiApplication::sync();
 	}
 
-	QWidget* container;
-	if (DisplayContainer::isNeeded(fullscreen, render_to_main))
+	m_display_surface = new DisplaySurface();
+	if (fullscreen || !render_to_main)
 	{
-		m_display_container = new DisplayContainer();
-		m_display_widget = new DisplayWidget(m_display_container);
-		m_display_container->setDisplayWidget(m_display_widget);
-		container = m_display_container;
+		m_display_container = m_display_surface->createWindowContainer();
+		m_display_container->setWindowTitle(windowTitle());
+		m_display_container->setWindowIcon(windowIcon());
 	}
 	else
 	{
-		m_display_widget = new DisplayWidget((!fullscreen && render_to_main) ? getContentParent() : nullptr);
-		container = m_display_widget;
-	}
-
-	if (fullscreen || !render_to_main)
-	{
-		container->setWindowTitle(windowTitle());
-		container->setWindowIcon(windowIcon());
+		m_display_container = m_display_surface->createWindowContainer(getContentParent());
 	}
 
 	if (fullscreen)
 	{
-		// Don't risk doing this on Wayland, it really doesn't like window state changes,
-		// and positioning has no effect anyway.
-		if (!s_use_central_widget)
-		{
-			if (isVisible() && g_emu_thread->shouldRenderToMain())
-				container->move(pos());
-			else
-				restoreDisplayWindowGeometryFromConfig();
-		}
-
-		container->showFullScreen();
+		// On Wayland, while move/restoreGeometry can't position the window, it can influence which screen they show up on
+		if (isVisible() && g_emu_thread->shouldRenderToMain())
+			m_display_container->move(pos());
+		else
+			restoreDisplayWindowGeometryFromConfig();
+		m_display_container->showFullScreen();
 	}
 	else if (!render_to_main)
 	{
 		if (m_is_temporarily_windowed && g_emu_thread->shouldRenderToMain())
-			container->setGeometry(geometry());
+			m_display_container->setGeometry(geometry());
 		else
 			restoreDisplayWindowGeometryFromConfig();
-		container->showNormal();
-	}
-	else if (s_use_central_widget)
-	{
-		m_game_list_widget->setVisible(false);
-		takeCentralWidget();
-		m_game_list_widget->setParent(this); // takeCentralWidget() removes parent
-		setCentralWidget(m_display_widget);
-		m_display_widget->setFocus();
-		update();
+		m_display_container->showNormal();
 	}
 	else
 	{
 		pxAssertRel(m_ui.mainContainer->count() == 1, "Has no display widget");
-		m_ui.mainContainer->addWidget(container);
+		m_ui.mainContainer->addWidget(m_display_container);
 		m_ui.mainContainer->setCurrentIndex(1);
 	}
 
+	// Attatch drag and drop signals
+	connect(m_display_surface, &DisplaySurface::dragEnterEvent, this, &MainWindow::dragEnterEvent);
+	connect(m_display_surface, &DisplaySurface::dropEvent, this, &MainWindow::dropEvent);
+
 	updateDisplayRelatedActions(true, render_to_main, fullscreen);
 
 	// We need the surface visible.
@@ -2515,7 +2453,7 @@ void MainWindow::createDisplayWidget(bool fullscreen, bool render_to_main)
 
 void MainWindow::displayResizeRequested(qint32 width, qint32 height)
 {
-	if (!m_display_widget)
+	if (!m_display_surface)
 		return;
 
 	// unapply the pixel scaling factor for hidpi
@@ -2523,15 +2461,15 @@ void MainWindow::displayResizeRequested(qint32 width, qint32 height)
 	width = static_cast<qint32>(std::max(static_cast<int>(std::lroundf(static_cast<float>(width) / dpr)), 1));
 	height = static_cast<qint32>(std::max(static_cast<int>(std::lroundf(static_cast<float>(height) / dpr)), 1));
 
-	if (m_display_container || !m_display_widget->parent())
+	if (!m_display_container->parent())
 	{
 		// no parent - rendering to separate window. easy.
-		QtUtils::ResizePotentiallyFixedSizeWindow(getDisplayContainer(), width, height);
+		QtUtils::ResizePotentiallyFixedSizeWindow(m_display_container, width, height);
 		return;
 	}
 
 	// we are rendering to the main window. we have to add in the extra height from the toolbar/status bar.
-	const s32 extra_height = this->height() - m_display_widget->height();
+	const s32 extra_height = this->height() - m_display_container->height();
 	QtUtils::ResizePotentiallyFixedSizeWindow(this, width, height + extra_height);
 }
 
@@ -2542,7 +2480,7 @@ void MainWindow::mouseModeRequested(bool relative_mode, bool hide_cursor)
 
 	m_relative_mouse_mode = relative_mode;
 	m_hide_mouse_cursor = hide_cursor;
-	if (m_display_widget && !s_vm_paused)
+	if (m_display_surface && !s_vm_paused)
 		updateDisplayWidgetCursor();
 }
 
@@ -2558,73 +2496,46 @@ void MainWindow::releaseRenderWindow()
 
 void MainWindow::destroyDisplayWidget(bool show_game_list)
 {
-	if (!m_display_widget)
+	if (!m_display_surface)
 		return;
 
 	if (!isRenderingFullscreen() && !isRenderingToMain())
 		saveDisplayWindowGeometryToConfig();
 
-	if (m_display_container)
-		m_display_container->removeDisplayWidget();
-
 	if (isRenderingToMain())
 	{
-		if (s_use_central_widget)
+		pxAssertRel(m_ui.mainContainer->indexOf(m_display_container) == 1, "Display widget in stack");
+		m_ui.mainContainer->removeWidget(m_display_container);
+		if (show_game_list)
 		{
-			pxAssertRel(centralWidget() == m_display_widget, "Display widget is currently central");
-			takeCentralWidget();
-			if (show_game_list)
-			{
-				m_game_list_widget->setVisible(true);
-				setCentralWidget(m_game_list_widget);
-				m_game_list_widget->resizeTableViewColumnsToFit();
-			}
-		}
-		else
-		{
-			pxAssertRel(m_ui.mainContainer->indexOf(m_display_widget) == 1, "Display widget in stack");
-			m_ui.mainContainer->removeWidget(m_display_widget);
-			if (show_game_list)
-			{
-				m_ui.mainContainer->setCurrentIndex(0);
-				m_game_list_widget->resizeTableViewColumnsToFit();
-			}
+			m_ui.mainContainer->setCurrentIndex(0);
+			m_game_list_widget->resizeTableViewColumnsToFit();
 		}
 	}
 
-	if (m_display_widget)
-	{
-		m_display_widget->destroy();
-		m_display_widget = nullptr;
-	}
-
-	if (m_display_container)
-	{
-		m_display_container->deleteLater();
-		m_display_container = nullptr;
-	}
+	// displau surface is always in a container
+	pxAssert(m_display_container != nullptr);
+	m_display_container->deleteLater();
+	m_display_container = nullptr;
+	// m_display_surface will be destroyed by the container's dtor
+	m_display_surface = nullptr;
 
 	updateDisplayRelatedActions(false, false, false);
 }
 
 void MainWindow::updateDisplayWidgetCursor()
 {
-	pxAssertRel(m_display_widget, "Should have a display widget");
-	m_display_widget->updateRelativeMode(s_vm_valid && !s_vm_paused && m_relative_mouse_mode);
-	m_display_widget->updateCursor(s_vm_valid && !s_vm_paused && shouldHideMouseCursor());
+	pxAssertRel(m_display_surface, "Should have a display widget");
+	m_display_surface->updateRelativeMode(s_vm_valid && !s_vm_paused && m_relative_mouse_mode);
+	m_display_surface->updateCursor(s_vm_valid && !s_vm_paused && shouldHideMouseCursor());
 }
 
 void MainWindow::focusDisplayWidget()
 {
-	if (!m_display_widget || centralWidget() != m_display_widget)
+	if (!m_display_surface || centralWidget() != m_display_container)
 		return;
 
-	m_display_widget->setFocus();
-}
-
-QWidget* MainWindow::getDisplayContainer() const
-{
-	return (m_display_container ? static_cast<QWidget*>(m_display_container) : static_cast<QWidget*>(m_display_widget));
+	m_display_container->setFocus();
 }
 
 void MainWindow::setupMouseMoveHandler()
@@ -2653,18 +2564,29 @@ void MainWindow::checkMousePosition(int x, int y)
 		// physical mouse position
 		const QPoint physicalPos(x, y);
 
-		const auto* displayWindow = getDisplayContainer()->window();
+		const auto* displayWindow = m_display_surface;
 
 		// logical (DIP) frame rect
-		QRectF logicalBounds = displayWindow->geometry();
+		const QSize logicalSize = displayWindow->size();
+		const QPoint logicalPosition = displayWindow->position() + displayWindow->parent()->position();
+
+		// The offset to the origin of the current screen is in device-independent pixels while the origin itself is native!
+		// The logicalPosition is the sum of these two values, so we need to separate them and only scale the offset
+		const QScreen* screen = displayWindow->screen();
+
+		// If we fail to get the screen associated with the window, avoid mouse locking as it's probably in an unexpected position.
+		if (!screen)
+			return;
+
+		const QPoint screenPosition = screen->geometry().topLeft();
 
 		// physical frame rect
-		const qreal scale = displayWindow->devicePixelRatioF();
-		QRectF physicalBounds(
-			logicalBounds.x() * scale,
-			logicalBounds.y() * scale,
-			logicalBounds.width() * scale,
-			logicalBounds.height() * scale);
+		const qreal scale = displayWindow->devicePixelRatio();
+		const QRectF physicalBounds(
+			screenPosition.x() + (logicalPosition.x() - screenPosition.x()) * scale,
+			screenPosition.y() + (logicalPosition.y() - screenPosition.y()) * scale,
+			logicalSize.width() * scale,
+			logicalSize.height() * scale);
 
 		if (physicalBounds.contains(physicalPos))
 			return;
@@ -2677,14 +2599,13 @@ void MainWindow::checkMousePosition(int x, int y)
 
 void MainWindow::saveDisplayWindowGeometryToConfig()
 {
-	QWidget* container = getDisplayContainer();
-	if (container->windowState() & Qt::WindowFullScreen)
+	if (m_display_container->windowState() & Qt::WindowFullScreen)
 	{
 		// if we somehow ended up here, don't save the fullscreen state to the config
 		return;
 	}
 
-	const QByteArray geometry = getDisplayContainer()->saveGeometry();
+	const QByteArray geometry = m_display_container->saveGeometry();
 	const QByteArray geometry_b64 = geometry.toBase64();
 	const std::string old_geometry_b64 = Host::GetBaseStringSettingValue("UI", "DisplayWindowGeometry");
 	if (old_geometry_b64 != geometry_b64.constData())
@@ -2698,18 +2619,17 @@ void MainWindow::restoreDisplayWindowGeometryFromConfig()
 {
 	const std::string geometry_b64 = Host::GetBaseStringSettingValue("UI", "DisplayWindowGeometry");
 	const QByteArray geometry = QByteArray::fromBase64(QByteArray::fromStdString(geometry_b64));
-	QWidget* container = getDisplayContainer();
 	if (!geometry.isEmpty())
 	{
-		container->restoreGeometry(geometry);
+		m_display_container->restoreGeometry(geometry);
 
 		// make sure we're not loading a dodgy config which had fullscreen set...
-		container->setWindowState(container->windowState() & ~(Qt::WindowFullScreen | Qt::WindowActive));
+		m_display_container->setWindowState(m_display_container->windowState() & ~(Qt::WindowFullScreen | Qt::WindowActive));
 	}
 	else
 	{
 		// default size
-		container->resize(640, 480);
+		m_display_container->resize(640, 480);
 	}
 }
 
@@ -2720,7 +2640,7 @@ SettingsWindow* MainWindow::getSettingsWindow()
 		m_settings_window = new SettingsWindow();
 		connect(m_settings_window->getInterfaceSettingsWidget(), &InterfaceSettingsWidget::themeChanged, this, &MainWindow::onThemeChanged);
 		connect(m_settings_window->getInterfaceSettingsWidget(), &InterfaceSettingsWidget::languageChanged, this, &MainWindow::onLanguageChanged);
-		connect(m_settings_window->getInterfaceSettingsWidget(), &InterfaceSettingsWidget::backgroundChanged, m_game_list_widget, [this] { m_game_list_widget->setCustomBackground(true); });
+		connect(m_settings_window->getInterfaceSettingsWidget(), &InterfaceSettingsWidget::backgroundChanged, m_game_list_widget, [this] { m_game_list_widget->setCustomBackground(); });
 		connect(m_settings_window->getGameListSettingsWidget(), &GameListSettingsWidget::preferEnglishGameListChanged, this, [] {
 			g_main_window->m_game_list_widget->refreshGridCovers();
 		});
@@ -2755,13 +2675,21 @@ void MainWindow::doGameSettings(const char* category)
 	// prefer to use a game list entry, if we have one, that way the summary is populated
 	if (!s_current_disc_path.isEmpty() || !s_current_elf_override.isEmpty())
 	{
-		auto lock = GameList::GetLock();
 		const QString& path = (s_current_elf_override.isEmpty() ? s_current_disc_path : s_current_elf_override);
-		const GameList::Entry* entry = GameList::GetEntryForPath(path.toUtf8().constData());
-		if (entry)
+
+		std::optional<GameList::Entry> entry;
+
+		{
+			auto lock = GameList::GetLock();
+			const GameList::Entry* entry_ptr = GameList::GetEntryForPath(path.toUtf8().constData());
+			if (entry_ptr)
+				entry = *entry_ptr;
+		}
+
+		if (entry.has_value())
 		{
 			SettingsWindow::openGamePropertiesDialog(
-				entry, entry->title, entry->serial, entry->crc, !s_current_elf_override.isEmpty(), category);
+				&*entry, entry->title, entry->serial, entry->crc, !s_current_elf_override.isEmpty(), category);
 			return;
 		}
 	}
@@ -2851,16 +2779,16 @@ QString MainWindow::getDiscDevicePath(const QString& title)
 	return ret;
 }
 
-void MainWindow::startGameListEntry(const GameList::Entry* entry, std::optional<s32> save_slot, std::optional<bool> fast_boot, bool load_backup)
+void MainWindow::startGameListEntry(const GameList::Entry& entry, std::optional<s32> save_slot, std::optional<bool> fast_boot, bool load_backup)
 {
 	std::shared_ptr<VMBootParameters> params = std::make_shared<VMBootParameters>();
 	params->fast_boot = fast_boot;
 
-	GameList::FillBootParametersForEntry(params.get(), entry);
+	GameList::FillBootParametersForEntry(params.get(), &entry);
 
-	if (save_slot.has_value() && !entry->serial.empty())
+	if (save_slot.has_value() && !entry.serial.empty())
 	{
-		std::string state_filename = VMManager::GetSaveStateFileName(entry->serial.c_str(), entry->crc, save_slot.value(), load_backup);
+		std::string state_filename = VMManager::GetSaveStateFileName(entry.serial.c_str(), entry.crc, save_slot.value(), load_backup);
 		if (!FileSystem::FileExists(state_filename.c_str()))
 		{
 			QMessageBox::critical(this, tr("Error"), tr("This save state does not exist."));
@@ -2873,15 +2801,15 @@ void MainWindow::startGameListEntry(const GameList::Entry* entry, std::optional<
 	g_emu_thread->startVM(std::move(params));
 }
 
-void MainWindow::setGameListEntryCoverImage(const GameList::Entry* entry)
+void MainWindow::setGameListEntryCoverImage(const GameList::Entry& entry)
 {
 	const QString filename = QDir::toNativeSeparators(
 		QFileDialog::getOpenFileName(this, tr("Select Cover Image"), QString(), tr("All Cover Image Types (*.jpg *.jpeg *.png *.webp)")));
 	if (filename.isEmpty())
 		return;
 
-	const QString old_filename = QString::fromStdString(GameList::GetCoverImagePathForEntry(entry));
-	const QString new_filename = QString::fromStdString(GameList::GetNewCoverImagePathForEntry(entry, filename.toUtf8().constData(), true));
+	const QString old_filename = QString::fromStdString(GameList::GetCoverImagePathForEntry(&entry));
+	const QString new_filename = QString::fromStdString(GameList::GetNewCoverImagePathForEntry(&entry, filename.toUtf8().constData(), true));
 	if (new_filename.isEmpty())
 		return;
 
@@ -2922,31 +2850,31 @@ void MainWindow::setGameListEntryCoverImage(const GameList::Entry* entry)
 	m_game_list_widget->refreshGridCovers();
 }
 
-void MainWindow::clearGameListEntryPlayTime(const GameList::Entry* entry, const time_t entry_played_time)
+void MainWindow::clearGameListEntryPlayTime(const GameList::Entry& entry, const time_t entry_played_time)
 {
 	if (QMessageBox::question(this, tr("Confirm Reset"),
 			tr("Are you sure you want to reset the play time for '%1' (%2)?\n\nYour current play time is %3.\n\nThis action cannot be undone.")
-				.arg(entry->title.empty() ? tr("empty title") : QString::fromStdString(entry->title),
-					entry->serial.empty() ? tr("no serial") : QString::fromStdString(entry->serial),
+				.arg(entry.title.empty() ? tr("empty title") : QString::fromStdString(entry.title),
+					entry.serial.empty() ? tr("no serial") : QString::fromStdString(entry.serial),
 					QString::fromStdString(GameList::FormatTimespan(entry_played_time, true))),
 			(QMessageBox::Yes | QMessageBox::No), QMessageBox::No) == QMessageBox::Yes)
 	{
-		GameList::ClearPlayedTimeForSerial(entry->serial);
+		GameList::ClearPlayedTimeForSerial(entry.serial);
 		m_game_list_widget->refresh(false, false);
 	}
 }
 
-void MainWindow::goToWikiPage(const GameList::Entry* entry)
+void MainWindow::goToWikiPage(const GameList::Entry& entry)
 {
-	QtUtils::OpenURL(this, fmt::format("https://wiki.pcsx2.net/{}", entry->serial).c_str());
+	QtUtils::OpenURL(this, fmt::format("https://wiki.pcsx2.net/{}", entry.serial).c_str());
 }
 
-void MainWindow::openSnapshotsFolderForGame(const GameList::Entry* entry)
+void MainWindow::openSnapshotsFolderForGame(const GameList::Entry& entry)
 {
 	// Go to top-level snapshots directory if not organizing by game.
-	if (EmuConfig.GS.OrganizeSnapshotsByGame && entry && !entry->title.empty())
+	if (EmuConfig.GS.OrganizeSnapshotsByGame && !entry.title.empty())
 	{
-		std::string game_name = entry->title;
+		std::string game_name = entry.title;
 		Path::SanitizeFileName(&game_name);
 
 		const std::string game_dir = Path::Combine(EmuFolders::Snapshots, game_name);
@@ -3021,11 +2949,11 @@ void MainWindow::loadSaveStateSlot(s32 slot, bool load_backup)
 	else
 	{
 		// we're not currently running, therefore we must've right clicked in the game list
-		const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
-		if (!entry)
+		const std::optional<GameList::Entry> entry = m_game_list_widget->getSelectedEntry();
+		if (!entry.has_value())
 			return;
 
-		startGameListEntry(entry, slot, std::nullopt, load_backup);
+		startGameListEntry(*entry, slot, std::nullopt, load_backup);
 	}
 }
 
@@ -3251,7 +3179,7 @@ MainWindow::VMLock MainWindow::pauseAndLockVM()
 	// period when there's no window, and Qt might shut us down. So avoid it there.
 	// On MacOS, it forces a workspace switch, which is kinda jarring.
 #ifndef __APPLE__
-	const bool was_fullscreen = g_emu_thread->isFullscreen() && !s_use_central_widget;
+	const bool was_fullscreen = g_emu_thread->isFullscreen();
 #else
 	const bool was_fullscreen = false;
 #endif
@@ -3270,25 +3198,20 @@ MainWindow::VMLock MainWindow::pauseAndLockVM()
 
 		g_emu_thread->setFullscreen(false, false);
 
-		// Container could change... thanks Wayland.
-		QWidget* container;
-		while (QtHost::IsVMValid() && (g_emu_thread->isFullscreen() ||
-										  !(container = getDisplayContainer()) || container->isFullScreen()))
+		// Process events untill both EmuThread and Qt have finished exiting fullscreen
+		while (QtHost::IsVMValid() && (g_emu_thread->isFullscreen() || m_display_container->isFullScreen()))
 		{
 			QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 		}
 	}
 
-	// Now we'll either have a borderless window, or a regular window (if we were exclusive fullscreen).
-	QWidget* dialog_parent = getDisplayContainer();
-
 	// Ensure main window is visible.
 	if (!g_main_window->isVisible())
 		g_main_window->show();
 	g_main_window->raise();
 	g_main_window->activateWindow();
 
-	return VMLock(dialog_parent, was_paused, was_fullscreen);
+	return VMLock(m_display_container, was_paused, was_fullscreen);
 }
 
 void MainWindow::rescanFile(const std::string& path)
@@ -3298,23 +3221,30 @@ void MainWindow::rescanFile(const std::string& path)
 
 MainWindow::VMLock::VMLock(QWidget* dialog_parent, bool was_paused, bool was_fullscreen)
 	: m_dialog_parent(dialog_parent)
+	, m_has_lock(true)
 	, m_was_paused(was_paused)
 	, m_was_fullscreen(was_fullscreen)
 {
+	QtHost::LockVMWithDialog();
 }
 
 MainWindow::VMLock::VMLock(VMLock&& lock)
 	: m_dialog_parent(lock.m_dialog_parent)
+	, m_has_lock(lock.m_has_lock)
 	, m_was_paused(lock.m_was_paused)
 	, m_was_fullscreen(lock.m_was_fullscreen)
 {
 	lock.m_dialog_parent = nullptr;
+	lock.m_has_lock = false;
 	lock.m_was_paused = true;
 	lock.m_was_fullscreen = false;
 }
 
 MainWindow::VMLock::~VMLock()
 {
+	if (m_has_lock)
+		QtHost::UnlockVMWithDialog();
+
 	if (m_was_fullscreen)
 	{
 		g_main_window->m_is_temporarily_windowed = false;
@@ -3327,10 +3257,15 @@ MainWindow::VMLock::~VMLock()
 
 MainWindow::VMLock& MainWindow::VMLock::operator=(VMLock&& lock)
 {
+	if (m_has_lock)
+		QtHost::UnlockVMWithDialog();
+
+	m_has_lock = lock.m_has_lock;
 	m_dialog_parent = lock.m_dialog_parent;
 	m_was_paused = lock.m_was_paused;
 	m_was_fullscreen = lock.m_was_fullscreen;
 
+	lock.m_has_lock = false;
 	lock.m_dialog_parent = nullptr;
 	lock.m_was_paused = true;
 	lock.m_was_fullscreen = false;

pcsx2-qt/MainWindow.h

@@ -20,7 +20,7 @@
 class QProgressBar;
 
 class AutoUpdaterDialog;
-class DisplayWidget;
+class DisplaySurface;
 class DisplayContainer;
 class GameListWidget;
 class ControllerSettingsWindow;
@@ -69,6 +69,7 @@ public:
 		friend MainWindow;
 
 		QWidget* m_dialog_parent;
+		bool m_has_lock;
 		bool m_was_paused;
 		bool m_was_fullscreen;
 	};
@@ -257,7 +258,6 @@ private:
 	bool shouldAbortForMemcardBusy(const VMLock& lock);
 
 	QWidget* getContentParent();
-	QWidget* getDisplayContainer() const;
 	void saveDisplayWindowGeometryToConfig();
 	void restoreDisplayWindowGeometryFromConfig();
 	void createDisplayWidget(bool fullscreen, bool render_to_main);
@@ -274,11 +274,11 @@ private:
 	QString getDiscDevicePath(const QString& title);
 
 	void startGameListEntry(
-		const GameList::Entry* entry, std::optional<s32> save_slot = std::nullopt, std::optional<bool> fast_boot = std::nullopt, bool load_backup = false);
-	void setGameListEntryCoverImage(const GameList::Entry* entry);
-	void clearGameListEntryPlayTime(const GameList::Entry* entry, const time_t entry_played_time);
-	void goToWikiPage(const GameList::Entry* entry);
-	void openSnapshotsFolderForGame(const GameList::Entry* entry);
+		const GameList::Entry& entry, std::optional<s32> save_slot = std::nullopt, std::optional<bool> fast_boot = std::nullopt, bool load_backup = false);
+	void setGameListEntryCoverImage(const GameList::Entry& entry);
+	void clearGameListEntryPlayTime(const GameList::Entry& entry, const time_t entry_played_time);
+	void goToWikiPage(const GameList::Entry& entry);
+	void openSnapshotsFolderForGame(const GameList::Entry& entry);
 
 	std::optional<bool> promptForResumeState(const QString& save_state_path);
 	void loadSaveStateSlot(s32 slot, bool load_backup = false);
@@ -291,8 +291,8 @@ private:
 	Ui::MainWindow m_ui;
 
 	GameListWidget* m_game_list_widget = nullptr;
-	DisplayWidget* m_display_widget = nullptr;
-	DisplayContainer* m_display_container = nullptr;
+	DisplaySurface* m_display_surface = nullptr;
+	QWidget* m_display_container = nullptr;
 
 	SettingsWindow* m_settings_window = nullptr;
 	ControllerSettingsWindow* m_controller_settings_window = nullptr;

pcsx2-qt/QtHost.cpp

@@ -88,12 +88,13 @@ static QTimer* s_settings_save_timer = nullptr;
 static std::unique_ptr<INISettingsInterface> s_base_settings_interface;
 static bool s_batch_mode = false;
 static bool s_nogui_mode = false;
-static bool s_start_fullscreen_ui = false;
-static bool s_start_fullscreen_ui_fullscreen = false;
+static bool s_start_big_picture_mode = false;
+static bool s_start_fullscreen = false;
 static bool s_test_config_and_exit = false;
 static bool s_run_setup_wizard = false;
 static bool s_cleanup_after_update = false;
 static bool s_boot_and_debug = false;
+static std::atomic_int s_vm_locked_with_dialog = 0;
 
 //////////////////////////////////////////////////////////////////////////
 // CPU Thread
@@ -495,6 +496,11 @@ void EmuThread::setFullscreen(bool fullscreen, bool allow_render_to_main)
 		return;
 	}
 
+	// HACK: Prevent entering/exiting fullscreen mode when a dialog is shown, so
+	// that we don't destroy the dialog while inside its exec function.
+	if (s_vm_locked_with_dialog > 0)
+		return;
+
 	if (!MTGS::IsOpen() || m_is_fullscreen == fullscreen)
 		return;
 
@@ -764,12 +770,12 @@ void EmuThread::enumerateVibrationMotors()
 	onVibrationMotorsEnumerated(qmotors);
 }
 
-void EmuThread::connectDisplaySignals(DisplayWidget* widget)
+void EmuThread::connectDisplaySignals(DisplaySurface* widget)
 {
 	widget->disconnect(this);
 
-	connect(widget, &DisplayWidget::windowResizedEvent, this, &EmuThread::onDisplayWindowResized);
-	connect(widget, &DisplayWidget::windowRestoredEvent, this, &EmuThread::redrawDisplayWindow);
+	connect(widget, &DisplaySurface::windowResizedEvent, this, &EmuThread::onDisplayWindowResized);
+	connect(widget, &DisplaySurface::windowRestoredEvent, this, &EmuThread::redrawDisplayWindow);
 }
 
 void EmuThread::onDisplayWindowResized(int width, int height, float scale)
@@ -959,6 +965,9 @@ void Host::OnGameChanged(const std::string& title, const std::string& elf_overri
 
 void EmuThread::updatePerformanceMetrics(bool force)
 {
+	if (!g_main_window)
+		return;
+
 	if (VMManager::HasValidVM())
 	{
 		QString gs_stat;
@@ -1713,6 +1722,16 @@ void Host::SetMouseMode(bool relative_mode, bool hide_cursor)
 	emit g_emu_thread->onMouseModeRequested(relative_mode, hide_cursor);
 }
 
+void QtHost::LockVMWithDialog()
+{
+	s_vm_locked_with_dialog++;
+}
+
+void QtHost::UnlockVMWithDialog()
+{
+	s_vm_locked_with_dialog--;
+}
+
 namespace
 {
 	class QtHostProgressCallback final : public BaseProgressCallback
@@ -2168,7 +2187,7 @@ bool QtHost::ParseCommandLineOptions(const QStringList& args, std::shared_ptr<VM
 			else if (CHECK_ARG(QStringLiteral("-fullscreen")))
 			{
 				AutoBoot(autoboot)->fullscreen = true;
-				s_start_fullscreen_ui_fullscreen = true;
+				s_start_fullscreen = true;
 				continue;
 			}
 			else if (CHECK_ARG(QStringLiteral("-nofullscreen")))
@@ -2183,7 +2202,7 @@ bool QtHost::ParseCommandLineOptions(const QStringList& args, std::shared_ptr<VM
 			}
 			else if (CHECK_ARG(QStringLiteral("-bigpicture")))
 			{
-				s_start_fullscreen_ui = true;
+				s_start_big_picture_mode = true;
 				continue;
 			}
 			else if (CHECK_ARG(QStringLiteral("-testconfig")))
@@ -2244,7 +2263,7 @@ bool QtHost::ParseCommandLineOptions(const QStringList& args, std::shared_ptr<VM
 
 	// if we don't have autoboot, we definitely don't want batch mode (because that'll skip
 	// scanning the game list).
-	if (s_batch_mode && !s_start_fullscreen_ui && !autoboot)
+	if (s_batch_mode && !s_start_big_picture_mode && !autoboot)
 	{
 		QMessageBox::critical(nullptr, QStringLiteral("Error"),
 			s_nogui_mode ? QStringLiteral("Cannot use no-gui mode, because no boot filename was specified.") :
@@ -2398,8 +2417,9 @@ int main(int argc, char* argv[])
 	}
 
 	// Initialize big picture mode if requested by command line or settings.
-	if (s_start_fullscreen_ui || Host::GetBaseBoolSettingValue("UI", "StartBigPictureMode", false))
-		g_emu_thread->startFullscreenUI(s_start_fullscreen_ui_fullscreen);
+	// As CLI arguments are baked-in, they're tracked separately from settings which can be changed during runtime.
+	if (s_start_big_picture_mode || Host::GetBaseBoolSettingValue("UI", "StartBigPictureMode", false))
+		g_emu_thread->startFullscreenUI(s_start_fullscreen || Host::GetBaseBoolSettingValue("UI", "StartFullscreen", false));
 
 	if (s_boot_and_debug || DebuggerWindow::shouldShowOnStartup())
 	{

pcsx2-qt/QtHost.h

@@ -28,7 +28,7 @@
 
 class SettingsInterface;
 
-class DisplayWidget;
+class DisplaySurface;
 struct VMBootParameters;
 
 enum class CDVD_SourceType : uint8_t;
@@ -69,7 +69,7 @@ public:
 
 	/// Called back from the GS thread when the display state changes (e.g. fullscreen, render to main).
 	std::optional<WindowInfo> acquireRenderWindow(bool recreate_window);
-	void connectDisplaySignals(DisplayWidget* widget);
+	void connectDisplaySignals(DisplaySurface* widget);
 	void releaseRenderWindow();
 
 	void startBackgroundControllerPollTimer();
@@ -290,4 +290,10 @@ namespace QtHost
 
 	/// Compare strings in the locale of the current UI language
 	int LocaleSensitiveCompare(QStringView lhs, QStringView rhs);
+
+	/// Determines whether or not requests to enter/exit fullscreen mode should
+	/// be ignored. This is a hack so that we don't destroy a dialog box while
+	/// inside its exec function, which would cause a crash.
+	void LockVMWithDialog();
+	void UnlockVMWithDialog();
 } // namespace QtHost

pcsx2-qt/QtUtils.cpp

@@ -8,10 +8,9 @@
 #include <QtCore/QtGlobal>
 #include <QtCore/QMetaObject>
 #include <QtGui/QAction>
-#include <QtGui/QGuiApplication>
 #include <QtGui/QDesktopServices>
 #include <QtGui/QKeyEvent>
-#include <QtGui/QScreen>
+#include <QtGui/QPainter>
 #include <QtWidgets/QComboBox>
 #include <QtWidgets/QDialog>
 #include <QtWidgets/QHeaderView>
@@ -40,8 +39,6 @@
 #if defined(_WIN32)
 #include "common/RedtapeWindows.h"
 #include <Shlobj.h>
-#elif !defined(APPLE)
-#include <qpa/qplatformnativeinterface.h>
 #endif
 
 namespace QtUtils
@@ -139,6 +136,126 @@ namespace QtUtils
 		ResizeColumnsForView(view, widths);
 	}
 
+	void resizeAndScalePixmap(QPixmap* pm, const int expected_width, const int expected_height, const qreal dpr, const ScalingMode scaling_mode, const float opacity)
+	{
+		if (!pm || pm->isNull() || pm->width() <= 0 || pm->height() <= 0)
+			return;
+
+		const int dpr_expected_width = qRound(expected_width * dpr);
+		const int dpr_expected_height = qRound(expected_height * dpr);
+
+		if (pm->width() == dpr_expected_width &&
+			pm->height() == dpr_expected_height &&
+			pm->devicePixelRatio() == dpr &&
+			opacity == 100.0f)
+		{
+			switch (scaling_mode)
+			{
+				case ScalingMode::Fit:
+				case ScalingMode::Stretch:
+				case ScalingMode::Center:
+					return;
+
+				case ScalingMode::Fill:
+				case ScalingMode::Tile:
+				default:
+					break;
+			}
+		}
+
+		QPixmap final_pixmap(dpr_expected_width, dpr_expected_height);
+		final_pixmap.setDevicePixelRatio(dpr);
+		final_pixmap.fill(Qt::transparent);
+
+		QPainter painter;
+		painter.begin(&final_pixmap);
+		painter.setRenderHint(QPainter::Antialiasing, true);
+		painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
+		painter.setOpacity(opacity / 100.0f);
+		painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+
+		const QRectF srcRect(0, 0, pm->width(), pm->height());
+		const QRectF painterRect(0, 0, expected_width, expected_height);
+
+		switch (scaling_mode)
+		{
+			case ScalingMode::Fit:
+			case ScalingMode::Fill:
+			{
+				auto const aspect_mode = (scaling_mode == ScalingMode::Fit) ?
+				                             Qt::KeepAspectRatio :
+				                             Qt::KeepAspectRatioByExpanding;
+
+				QSizeF scaledSize(pm->width(), pm->height());
+				scaledSize.scale(dpr_expected_width, dpr_expected_height, aspect_mode);
+
+				*pm = pm->scaled(
+					qRound(scaledSize.width()),
+					qRound(scaledSize.height()),
+					Qt::IgnoreAspectRatio,
+					Qt::SmoothTransformation
+				);
+
+				const QRectF scaledSrcRect(0, 0, pm->width(), pm->height());
+
+				QSizeF logicalSize = pm->size() / dpr;
+				QRectF destRect(QPointF(0, 0), logicalSize);
+
+				destRect.moveCenter(painterRect.center());
+
+				painter.drawPixmap(destRect, *pm, scaledSrcRect);
+				break;
+			}
+			case ScalingMode::Stretch:
+			{
+				*pm = pm->scaled(
+					dpr_expected_width,
+					dpr_expected_height,
+					Qt::IgnoreAspectRatio,
+					Qt::SmoothTransformation
+				);
+
+				const QRectF scaledSrcRect(0, 0, pm->width(), pm->height());
+
+				painter.drawPixmap(painterRect, *pm, scaledSrcRect);
+				break;
+			}
+			case ScalingMode::Center:
+			{
+				const qreal pmWidth = pm->width() / dpr;
+				const qreal pmHeight = pm->height() / dpr;
+
+				QRectF destRect(0, 0, pmWidth, pmHeight);
+
+				destRect.moveCenter(painterRect.center());
+
+				painter.drawPixmap(destRect, *pm, srcRect);
+				break;
+			}
+			case ScalingMode::Tile:
+			{
+				const qreal tileWidth = pm->width() / dpr;
+				const qreal tileHeight = pm->height() / dpr;
+
+				if (tileWidth <= 0 || tileHeight <= 0)
+					break;
+
+				QPixmap tileSource = pm->scaled(tileWidth, tileHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+				tileSource.setDevicePixelRatio(dpr);
+
+				QBrush tileBrush(tileSource);
+				tileBrush.setTextureImage(tileSource.toImage());
+
+				painter.fillRect(painterRect, tileBrush);
+				break;
+			}
+			default:
+				break;
+		}
+		painter.end();
+		*pm = std::move(final_pixmap);
+	}
+
 	void ShowInFileExplorer(QWidget* parent, const QFileInfo& file)
 	{
 #if defined(_WIN32)
@@ -254,68 +371,6 @@ namespace QtUtils
 		widget->resize(width, height);
 	}
 
-	std::optional<WindowInfo> GetWindowInfoForWidget(QWidget* widget)
-	{
-		WindowInfo wi;
-
-		// Windows and Apple are easy here since there's no display connection.
-#if defined(_WIN32)
-		wi.type = WindowInfo::Type::Win32;
-		wi.window_handle = reinterpret_cast<void*>(widget->winId());
-#elif defined(__APPLE__)
-		wi.type = WindowInfo::Type::MacOS;
-		wi.window_handle = reinterpret_cast<void*>(widget->winId());
-#else
-		QPlatformNativeInterface* pni = QGuiApplication::platformNativeInterface();
-		const QString platform_name = QGuiApplication::platformName();
-		if (platform_name == QStringLiteral("xcb"))
-		{
-			// Can't get a handle for an unmapped window in X, it doesn't like it.
-			if (!widget->isVisible())
-			{
-				Console.WriteLn("Returning null window info for widget because it is not visible.");
-				return std::nullopt;
-			}
-
-			wi.type = WindowInfo::Type::X11;
-			wi.display_connection = pni->nativeResourceForWindow("display", widget->windowHandle());
-			wi.window_handle = reinterpret_cast<void*>(widget->winId());
-		}
-		else if (platform_name == QStringLiteral("wayland"))
-		{
-			wi.type = WindowInfo::Type::Wayland;
-			wi.display_connection = pni->nativeResourceForWindow("display", widget->windowHandle());
-			wi.window_handle = pni->nativeResourceForWindow("surface", widget->windowHandle());
-		}
-		else
-		{
-			Console.WriteLn("Unknown PNI platform '%s'.", platform_name.toUtf8().constData());
-			return std::nullopt;
-		}
-#endif
-
-		const qreal dpr = widget->devicePixelRatioF();
-		wi.surface_width = static_cast<u32>(static_cast<qreal>(widget->width()) * dpr);
-		wi.surface_height = static_cast<u32>(static_cast<qreal>(widget->height()) * dpr);
-		wi.surface_scale = static_cast<float>(dpr);
-
-		// Query refresh rate, we need it for sync.
-		std::optional<float> surface_refresh_rate = WindowInfo::QueryRefreshRateForWindow(wi);
-		if (!surface_refresh_rate.has_value())
-		{
-			// Fallback to using the screen, getting the rate for Wayland is an utter mess otherwise.
-			const QScreen* widget_screen = widget->screen();
-			if (!widget_screen)
-				widget_screen = QGuiApplication::primaryScreen();
-			surface_refresh_rate = widget_screen ? static_cast<float>(widget_screen->refreshRate()) : 0.0f;
-		}
-
-		wi.surface_refresh_rate = surface_refresh_rate.value();
-		INFO_LOG("Surface refresh rate: {} hz", wi.surface_refresh_rate);
-
-		return wi;
-	}
-
 	QString AbstractItemModelToCSV(QAbstractItemModel* model, int role, bool useQuotes)
 	{
 		QString csv;

pcsx2-qt/QtUtils.h

@@ -9,11 +9,20 @@
 #include <QtCore/QMetaType>
 #include <QtCore/QString>
 #include <QtCore/QAbstractItemModel>
+#include <QtGui/QGuiApplication>
+#include <QtGui/QWindow>
+#if !defined(_WIN32) and !defined(__APPLE__)
+#include <qpa/qplatformnativeinterface.h>
+#endif
+#include <QtGui/QScreen>
 #include <functional>
 #include <initializer_list>
 #include <string_view>
+#include <type_traits>
 #include <optional>
 
+#include "common/Console.h"
+
 class ByteStream;
 
 class QAction;
@@ -49,6 +58,20 @@ namespace QtUtils
 	void ResizeColumnsForTableView(QTableView* view, const std::initializer_list<int>& widths);
 	void ResizeColumnsForTreeView(QTreeView* view, const std::initializer_list<int>& widths);
 
+	enum struct ScalingMode
+	{
+		Fit,
+		Fill,
+		Stretch,
+		Center,
+		Tile,
+
+		MaxCount
+	};
+
+	/// Resize and scale a given Pixmap (and optionally adjust opacity)
+	void resizeAndScalePixmap(QPixmap* pm, const int expected_width, const int expected_height, const qreal dpr, const ScalingMode scaling_mode, const float opacity);
+
 	/// Returns a key id for a key event, including any modifiers that we need (e.g. Keypad).
 	/// NOTE: Defined in QtKeyCodes.cpp, not QtUtils.cpp.
 	u32 KeyEventToCode(const QKeyEvent* ev);
@@ -83,8 +106,82 @@ namespace QtUtils
 	/// Adjusts the fixed size for a window if it's not resizeable.
 	void ResizePotentiallyFixedSizeWindow(QWidget* widget, int width, int height);
 
-	/// Returns the common window info structure for a Qt widget.
-	std::optional<WindowInfo> GetWindowInfoForWidget(QWidget* widget);
+	/// Returns the common window info structure for a Qt Window/Widget.
+	template <class T>
+		requires std::is_base_of_v<QWidget, T> || std::is_base_of_v<QWindow, T>
+	std::optional<WindowInfo> GetWindowInfoForWindow(T* window)
+	{
+		WindowInfo wi;
+
+		// Windows and Apple are easy here since there's no display connection.
+#if defined(_WIN32)
+		wi.type = WindowInfo::Type::Win32;
+		wi.window_handle = reinterpret_cast<void*>(window->winId());
+#elif defined(__APPLE__)
+		wi.type = WindowInfo::Type::MacOS;
+		wi.window_handle = reinterpret_cast<void*>(window->winId());
+#else
+		QPlatformNativeInterface* pni = QGuiApplication::platformNativeInterface();
+		const QString platform_name = QGuiApplication::platformName();
+
+		QWindow* windowHandle;
+		if constexpr (std::is_base_of_v<QWidget, T>)
+			windowHandle = window->windowHandle();
+		else
+			windowHandle = window;
+
+		if (platform_name == QStringLiteral("xcb"))
+		{
+			// Can't get a handle for an unmapped window in X, it doesn't like it.
+			if (!window->isVisible())
+			{
+				Console.WriteLn("Returning null window info for widget because it is not visible.");
+				return std::nullopt;
+			}
+
+			wi.type = WindowInfo::Type::X11;
+			wi.display_connection = pni->nativeResourceForWindow("display", windowHandle);
+			wi.window_handle = reinterpret_cast<void*>(window->winId());
+		}
+		else if (platform_name == QStringLiteral("wayland"))
+		{
+			wi.type = WindowInfo::Type::Wayland;
+			wi.display_connection = pni->nativeResourceForWindow("display", windowHandle);
+			wi.window_handle = pni->nativeResourceForWindow("surface", windowHandle);
+		}
+		else
+		{
+			Console.WriteLn("Unknown PNI platform '%s'.", platform_name.toUtf8().constData());
+			return std::nullopt;
+		}
+#endif
+
+		qreal dpr;
+		if constexpr (std::is_base_of_v<QWidget, T>)
+			dpr = window->devicePixelRatioF();
+		else
+			dpr = window->devicePixelRatio();
+
+		wi.surface_width = static_cast<u32>(std::max(static_cast<int>(std::round(static_cast<qreal>(window->width()) * dpr)), 1));
+		wi.surface_height = static_cast<u32>(std::max(static_cast<int>(std::round(static_cast<qreal>(window->height()) * dpr)), 1));
+		wi.surface_scale = static_cast<float>(dpr);
+
+		// Query refresh rate, we need it for sync.
+		std::optional<float> surface_refresh_rate = WindowInfo::QueryRefreshRateForWindow(wi);
+		if (!surface_refresh_rate.has_value())
+		{
+			// Fallback to using the screen, getting the rate for Wayland is an utter mess otherwise.
+			const QScreen* widget_screen = window->screen();
+			if (!widget_screen)
+				widget_screen = QGuiApplication::primaryScreen();
+			surface_refresh_rate = widget_screen ? static_cast<float>(widget_screen->refreshRate()) : 0.0f;
+		}
+
+		wi.surface_refresh_rate = surface_refresh_rate.value();
+		INFO_LOG("Surface refresh rate: {} hz", wi.surface_refresh_rate);
+
+		return wi;
+	}
 
 	/// Converts a value to a QString of said value with a proper fixed width
 	template <typename T>

pcsx2-qt/Settings/AchievementLoginDialog.cpp

@@ -127,7 +127,25 @@ void AchievementLoginDialog::processLoginResult(bool result, const QString& mess
 		}
 	}
 
-	done(0);
+	// Show success messagebox
+	const std::string username = Host::GetBaseStringSettingValue("Achievements", "Username");
+	QMessageBox::information(
+		this, tr("Login Successful"),
+		tr("Successfully logged in to RetroAchievements as %1.").arg(QString::fromStdString(username)));
+	
+	m_ui.status->setText(tr("Successfully logged in as %1.").arg(QString::fromStdString(username)));
+	m_ui.status->setStyleSheet("color: green; font-weight: bold;");
+	
+	disconnect(m_ui.buttonBox, &QDialogButtonBox::accepted, this, &AchievementLoginDialog::loginClicked);
+	
+	m_login->setVisible(false);
+	QPushButton* dismissButton = m_ui.buttonBox->addButton(tr("&Dismiss"), QDialogButtonBox::AcceptRole);
+	dismissButton->setDefault(true);
+	dismissButton->setFocus();
+	
+	connect(dismissButton, &QPushButton::clicked, this, [this]() { done(0); });
+	
+	enableUI(false);
 }
 
 void AchievementLoginDialog::connectUi()

pcsx2-qt/Settings/DebugGSSettingsTab.ui

@@ -71,7 +71,21 @@
           </property>
          </widget>
         </item>
-        <item row="4" column="0">
+		<item row="4" column="0">
+		  <widget class="QCheckBox" name="saveDrawStats">
+		   <property name="text">
+		    <string>Save Draw Stats</string>
+		   </property>
+		  </widget>
+		</item>
+		<item row="4" column="1">
+		  <widget class="QCheckBox" name="saveFrameStats">
+		    <property name="text">
+		      <string>Save Frame Stats</string>
+		    </property>
+		  </widget>
+		</item>
+        <item row="5" column="0">
          <widget class="QCheckBox" name="saveTransferImages">
           <property name="text">
            <string>Save Transfer Image Data</string>

pcsx2-qt/Settings/DebugSettingsWidget.cpp

@@ -110,6 +110,8 @@ DebugSettingsWidget::DebugSettingsWidget(SettingsWindow* settings_dialog, QWidge
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_gs.saveAlpha, "EmuCore/GS", "SaveAlpha", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_gs.saveInfo, "EmuCore/GS", "SaveInfo", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_gs.saveTransferImages, "EmuCore/GS", "SaveTransferImages", false);
+	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_gs.saveDrawStats, "EmuCore/GS", "SaveDrawStats", false);
+	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_gs.saveFrameStats, "EmuCore/GS", "SaveFrameStats", false);
 	SettingWidgetBinder::BindWidgetToIntSetting(sif, m_gs.saveDrawStart, "EmuCore/GS", "SaveDrawStart", 0);
 	SettingWidgetBinder::BindWidgetToIntSetting(sif, m_gs.saveDrawCount, "EmuCore/GS", "SaveDrawCount", 5000);
 	SettingWidgetBinder::BindWidgetToIntSetting(sif, m_gs.saveFrameStart, "EmuCore/GS", "SaveFrameStart", 0);
@@ -215,6 +217,8 @@ void DebugSettingsWidget::onDrawDumpingChanged()
 	m_gs.saveAlpha->setEnabled(enabled);
 	m_gs.saveInfo->setEnabled(enabled);
 	m_gs.saveTransferImages->setEnabled(enabled);
+	m_gs.saveDrawStats->setEnabled(enabled);
+	m_gs.saveFrameStats->setEnabled(enabled);
 	m_gs.saveDrawStart->setEnabled(enabled);
 	m_gs.saveDrawCount->setEnabled(enabled);
 	m_gs.saveFrameStart->setEnabled(enabled);

pcsx2-qt/Settings/GameSummaryWidget.cpp

@@ -45,7 +45,8 @@ GameSummaryWidget::GameSummaryWidget(const GameList::Entry* entry, SettingsWindo
 	connect(m_ui.inputProfile, &QComboBox::currentIndexChanged, this, &GameSummaryWidget::onInputProfileChanged);
 	connect(m_ui.verify, &QAbstractButton::clicked, this, &GameSummaryWidget::onVerifyClicked);
 	connect(m_ui.searchHash, &QAbstractButton::clicked, this, &GameSummaryWidget::onSearchHashClicked);
-	connect(m_ui.checkWiki, &QAbstractButton::clicked, this, [this, entry]() { onCheckWikiClicked(entry); });
+	connect(m_ui.checkWiki, &QAbstractButton::clicked, this,
+		[this, serial = entry->serial]() { onCheckWikiClicked(serial); });
 
 	bool has_custom_title = false, has_custom_region = false;
 	GameList::CheckCustomAttributesForPath(m_entry_path, has_custom_title, has_custom_region);
@@ -366,9 +367,9 @@ void GameSummaryWidget::onSearchHashClicked()
 	QtUtils::OpenURL(this, fmt::format("http://redump.org/discs/quicksearch/{}", m_redump_search_keyword).c_str());
 }
 
-void GameSummaryWidget::onCheckWikiClicked(const GameList::Entry* entry)
+void GameSummaryWidget::onCheckWikiClicked(const std::string& serial)
 {
-	QtUtils::OpenURL(this, fmt::format("https://wiki.pcsx2.net/{}", entry->serial).c_str());
+	QtUtils::OpenURL(this, fmt::format("https://wiki.pcsx2.net/{}", serial).c_str());
 }
 
 void GameSummaryWidget::setVerifyResult(QString error)

pcsx2-qt/Settings/GameSummaryWidget.h

@@ -26,7 +26,7 @@ private Q_SLOTS:
 	void onDiscPathBrowseClicked();
 	void onVerifyClicked();
 	void onSearchHashClicked();
-	void onCheckWikiClicked(const GameList::Entry* entry);
+	void onCheckWikiClicked(const std::string& serial);
 
 private:
 	void populateInputProfiles();

pcsx2-qt/Settings/InterfaceSettingsWidget.cpp

@@ -6,13 +6,11 @@
 #include "Common.h"
 #include "Host.h"
 #include "MainWindow.h"
+#include "QtUtils.h"
 #include "SettingWidgetBinder.h"
 #include "SettingsWindow.h"
 #include "QtHost.h"
 
-static const char* IMAGE_FILE_FILTER = QT_TRANSLATE_NOOP(InterfaceSettingsWidget, 
-	"Supported Image Types (*.bmp *.gif *.jpg *.jpeg *.png *.webp)");
-
 const char* InterfaceSettingsWidget::THEME_NAMES[] = {
 	QT_TRANSLATE_NOOP("InterfaceSettingsWidget", "Native"),
 //: Ignore what Crowdin says in this string about "[Light]/[Dark]" being untouchable here, these are not variables in this case and must be translated.
@@ -75,6 +73,17 @@ const char* InterfaceSettingsWidget::THEME_VALUES[] = {
 	"Custom",
 	nullptr};
 
+const char* InterfaceSettingsWidget::BACKGROUND_SCALE_NAMES[] = {
+	"fit",
+	"fill",
+	"stretch",
+	"center",
+	"tile",
+	nullptr};
+
+const char* InterfaceSettingsWidget::IMAGE_FILE_FILTER = QT_TRANSLATE_NOOP("InterfaceSettingsWidget",
+	"Supported Image Types (*.bmp *.gif *.jpg *.jpeg *.png *.webp)");
+
 InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog, QWidget* parent)
 	: SettingsWidget(settings_dialog, parent)
 {
@@ -123,12 +132,12 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		QtHost::GetDefaultThemeName(), "InterfaceSettingsWidget");
 	connect(m_ui.theme, QOverload<int>::of(&QComboBox::currentIndexChanged), [this]() { emit themeChanged(); });
 
-	SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.backgroundOpacity, "UI", "GameListBackgroundOpacity", 100);
-	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.backgroundFill, "UI", "GameListBackgroundFill", false);
+	SettingWidgetBinder::BindWidgetToFloatSetting(sif, m_ui.backgroundOpacity, "UI", "GameListBackgroundOpacity", 100.0f);
+	SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.backgroundScale, "UI", "GameListBackgroundMode", BACKGROUND_SCALE_NAMES, QtUtils::ScalingMode::Fit);
 	connect(m_ui.backgroundBrowse, &QPushButton::clicked, [this]() { onSetGameListBackgroundTriggered(); });
 	connect(m_ui.backgroundReset, &QPushButton::clicked, [this]() { onClearGameListBackgroundTriggered(); });
-	connect(m_ui.backgroundOpacity, &QSpinBox::valueChanged, [this]() { emit backgroundChanged(); });
-	connect(m_ui.backgroundFill, &QCheckBox::checkStateChanged, [this]() {emit backgroundChanged(); });
+	connect(m_ui.backgroundOpacity, &QSpinBox::editingFinished, [this]() { emit backgroundChanged(); });
+	connect(m_ui.backgroundScale, QOverload<int>::of(&QComboBox::currentIndexChanged), [this]() { emit backgroundChanged(); });
 
 	populateLanguages();
 	SettingWidgetBinder::BindWidgetToStringSetting(sif, m_ui.language, "UI", "Language", QtHost::GetDefaultLanguage());
@@ -200,7 +209,7 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		tr("Shows the game you are currently playing as part of your profile in Discord."));
 	dialog()->registerWidgetHelp(
 		m_ui.mouseLock, tr("Enable Mouse Lock"), tr("Unchecked"),
-		tr("Locks the mouse cursor to the windows when PCSX2 is in focus and all other windows are closed.<br><b>Unavailable on Linux Wayland.</b><br><b>Requires accessibility permissions on macOS.</b><br><b>Limited support for mixed-resolution with non-100% DPI configurations.</b>"));
+		tr("Locks the mouse cursor to the windows when PCSX2 is in focus and all other windows are closed.<br><b>Unavailable on Linux Wayland.</b><br><b>Requires accessibility permissions on macOS.</b>"));
 	dialog()->registerWidgetHelp(
 		m_ui.doubleClickTogglesFullscreen, tr("Double-Click Toggles Fullscreen"), tr("Checked"),
 		tr("Allows switching in and out of fullscreen mode by double-clicking the game window."));
@@ -212,7 +221,7 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		tr("Automatically starts Big Picture Mode instead of the regular Qt interface when PCSX2 launches."));
 	dialog()->registerWidgetHelp(
 		m_ui.backgroundBrowse, tr("Game List Background"), tr("None"),
-		tr("Enable an animated / static background on the game list (where you launch your games).<br>"
+		tr("Enable an animated/static background on the game list (where you launch your games).<br>"
 		"This background is only visible in the library and will be hidden once a game is launched. It will also be paused when it's not in focus."));
 	dialog()->registerWidgetHelp(
 		m_ui.backgroundReset, tr("Disable/Reset Game List Background"), tr("None"),
@@ -221,8 +230,9 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		m_ui.backgroundOpacity, tr("Game List Background Opacity"), tr("100%"),
 		tr("Sets the opacity of the custom background."));
 	dialog()->registerWidgetHelp(
-		m_ui.backgroundFill, tr("Fill Image"), tr("Unchecked"),
-		tr("Expand the image to fill all available background area."));
+		m_ui.backgroundScale, tr("Background Image Scaling"), tr("Fit"),
+		tr("Select how to display the background image: <br><br>Fit (Preserve aspect ratio, fit to screen)"
+		   "<br>Fill (Preserve aspect ratio, fill the screen) <br>Stretch (Ignore aspect ratio) <br>Center (Centers the image without any scaling) <br>Tile (Repeat the image to fill the screen)"));
 
 	onRenderToSeparateWindowChanged();
 }
@@ -249,19 +259,14 @@ void InterfaceSettingsWidget::onSetGameListBackgroundTriggered()
 		return;
 
 	std::string relative_path = Path::MakeRelative(QDir::toNativeSeparators(path).toStdString(), EmuFolders::DataRoot);
-	Host::SetBaseBoolSettingValue("UI", "GameListBackgroundEnabled", true);
 	Host::SetBaseStringSettingValue("UI", "GameListBackgroundPath", relative_path.c_str());
 
-	if (!Host::ContainsBaseSettingValue("UI", "GameListBackgroundOpacity"))
-		Host::SetBaseFloatSettingValue("UI", "GameListBackgroundOpacity", 100.0f);
-
 	Host::CommitBaseSettingChanges();
 	emit backgroundChanged();
 }
 
 void InterfaceSettingsWidget::onClearGameListBackgroundTriggered()
 {
-	Host::SetBaseBoolSettingValue("UI", "GameListBackgroundEnabled", false);
 	Host::RemoveBaseSettingValue("UI", "GameListBackgroundPath");
 	Host::CommitBaseSettingChanges();
 	emit backgroundChanged();

pcsx2-qt/Settings/InterfaceSettingsWidget.h

@@ -33,4 +33,6 @@ private:
 public:
 	static const char* THEME_NAMES[];
 	static const char* THEME_VALUES[];
+	static const char* BACKGROUND_SCALE_NAMES[];
+	static const char* IMAGE_FILE_FILTER;
 };

pcsx2-qt/Settings/InterfaceSettingsWidget.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>725</width>
-    <height>617</height>
+    <height>625</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
@@ -224,9 +224,6 @@
         </item>
         <item>
          <widget class="QSpinBox" name="backgroundOpacity">
-          <property name="wrapping">
-           <bool>false</bool>
-          </property>
           <property name="buttonSymbols">
            <enum>QAbstractSpinBox::ButtonSymbols::PlusMinus</enum>
           </property>
@@ -251,10 +248,54 @@
          </widget>
         </item>
         <item>
-         <widget class="QCheckBox" name="backgroundFill">
-          <property name="text">
-           <string>Fill Image</string>
+         <widget class="QLabel" name="backgroundScaleLabel">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
           </property>
+          <property name="text">
+           <string>Scaling:</string>
+          </property>
+          <property name="buddy">
+           <cstring>backgroundScale</cstring>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="backgroundScale">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <item>
+           <property name="text">
+            <string>Fit</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Fill</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Stretch</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Center</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Tile</string>
+           </property>
+          </item>
          </widget>
         </item>
        </layout>
@@ -351,7 +392,7 @@
   <tabstop>backgroundBrowse</tabstop>
   <tabstop>backgroundReset</tabstop>
   <tabstop>backgroundOpacity</tabstop>
-  <tabstop>backgroundFill</tabstop>
+  <tabstop>backgroundScale</tabstop>
   <tabstop>autoUpdateTag</tabstop>
   <tabstop>autoUpdateEnabled</tabstop>
   <tabstop>checkForUpdates</tabstop>

pcsx2-qt/Settings/MemoryCardSettingsWidget.cpp

@@ -138,7 +138,7 @@ void MemoryCardSettingsWidget::autoSizeUI()
 void MemoryCardSettingsWidget::tryInsertCard(u32 slot, const QString& newCard)
 {
 	// handle where the card is dragged in from explorer or something
-	const int lastSlashPos = std::max(newCard.lastIndexOf('/'), newCard.lastIndexOf('\\'));
+	const qsizetype lastSlashPos = std::max(newCard.lastIndexOf('/'), newCard.lastIndexOf('\\'));
 	const std::string newCardStr(
 		(lastSlashPos >= 0) ? newCard.mid(0, lastSlashPos).toStdString() : newCard.toStdString());
 	if (newCardStr.empty())

pcsx2-qt/Translations.cpp

@@ -133,7 +133,7 @@ void QtHost::InstallTranslator(QWidget* dialog_parent)
 	if (!has_base_ts)
 	{
 		// Try without the country suffix.
-		const int index = language.lastIndexOf('-');
+		const qsizetype index = language.lastIndexOf('-');
 		if (index > 0)
 		{
 			base_path = QStringLiteral("%1/qt_%2.qm").arg(base_dir).arg(language.left(index));

pcsx2/Achievements.cpp

@@ -484,6 +484,13 @@ bool Achievements::CreateClient(rc_client_t** client, std::unique_ptr<HTTPDownlo
 
 	rc_client_set_userdata(new_client, http->get());
 
+	const std::string custom_host = Host::GetBaseStringSettingValue("Achievements", "Host", "");
+	if (!custom_host.empty())
+	{
+		Console.WriteLn("Achievements: Using custom host %s", custom_host.c_str());
+		rc_client_set_host(new_client, custom_host.c_str());
+	}
+
 	*client = new_client;
 	return true;
 }

pcsx2/CDVD/CDVD.cpp

@@ -35,7 +35,7 @@
 
 cdvdStruct cdvd;
 
-s64 PSXCLK = 36864000;
+u32 PSXCLK = 36864000;
 
 static constexpr s32 GMT9_OFFSET_SECONDS = 9 * 60 * 60; // 32400
 

pcsx2/Common.h

@@ -7,7 +7,7 @@
 
 static const u32 BIAS = 2;				// Bus is half of the actual ps2 speed
 static const u32 PS2CLK = 294912000;	//hz	/* 294.912 mhz */
-extern s64 PSXCLK;	/* 36.864 Mhz */
+extern u32 PSXCLK;	/* 36.864 Mhz */
 
 
 #include "Memory.h"
@@ -21,4 +21,4 @@ extern s64 PSXCLK;	/* 36.864 Mhz */
 #include <string>
 
 extern std::string ShiftJIS_ConvertString( const char* src );
-extern std::string ShiftJIS_ConvertString( const char* src, int maxlen );
+extern std::string ShiftJIS_ConvertString( const char* src, int maxlen );

pcsx2/Config.h

@@ -713,7 +713,7 @@ struct Pcsx2Config
 
 		union
 		{
-			u64 bitset[2];
+			u64 bitsets[2];
 
 			struct
 			{
@@ -778,6 +778,8 @@ struct Pcsx2Config
 					SaveAlpha : 1,
 					SaveInfo : 1,
 					SaveTransferImages : 1,
+					SaveDrawStats : 1,
+					SaveFrameStats : 1,
 					DumpReplaceableTextures : 1,
 					DumpReplaceableMipmaps : 1,
 					DumpTexturesWithFMVActive : 1,

pcsx2/Counters.cpp

@@ -252,7 +252,7 @@ static void vSyncInfoCalc(vSyncTimingInfo* info, double framesPerSecond, u32 sca
 	const u64 accumilatedHRenderError = (hRender % 10000) + (hBlank % 10000);
 	const u64 accumilatedHFractional = accumilatedHRenderError % 10000;
 	info->hRender += (u32)(accumilatedHRenderError / 10000);
-	info->hSyncError = (accumilatedHFractional * (scansPerFrame / (IsInterlacedVideoMode() ? 2 : 1))) / 10000;
+	info->hSyncError = (u32)((accumilatedHFractional * (scansPerFrame / (IsInterlacedVideoMode() ? 2 : 1))) / 10000);
 
 	// Note: In NTSC modes there is some small rounding error in the vsync too,
 	// however it would take thousands of frames for it to amount to anything and

pcsx2/DEV9/ATA/ATA_Transfer.cpp

@@ -105,7 +105,7 @@ bool ATA::IO_Write()
 		{
 			IO_SparseCacheUpdateLocation(imagePos + written);
 			// Align to sparse block size.
-			u32 writeSize = hddSparseBlockSize - ((imagePos + written) % hddSparseBlockSize);
+			u32 writeSize = static_cast<u32>(hddSparseBlockSize - ((imagePos + written) % hddSparseBlockSize));
 			// Limit to size of write.
 			writeSize = std::min(writeSize, entry.length - written);
 

pcsx2/DEV9/InternalServers/DNS_Server.cpp

@@ -160,7 +160,7 @@ namespace InternalServers
 			//Counts
 			ret->questions = dns.questions;
 
-			DNS_State* state = new DNS_State(reqs.size(), reqs, ret, payload->sourcePort);
+			DNS_State* state = new DNS_State(static_cast<int>(reqs.size()), reqs, ret, payload->sourcePort);
 			outstandingQueries++;
 
 			for (size_t i = 0; i < reqs.size(); i++)

pcsx2/DebugTools/BiosDebugData.cpp

@@ -8,22 +8,19 @@
 
 std::vector<std::unique_ptr<BiosThread>> getEEThreads()
 {
-	std::vector<std::unique_ptr<BiosThread>> threads;
-
-	if (CurrentBiosInformation.eeThreadListAddr <= 0)
-		return threads;
+	if (!VMManager::HasValidVM() || CurrentBiosInformation.eeThreadListAddr == 0)
+		return {};
 
 	const u32 start = CurrentBiosInformation.eeThreadListAddr & 0x3fffff;
 
+	std::vector<std::unique_ptr<BiosThread>> threads;
 	for (int tid = 0; tid < 256; tid++)
 	{
+		EEInternalThread* internal = static_cast<EEInternalThread*>(
+			PSM(start + tid * sizeof(EEInternalThread)));
 
-		EEInternalThread* internal = static_cast<EEInternalThread*>(PSM(start + tid * sizeof(EEInternalThread)));
-		if (internal->status != (int)ThreadStatus::THS_BAD)
-		{
-			auto thread = std::make_unique<EEThread>(tid, *internal);
-			threads.push_back(std::move(thread));
-		}
+		if (internal && internal->status != (int)ThreadStatus::THS_BAD)
+			threads.emplace_back(std::make_unique<EEThread>(tid, *internal));
 	}
 
 	return threads;
@@ -63,8 +60,7 @@ std::vector<std::unique_ptr<BiosThread>> getIOPThreads()
 
 		data.PC = iopMemRead32(data.SavedSP + 0x8c);
 
-		auto thread = std::make_unique<IOPThread>(data);
-		threads.push_back(std::move(thread));
+		threads.emplace_back(std::make_unique<IOPThread>(data));
 
 		item = iopMemRead32(item + 0x24);
 	}
@@ -93,7 +89,7 @@ std::vector<IopMod> getIOPModules()
 		if (i > 1000)
 			return {};
 
-		IopMod mod;
+		IopMod& mod = modlist.emplace_back();
 
 		u32 nstr = iopMemRead32(maddr + 4);
 		if (nstr)
@@ -113,8 +109,6 @@ std::vector<IopMod> getIOPModules()
 		mod.data_size = iopMemRead32(maddr + 0x20);
 		mod.bss_size = iopMemRead32(maddr + 0x24);
 
-		modlist.push_back(mod);
-
 		maddr = iopMemRead32(maddr);
 	}
 

pcsx2/DebugTools/MIPSAnalyst.cpp

@@ -186,7 +186,9 @@ namespace MIPSAnalyst
 		bool suspectedNoReturn = false;
 
 		u32 addr;
-		for (addr = startAddr; addr <= endAddr; addr += 4) {
+		for (u64 i = startAddr; i <= endAddr; i += 4) {
+			addr = static_cast<u32>(i);
+
 			// Use pre-existing symbol map info if available. May be more reliable.
 			ccc::FunctionHandle existing_symbol_handle = database.functions.first_handle_from_starting_address(addr);
 			const ccc::Function* existing_symbol = database.functions.symbol_from_handle(existing_symbol_handle);

pcsx2/DebugTools/MipsStackWalk.cpp

@@ -108,7 +108,7 @@ namespace MipsStackWalk
 
 		if (entry == INVALIDTARGET)
 		{
-			stop = std::max<s64>(0, (s64)start - LONGEST_FUNCTION);
+			stop = static_cast<u32>(std::max<s64>(0, (s64)start - LONGEST_FUNCTION));
 		}
 
 		for (u32 pc = start; cpu->isValidAddress(pc) && pc >= stop; pc -= 4)

pcsx2/Docs/Debugger.md

@@ -1,53 +0,0 @@
-<!-- PDF METADATA STARTS ---
-title: "PCSX2 - Debugger Documentation"
-date: "2021"
-footer-left: "[Document Source](https://github.com/PCSX2/pcsx2/blob/{LATEST-GIT-TAG}/pcsx2/Docs/Debugger.md)"
-urlcolor: "cyan"
-... PDF METADATA ENDS -->
-
-# Debugger Key Bindings
-
-## Disassembly View
--   `G`   -   goto
--   `E`   -   edit breakpoint
--   `D`   -   enable/disable breakpoint
--   `B`   -   add breakpoint
--   `M`   -   assemble opcode
--   `Right Arrow`   -   follow branch/position memory view to accessed address
--   `Left Arrow`   -   go back one branch level/goto pc
--   `Up Arrow`   -   move cursor up one line
--   `Down Arrow`   -   move cursor down one line
--   `Page Up`   -   move visible area up one page
--   `Page Down`   -   move visible area down one page
--   `F10`   -   step over
--   `F11`   -   step into
--   `Tab`   -   toggle display symbols
--   `Left Click`   -   select line/toggle breakpoint if line is already highlighted
--   `Right Click`   -   open context menu
-
-## Memory View
-
--   `G`   -   goto
--   `Ctrl+B`   -   add breakpoint
--   `Left Arrow`   -   move cursor back one byte/nibble
--   `Right Arrow`   -   move cursor ahead one byte/nibble
--   `Up Arrow`   -   move cursor up one line
--   `Down Arrow`   -   move cursor down one line
--   `Page Up`   -   move cursor up one page
--   `Page Down`   -   move cursor down one page
--   `0-9,A-F`   -   overwrite hex nibble
--   `any`   -   overwrite ansi byte
--   `Left Click`   -   select byte/nibble
--   `Right Click`   -   open context menu
--   `Ctrl+Mouse Wheel`   -   zoom memory view
--   `Esc`   -   return to previous goto address
--   `Ctrl+V`   -   paste a hex string into memory
--   `Enter/Return`   -   edit selected float
-
-## Breakpoint List
-
--   `Up Arrow`   -   select previous item
--   `Down Arrow`   -   select next item
--   `Delete`   - remove   selected breakpoint
--   `Enter/Return`   -   edit selected breakpoint
--   `Space`   - toggle   enable state of selected breakpoint

pcsx2/GS/GS.cpp

@@ -664,40 +664,36 @@ void GSgetStats(SmallStringBase& info)
 
 		if (pps >= 170000000)
 		{
-			pps /= 1073741824; // Gpps
+			pps /= _1gb; // Gpps
 			prefix = 'G';
 		}
 		else if (pps >= 35000000)
 		{
-			pps /= 1048576; // Mpps
+			pps /= _1mb; // Mpps
 			prefix = 'M';
 		}
-		else if (pps >= 1024)
+		else if (pps >= _1kb)
 		{
-			pps /= 1024;
-			prefix = 'K';
-		}
-		else
-		{
-			prefix = '\0';
+			pps /= _1kb; // kpps
+			prefix = 'k';
 		}
 
-		info.format("{} SW | {} SP | {} P | {} D | {:.2f} S | {:.2f} U | {:.2f} {}pps",
+		info.format("{} SW | {} SYNP | {} PRIM | {} DRW | {:.2f} SWIZ | {:.2f} UNSWIZ | {:.2f} {}pps",
 			api_name,
 			(int)pm.Get(GSPerfMon::SyncPoint),
 			(int)pm.Get(GSPerfMon::Prim),
 			(int)pm.Get(GSPerfMon::Draw),
-			pm.Get(GSPerfMon::Swizzle) / 1024,
-			pm.Get(GSPerfMon::Unswizzle) / 1024,
+			pm.Get(GSPerfMon::Swizzle) / _1kb,
+			pm.Get(GSPerfMon::Unswizzle) / _1kb,
 			pps, prefix);
 	}
 	else if (GSCurrentRenderer == GSRendererType::Null)
 	{
-		fmt::format_to(std::back_inserter(info), "{} Null", api_name);
+		info.format("{} Null", api_name);
 	}
 	else
 	{
-		info.format("{} HW | {} P | {} D | {} DC | {} B | {} RP | {} RB | {} TC | {} TU",
+		info.format("{} HW | {} PRIM | {} DRW | {} DRWC | {} BAR | {} RP | {} RB | {} TC | {} TU",
 			api_name,
 			(int)pm.Get(GSPerfMon::Prim),
 			(int)pm.Get(GSPerfMon::Draw),
@@ -713,30 +709,45 @@ void GSgetStats(SmallStringBase& info)
 void GSgetMemoryStats(SmallStringBase& info)
 {
 	if (!g_texture_cache)
+	{
+		info.assign("");
 		return;
+	}
 
-	const u64 targets = g_texture_cache->GetTargetMemoryUsage();
-	const u64 sources = g_texture_cache->GetSourceMemoryUsage();
-	const u64 hashcache = g_texture_cache->GetHashCacheMemoryUsage();
-	const u64 pool = g_gs_device->GetPoolMemoryUsage();
-	const u64 total = targets + sources + hashcache + pool;
+	// Get megabyte values. Round negligible values to 0.1 MB to avoid swamping.
+	const auto get_MB = [](const double bytes) {
+		return (bytes <= 0.0 ? bytes : std::max(0.1, bytes / static_cast<double>(_1mb)));
+	};
+
+	const auto format_precision = [](const double megabytes) -> std::string {
+		return (megabytes < 10.0 ?
+			fmt::format("{:.1f}", megabytes) :
+			fmt::format("{:.0f}", std::round(megabytes)));
+	};
+
+	const double targets_MB = get_MB(static_cast<double>(g_texture_cache->GetTargetMemoryUsage()));
+	const double sources_MB = get_MB(static_cast<double>(g_texture_cache->GetSourceMemoryUsage()));
+	const double pool_MB = get_MB(static_cast<double>(g_gs_device->GetPoolMemoryUsage()));
 
 	if (GSConfig.TexturePreloading == TexturePreloadingLevel::Full)
 	{
-		fmt::format_to(std::back_inserter(info), "VRAM: {} MB | T: {} MB | S: {} MB | H: {} MB | P: {} MB",
-			(int)std::ceil(total / 1048576.0f),
-			(int)std::ceil(targets / 1048576.0f),
-			(int)std::ceil(sources / 1048576.0f),
-			(int)std::ceil(hashcache / 1048576.0f),
-			(int)std::ceil(pool / 1048576.0f));
+		const double hashcache_MB = get_MB(static_cast<double>(g_texture_cache->GetHashCacheMemoryUsage()));
+		const double total_MB = targets_MB + sources_MB + hashcache_MB + pool_MB;
+		info.format("VRAM: {} MB | TGT: {} MB | SRC: {} MB | HC: {} MB | PL: {} MB",
+			format_precision(total_MB),
+			format_precision(targets_MB),
+			format_precision(sources_MB),
+			format_precision(hashcache_MB),
+			format_precision(pool_MB));
 	}
 	else
 	{
-		fmt::format_to(std::back_inserter(info), "VRAM: {} MB | T: {} MB | S: {} MB | P: {} MB",
-			(int)std::ceil(total / 1048576.0f),
-			(int)std::ceil(targets / 1048576.0f),
-			(int)std::ceil(sources / 1048576.0f),
-			(int)std::ceil(pool / 1048576.0f));
+		const double total_MB = targets_MB + sources_MB + pool_MB;
+		info.format("VRAM: {} MB | TGT: {} MB | SRC: {} MB | PL: {} MB",
+			format_precision(total_MB),
+			format_precision(targets_MB),
+			format_precision(sources_MB),
+			format_precision(pool_MB));
 	}
 }
 

pcsx2/GS/GSPerfMon.cpp

@@ -3,8 +3,10 @@
 
 #include "GSPerfMon.h"
 #include "GS.h"
+#include "GSUtil.h"
 
 #include <cstring>
+#include <inttypes.h>
 
 GSPerfMon g_perfmon;
 
@@ -41,3 +43,28 @@ void GSPerfMon::Update()
 
 	memset(m_counters, 0, sizeof(m_counters));
 }
+
+GSPerfMon GSPerfMon::operator-(const GSPerfMon& other)
+{
+	GSPerfMon diff;
+	for (std::size_t i = 0; i < std::size(diff.m_counters); i++)
+	{
+		diff.m_counters[i] = m_counters[i] - other.m_counters[i];
+	}
+	return diff;
+}
+
+void GSPerfMon::Dump(const std::string& filename, bool hw)
+{
+	FILE* fp = fopen(filename.c_str(), "w");
+	if (!fp)
+		return;
+
+	std::size_t last = hw ? CounterLastHW : CounterLastSW;
+	for (std::size_t i = 0; i < last; i++)
+	{
+		fprintf(fp, "%s: %" PRIu64 "\n", GSUtil::GetPerfMonCounterName(static_cast<counter_t>(i), hw), static_cast<u64>(m_counters[i]));
+	}
+
+	fclose(fp);
+}

pcsx2/GS/GSPerfMon.h

@@ -6,6 +6,7 @@
 #include "common/Pcsx2Defs.h"
 
 #include <ctime>
+#include <string>
 
 class GSPerfMon
 {
@@ -27,12 +28,15 @@ public:
 		// Reused counters for HW.
 		TextureCopies = Fillrate,
 		TextureUploads = SyncPoint,
+
+		CounterLastHW = CounterLast,
+		CounterLastSW = SyncPoint + 1
 	};
 
 protected:
 	double m_counters[CounterLast] = {};
 	double m_stats[CounterLast] = {};
-	u64 m_frame = 0;
+	int m_frame = 0;
 	clock_t m_lastframe = 0;
 	int m_count = 0;
 	int m_disp_fb_sprite_blits = 0;
@@ -42,8 +46,8 @@ public:
 
 	void Reset();
 
-	void SetFrame(u64 frame) { m_frame = frame; }
-	u64 GetFrame() { return m_frame; }
+	void SetFrame(int frame) { m_frame = frame; }
+	int GetFrame() { return m_frame; }
 	void EndFrame(bool frame_only);
 
 	void Put(counter_t c, double val) { m_counters[c] += val; }
@@ -58,6 +62,10 @@ public:
 		m_disp_fb_sprite_blits = 0;
 		return blits;
 	}
+
+	GSPerfMon operator-(const GSPerfMon& other);
+
+	void Dump(const std::string& filename, bool hw);
 };
 
-extern GSPerfMon g_perfmon;
+extern GSPerfMon g_perfmon;

pcsx2/GS/GSState.cpp

@@ -202,6 +202,9 @@ void GSState::Reset(bool hardware_reset)
 	m_backed_up_ctx = -1;
 
 	memcpy(&m_prev_env, &m_env, sizeof(m_prev_env));
+
+	m_perfmon_draw.Reset();
+	m_perfmon_frame.Reset();
 }
 
 template<bool auto_flush>
@@ -2125,6 +2128,16 @@ void GSState::FlushPrim()
 		g_perfmon.Put(GSPerfMon::Draw, 1);
 		g_perfmon.Put(GSPerfMon::Prim, m_index.tail / GSUtil::GetVertexCount(PRIM->PRIM));
 
+		if (GSConfig.ShouldDump(s_n, g_perfmon.GetFrame()))
+		{
+			if (GSConfig.SaveDrawStats)
+			{
+				m_perfmon_draw = g_perfmon - m_perfmon_draw;
+				m_perfmon_draw.Dump(GetDrawDumpPath("%05d_draw_stats.txt", s_n), GSIsHardwareRenderer());
+				m_perfmon_draw = g_perfmon;
+			}
+		}
+
 		m_index.tail = 0;
 		m_vertex.head = 0;
 
@@ -2429,8 +2442,8 @@ void GSState::InitReadFIFO(u8* mem, int len)
 	if (GSConfig.SaveRT && GSConfig.ShouldDump(s_n, g_perfmon.GetFrame()))
 	{
 		const std::string s(GetDrawDumpPath(
-			"%05d_read_%05x_%d_%d_%d_%d_%d_%d.bmp",
-			s_n, (int)m_env.BITBLTBUF.SBP, (int)m_env.BITBLTBUF.SBW, (int)m_env.BITBLTBUF.SPSM,
+			"%05d_read_%05x_%d_%s_%d_%d_%d_%d.bmp",
+			s_n, (int)m_env.BITBLTBUF.SBP, (int)m_env.BITBLTBUF.SBW, GSUtil::GetPSMName(m_env.BITBLTBUF.SPSM),
 			r.left, r.top, r.right, r.bottom));
 
 		m_mem.SaveBMP(s, m_env.BITBLTBUF.SBP, m_env.BITBLTBUF.SBW, m_env.BITBLTBUF.SPSM, r.right, r.bottom);

pcsx2/GS/GSState.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "GS/GS.h"
+#include "GS/GSPerfMon.h"
 #include "GS/GSLocalMemory.h"
 #include "GS/GSDrawingContext.h"
 #include "GS/GSDrawingEnvironment.h"
@@ -264,6 +265,9 @@ public:
 	static int s_last_transfer_draw_n;
 	static int s_transfer_n;
 
+	GSPerfMon m_perfmon_frame; // Track stat across a frame.
+	GSPerfMon m_perfmon_draw;  // Track stat across a draw.
+
 	static constexpr u32 STATE_VERSION = 9;
 
 	enum REG_DIRTY

pcsx2/GS/GSUtil.cpp

@@ -176,6 +176,40 @@ const char* GSUtil::GetACName(u32 ac)
 	return (ac < std::size(names)) ? names[ac] : "";
 }
 
+const char* GSUtil::GetPerfMonCounterName(GSPerfMon::counter_t counter, bool hw)
+{
+	if (hw)
+	{
+		static constexpr const char* names_hw[GSPerfMon::CounterLastHW] = {
+			"Prim",
+			"Draw",
+			"DrawCalls",
+			"Readbacks",
+			"Swizzle",
+			"Unswizzle",
+			"TextureCopies",
+			"TextureUploads",
+			"Barriers",
+			"RenderPasses"
+		};
+		return counter < std::size(names_hw) ? names_hw[counter] : "";
+	}
+	else
+	{
+		static constexpr const char* names_sw[GSPerfMon::CounterLastSW] = {
+			"Prim",
+			"Draw",
+			"DrawCalls",
+			"Readbacks",
+			"Swizzle",
+			"Unswizzle",
+			"Fillrate",
+			"SyncPoint"
+		};
+		return counter < std::size(names_sw) ? names_sw[counter] : "";
+	}
+}
+
 const u32* GSUtil::HasSharedBitsPtr(u32 dpsm)
 {
 	return s_maps.SharedBitsField[dpsm];

pcsx2/GS/GSUtil.h

@@ -5,6 +5,7 @@
 
 #include "GS.h"
 #include "GSRegs.h"
+#include "GSPerfMon.h"
 
 class GSUtil
 {
@@ -25,6 +26,7 @@ public:
 	static const char* GetTFXName(u32 tfx);
 	static const char* GetTCCName(u32 tcc);
 	static const char* GetACName(u32 ac);
+	static const char* GetPerfMonCounterName(GSPerfMon::counter_t counter, bool hw = true);
 
 	static const u32* HasSharedBitsPtr(u32 dpsm);
 	static bool HasSharedBits(u32 spsm, const u32* ptr);

pcsx2/GS/Renderers/Common/GSDevice.cpp

@@ -723,6 +723,39 @@ GSTexture* GSDevice::CreateTexture(int w, int h, int mipmap_levels, GSTexture::F
 	return FetchSurface(GSTexture::Type::Texture, w, h, levels, format, false, m_features.prefer_new_textures && !prefer_reuse);
 }
 
+void GSDevice::DoStretchRectWithAssertions(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear)
+{
+	pxAssert((dTex && dTex->IsDepthStencil()) == HasDepthOutput(shader));
+	pxAssert(linear ? SupportsBilinear(shader) : SupportsNearest(shader));
+	GL_INS("StretchRect(%d) {%d,%d} %dx%d -> {%d,%d) %dx%d", shader, int(sRect.left), int(sRect.top),
+		int(sRect.right - sRect.left), int(sRect.bottom - sRect.top), int(dRect.left), int(dRect.top),
+		int(dRect.right - dRect.left), int(dRect.bottom - dRect.top));
+	DoStretchRect(sTex, sRect, dTex, dRect, cms, shader, linear);
+}
+
+void GSDevice::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	bool red, bool green, bool blue, bool alpha, ShaderConvert shader)
+{
+	GSHWDrawConfig::ColorMaskSelector cms;
+
+	cms.wr = red;
+	cms.wg = green;
+	cms.wb = blue;
+	cms.wa = alpha;
+
+	pxAssert(HasVariableWriteMask(shader));
+	GL_INS("ColorCopy Red:%d Green:%d Blue:%d Alpha:%d", cms.wr, cms.wg, cms.wb, cms.wa);
+
+	DoStretchRectWithAssertions(sTex, sRect, dTex, dRect, cms, shader, false);
+}
+
+void GSDevice::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	ShaderConvert shader, bool linear)
+{
+	DoStretchRectWithAssertions(sTex, sRect, dTex, dRect, GSHWDrawConfig::ColorMaskSelector(ShaderConvertWriteMask(shader)), shader, linear);
+}
+
 void GSDevice::StretchRect(GSTexture* sTex, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader, bool linear)
 {
 	StretchRect(sTex, GSVector4(0, 0, 1, 1), dTex, dRect, shader, linear);
@@ -734,11 +767,11 @@ void GSDevice::DrawMultiStretchRects(
 	for (u32 i = 0; i < num_rects; i++)
 	{
 		const MultiStretchRect& sr = rects[i];
-		pxAssert(shader == ShaderConvert::COPY || shader == ShaderConvert::RTA_CORRECTION || rects[0].wmask.wrgba == 0xf);
+		pxAssert(HasVariableWriteMask(shader) || rects[0].wmask.wrgba == 0xf);
 		if (rects[0].wmask.wrgba != 0xf)
 		{
 			g_gs_device->StretchRect(sr.src, sr.src_rect, dTex, sr.dst_rect, rects[0].wmask.wr,
-				rects[0].wmask.wg, rects[0].wmask.wb, rects[0].wmask.wa);
+				rects[0].wmask.wg, rects[0].wmask.wb, rects[0].wmask.wa, shader);
 		}
 		else
 		{

pcsx2/GS/Renderers/Common/GSDevice.h

@@ -69,6 +69,27 @@ enum class ShaderInterlace
 	Count
 };
 
+static inline bool HasVariableWriteMask(ShaderConvert shader)
+{
+	switch (shader)
+	{
+		case ShaderConvert::COPY:
+		case ShaderConvert::RTA_CORRECTION:
+			return true;
+		default:
+			return false;
+	}
+}
+
+static inline int GetShaderIndexForMask(ShaderConvert shader, int mask)
+{
+	pxAssert(HasVariableWriteMask(shader));
+	int index = mask;
+	if (shader == ShaderConvert::RTA_CORRECTION)
+		index |= 1 << 4;
+	return index;
+}
+
 static inline bool HasDepthOutput(ShaderConvert shader)
 {
 	switch (shader)
@@ -549,6 +570,7 @@ struct alignas(16) GSHWDrawConfig
 		constexpr ColorMaskSelector(): key(0xF) {}
 		constexpr ColorMaskSelector(u8 c): key(0) { wrgba = c; }
 	};
+
 #pragma pack(pop)
 	struct alignas(16) VSConstantBuffer
 	{
@@ -560,11 +582,11 @@ struct alignas(16) GSHWDrawConfig
 		GSVector2i max_depth;
 		__fi VSConstantBuffer()
 		{
-			memset(this, 0, sizeof(*this));
+			memset(static_cast<void*>(this), 0, sizeof(*this));
 		}
 		__fi VSConstantBuffer(const VSConstantBuffer& other)
 		{
-			memcpy(this, &other, sizeof(*this));
+			memcpy(static_cast<void*>(this), static_cast<const void*>(&other), sizeof(*this));
 		}
 		__fi VSConstantBuffer& operator=(const VSConstantBuffer& other)
 		{
@@ -584,7 +606,7 @@ struct alignas(16) GSHWDrawConfig
 			if (*this == other)
 				return false;
 
-			memcpy(this, &other, sizeof(*this));
+			memcpy(static_cast<void*>(this), static_cast<const void*>(&other), sizeof(*this));
 			return true;
 		}
 	};
@@ -609,11 +631,11 @@ struct alignas(16) GSHWDrawConfig
 
 		__fi PSConstantBuffer()
 		{
-			memset(this, 0, sizeof(*this));
+			memset(static_cast<void*>(this), 0, sizeof(*this));
 		}
 		__fi PSConstantBuffer(const PSConstantBuffer& other)
 		{
-			memcpy(this, &other, sizeof(*this));
+			memcpy(static_cast<void*>(this), static_cast<const void*>(&other), sizeof(*this));
 		}
 		__fi PSConstantBuffer& operator=(const PSConstantBuffer& other)
 		{
@@ -633,7 +655,7 @@ struct alignas(16) GSHWDrawConfig
 			if (*this == other)
 				return false;
 
-			memcpy(this, &other, sizeof(*this));
+			memcpy(static_cast<void*>(this), static_cast<const void*>(&other), sizeof(*this));
 			return true;
 		}
 	};
@@ -922,6 +944,12 @@ protected:
 	/// Perform texture operations for ImGui
 	void UpdateImGuiTextures();
 
+protected:
+	// Entry point to the renderer-specific StretchRect code.
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) = 0;
+	void DoStretchRectWithAssertions(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear);
+
 public:
 	GSDevice();
 	virtual ~GSDevice();
@@ -1037,9 +1065,9 @@ public:
 	virtual std::unique_ptr<GSDownloadTexture> CreateDownloadTexture(u32 width, u32 height, GSTexture::Format format) = 0;
 
 	virtual void CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r, u32 destX, u32 destY) = 0;
-	virtual void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true) = 0;
-	virtual void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) = 0;
 
+	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY);
+	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true);
 	void StretchRect(GSTexture* sTex, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true);
 
 	/// Performs a screen blit for display. If dTex is null, it assumes you are writing to the system framebuffer/swap chain.

pcsx2/GS/Renderers/Common/GSRenderer.cpp

@@ -591,6 +591,13 @@ void GSRenderer::VSync(u32 field, bool registers_written, bool idle_frame)
 
 		if (GSConfig.SaveTransferImages)
 			DumpTransferImages();
+
+		if (GSConfig.SaveFrameStats)
+		{
+			m_perfmon_frame = g_perfmon - m_perfmon_frame;
+			m_perfmon_frame.Dump(GetDrawDumpPath("%05d_f%05lld_frame_stats.txt", s_n, g_perfmon.GetFrame()), GSIsHardwareRenderer());
+			m_perfmon_frame = g_perfmon;
+		}
 	}
 
 	const int fb_sprite_blits = g_perfmon.GetDisplayFramebufferSpriteBlits();

pcsx2/GS/Renderers/DX11/GSDevice11.cpp

@@ -1274,28 +1274,18 @@ void GSDevice11::CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r,
 	dTex->SetState(GSTexture::State::Dirty);
 }
 
-void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader, bool linear)
+void GSDevice11::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear)
 {
-	pxAssert(dTex->IsDepthStencil() == HasDepthOutput(shader));
-	pxAssert(linear ? SupportsBilinear(shader) : SupportsNearest(shader));
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), nullptr,
-		m_convert.bs[ShaderConvertWriteMask(shader)].get(), linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), nullptr, m_convert.bs[cms.wrgba].get(), linear);
 }
 
-void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear)
+void GSDevice11::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear)
 {
-	StretchRect(sTex, sRect, dTex, dRect, ps, ps_cb, m_convert.bs[D3D11_COLOR_WRITE_ENABLE_ALL].get(), linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, ps, ps_cb, m_convert.bs[D3D11_COLOR_WRITE_ENABLE_ALL].get(), linear);
 }
 
-void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader)
-{
-	const u8 index = static_cast<u8>(red) | (static_cast<u8>(green) << 1) | (static_cast<u8>(blue) << 2) |
-	                 (static_cast<u8>(alpha) << 3);
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), nullptr,
-		m_convert.bs[index].get(), false);
-}
-
-void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear)
+void GSDevice11::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear)
 {
 	CommitClear(sTex);
 
@@ -1439,7 +1429,7 @@ void GSDevice11::UpdateCLUTTexture(GSTexture* sTex, float sScale, u32 offsetX, u
 
 	const GSVector4 dRect(0, 0, dSize, 1);
 	const ShaderConvert shader = (dSize == 16) ? ShaderConvert::CLUT_4 : ShaderConvert::CLUT_8;
-	StretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
+	DoStretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
 }
 
 void GSDevice11::ConvertToIndexedTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, u32 SBW, u32 SPSM, GSTexture* dTex, u32 DBW, u32 DPSM)
@@ -1457,7 +1447,7 @@ void GSDevice11::ConvertToIndexedTexture(GSTexture* sTex, float sScale, u32 offs
 
 	const GSVector4 dRect(0, 0, dTex->GetWidth(), dTex->GetHeight());
 	const ShaderConvert shader = ((SPSM & 0xE) == 0) ? ShaderConvert::RGBA_TO_8I : ShaderConvert::RGB5A1_TO_8I;
-	StretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
+	DoStretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
 }
 
 void GSDevice11::FilteredDownsampleTexture(GSTexture* sTex, GSTexture* dTex, u32 downsample_factor, const GSVector2i& clamp_min, const GSVector4& dRect)
@@ -1477,7 +1467,7 @@ void GSDevice11::FilteredDownsampleTexture(GSTexture* sTex, GSTexture* dTex, u32
 	m_ctx->UpdateSubresource(m_merge.cb.get(), 0, nullptr, &cb, 0, 0);
 
 	const ShaderConvert shader = ShaderConvert::DOWNSAMPLE_COPY;
-	StretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
+	DoStretchRect(sTex, GSVector4::zero(), dTex, dRect, m_convert.ps[static_cast<int>(shader)].get(), m_merge.cb.get(), nullptr, false);
 }
 
 void GSDevice11::DrawMultiStretchRects(const MultiStretchRect* rects, u32 num_rects, GSTexture* dTex, ShaderConvert shader)
@@ -1596,7 +1586,7 @@ void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	// Save 2nd output
 	if (feedback_write_2)
 	{
-		StretchRect(dTex, full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
+		DoStretchRect(dTex, full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
 			m_merge.cb.get(), nullptr, linear);
 	}
 
@@ -1607,12 +1597,12 @@ void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 	if (sTex[0])
 	{
 		// 1st output is enabled. It must be blended
-		StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[PMODE.MMOD].get(), m_merge.cb.get(), m_merge.bs.get(), linear);
+		DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[PMODE.MMOD].get(), m_merge.cb.get(), m_merge.bs.get(), linear);
 	}
 
 	if (feedback_write_1)
 	{
-		StretchRect(dTex, full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
+		DoStretchRect(dTex, full_r, sTex[2], dRect[2], m_convert.ps[static_cast<int>(ShaderConvert::YUV)].get(),
 			m_merge.cb.get(), nullptr, linear);
 	}
 }
@@ -1621,7 +1611,7 @@ void GSDevice11::DoInterlace(GSTexture* sTex, const GSVector4& sRect, GSTexture*
 {
 	m_ctx->UpdateSubresource(m_interlace.cb.get(), 0, nullptr, &cb, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[static_cast<int>(shader)].get(), m_interlace.cb.get(), linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[static_cast<int>(shader)].get(), m_interlace.cb.get(), linear);
 }
 
 void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
@@ -1647,7 +1637,7 @@ void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
 			return;
 	}
 
-	StretchRect(sTex, sRect, dTex, dRect, m_fxaa_ps.get(), nullptr, true);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_fxaa_ps.get(), nullptr, true);
 }
 
 void GSDevice11::DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float params[4])
@@ -1659,7 +1649,7 @@ void GSDevice11::DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float para
 
 	m_ctx->UpdateSubresource(m_shadeboost.cb.get(), 0, nullptr, params, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps.get(), m_shadeboost.cb.get(), false);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps.get(), m_shadeboost.cb.get(), false);
 }
 
 void GSDevice11::SetupVS(VSSelector sel, const GSHWDrawConfig::VSConstantBuffer* cb)
@@ -2158,7 +2148,7 @@ void GSDevice11::RenderImGui()
 	m_ctx->IASetVertexBuffers(0, 1, m_vb.addressof(), &m_state.vb_stride, &vb_offset);
 }
 
-void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, SetDATM datm)
+void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, SetDATM datm, const GSVector4i& bbox)
 {
 	// sfex3 (after the capcom logo), vf4 (first menu fading in), ffxii shadows, rumble roses shadows, persona4 shadows
 
@@ -2179,6 +2169,17 @@ void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vert
 
 	// ia
 
+	const GSVector4 src = GSVector4(bbox) / GSVector4(ds->GetSize()).xyxy();
+	const GSVector4 dst = src * 2.0f - 1.0f;
+
+	const GSVertexPT1 vertices[] =
+	{
+		{GSVector4(dst.x, -dst.y, 0.5f, 1.0f), GSVector2(src.x, src.y)},
+		{GSVector4(dst.z, -dst.y, 0.5f, 1.0f), GSVector2(src.z, src.y)},
+		{GSVector4(dst.x, -dst.w, 0.5f, 1.0f), GSVector2(src.x, src.w)},
+		{GSVector4(dst.z, -dst.w, 0.5f, 1.0f), GSVector2(src.z, src.w)},
+	};
+
 	IASetVertexBuffer(vertices, sizeof(vertices[0]), 4);
 	IASetInputLayout(m_convert.il.get());
 	IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
@@ -2447,7 +2448,7 @@ void GSDevice11::PSUnbindConflictingSRVs(GSTexture* tex1, GSTexture* tex2)
 	bool changed = false;
 	for (size_t i = 0; i < m_state.ps_sr_views.size(); i++)
 	{
-		if ((tex1 && m_state.ps_sr_views[i] == *(GSTexture11*)tex1) || (tex2 && m_state.ps_sr_views[i] == *(GSTexture11*)tex2))
+		if ((tex1 && m_state.ps_sr_views[i] == *static_cast<GSTexture11*>(tex1)) || (tex2 && m_state.ps_sr_views[i] == *static_cast<GSTexture11*>(tex2)))
 		{
 			m_state.ps_sr_views[i] = nullptr;
 			changed = true;
@@ -2624,6 +2625,8 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 		}
 	}
 
+	// Destination Alpha Setup
+	const bool multidraw_fb_copy = m_features.multidraw_fb_copy && (config.require_one_barrier || config.require_full_barrier);
 	GSTexture* primid_texture = nullptr;
 	if (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::PrimIDTracking)
 	{
@@ -2634,25 +2637,12 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 			return;
 		}
 
-		StretchRect(colclip_rt ? colclip_rt : config.rt, GSVector4(config.drawarea) / GSVector4(rtsize).xyxy(),
+		DoStretchRect(colclip_rt ? colclip_rt : config.rt, GSVector4(config.drawarea) / GSVector4(rtsize).xyxy(),
 			primid_texture, GSVector4(config.drawarea), m_date.primid_init_ps[static_cast<u8>(config.datm)].get(), nullptr, false);
 	}
 	else if (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::Stencil ||
-			 config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne)
-	{
-		const GSVector4 src = GSVector4(config.drawarea) / GSVector4(config.ds->GetSize()).xyxy();
-		const GSVector4 dst = src * 2.0f - 1.0f;
-
-		GSVertexPT1 vertices[] =
-		{
-			{GSVector4(dst.x, -dst.y, 0.5f, 1.0f), GSVector2(src.x, src.y)},
-			{GSVector4(dst.z, -dst.y, 0.5f, 1.0f), GSVector2(src.z, src.y)},
-			{GSVector4(dst.x, -dst.w, 0.5f, 1.0f), GSVector2(src.x, src.w)},
-			{GSVector4(dst.z, -dst.w, 0.5f, 1.0f), GSVector2(src.z, src.w)},
-		};
-
-		SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, vertices, config.datm);
-	}
+			 (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne && !multidraw_fb_copy))
+		SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, config.datm, config.drawarea);
 
 	if (config.vs.expand != GSHWDrawConfig::VSExpand::None)
 	{
@@ -2697,8 +2687,13 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	}
 	IASetPrimitiveTopology(topology);
 
+	// Depth testing and sampling, bind resource as dsv read only and srv at the same time without the need of a copy.
+	ID3D11DepthStencilView* read_only_dsv = nullptr;
+	if (config.tex && config.tex == config.ds)
+		read_only_dsv = static_cast<GSTexture11*>(config.ds)->ReadOnlyDepthStencilView();
+
 	// Should be called before changing local srv state.
-	PSUnbindConflictingSRVs(colclip_rt ? colclip_rt : config.rt, config.ds);
+	PSUnbindConflictingSRVs(colclip_rt ? colclip_rt : config.rt, read_only_dsv ? nullptr : config.ds);
 
 	if (config.tex)
 	{
@@ -2714,11 +2709,6 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	SetupVS(config.vs, &config.cb_vs);
 	SetupPS(config.ps, &config.cb_ps, config.sampler);
 
-	// Depth testing and sampling, bind resource as dsv read only and srv at the same time without the need of a copy.
-	ID3D11DepthStencilView* read_only_dsv = nullptr;
-	if (config.tex && config.tex == config.ds)
-		read_only_dsv = static_cast<GSTexture11*>(config.ds)->ReadOnlyDepthStencilView();
-
 	if (primid_texture)
 	{
 		OMDepthStencilSelector dss = config.depth;
@@ -2766,6 +2756,11 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 
 	OMSetRenderTargets(draw_rt, draw_ds, &config.scissor, read_only_dsv);
 	SetupOM(config.depth, OMBlendSelector(config.colormask, config.blend), config.blend.constant);
+
+	// Clear stencil as close as possible to the RT bind, to avoid framebuffer swaps.
+	if (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne && multidraw_fb_copy)
+		m_ctx->ClearDepthStencilView(*static_cast<GSTexture11*>(draw_ds), D3D11_CLEAR_STENCIL, 0.0f, 1);
+
 	SendHWDraw(config, draw_rt_clone, draw_rt, config.require_one_barrier, config.require_full_barrier, false);
 
 	if (config.blend_multi_pass.enable)

pcsx2/GS/Renderers/DX11/GSDevice11.h

@@ -253,6 +253,10 @@ private:
 	D3D11ShaderCache m_shader_cache;
 	std::string m_tfx_source;
 
+protected:
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) override;
+
 public:
 	GSDevice11();
 	~GSDevice11() override;
@@ -298,10 +302,8 @@ public:
 
 	void CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r, u32 destX, u32 destY) override;
 
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear = true);
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear = true);
+	void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear);
+	void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear);
 	void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) override;
 	void UpdateCLUTTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, GSTexture* dTex, u32 dOffset, u32 dSize) override;
 	void ConvertToIndexedTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, u32 SBW, u32 SPSM, GSTexture* dTex, u32 DBW, u32 DPSM) override;
@@ -309,7 +311,7 @@ public:
 	void DrawMultiStretchRects(const MultiStretchRect* rects, u32 num_rects, GSTexture* dTex, ShaderConvert shader) override;
 	void DoMultiStretchRects(const MultiStretchRect* rects, u32 num_rects, const GSVector2& ds);
 
-	void SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, SetDATM datm);
+	void SetupDATE(GSTexture* rt, GSTexture* ds, SetDATM datm, const GSVector4i& bbox);
 
 	void* IAMapVertexBuffer(u32 stride, u32 count);
 	void IAUnmapVertexBuffer(u32 stride, u32 count);

pcsx2/GS/Renderers/DX12/GSDevice12.cpp

@@ -1425,30 +1425,17 @@ void GSDevice12::CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r,
 	dTex12->SetState(GSTexture::State::Dirty);
 }
 
-void GSDevice12::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
-	ShaderConvert shader /* = ShaderConvert::COPY */, bool linear /* = true */)
+void GSDevice12::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear)
 {
-	pxAssert(HasDepthOutput(shader) == (dTex && dTex->GetType() == GSTexture::Type::DepthStencil));
-
-	GL_INS("StretchRect(%d) {%d,%d} %dx%d -> {%d,%d) %dx%d", shader, int(sRect.left), int(sRect.top),
-		int(sRect.right - sRect.left), int(sRect.bottom - sRect.top), int(dRect.left), int(dRect.top),
-		int(dRect.right - dRect.left), int(dRect.bottom - dRect.top));
-
+	const bool allow_discard = (cms.wrgba == 0xf);
+	const ID3D12PipelineState* state;
+	if (HasVariableWriteMask(shader))
+		state = m_color_copy[GetShaderIndexForMask(shader, cms.wrgba)].get();
+	else
+		state = dTex ? m_convert[static_cast<int>(shader)].get() : m_present[static_cast<int>(shader)].get();
 	DoStretchRect(static_cast<GSTexture12*>(sTex), sRect, static_cast<GSTexture12*>(dTex), dRect,
-		dTex ? m_convert[static_cast<int>(shader)].get() : m_present[static_cast<int>(shader)].get(), linear,
-		ShaderConvertWriteMask(shader) == 0xf);
-}
-
-void GSDevice12::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
-	bool green, bool blue, bool alpha, ShaderConvert shader)
-{
-	GL_PUSH("ColorCopy Red:%d Green:%d Blue:%d Alpha:%d", red, green, blue, alpha);
-
-	const u32 index = (red ? 1 : 0) | (green ? 2 : 0) | (blue ? 4 : 0) | (alpha ? 8 : 0);
-	int rta_offset = (shader == ShaderConvert::RTA_CORRECTION) ? 16 : 0;
-	const bool allow_discard = (index == 0xf);
-	DoStretchRect(static_cast<GSTexture12*>(sTex), sRect, static_cast<GSTexture12*>(dTex), dRect,
-		m_color_copy[index + rta_offset].get(), false, allow_discard);
+		state, linear, allow_discard);
 }
 
 void GSDevice12::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
@@ -1639,10 +1626,10 @@ void GSDevice12::DoMultiStretchRects(
 	SetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 	SetUtilityTexture(rects[0].src, rects[0].linear ? m_linear_sampler_cpu : m_point_sampler_cpu);
 
-	pxAssert(shader == ShaderConvert::COPY || shader == ShaderConvert::RTA_CORRECTION || rects[0].wmask.wrgba == 0xf);
-	int rta_bit = (shader == ShaderConvert::RTA_CORRECTION) ? 16 : 0;
-	SetPipeline((rects[0].wmask.wrgba != 0xf) ? m_color_copy[rects[0].wmask.wrgba | rta_bit].get() :
-												m_convert[static_cast<int>(shader)].get());
+	pxAssert(HasVariableWriteMask(shader) || rects[0].wmask.wrgba == 0xf);
+	SetPipeline((rects[0].wmask.wrgba != 0xf) ?
+		m_color_copy[GetShaderIndexForMask(shader, rects[0].wmask.wrgba)].get() :
+		m_convert[static_cast<int>(shader)].get());
 
 	if (ApplyUtilityState())
 		DrawIndexedPrimitive();
@@ -3831,8 +3818,12 @@ GSTexture12* GSDevice12::SetupPrimitiveTrackingDATE(GSHWDrawConfig& config, Pipe
 void GSDevice12::RenderHW(GSHWDrawConfig& config)
 {
 	// Destination Alpha Setup
-	const bool stencil_DATE = (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::Stencil ||
-							   config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne);
+	const bool stencil_DATE_One = config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne;
+	const bool stencil_DATE = (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::Stencil || stencil_DATE_One);
+
+	// TODO: Backport from vk.
+	if (stencil_DATE_One)
+		config.ps.date = 0;
 
 	GSTexture12* colclip_rt = static_cast<GSTexture12*>(g_gs_device->GetColorClipTexture());
 	GSTexture12* draw_rt = static_cast<GSTexture12*>(config.rt);
@@ -3940,9 +3931,6 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config)
 			{
 				Console.Warning("D3D12: Failed to allocate ColorClip render target, aborting draw.");
 
-				if (draw_rt_clone)
-					Recycle(draw_rt_clone);
-
 				if (date_image)
 					Recycle(date_image);
 
@@ -3964,15 +3952,16 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config)
 			}
 
 			// we're not drawing to the RT, so we can use it as a source
-			if (config.require_one_barrier)
+			if (config.require_one_barrier && !m_features.multidraw_fb_copy)
 				PSSetShaderResource(2, draw_rt, true);
 		}
 
 		draw_rt = colclip_rt;
 	}
 
-	// Clear texture binding when it's bound to RT, DSV will be read only.
-	if (draw_rt && static_cast<GSTexture12*>(draw_rt)->GetSRVDescriptor() == m_tfx_textures[0])
+	// Clear texture binding when it's bound to RT or DS.
+	if (!config.tex && ((draw_rt && static_cast<GSTexture12*>(draw_rt)->GetSRVDescriptor() == m_tfx_textures[0]) ||
+		(draw_ds && static_cast<GSTexture12*>(draw_ds)->GetSRVDescriptor() == m_tfx_textures[0])))
 		PSSetShaderResource(0, nullptr, false);
 
 	if (m_in_render_pass && (m_current_render_target == draw_rt || m_current_depth_target == draw_ds))

pcsx2/GS/Renderers/DX12/GSDevice12.h

@@ -390,6 +390,10 @@ private:
 
 	void DestroyResources();
 
+protected:
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) override;
+
 public:
 	GSDevice12();
 	~GSDevice12() override;
@@ -428,10 +432,6 @@ public:
 
 	void CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r, u32 destX, u32 destY) override;
 
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
-		ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
-		bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) override;
 	void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
 		PresentShader shader, float shaderTime, bool linear) override;
 	void UpdateCLUTTexture(

pcsx2/GS/Renderers/HW/GSRendererHW.cpp

@@ -26,7 +26,7 @@ GSRendererHW::GSRendererHW()
 	// Hope nothing requires too many draw calls.
 	m_drawlist.reserve(2048);
 
-	memset(&m_conf, 0, sizeof(m_conf));
+	memset(static_cast<void*>(&m_conf), 0, sizeof(m_conf));
 
 	ResetStates();
 }
@@ -1760,7 +1760,7 @@ bool GSRendererHW::IsUsingAsInBlend()
 }
 bool GSRendererHW::ChannelsSharedTEX0FRAME()
 {
-	if (!IsRTWritten() && !m_cached_ctx.TEST.DATE)
+	if (!m_cached_ctx.TEST.DATE && !IsRTWritten())
 		return false;
 
 	return GSUtil::GetChannelMask(m_cached_ctx.FRAME.PSM, m_cached_ctx.FRAME.FBMSK) & GSUtil::GetChannelMask(m_cached_ctx.TEX0.PSM);
@@ -1778,7 +1778,7 @@ bool GSRendererHW::IsTBPFrameOrZ(u32 tbp, bool frame_only)
 	const u32 fm_mask = GSLocalMemory::m_psm[m_cached_ctx.FRAME.PSM].fmsk;
 
 	const u32 max_z = (0xFFFFFFFF >> (GSLocalMemory::m_psm[m_cached_ctx.ZBUF.PSM].fmt * 8));
-	const bool no_rt = (!IsRTWritten() && !m_cached_ctx.TEST.DATE);
+	const bool no_rt = (!m_cached_ctx.TEST.DATE && !IsRTWritten());
 	const bool no_ds = (
 	                       // Depth is always pass/fail (no read) and write are discarded.
 	                       (zm != 0 && m_cached_ctx.TEST.ZTST <= ZTST_ALWAYS) ||
@@ -2517,7 +2517,7 @@ void GSRendererHW::Draw()
 	// 2/ SuperMan really draws (0,0,0,0) color and a (0) 32-bits depth
 	// 3/ 50cents really draws (0,0,0,128) color and a (0) 24 bits depth
 	// Note: FF DoC has both buffer at same location but disable the depth test (write?) with ZTE = 0
-	bool no_rt = (!IsRTWritten() && !m_cached_ctx.TEST.DATE);
+	bool no_rt = (!m_cached_ctx.TEST.DATE && !IsRTWritten());
 	const bool all_depth_tests_pass = IsDepthAlwaysPassing();
 	bool no_ds = (zm != 0 && all_depth_tests_pass) ||
 	             // No color or Z being written.
@@ -3151,18 +3151,28 @@ void GSRendererHW::Draw()
 					m_cached_ctx.ZBUF.ZMSK = (new_zm != 0);
 					fm = new_fm;
 					zm = new_zm;
-					no_rt = no_rt || (!IsRTWritten() && !m_cached_ctx.TEST.DATE);
+					no_rt = no_rt || (!m_cached_ctx.TEST.DATE && !IsRTWritten());
 					no_ds = no_ds || (zm != 0 && all_depth_tests_pass) ||
 					        // Depth will be written through the RT
 					        (!no_rt && m_cached_ctx.FRAME.FBP == m_cached_ctx.ZBUF.ZBP && !PRIM->TME && zm == 0 && (fm & fm_mask) == 0 && m_cached_ctx.TEST.ZTE) ||
 					        // No color or Z being written.
 					        (no_rt && zm != 0);
-					if (no_rt && no_ds)
-					{
-						GL_INS("HW: Late draw cancel because no pixels pass alpha test.");
-						CleanupDraw(true);
-						return;
-					}
+				}
+				else
+				{
+					no_rt = no_rt || (!m_cached_ctx.TEST.DATE && !IsRTWritten());
+					no_ds = no_ds ||
+					        // Depth will be written through the RT
+					        (!no_rt && m_cached_ctx.FRAME.FBP == m_cached_ctx.ZBUF.ZBP && !PRIM->TME && zm == 0 && (fm & fm_mask) == 0 && m_cached_ctx.TEST.ZTE) ||
+					        // No color or Z being written.
+					        (no_rt && zm != 0);
+				}
+
+				if (no_rt && no_ds)
+				{
+					GL_INS("HW: Late draw cancel.");
+					CleanupDraw(true);
+					return;
 				}
 			}
 		}
@@ -5750,8 +5760,7 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo
 	// Replace Ad with As, blend flags will be used from As since we are chaging the blend_index value.
 	// Must be done before index calculation, after blending equation optimizations
 	const bool blend_ad = m_conf.ps.blend_c == 1;
-	const bool alpha_mask = (m_cached_ctx.FRAME.FBMSK & 0xFF000000) == 0xFF000000;
-	bool blend_ad_alpha_masked = blend_ad && alpha_mask;
+	bool blend_ad_alpha_masked = blend_ad && !m_conf.colormask.wa;
 	const bool is_basic_blend = GSConfig.AccurateBlendingUnit != AccBlendLevel::Minimum;
 	if (blend_ad_alpha_masked && (((is_basic_blend || (COLCLAMP.CLAMP == 0)) && (features.texture_barrier || features.multidraw_fb_copy))
 		|| ((GSConfig.AccurateBlendingUnit >= AccBlendLevel::Medium) || m_conf.require_one_barrier)))
@@ -6717,7 +6726,9 @@ __ri void GSRendererHW::EmulateTextureSampler(const GSTextureCache::Target* rt,
 		// Bigger problem when WH is 1024x1024 and the target is only small.
 		// This "fixes" a lot of the rainbow garbage in games when upscaling (and xenosaga shadows + VP2 forest seem quite happy).
 		// Note that this is done on the original texture scale, during upscales it can mess up otherwise.
-		const GSVector4 region_clamp_offset = GSVector4::cxpr(0.5f, 0.5f, 0.1f, 0.1f);
+		const GSVector4 region_clamp_offset = ((GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::Native && tex->GetScale() > 1.0f) && !m_channel_shuffle) ? 
+												(GSVector4::cxpr(1.0f, 1.0f, 0.1f, 0.1f) + (GSVector4::cxpr(0.1f, 0.1f, 0.0f, 0.0f) * tex->GetScale())) :
+		                                         GSVector4::cxpr(0.5f, 0.5f, 0.1f, 0.1f);
 
 		const GSVector4 region_clamp = (GSVector4(clamp) + region_clamp_offset) / WH.xyxy();
 		if (wms >= CLAMP_REGION_CLAMP)
@@ -7237,7 +7248,7 @@ void GSRendererHW::ResetStates()
 {
 	// We don't want to zero out the constant buffers, since fields used by the current draw could result in redundant uploads.
 	// This memset should be pretty efficient - the struct is 16 byte aligned, as is the cb_vs offset.
-	memset(&m_conf, 0, reinterpret_cast<const char*>(&m_conf.cb_vs) - reinterpret_cast<const char*>(&m_conf));
+	memset(static_cast<void*>(&m_conf), 0, reinterpret_cast<const char*>(&m_conf.cb_vs) - reinterpret_cast<const char*>(&m_conf));
 }
 
 __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Target* ds, GSTextureCache::Source* tex, const TextureMinMaxResult& tmm)
@@ -7652,6 +7663,21 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 	if ((!IsOpaque() || m_context->ALPHA.IsBlack()) && rt && ((m_conf.colormask.wrgba & 0x7) || (m_texture_shuffle && !m_copy_16bit_to_target_shuffle && !m_same_group_texture_shuffle)))
 	{
 		EmulateBlending(blend_alpha_min, blend_alpha_max, DATE, DATE_PRIMID, DATE_BARRIER, rt, can_scale_rt_alpha, new_scale_rt_alpha);
+
+		// Similar to IsRTWritten(), check if the rt will change.
+		const bool no_rt = (!DATE && !m_conf.colormask.wrgba && !m_channel_shuffle);
+		const bool no_ds = !m_conf.ds ||
+			// Depth will be written through the RT.
+			(!no_rt && m_cached_ctx.FRAME.FBP == m_cached_ctx.ZBUF.ZBP && !PRIM->TME && m_cached_ctx.ZBUF.ZMSK == 0 &&
+				(m_cached_ctx.FRAME.FBMSK & GSLocalMemory::m_psm[m_cached_ctx.FRAME.PSM].fmsk) == 0 && m_cached_ctx.TEST.ZTE) ||
+			// No color or Z being written.
+			(no_rt && m_cached_ctx.ZBUF.ZMSK != 0);
+
+		if (no_rt && no_ds)
+		{
+			GL_INS("HW: Late draw cancel EmulateBlending().");
+			return;
+		}
 	}
 	else
 	{
@@ -7669,6 +7695,11 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 		}
 	}
 
+	// Always swap DATE with DATE_BARRIER if we have barriers on when alpha write is masked.
+	// This is always enabled on vk/gl but not on dx11/12 as copies are slow so we can selectively enable it like now.
+	if (DATE && !m_conf.colormask.wa && (m_conf.require_one_barrier || m_conf.require_full_barrier))
+		DATE_BARRIER = true;
+
 	if ((m_conf.ps.tex_is_fb && rt && rt->m_rt_alpha_scale) || (tex && tex->m_from_target && tex->m_target_direct && tex->m_from_target->m_rt_alpha_scale))
 		m_conf.ps.rta_source_correction = 1;
 
@@ -7908,7 +7939,8 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 	}
 	else if (DATE_one)
 	{
-		if (features.texture_barrier)
+		const bool multidraw_fb_copy = features.multidraw_fb_copy && (m_conf.require_one_barrier || m_conf.require_full_barrier);
+		if (features.texture_barrier || multidraw_fb_copy)
 		{
 			m_conf.require_one_barrier = true;
 			m_conf.ps.date = 5 + m_cached_ctx.TEST.DATM;
@@ -9401,8 +9433,8 @@ GSHWDrawConfig& GSRendererHW::BeginHLEHardwareDraw(
 
 	// Bit gross, but really no other way to ensure there's nothing of the last draw left over.
 	GSHWDrawConfig& config = m_conf;
-	std::memset(&config.cb_vs, 0, sizeof(config.cb_vs));
-	std::memset(&config.cb_ps, 0, sizeof(config.cb_ps));
+	std::memset(static_cast<void*>(&config.cb_vs), 0, sizeof(config.cb_vs));
+	std::memset(static_cast<void*>(&config.cb_ps), 0, sizeof(config.cb_ps));
 
 	// Reused between draws, since the draw config is shared, you can't have multiple draws in flight anyway.
 	static GSVertex vertices[4];
@@ -9535,4 +9567,4 @@ std::size_t GSRendererHW::ComputeDrawlistGetSize(float scale)
 		GetPrimitiveOverlapDrawlist(true, save_bbox, scale);
 	}
 	return m_drawlist.size();
-}
+}

pcsx2/GS/Renderers/HW/GSTextureCache.cpp

@@ -1347,6 +1347,11 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const bool is_color, const
 	int x_offset = 0;
 	int y_offset = 0;
 
+	// Indicates that in looking for targets that match the source BP, we found a perfect BP match
+	// but the target's valid area was outside the required area for the source. In such cases
+	// we want to create a temporary source and load the data from memory.
+	bool target_bp_hit_outside_valid_area = false;
+
 #ifdef DISABLE_HW_TEXTURE_CACHE
 	if (0)
 #else
@@ -1723,8 +1728,17 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const bool is_color, const
 						{
 							const bool outside_target = !t->Overlaps(bp, bw, psm, r);
 
-							if (!possible_shuffle && TEX0.PSM == PSMT8 && outside_target)
+							if (!possible_shuffle && outside_target)
 							{
+								// Hit a target but source required area outside the target's valid area.
+								target_bp_hit_outside_valid_area = true;
+								GL_CACHE(
+									"TC: LookupSource: Target BP match but outside valid area;"
+									" Source=(BP=%04x, BW=%d, PSM=%s, req=(%x,%x - %x,%x));"
+									" Target=(BP=%04x, BW=%d, PSM=%s, valid_area=(%x,%x - %x,%x))",
+									bp, bw, GSUtil::GetPSMName(psm), r.x, r.y, r.z, r.w,
+									t->m_TEX0.TBP0, t->m_TEX0.TBW, GSUtil::GetPSMName(t->m_TEX0.PSM),
+									t->m_valid.x, t->m_valid.y, t->m_valid.z, t->m_valid.w);
 								continue;
 							}
 							else
@@ -2034,7 +2048,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const bool is_color, const
 		//
 		// Sigh... They don't help us.
 
-		if (!found_t && !dst && !GSConfig.UserHacks_DisableDepthSupport)
+		if (!found_t && !dst && !GSConfig.UserHacks_DisableDepthSupport && !target_bp_hit_outside_valid_area)
 		{
 			// Let's try a trick to avoid to use wrongly a depth buffer
 			// Unfortunately, I don't have any Arc the Lad testcase
@@ -2172,7 +2186,7 @@ GSTextureCache::Source* GSTextureCache::LookupSource(const bool is_color, const
 			}
 		}
 
-		src = CreateSource(src_TEX0, TEXA, dst, x_offset, y_offset, lod, &rect, gpu_clut, region);
+		src = CreateSource(src_TEX0, TEXA, dst, x_offset, y_offset, lod, &rect, gpu_clut, region, target_bp_hit_outside_valid_area && TEX0.PSM != PSMT8);
 		if (!src) [[unlikely]]
 			return nullptr;
 	}
@@ -2649,8 +2663,10 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(GIFRegTEX0 TEX0, const GSVe
 			for (auto i = list.begin(); i != list.end(); ++i)
 			{
 				Target* t = *i;
+				const bool half_buffer_match = GSConfig.UserHacks_TextureInsideRt >= GSTextureInRtMode::InsideTargets && TEX0.TBW == t->m_TEX0.TBW && TEX0.PSM == t->m_TEX0.PSM &&
+												bp == GSLocalMemory::GetStartBlockAddress(t->m_TEX0.TBP0, t->m_TEX0.TBW, t->m_TEX0.PSM, GSVector4i(0, size.y, size.x, size.y + 1));
 				// Make sure the target is inside the texture
-				if (t->m_TEX0.TBP0 <= bp && bp <= t->m_end_block && t->Inside(bp, TEX0.TBW, TEX0.PSM, GSVector4i::loadh(size)))
+				if (t->m_TEX0.TBP0 <= bp && bp <= t->m_end_block && (half_buffer_match || t->Inside(bp, TEX0.TBW, TEX0.PSM, GSVector4i::loadh(size))))
 				{
 					if (dst && (GSState::s_n - dst->m_last_draw) < (GSState::s_n - t->m_last_draw))
 						continue;
@@ -4760,9 +4776,6 @@ void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r
 		{
 			Target* t = *it;
 
-			if (t->m_32_bits_fmt && t->m_TEX0.PSM > PSMCT24)
-				t->m_TEX0.PSM = PSMCT32;
-
 			const bool exact_bp = t->m_TEX0.TBP0 == bp;
 			// pass 0 == Exact match, pass 1 == partial match
 			if (pass == 0)
@@ -5776,7 +5789,7 @@ void GSTextureCache::IncAge()
 }
 
 //Fixme: Several issues in here. Not handling depth stencil, pitch conversion doesnt work.
-GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, Target* dst, int x_offset, int y_offset, const GSVector2i* lod, const GSVector4i* src_range, GSTexture* gpu_clut, SourceRegion region)
+GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, Target* dst, int x_offset, int y_offset, const GSVector2i* lod, const GSVector4i* src_range, GSTexture* gpu_clut, SourceRegion region, bool force_temp)
 {
 	const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
 	Source* src = new Source(TEX0, TEXA);
@@ -6242,7 +6255,7 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
 	}
 	else
 	{
-		if (GSUtil::GetChannelMask(TEX0.PSM) == 0xf && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.Block() && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->ZBUF.Block())
+		if (GSUtil::GetChannelMask(TEX0.PSM) == 0xf && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.Block() && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->ZBUF.Block() && !force_temp)
 		{
 			// Kill any possible targets we missed, they might be wrong now.
 			g_texture_cache->InvalidateVideoMemType(GSTextureCache::RenderTarget, TEX0.TBP0, TEX0.PSM, GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.FBMSK, true);
@@ -6250,7 +6263,7 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
 		}
 
 		// kill source immediately after the draw if it's the RT, because that'll get invalidated immediately.
-		if (GSRendererHW::GetInstance()->IsTBPFrameOrZ(TEX0.TBP0, true) && GSRendererHW::GetInstance()->ChannelsSharedTEX0FRAME())
+		if (force_temp || (GSRendererHW::GetInstance()->IsTBPFrameOrZ(TEX0.TBP0, true) && GSRendererHW::GetInstance()->ChannelsSharedTEX0FRAME()))
 		{
 			GL_CACHE("TC: Source == RT before RT creation, invalidating after draw.");
 			m_temporary_source = src;
@@ -6905,6 +6918,24 @@ GSTexture* GSTextureCache::LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVec
 			GL_INS("TC: Exact match on BP 0x%04x BW %u", t->m_TEX0.TBP0, t->m_TEX0.TBW);
 			this_offset.x = 0;
 			this_offset.y = 0;
+
+			// If we're using native scaling we can take this opertunity to downscale the target, it should maintain this.
+			if (GSConfig.UserHacks_NativeScaling != GSNativeScaling::Off && t->m_scale > 1.0f)
+			{
+				GSTexture* tex = t->m_type == RenderTarget ? g_gs_device->CreateRenderTarget(t->m_unscaled_size.x, t->m_unscaled_size.y, GSTexture::Format::Color, false) :
+															 g_gs_device->CreateDepthStencil(t->m_unscaled_size.x, t->m_unscaled_size.y, GSTexture::Format::DepthStencil, false);
+				if (!tex)
+					return nullptr;
+
+				g_gs_device->StretchRect(t->m_texture, GSVector4(0, 0, 1, 1), tex, GSVector4(GSVector4i::loadh(t->m_unscaled_size)), (t->m_type == RenderTarget) ? ShaderConvert::COPY : ShaderConvert::DEPTH_COPY, false);
+				g_perfmon.Put(GSPerfMon::TextureCopies, 1);
+				m_target_memory_usage = (m_target_memory_usage - t->m_texture->GetMemUsage()) + tex->GetMemUsage();
+				g_gs_device->Recycle(t->m_texture);
+			
+				t->m_texture = tex;
+				t->m_scale = 1.0f;
+				t->m_downscaled = true;
+			}
 		}
 		else if (GSConfig.UserHacks_GPUTargetCLUTMode == GSGPUTargetCLUTMode::InsideTarget &&
 				 t->m_TEX0.TBP0 < CBP && t->m_end_block >= CBP)

pcsx2/GS/Renderers/HW/GSTextureCache.h

@@ -445,7 +445,7 @@ protected:
 	std::unique_ptr<GSDownloadTexture> m_uint16_download_texture;
 	std::unique_ptr<GSDownloadTexture> m_uint32_download_texture;
 
-	Source* CreateSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, Target* t, int x_offset, int y_offset, const GSVector2i* lod, const GSVector4i* src_range, GSTexture* gpu_clut, SourceRegion region);
+	Source* CreateSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, Target* t, int x_offset, int y_offset, const GSVector2i* lod, const GSVector4i* src_range, GSTexture* gpu_clut, SourceRegion region, bool force_temporary = false);
 
 	bool PreloadTarget(GIFRegTEX0 TEX0, const GSVector2i& size, const GSVector2i& valid_size, bool is_frame,
 		bool preload, bool preserve_target, const GSVector4i draw_rect, Target* dst, GSTextureCache::Source* src = nullptr);

pcsx2/GS/Renderers/Metal/GSDeviceMTL.h

@@ -407,8 +407,6 @@ public:
 	void DrawStretchRect(const GSVector4& sRect, const GSVector4& dRect, const GSVector2& ds);
 	/// Copy from a position in sTex to the same position in the currently active render encoder using the given fs pipeline and rect
 	void RenderCopy(GSTexture* sTex, id<MTLRenderPipelineState> pipeline, const GSVector4i& rect);
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) override;
 	void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) override;
 	void DrawMultiStretchRects(const MultiStretchRect* rects, u32 num_rects, GSTexture* dTex, ShaderConvert shader) override;
 	void UpdateCLUTTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, GSTexture* dTex, u32 dOffset, u32 dSize) override;
@@ -452,6 +450,10 @@ public:
 
 	void RenderImGui(ImDrawData* data);
 	u32 FrameNo() const { return m_frame; }
+
+protected:
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) override;
 };
 
 static constexpr bool IsCommandBufferCompleted(MTLCommandBufferStatus status)

pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm

@@ -1600,33 +1600,21 @@ void GSDeviceMTL::RenderCopy(GSTexture* sTex, id<MTLRenderPipelineState> pipelin
 	g_perfmon.Put(GSPerfMon::DrawCalls, 1);
 }
 
-void GSDeviceMTL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader, bool linear)
+void GSDeviceMTL::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear)
 { @autoreleasepool {
 
-	pxAssert(linear ? SupportsBilinear(shader) : SupportsNearest(shader));
-
-	id<MTLRenderPipelineState> pipeline = m_convert_pipeline[static_cast<int>(shader)];
+	const LoadAction load_action = (cms.wrgba == 0xf) ? LoadAction::DontCareIfFull : LoadAction::Load;
+	id<MTLRenderPipelineState> pipeline;
+	if (HasVariableWriteMask(shader))
+		pipeline = m_convert_pipeline_copy_mask[GetShaderIndexForMask(shader, cms.wrgba)];
+	else
+		pipeline = m_convert_pipeline[static_cast<int>(shader)];
 	pxAssertRel(pipeline, fmt::format("No pipeline for {}", shaderName(shader)).c_str());
 
-	const LoadAction load_action = (ShaderConvertWriteMask(shader) == 0xf) ? LoadAction::DontCareIfFull : LoadAction::Load;
 	DoStretchRect(sTex, sRect, dTex, dRect, pipeline, linear, load_action, nullptr, 0);
 }}
 
-void GSDeviceMTL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader)
-{ @autoreleasepool {
-	int sel = 0;
-	if (red)   sel |= 1;
-	if (green) sel |= 2;
-	if (blue)  sel |= 4;
-	if (alpha) sel |= 8;
-	if (shader == ShaderConvert::RTA_CORRECTION) sel |= 16;
-	const int color_sel = sel & 15;
-
-	id<MTLRenderPipelineState> pipeline = m_convert_pipeline_copy_mask[sel];
-
-	DoStretchRect(sTex, sRect, dTex, dRect, pipeline, false, color_sel == 15 ? LoadAction::DontCareIfFull : LoadAction::Load, nullptr, 0);
-}}
-
 static_assert(sizeof(DisplayConstantBuffer) == sizeof(GSMTLPresentPSUniform));
 static_assert(offsetof(DisplayConstantBuffer, SourceRect)          == offsetof(GSMTLPresentPSUniform, source_rect));
 static_assert(offsetof(DisplayConstantBuffer, TargetRect)          == offsetof(GSMTLPresentPSUniform, target_rect));
@@ -1683,9 +1671,9 @@ void GSDeviceMTL::DrawMultiStretchRects(const MultiStretchRect* rects, u32 num_r
 		const u32 end = i * 4;
 		const u32 vertex_count = end - start;
 		const u32 index_count = vertex_count + (vertex_count >> 1); // 6 indices per 4 vertices
-		const int rta_bit = shader == ShaderConvert::RTA_CORRECTION ? 16 : 0;
+		pxAssert(HasVariableWriteMask(shader) || wmask == 0xf);
 		id<MTLRenderPipelineState> new_pipeline = wmask == 0xf ? m_convert_pipeline[static_cast<int>(shader)]
-		                                                       : m_convert_pipeline_copy_mask[wmask | rta_bit];
+		                                                       : m_convert_pipeline_copy_mask[GetShaderIndexForMask(shader, wmask)];
 		if (new_pipeline != pipeline)
 		{
 			pipeline = new_pipeline;

pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp

@@ -272,8 +272,8 @@ bool GSDeviceOGL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 		m_index_stream_buffer->Bind();
 
 		// Force UBOs to be uploaded on first use.
-		std::memset(&m_vs_cb_cache, 0xFF, sizeof(m_vs_cb_cache));
-		std::memset(&m_ps_cb_cache, 0xFF, sizeof(m_ps_cb_cache));
+		std::memset(static_cast<void*>(&m_vs_cb_cache), 0xFF, sizeof(m_vs_cb_cache));
+		std::memset(static_cast<void*>(&m_ps_cb_cache), 0xFF, sizeof(m_ps_cb_cache));
 
 		static_assert(sizeof(GSVertexPT1) == sizeof(GSVertex), "wrong GSVertex size");
 		for (u32 i = 0; i < 8; i++)
@@ -1253,7 +1253,7 @@ GSTexture* GSDeviceOGL::InitPrimDateTexture(GSTexture* rt, const GSVector4i& are
 		return nullptr;
 
 	GL_PUSH("PrimID Destination Alpha Clear");
-	StretchRect(rt, GSVector4(area) / GSVector4(rtsize).xyxy(), tex, GSVector4(area), m_date.primid_ps[static_cast<u8>(datm)], false);
+	DoStretchRect(rt, GSVector4(area) / GSVector4(rtsize).xyxy(), tex, GSVector4(area), m_date.primid_ps[static_cast<u8>(datm)], false);
 	return tex;
 }
 
@@ -1472,31 +1472,20 @@ void GSDeviceOGL::CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r
 	dTex->SetState(GSTexture::State::Dirty);
 }
 
-void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader, bool linear)
+void GSDeviceOGL::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	OMColorMaskSelector cms, ShaderConvert shader, bool linear)
 {
-	pxAssert(dTex->IsDepthStencil() == HasDepthOutput(shader));
-	pxAssert(linear ? SupportsBilinear(shader) : SupportsNearest(shader));
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[(int)shader], false, OMColorMaskSelector(ShaderConvertWriteMask(shader)), linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_convert.ps[static_cast<int>(shader)], false, cms, linear);
 }
 
-void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool linear)
+void GSDeviceOGL::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	const GLProgram& ps, bool linear)
 {
-	StretchRect(sTex, sRect, dTex, dRect, ps, false, OMColorMaskSelector(), linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, ps, false, OMColorMaskSelector(), linear);
 }
 
-void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader)
-{
-	OMColorMaskSelector cms;
-
-	cms.wr = red;
-	cms.wg = green;
-	cms.wb = blue;
-	cms.wa = alpha;
-
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[(int)shader], false, cms, false);
-}
-
-void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool alpha_blend, OMColorMaskSelector cms, bool linear)
+void GSDeviceOGL::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	const GLProgram& ps, bool alpha_blend, OMColorMaskSelector cms, bool linear)
 {
 	CommitClear(sTex, true);
 
@@ -1816,12 +1805,12 @@ void GSDeviceOGL::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 			// Blend with a constant alpha
 			m_merge_obj.ps[1].Bind();
 			m_merge_obj.ps[1].Uniform4fv(0, GSVector4::unorm8(c).v);
-			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[1], true, OMColorMaskSelector(), linear);
+			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[1], true, OMColorMaskSelector(), linear);
 		}
 		else
 		{
 			// Blend with 2 * input alpha
-			StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[0], true, OMColorMaskSelector(), linear);
+			DoStretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge_obj.ps[0], true, OMColorMaskSelector(), linear);
 		}
 	}
 
@@ -1836,7 +1825,7 @@ void GSDeviceOGL::DoInterlace(GSTexture* sTex, const GSVector4& sRect, GSTexture
 	m_interlace.ps[static_cast<int>(shader)].Bind();
 	m_interlace.ps[static_cast<int>(shader)].Uniform4fv(0, cb.ZrH.F32);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[static_cast<int>(shader)], linear);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[static_cast<int>(shader)], linear);
 }
 
 bool GSDeviceOGL::CompileFXAAProgram()
@@ -1875,7 +1864,7 @@ void GSDeviceOGL::DoFXAA(GSTexture* sTex, GSTexture* dTex)
 	const GSVector4 sRect(0, 0, 1, 1);
 	const GSVector4 dRect(0, 0, s.x, s.y);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_fxaa.ps, true);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_fxaa.ps, true);
 }
 
 bool GSDeviceOGL::CompileShadeBoostProgram()
@@ -1909,10 +1898,10 @@ void GSDeviceOGL::DoShadeBoost(GSTexture* sTex, GSTexture* dTex, const float par
 	const GSVector4 sRect(0, 0, 1, 1);
 	const GSVector4 dRect(0, 0, s.x, s.y);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps, false);
+	DoStretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps, false);
 }
 
-void GSDeviceOGL::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, SetDATM datm)
+void GSDeviceOGL::SetupDATE(GSTexture* rt, GSTexture* ds, SetDATM datm, const GSVector4i& bbox)
 {
 	GL_PUSH("DATE First Pass");
 
@@ -1933,6 +1922,17 @@ void GSDeviceOGL::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* ver
 
 	// ia
 
+	const GSVector4 src = GSVector4(bbox) / GSVector4(ds->GetSize()).xyxy();
+	const GSVector4 dst = src * 2.f - 1.f;
+
+	const GSVertexPT1 vertices[] =
+	{
+		{GSVector4(dst.x, dst.y, 0.0f, 0.0f), GSVector2(src.x, src.y)},
+		{GSVector4(dst.z, dst.y, 0.0f, 0.0f), GSVector2(src.z, src.y)},
+		{GSVector4(dst.x, dst.w, 0.0f, 0.0f), GSVector2(src.x, src.w)},
+		{GSVector4(dst.z, dst.w, 0.0f, 0.0f), GSVector2(src.z, src.w)},
+	};
+
 	IASetVAO(m_vao);
 	IASetVertexBuffer(vertices, 4);
 	IASetPrimitiveTopology(GL_TRIANGLE_STRIP);
@@ -2490,18 +2490,8 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config)
 			}
 			[[fallthrough]];
 		case GSHWDrawConfig::DestinationAlphaMode::Stencil:
-		{
-			const GSVector4 src = GSVector4(config.drawarea) / GSVector4(config.ds->GetSize()).xyxy();
-			const GSVector4 dst = src * 2.f - 1.f;
-			GSVertexPT1 vertices[] =
-			{
-				{GSVector4(dst.x, dst.y, 0.0f, 0.0f), GSVector2(src.x, src.y)},
-				{GSVector4(dst.z, dst.y, 0.0f, 0.0f), GSVector2(src.z, src.y)},
-				{GSVector4(dst.x, dst.w, 0.0f, 0.0f), GSVector2(src.x, src.w)},
-				{GSVector4(dst.z, dst.w, 0.0f, 0.0f), GSVector2(src.z, src.w)},
-			};
-			SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, vertices, config.datm);
-		}
+			SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, config.datm, config.drawarea);
+			break;
 	}
 
 	GSTexture* draw_rt_clone = nullptr;

pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.h

@@ -265,6 +265,10 @@ private:
 
 	void DrawStretchRect(const GSVector4& sRect, const GSVector4& dRect, const GSVector2i& ds);
 
+protected:
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) override;
+
 public:
 	GSDeviceOGL();
 	virtual ~GSDeviceOGL();
@@ -317,10 +321,8 @@ public:
 	// BlitRect *does* mess with GL state, be sure to re-bind.
 	void BlitRect(GSTexture* sTex, const GSVector4i& r, const GSVector2i& dsize, bool at_origin, bool linear);
 
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool linear = true);
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool alpha_blend, OMColorMaskSelector cms, bool linear = true);
+	void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool linear);
+	void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GLProgram& ps, bool alpha_blend, OMColorMaskSelector cms, bool linear);
 	void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) override;
 	void UpdateCLUTTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, GSTexture* dTex, u32 dOffset, u32 dSize) override;
 	void ConvertToIndexedTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, u32 SBW, u32 SPSM, GSTexture* dTex, u32 DBW, u32 DPSM) override;
@@ -332,7 +334,7 @@ public:
 	void RenderHW(GSHWDrawConfig& config) override;
 	void SendHWDraw(const GSHWDrawConfig& config, bool one_barrier, bool full_barrier);
 
-	void SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, SetDATM datm);
+	void SetupDATE(GSTexture* rt, GSTexture* ds, SetDATM datm, const GSVector4i& bbox);
 
 	void IASetVAO(GLuint vao);
 	void IASetPrimitiveTopology(GLenum topology);

pcsx2/GS/Renderers/SW/GSRasterizer.cpp

@@ -1549,7 +1549,7 @@ void GSRasterizerList::Queue(const GSRingHeap::SharedPtr<GSRasterizerData>& data
 	pxAssert(r.top >= 0 && r.top < 2048 && r.bottom >= 0 && r.bottom < 2048);
 
 	int top = r.top >> m_thread_height;
-	int bottom = std::min<int>((r.bottom + (1 << m_thread_height) - 1) >> m_thread_height, top + m_workers.size());
+	int bottom = std::min<int>((r.bottom + (1 << m_thread_height) - 1) >> m_thread_height, top + (int)m_workers.size());
 
 	while (top < bottom)
 	{

pcsx2/GS/Renderers/SW/GSRendererSW.cpp

@@ -1652,7 +1652,7 @@ void GSRendererSW::SharedData::UpdateSource()
 
 		std::string s;
 
-		for (size_t i = 0; m_tex[i].t; i++)
+		for (u32 i = 0; m_tex[i].t; i++)
 		{
 			const GIFRegTEX0& TEX0 = g_gs_renderer->GetTex0Layer(i);
 

pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp

@@ -2821,31 +2821,16 @@ void GSDeviceVK::CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r,
 	dTexVK->SetState(GSTexture::State::Dirty);
 }
 
-void GSDeviceVK::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
-	ShaderConvert shader /* = ShaderConvert::COPY */, bool linear /* = true */)
+void GSDeviceVK::DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+	GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear)
 {
-	pxAssert(HasDepthOutput(shader) == (dTex && dTex->GetType() == GSTexture::Type::DepthStencil));
-	pxAssert(linear ? SupportsBilinear(shader) : SupportsNearest(shader));
-
-	GL_INS("StretchRect(%d) {%d,%d} %dx%d -> {%d,%d) %dx%d", shader, int(sRect.left), int(sRect.top),
-		int(sRect.right - sRect.left), int(sRect.bottom - sRect.top), int(dRect.left), int(dRect.top),
-		int(dRect.right - dRect.left), int(dRect.bottom - dRect.top));
-
-	DoStretchRect(static_cast<GSTextureVK*>(sTex), sRect, static_cast<GSTextureVK*>(dTex), dRect,
-		dTex ? m_convert[static_cast<int>(shader)] : m_present[static_cast<int>(shader)], linear,
-		ShaderConvertWriteMask(shader) == 0xf);
-}
-
-void GSDeviceVK::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
-	bool green, bool blue, bool alpha, ShaderConvert shader)
-{
-	GL_PUSH("ColorCopy Red:%d Green:%d Blue:%d Alpha:%d", red, green, blue, alpha);
-
-	const u32 index = (red ? 1 : 0) | (green ? 2 : 0) | (blue ? 4 : 0) | (alpha ? 8 : 0);
-	const bool allow_discard = (index == 0xf);
-	int rta_offset = (shader == ShaderConvert::RTA_CORRECTION) ? 16 : 0;
-	DoStretchRect(static_cast<GSTextureVK*>(sTex), sRect, static_cast<GSTextureVK*>(dTex), dRect, m_color_copy[index + rta_offset],
-		false, allow_discard);
+	const bool allow_discard = (cms.wrgba == 0xf);
+	VkPipeline state;
+	if (HasVariableWriteMask(shader))
+		state = m_color_copy[GetShaderIndexForMask(shader, cms.wrgba)];
+	else
+		state = dTex ? m_convert[static_cast<int>(shader)] : m_present[static_cast<int>(shader)];
+	DoStretchRect(static_cast<GSTextureVK*>(sTex), sRect, static_cast<GSTextureVK*>(dTex), dRect, state, linear, allow_discard);
 }
 
 void GSDeviceVK::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
@@ -2967,10 +2952,10 @@ void GSDeviceVK::DoMultiStretchRects(
 		BeginRenderPassForStretchRect(dTex, rc, rc, false);
 	SetUtilityTexture(rects[0].src, rects[0].linear ? m_linear_sampler : m_point_sampler);
 
-	pxAssert(shader == ShaderConvert::COPY || shader == ShaderConvert::RTA_CORRECTION || rects[0].wmask.wrgba == 0xf);
-	int rta_bit = (shader == ShaderConvert::RTA_CORRECTION) ? 16 : 0;
-	SetPipeline(
-		(rects[0].wmask.wrgba != 0xf) ? m_color_copy[rects[0].wmask.wrgba | rta_bit] : m_convert[static_cast<int>(shader)]);
+	pxAssert(HasVariableWriteMask(shader) || rects[0].wmask.wrgba == 0xf);
+	SetPipeline((rects[0].wmask.wrgba != 0xf) ?
+		m_color_copy[GetShaderIndexForMask(shader, rects[0].wmask.wrgba)] :
+		m_convert[static_cast<int>(shader)]);
 
 	if (ApplyUtilityState())
 		DrawIndexedPrimitive();

pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h

@@ -278,7 +278,6 @@ private:
 	u32 m_current_frame = 0;
 
 	bool m_last_submit_failed = false;
-	bool m_last_present_failed = false;
 
 	std::map<u32, VkRenderPass> m_render_pass_cache;
 
@@ -471,6 +470,10 @@ private:
 
 	void DestroyResources();
 
+protected:
+	virtual void DoStretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
+		GSHWDrawConfig::ColorMaskSelector cms, ShaderConvert shader, bool linear) override;
+
 public:
 	GSDeviceVK();
 	~GSDeviceVK() override;
@@ -526,10 +529,6 @@ public:
 
 	void CopyRect(GSTexture* sTex, GSTexture* dTex, const GSVector4i& r, u32 destX, u32 destY) override;
 
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
-		ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
-	void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
-		bool green, bool blue, bool alpha, ShaderConvert shader = ShaderConvert::COPY) override;
 	void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
 		PresentShader shader, float shaderTime, bool linear) override;
 	void DrawMultiStretchRects(

pcsx2/GSDumpReplayer.cpp

@@ -213,16 +213,18 @@ static void GSDumpReplayerLoadInitialState()
 		Host::ReportFormattedErrorAsync("GSDumpReplayer", "Failed to load GS state.");
 }
 
-static void GSDumpReplayerSendPacketToMTGS(GIF_PATH path, const u8* data, u32 length)
+static void GSDumpReplayerSendPacketToMTGS(GIF_PATH path, const u8* data, size_t length)
 {
-	pxAssert((length % 16) == 0);
+	pxAssert((length % 16) == 0 && length < UINT32_MAX);
+
+	const u32 truncated_length = static_cast<u32>(length);
 
 	Gif_Path& gifPath = gifUnit.gifPath[path];
-	gifPath.CopyGSPacketData(const_cast<u8*>(data), length);
+	gifPath.CopyGSPacketData(const_cast<u8*>(data), truncated_length);
 
 	GS_Packet gsPack;
 	gsPack.offset = gifPath.curOffset;
-	gsPack.size = length;
+	gsPack.size = truncated_length;
 	gifPath.curOffset += length;
 	Gif_AddCompletedGSPacket(gsPack, path);
 }
@@ -248,7 +250,7 @@ static void GSDumpReplayerFrameLimit()
 	const s64 ms = GetTickFrequency() / 1000;
 	const s64 sleep = s_next_frame_time - now - ms;
 	if (sleep > ms)
-		Threading::Sleep(sleep / ms);
+		Threading::Sleep(static_cast<s32>(sleep / ms));
 	while ((now = GetCPUTicks()) < s_next_frame_time)
 		ShortSpin();
 	s_next_frame_time = std::max(now, s_next_frame_time + s_frame_ticks);
@@ -284,8 +286,13 @@ void GSDumpReplayerCpuStep()
 			{
 				case GSDumpTypes::GSTransferPath::Path1Old:
 				{
+					if(packet.length > 16384)
+					{
+						Console.Error("GSDumpReplayer: Path1Old transfer exceeds 16KB buffer. Skipping transfer");
+						break;
+					}
 					std::unique_ptr<u8[]> data(new u8[16384]);
-					const s32 addr = 16384 - packet.length;
+					const size_t addr = 16384 - packet.length;
 					std::memcpy(data.get(), packet.data + addr, packet.length);
 					GSDumpReplayerSendPacketToMTGS(GIF_PATH_1, data.get(), packet.length);
 				}
@@ -332,7 +339,7 @@ void GSDumpReplayerCpuStep()
 
 		case GSDumpTypes::GSType::Registers:
 		{
-			std::memcpy(PS2MEM_GS, packet.data, std::min<s32>(packet.length, Ps2MemSize::GSregs));
+			std::memcpy(PS2MEM_GS, packet.data, std::min<s32>(static_cast<u32>(packet.length), Ps2MemSize::GSregs));
 		}
 		break;
 	}

pcsx2/Gif_Unit.h

@@ -521,7 +521,7 @@ struct Gif_Path
 	// GS Packets that MTGS hasn't yet processed
 	u32 GetPendingGSPackets()
 	{
-		return mtvu.gsPackQueue.size();
+		return (u32)mtvu.gsPackQueue.size();
 	}
 };
 

pcsx2/Host.cpp

@@ -71,7 +71,7 @@ std::pair<const char*, u32> Host::LookupTranslationString(const std::string_view
 
 add_string:
 	s_translation_string_mutex.unlock_shared();
-	s_translation_string_mutex.lock();
+	std::lock_guard lock(s_translation_string_mutex);
 
 	if (s_translation_string_cache.empty()) [[unlikely]]
 	{
@@ -110,7 +110,6 @@ add_string:
 
 	ret.first = &s_translation_string_cache[insert_pos];
 	ret.second = static_cast<u32>(len);
-	s_translation_string_mutex.unlock();
 	return ret;
 }
 
@@ -132,10 +131,9 @@ std::string Host::TranslateToString(const std::string_view context, const std::s
 
 void Host::ClearTranslationCache()
 {
-	s_translation_string_mutex.lock();
+	std::lock_guard lock(s_translation_string_mutex);
 	s_translation_string_map.clear();
 	s_translation_string_cache_pos = 0;
-	s_translation_string_mutex.unlock();
 }
 
 void Host::ReportFormattedInfoAsync(const std::string_view title, const char* format, ...)

pcsx2/Host/CubebAudioStream.cpp

@@ -312,7 +312,7 @@ std::vector<std::pair<std::string, std::string>> AudioStream::GetCubebDriverName
 	names.emplace_back(std::string(), TRANSLATE_STR("AudioStream", "Default"));
 
 	auto cubeb_names = cubeb_get_backend_names();
-	for (int i = 0; i < cubeb_names.count; i++)
+	for (size_t i = 0; i < cubeb_names.count; i++)
 		names.emplace_back(cubeb_names.names[i], cubeb_names.names[i]);
 
 	return names;

pcsx2/ImGui/FullscreenUI.cpp

@@ -488,6 +488,7 @@ namespace FullscreenUI
 	static ImGuiFullscreen::FileSelectorFilters GetOpenFileFilters();
 	static ImGuiFullscreen::FileSelectorFilters GetDiscImageFilters();
 	static ImGuiFullscreen::FileSelectorFilters GetAudioFileFilters();
+	static ImGuiFullscreen::FileSelectorFilters GetImageFileFilters();
 	static void DoStartPath(
 		const std::string& path, std::optional<s32> state_index = std::nullopt, std::optional<bool> fast_boot = std::nullopt);
 	static void DoStartFile();
@@ -701,6 +702,16 @@ namespace FullscreenUI
 	static std::vector<const GameList::Entry*> s_game_list_sorted_entries;
 	static GameListView s_game_list_view = GameListView::Grid;
 
+	//////////////////////////////////////////////////////////////////////////
+	// Background
+	//////////////////////////////////////////////////////////////////////////
+	static void LoadCustomBackground();
+	static void DrawCustomBackground();
+
+	static std::shared_ptr<GSTexture> s_custom_background_texture;
+	static std::string s_custom_background_path;
+	static bool s_custom_background_enabled = false;
+
 	//////////////////////////////////////////////////////////////////////////
 	// Achievements
 	//////////////////////////////////////////////////////////////////////////
@@ -980,6 +991,8 @@ bool FullscreenUI::Initialize()
 	s_hotkey_list_cache = InputManager::GetHotkeyList();
 	MTGS::SetRunIdle(true);
 
+	LoadCustomBackground();
+
 	if (VMManager::HasValidVM())
 	{
 		UpdateGameDetails(VMManager::GetDiscPath(), VMManager::GetDiscSerial(), VMManager::GetTitle(true), VMManager::GetDiscCRC(),
@@ -1025,6 +1038,8 @@ void FullscreenUI::CheckForConfigChanges(const Pcsx2Config& old_config)
 
 	ImGuiFullscreen::SetTheme(Host::GetBaseStringSettingValue("UI", "FullscreenUITheme", "Dark"));
 
+	LoadCustomBackground();
+
 	// If achievements got disabled, we might have the menu open...
 	// That means we're going to be reaching achievement state.
 	if (old_config.Achievements.Enabled && !EmuConfig.Achievements.Enabled)
@@ -1184,6 +1199,11 @@ void FullscreenUI::Shutdown(bool clear_state)
 		s_about_window_open = false;
 	}
 	s_hotkey_list_cache = {};
+	
+	s_custom_background_texture.reset();
+	s_custom_background_path.clear();
+	s_custom_background_enabled = false;
+	
 	DestroyResources();
 	ImGuiFullscreen::Shutdown(clear_state);
 	s_initialized = false;
@@ -1195,6 +1215,15 @@ void FullscreenUI::Render()
 	if (!s_initialized)
 		return;
 
+	// see if background setting changed
+	static std::string s_last_background_path;
+	std::string current_path = Host::GetBaseStringSettingValue("UI", "GameListBackgroundPath");
+	if (s_last_background_path != current_path)
+	{
+		s_last_background_path = current_path;
+		LoadCustomBackground();
+	}
+
 	for (std::unique_ptr<GSTexture>& tex : s_cleanup_textures)
 		g_gs_device->Recycle(tex.release());
 	s_cleanup_textures.clear();
@@ -1202,6 +1231,20 @@ void FullscreenUI::Render()
 
 	ImGuiFullscreen::BeginLayout();
 
+	const bool should_draw_background = (s_current_main_window == MainWindowType::Landing ||
+		s_current_main_window == MainWindowType::StartGame ||
+		s_current_main_window == MainWindowType::Exit ||
+		s_current_main_window == MainWindowType::GameList ||
+		s_current_main_window == MainWindowType::GameListSettings ||
+		s_current_main_window == MainWindowType::Settings) && s_custom_background_enabled && s_custom_background_texture;
+	
+	ImVec4 original_background_color;
+	if (should_draw_background)
+	{
+		original_background_color = ImGuiFullscreen::UIBackgroundColor;
+		DrawCustomBackground();
+	}
+
 	// Primed achievements must come first, because we don't want the pause screen to be behind them.
 	if (s_current_main_window == MainWindowType::None && (EmuConfig.Achievements.Overlays || EmuConfig.Achievements.LBOverlays))
 		Achievements::DrawGameOverlays();
@@ -1297,6 +1340,9 @@ void FullscreenUI::Render()
 		s_game_settings_changed.store(false, std::memory_order_release);
 	}
 
+	if (should_draw_background)
+		ImGuiFullscreen::UIBackgroundColor = original_background_color;
+
 	ImGuiFullscreen::ResetCloseMenuIfNeeded();
 }
 
@@ -1383,6 +1429,11 @@ ImGuiFullscreen::FileSelectorFilters FullscreenUI::GetAudioFileFilters()
 	return {"*.wav"};
 }
 
+ImGuiFullscreen::FileSelectorFilters FullscreenUI::GetImageFileFilters()
+{
+	return {"*.png", "*.jpg", "*.jpeg", "*.bmp"};
+}
+
 void FullscreenUI::DoStartPath(const std::string& path, std::optional<s32> state_index, std::optional<bool> fast_boot)
 {
 	VMBootParameters params;
@@ -1598,6 +1649,158 @@ bool FullscreenUI::ShouldDefaultToGameList()
 	return Host::GetBaseBoolSettingValue("UI", "FullscreenUIDefaultToGameList", false);
 }
 
+//////////////////////////////////////////////////////////////////////////
+// Custom Background
+//////////////////////////////////////////////////////////////////////////
+
+void FullscreenUI::LoadCustomBackground()
+{
+	std::string path = Host::GetBaseStringSettingValue("UI", "GameListBackgroundPath");
+	
+	if (path.empty())
+	{
+		s_custom_background_texture.reset();
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+		return;
+	}
+
+	if (s_custom_background_path == path && s_custom_background_texture)
+	{
+		s_custom_background_enabled = true;
+		return;
+	}
+
+	if (!Path::IsAbsolute(path))
+		path = Path::Combine(EmuFolders::DataRoot, path);
+
+	if (!FileSystem::FileExists(path.c_str()))
+	{
+		Console.Warning("Custom background file not found: %s", path.c_str());
+		s_custom_background_texture.reset();
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+		return;
+	}
+
+	if (StringUtil::EndsWithNoCase(path, ".gif"))
+	{
+		Console.Warning("GIF files aren't supported as backgrounds: %s", path.c_str());
+		s_custom_background_texture.reset();
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+		return;
+	}
+
+	if (StringUtil::EndsWithNoCase(path, ".webp"))
+	{
+		Console.Warning("WebP files aren't supported as backgrounds: %s", path.c_str());
+		s_custom_background_texture.reset();
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+		return;
+	}
+
+	s_custom_background_texture = LoadTexture(path.c_str());
+	if (s_custom_background_texture)
+	{
+		s_custom_background_path = std::move(path);
+		s_custom_background_enabled = true;
+	}
+	else
+	{
+		Console.Error("Failed to load custom background: %s", path.c_str());
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+	}
+}
+
+void FullscreenUI::DrawCustomBackground()
+{
+	if (!s_custom_background_enabled || !s_custom_background_texture)
+		return;
+
+	const ImGuiIO& io = ImGui::GetIO();
+	const ImVec2 display_size = io.DisplaySize;
+	
+	const float opacity = Host::GetBaseFloatSettingValue("UI", "GameListBackgroundOpacity", 100.0f) / 100.0f;
+	const std::string mode = Host::GetBaseStringSettingValue("UI", "GameListBackgroundMode", "fit");
+
+	const float tex_width = static_cast<float>(s_custom_background_texture->GetWidth());
+	const float tex_height = static_cast<float>(s_custom_background_texture->GetHeight());
+	
+	ImVec2 img_min, img_max;
+	
+	if (mode == "stretch")
+	{
+		// stretch to fill entire display (ignores aspect ratio)
+		img_min = ImVec2(0.0f, 0.0f);
+		img_max = display_size;
+	}
+	else if (mode == "fill")
+	{
+		// Fill display while preserving aspect ratio (could crop edges)
+		const float display_aspect = display_size.x / display_size.y;
+		const float tex_aspect = tex_width / tex_height;
+		
+		float scale;
+		if (tex_aspect > display_aspect)
+		{
+			// Image is wider scale to height and crop sides
+			scale = display_size.y / tex_height;
+		}
+		else
+		{
+			// Image is taller scale to width and crop top/bottom
+			scale = display_size.x / tex_width;
+		}
+		
+		const float scaled_width = tex_width * scale;
+		const float scaled_height = tex_height * scale;
+		const float offset_x = (display_size.x - scaled_width) * 0.5f;
+		const float offset_y = (display_size.y - scaled_height) * 0.5f;
+		
+		img_min = ImVec2(offset_x, offset_y);
+		img_max = ImVec2(offset_x + scaled_width, offset_y + scaled_height);
+	}
+	else // "fit" or default
+	{
+		// Fit on screen while preserving aspect ratio (no cropping)
+		const float display_aspect = display_size.x / display_size.y;
+		const float tex_aspect = tex_width / tex_height;
+		
+		float scale;
+		if (tex_aspect > display_aspect)
+		{
+			// Image is wider than display
+			scale = display_size.x / tex_width;
+		}
+		else
+		{
+			// Image is taller than display
+			scale = display_size.y / tex_height;
+		}
+		
+		const float scaled_width = tex_width * scale;
+		const float scaled_height = tex_height * scale;
+		const float offset_x = (display_size.x - scaled_width) * 0.5f;
+		const float offset_y = (display_size.y - scaled_height) * 0.5f;
+		
+		img_min = ImVec2(offset_x, offset_y);
+		img_max = ImVec2(offset_x + scaled_width, offset_y + scaled_height);
+	}
+
+	// Override the UIBackgroundColor that windows use
+	// We need to make windows transparent so our background image shows through
+	const ImVec4 transparent_bg = ImVec4(UIBackgroundColor.x, UIBackgroundColor.y, UIBackgroundColor.z, 0.0f);
+	ImGuiFullscreen::UIBackgroundColor = transparent_bg;
+	
+	ImDrawList* bg_draw_list = ImGui::GetBackgroundDrawList();
+	const ImU32 col = IM_COL32(255, 255, 255, static_cast<u8>(opacity * 255.0f));
+	bg_draw_list->AddImage(reinterpret_cast<ImTextureID>(s_custom_background_texture->GetNativeHandle()),
+		img_min, img_max, ImVec2(0.0f, 0.0f), ImVec2(1.0f, 1.0f), col);
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Landing Window
 //////////////////////////////////////////////////////////////////////////
@@ -3391,13 +3594,15 @@ void FullscreenUI::DrawSettingsWindow()
 		ImVec2(io.DisplaySize.x, LayoutScale(LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY) +
 									 (LayoutScale(LAYOUT_MENU_BUTTON_Y_PADDING) * 2.0f) + LayoutScale(2.0f));
 
-	const float bg_alpha = VMManager::HasValidVM() ? 0.90f : 1.0f;
+	const bool using_custom_bg = s_custom_background_enabled && s_custom_background_texture;
+	const float header_bg_alpha = VMManager::HasValidVM() ? 0.90f : 1.0f;
+	const float content_bg_alpha = using_custom_bg ? 0.0f : (VMManager::HasValidVM() ? 0.90f : 1.0f);
 	SettingsInterface* bsi = GetEditingSettingsInterface();
 	const bool game_settings = IsEditingGameSettings(bsi);
 	const bool show_advanced_settings = ShouldShowAdvancedSettings(bsi);
 
 	if (BeginFullscreenWindow(
-			ImVec2(0.0f, 0.0f), heading_size, "settings_category", ImVec4(UIPrimaryColor.x, UIPrimaryColor.y, UIPrimaryColor.z, bg_alpha)))
+			ImVec2(0.0f, 0.0f), heading_size, "settings_category", ImVec4(UIPrimaryColor.x, UIPrimaryColor.y, UIPrimaryColor.z, header_bg_alpha)))
 	{
 		static constexpr float ITEM_WIDTH = 25.0f;
 
@@ -3549,7 +3754,7 @@ void FullscreenUI::DrawSettingsWindow()
 			ImVec2(0.0f, heading_size.y),
 			ImVec2(io.DisplaySize.x, io.DisplaySize.y - heading_size.y - LayoutScale(LAYOUT_FOOTER_HEIGHT)),
 			TinyString::from_format("settings_page_{}", static_cast<u32>(s_settings_page)).c_str(),
-			ImVec4(UIBackgroundColor.x, UIBackgroundColor.y, UIBackgroundColor.z, bg_alpha), 0.0f,
+			ImVec4(UIBackgroundColor.x, UIBackgroundColor.y, UIBackgroundColor.z, content_bg_alpha), 0.0f,
 			ImVec2(ImGuiFullscreen::LAYOUT_MENU_WINDOW_X_PADDING, 0.0f)))
 	{
 		ResetFocusHere();
@@ -3810,6 +4015,72 @@ void FullscreenUI::DrawInterfaceSettingsPage()
 		FSUI_CSTR("Show a save state selector UI when switching slots instead of showing a notification bubble."),
 		"EmuCore", "UseSavestateSelector", true);
 
+	MenuHeading(FSUI_CSTR("Background"));
+	
+	std::string background_path = bsi->GetStringValue("UI", "GameListBackgroundPath", "");
+	const bool background_enabled = bsi->GetBoolValue("UI", "GameListBackgroundEnabled", false);
+	
+	std::string background_display = FSUI_STR("None");
+	if (!background_path.empty() && background_enabled)
+	{
+		background_display = Path::GetFileName(background_path);
+	}
+	
+	if (MenuButtonWithValue(FSUI_ICONSTR(ICON_FA_IMAGE, "Background Image"),
+			FSUI_CSTR("Select a custom background image to use in Big Picture Mode menus."),
+			background_display.c_str()))
+	{
+		OpenFileSelector(FSUI_ICONSTR(ICON_FA_IMAGE, "Select Background Image"), false,
+			[](const std::string& path) {
+				if (!path.empty())
+				{
+					auto lock = Host::GetSettingsLock();
+					SettingsInterface* bsi = GetEditingSettingsInterface(false);
+					
+					std::string relative_path = Path::MakeRelative(path, EmuFolders::DataRoot);
+					bsi->SetStringValue("UI", "GameListBackgroundPath", relative_path.c_str());
+					bsi->SetBoolValue("UI", "GameListBackgroundEnabled", true);
+					SetSettingsChanged(bsi);
+					
+					Host::RunOnCPUThread([]() {
+						LoadCustomBackground();
+					});
+				}
+				CloseFileSelector();
+			},
+			GetImageFileFilters());
+	}
+	
+	if (MenuButton(FSUI_ICONSTR(ICON_FA_XMARK, "Clear Background Image"),
+			FSUI_CSTR("Removes the custom background image.")))
+	{
+		bsi->DeleteValue("UI", "GameListBackgroundPath");
+		bsi->SetBoolValue("UI", "GameListBackgroundEnabled", false);
+		SetSettingsChanged(bsi);
+		
+		s_custom_background_texture.reset();
+		s_custom_background_path.clear();
+		s_custom_background_enabled = false;
+	}
+	
+	DrawIntRangeSetting(bsi, FSUI_ICONSTR(ICON_FA_DROPLET, "Background Opacity"),
+		FSUI_CSTR("Sets the transparency of the custom background image."),
+		"UI", "GameListBackgroundOpacity", 100, 0, 100, "%d%%");
+	
+	static constexpr const char* s_background_mode_names[] = {
+		FSUI_NSTR("Fit"),
+		FSUI_NSTR("Fill"),
+		FSUI_NSTR("Stretch"),
+	};
+	static constexpr const char* s_background_mode_values[] = {
+		"fit",
+		"fill",
+		"stretch",
+	};
+	DrawStringListSetting(bsi, FSUI_ICONSTR(ICON_FA_EXPAND, "Background Mode"),
+		FSUI_CSTR("Select how to display the background image."),
+		"UI", "GameListBackgroundMode", "fit", s_background_mode_names, s_background_mode_values, std::size(s_background_mode_names), true);
+
 	MenuHeading(FSUI_CSTR("Behaviour"));
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_PF_SNOOZE, "Inhibit Screensaver"),
 		FSUI_CSTR("Prevents the screen saver from activating and the host from sleeping while emulation is running."), "EmuCore",
@@ -6595,6 +6866,46 @@ void FullscreenUI::DrawPauseMenu(MainWindowType type)
 		BeginMenuButtons(submenu_item_count[static_cast<u32>(s_current_pause_submenu)], 1.0f, ImGuiFullscreen::LAYOUT_MENU_BUTTON_X_PADDING,
 			ImGuiFullscreen::LAYOUT_MENU_BUTTON_Y_PADDING, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
 
+		if (!ImGui::IsPopupOpen(0u, ImGuiPopupFlags_AnyPopup))
+		{
+			const bool up_pressed = ImGui::IsKeyPressed(ImGuiKey_GamepadDpadUp, ImGuiInputFlags_Repeat, ImGuiKeyOwner_NoOwner) ||
+									ImGui::IsKeyPressed(ImGuiKey_UpArrow, ImGuiInputFlags_Repeat, ImGuiKeyOwner_NoOwner);
+			const bool down_pressed = ImGui::IsKeyPressed(ImGuiKey_GamepadDpadDown, ImGuiInputFlags_Repeat, ImGuiKeyOwner_NoOwner) ||
+									  ImGui::IsKeyPressed(ImGuiKey_DownArrow, ImGuiInputFlags_Repeat, ImGuiKeyOwner_NoOwner);
+
+			if (up_pressed || down_pressed)
+			{
+				const ImGuiID current_focus_id = ImGui::GetFocusID();
+				ImGuiWindow* window = ImGui::GetCurrentWindow();
+				ImGuiID first_id = 0;
+				ImGuiID last_id = 0;
+
+				switch (s_current_pause_submenu)
+				{
+					case PauseSubMenu::None:
+						first_id = ImGui::GetID(FSUI_ICONSTR(ICON_FA_PLAY, "Resume Game"));
+						last_id = ImGui::GetID(FSUI_ICONSTR(ICON_FA_POWER_OFF, "Close Game"));
+						break;
+					case PauseSubMenu::Exit:
+						first_id = ImGui::GetID(FSUI_ICONSTR(ICON_PF_BACKWARD, "Back To Pause Menu"));
+						last_id = ImGui::GetID(FSUI_ICONSTR(ICON_FA_POWER_OFF, "Exit Without Saving"));
+						break;
+					case PauseSubMenu::Achievements:
+						first_id = ImGui::GetID(FSUI_ICONSTR(ICON_PF_BACKWARD, "Back To Pause Menu"));
+						last_id = ImGui::GetID(FSUI_ICONSTR(ICON_FA_STOPWATCH, "Leaderboards"));
+						break;
+				}
+
+				if (first_id != 0 && last_id != 0)
+				{
+					if (up_pressed && current_focus_id == first_id)
+						ImGui::SetFocusID(last_id, window);
+					else if (down_pressed && current_focus_id == last_id)
+						ImGui::SetFocusID(first_id, window);
+				}
+			}
+		}
+
 		switch (s_current_pause_submenu)
 		{
 			case PauseSubMenu::None:
@@ -7554,9 +7865,12 @@ void FullscreenUI::DrawGameListWindow()
 
 void FullscreenUI::DrawGameList(const ImVec2& heading_size)
 {
+	ImGui::PushStyleColor(ImGuiCol_WindowBg, UIBackgroundColor);
+	
 	if (!BeginFullscreenColumns(nullptr, heading_size.y, true, true))
 	{
 		EndFullscreenColumns();
+		ImGui::PopStyleColor();
 		return;
 	}
 
@@ -7753,6 +8067,8 @@ void FullscreenUI::DrawGameList(const ImVec2& heading_size)
 	}
 	EndFullscreenColumnWindow();
 	EndFullscreenColumns();
+
+	ImGui::PopStyleColor();
 }
 
 void FullscreenUI::DrawGameGrid(const ImVec2& heading_size)
@@ -8884,8 +9200,8 @@ TRANSLATE_NOOP("FullscreenUI", "Game type copied to clipboard.");
 TRANSLATE_NOOP("FullscreenUI", "Game region copied to clipboard.");
 TRANSLATE_NOOP("FullscreenUI", "Game compatibility copied to clipboard.");
 TRANSLATE_NOOP("FullscreenUI", "Game path copied to clipboard.");
-TRANSLATE_NOOP("FullscreenUI", "Automatic");
 TRANSLATE_NOOP("FullscreenUI", "None");
+TRANSLATE_NOOP("FullscreenUI", "Automatic");
 TRANSLATE_NOOP("FullscreenUI", "Browse...");
 TRANSLATE_NOOP("FullscreenUI", "Create New...");
 TRANSLATE_NOOP("FullscreenUI", "Enter custom HDD size in gigabytes (40–2000):");
@@ -8966,6 +9282,11 @@ TRANSLATE_NOOP("FullscreenUI", "Appearance");
 TRANSLATE_NOOP("FullscreenUI", "Selects the color style to be used for Big Picture Mode.");
 TRANSLATE_NOOP("FullscreenUI", "When Big Picture mode is started, the game list will be displayed instead of the main menu.");
 TRANSLATE_NOOP("FullscreenUI", "Show a save state selector UI when switching slots instead of showing a notification bubble.");
+TRANSLATE_NOOP("FullscreenUI", "Background");
+TRANSLATE_NOOP("FullscreenUI", "Select a custom background image to use in Big Picture Mode menus.");
+TRANSLATE_NOOP("FullscreenUI", "Removes the custom background image.");
+TRANSLATE_NOOP("FullscreenUI", "Sets the transparency of the custom background image.");
+TRANSLATE_NOOP("FullscreenUI", "Select how to display the background image.");
 TRANSLATE_NOOP("FullscreenUI", "Behaviour");
 TRANSLATE_NOOP("FullscreenUI", "Prevents the screen saver from activating and the host from sleeping while emulation is running.");
 TRANSLATE_NOOP("FullscreenUI", "Pauses the emulator when a game is started.");
@@ -9434,6 +9755,9 @@ TRANSLATE_NOOP("FullscreenUI", "Scarlet Devil");
 TRANSLATE_NOOP("FullscreenUI", "Violet Angel");
 TRANSLATE_NOOP("FullscreenUI", "Cobalt Sky");
 TRANSLATE_NOOP("FullscreenUI", "AMOLED");
+TRANSLATE_NOOP("FullscreenUI", "Fit");
+TRANSLATE_NOOP("FullscreenUI", "Fill");
+TRANSLATE_NOOP("FullscreenUI", "Stretch");
 TRANSLATE_NOOP("FullscreenUI", "Enabled");
 TRANSLATE_NOOP("FullscreenUI", "Disabled");
 TRANSLATE_NOOP("FullscreenUI", "Top Left");
@@ -9569,7 +9893,10 @@ TRANSLATE_NOOP("FullscreenUI", "Special (Texture)");
 TRANSLATE_NOOP("FullscreenUI", "Special (Texture - Aggressive)");
 TRANSLATE_NOOP("FullscreenUI", "Align to Native");
 TRANSLATE_NOOP("FullscreenUI", "Align to Native - with Texture Offset");
+TRANSLATE_NOOP("FullscreenUI", "Normal");
 TRANSLATE_NOOP("FullscreenUI", "Aggressive");
+TRANSLATE_NOOP("FullscreenUI", "Normal (Maintain Upscale)");
+TRANSLATE_NOOP("FullscreenUI", "Aggressive (Maintain Upscale)");
 TRANSLATE_NOOP("FullscreenUI", "Half");
 TRANSLATE_NOOP("FullscreenUI", "Force Bilinear");
 TRANSLATE_NOOP("FullscreenUI", "Force Nearest");
@@ -9646,6 +9973,11 @@ TRANSLATE_NOOP("FullscreenUI", "Clear Settings");
 TRANSLATE_NOOP("FullscreenUI", "Theme");
 TRANSLATE_NOOP("FullscreenUI", "Default To Game List");
 TRANSLATE_NOOP("FullscreenUI", "Use Save State Selector");
+TRANSLATE_NOOP("FullscreenUI", "Background Image");
+TRANSLATE_NOOP("FullscreenUI", "Select Background Image");
+TRANSLATE_NOOP("FullscreenUI", "Clear Background Image");
+TRANSLATE_NOOP("FullscreenUI", "Background Opacity");
+TRANSLATE_NOOP("FullscreenUI", "Background Mode");
 TRANSLATE_NOOP("FullscreenUI", "Inhibit Screensaver");
 TRANSLATE_NOOP("FullscreenUI", "Pause On Start");
 TRANSLATE_NOOP("FullscreenUI", "Pause On Focus Loss");
@@ -9821,6 +10153,10 @@ TRANSLATE_NOOP("FullscreenUI", "Compression Method");
 TRANSLATE_NOOP("FullscreenUI", "Compression Level");
 TRANSLATE_NOOP("FullscreenUI", "Use Debug Device");
 TRANSLATE_NOOP("FullscreenUI", "Resume Game");
+TRANSLATE_NOOP("FullscreenUI", "Close Game");
+TRANSLATE_NOOP("FullscreenUI", "Back To Pause Menu");
+TRANSLATE_NOOP("FullscreenUI", "Exit Without Saving");
+TRANSLATE_NOOP("FullscreenUI", "Leaderboards");
 TRANSLATE_NOOP("FullscreenUI", "Toggle Frame Limit");
 TRANSLATE_NOOP("FullscreenUI", "Game Properties");
 TRANSLATE_NOOP("FullscreenUI", "Achievements");
@@ -9828,11 +10164,7 @@ TRANSLATE_NOOP("FullscreenUI", "Save Screenshot");
 TRANSLATE_NOOP("FullscreenUI", "Switch To Software Renderer");
 TRANSLATE_NOOP("FullscreenUI", "Switch To Hardware Renderer");
 TRANSLATE_NOOP("FullscreenUI", "Change Disc");
-TRANSLATE_NOOP("FullscreenUI", "Close Game");
-TRANSLATE_NOOP("FullscreenUI", "Exit Without Saving");
-TRANSLATE_NOOP("FullscreenUI", "Back To Pause Menu");
 TRANSLATE_NOOP("FullscreenUI", "Exit And Save State");
-TRANSLATE_NOOP("FullscreenUI", "Leaderboards");
 TRANSLATE_NOOP("FullscreenUI", "Delete Save");
 TRANSLATE_NOOP("FullscreenUI", "Close Menu");
 TRANSLATE_NOOP("FullscreenUI", "Default Boot");

pcsx2/ImGui/ImGuiOverlays.cpp

@@ -49,6 +49,31 @@
 
 InputRecordingUI::InputRecordingData g_InputRecordingData;
 
+// Start timers at 0 so we immediately get lines to cache.
+static constexpr double ONE_BILLION = 1000000000;
+static constexpr double UPDATE_INTERVAL = 0.1 * ONE_BILLION;
+static constexpr double UPDATE_INTERVAL_CPU_INFO = 5.0 * ONE_BILLION;
+Common::Timer s_last_update_timer = Common::Timer(0.0);
+Common::Timer s_last_update_timer_cpu_info = Common::Timer(0.0);
+
+ImU32 s_speed_line_color;
+SmallString s_speed_line;
+SmallString s_gs_stats_line;
+SmallString s_gs_memory_stats_line;
+SmallString s_gs_frame_times_line;
+SmallString s_resolution_line;
+SmallString s_hardware_info_cpu_line;
+SmallString s_hardware_info_gpu_line;
+SmallString s_cpu_usage_ee_line;
+SmallString s_cpu_usage_gs_line;
+SmallString s_cpu_usage_vu_line;
+std::vector<SmallString> s_software_thread_lines;
+SmallString s_capture_line;
+SmallString s_gpu_usage_line;
+SmallString s_speed_icon;
+
+constexpr ImU32 white_color = IM_COL32(255, 255, 255, 255);
+
 // OSD positioning funcs
 ImVec2 CalculateOSDPosition(OsdOverlayPos position, float margin, const ImVec2& text_size, float window_width, float window_height)
 {
@@ -170,7 +195,6 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 	const float font_size = ImGuiManager::GetFontSizeStandard();
 
 	ImDrawList* dl = ImGui::GetBackgroundDrawList();
-	SmallString text;
 	ImVec2 text_size;
 
 	// Adjust initial Y position based on vertical alignment
@@ -208,184 +232,233 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 		position_y += text_size.y + spacing; \
 	} while (0)
 
-	const bool paused = (VMManager::GetState() == VMState::Paused);
-	const bool fsui_active = FullscreenUI::HasActiveWindow();
-
-	if (!paused)
+	if (VMManager::GetState() != VMState::Paused)
 	{
-		bool first = true;
-		const float speed = PerformanceMetrics::GetSpeed();
-
-		if (GSConfig.OsdShowFPS)
+		if (s_last_update_timer.GetTimeNanoseconds() >= UPDATE_INTERVAL)
 		{
-			switch (PerformanceMetrics::GetInternalFPSMethod())
+			s_last_update_timer.Reset();
+			const float speed = PerformanceMetrics::GetSpeed();
+
+			s_speed_line.clear();
+			if (GSConfig.OsdShowFPS)
 			{
-				case PerformanceMetrics::InternalFPSMethod::GSPrivilegedRegister:
-					text.append_format("FPS: {:.2f} [P]", PerformanceMetrics::GetInternalFPS());
-					break;
+				switch (PerformanceMetrics::GetInternalFPSMethod())
+				{
+					case PerformanceMetrics::InternalFPSMethod::GSPrivilegedRegister:
+						s_speed_line.append_format("FPS: {:.2f} [P]", PerformanceMetrics::GetInternalFPS());
+						break;
 
-				case PerformanceMetrics::InternalFPSMethod::DISPFBBlit:
-					text.append_format("FPS: {:.2f} [B]", PerformanceMetrics::GetInternalFPS());
-					break;
+					case PerformanceMetrics::InternalFPSMethod::DISPFBBlit:
+						s_speed_line.append_format("FPS: {:.2f} [B]", PerformanceMetrics::GetInternalFPS());
+						break;
 
-				case PerformanceMetrics::InternalFPSMethod::None:
-				default:
-					text.append("FPS: N/A");
-					break;
-			}
-			first = false;
-		}
-
-		if (GSConfig.OsdShowVPS)
-		{
-			text.append_format("{}VPS: {:.2f}", first ? "" : " | ", PerformanceMetrics::GetFPS(),
-				PerformanceMetrics::GetFPS());
-			first = false;
-		}
-
-		if (GSConfig.OsdShowSpeed)
-		{
-			text.append_format("{}Speed: {}%", first ? "" : " | ", static_cast<u32>(std::round(speed)));
-
-			const float target_speed = VMManager::GetTargetSpeed();
-			if (target_speed == 0.0f)
-				text.append(" (T: Max)");
-			else
-				text.append_format(" (T: {:.0f}%)", target_speed * 100.0f);
-			first = false;
-		}
-
-		if (GSConfig.OsdShowVersion)
-		{
-			text.append_format("{}PCSX2 {}", first ? "" : " | ", BuildVersion::GitRev);
-		}
-
-		if (!text.empty())
-		{
-			ImU32 color;
-			if (speed < 95.0f)
-				color = IM_COL32(255, 100, 100, 255);
-			else if (speed > 105.0f)
-				color = IM_COL32(100, 255, 100, 255);
-			else
-				color = IM_COL32(255, 255, 255, 255);
-
-			DRAW_LINE(fixed_font, font_size, text.c_str(), color);
-		}
-
-		if (GSConfig.OsdShowGSStats)
-		{
-			text.clear();
-			GSgetStats(text);
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-
-			text.clear();
-			GSgetMemoryStats(text);
-			if (!text.empty())
-				DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-
-			text.clear();
-			text.append_format("{} QF | Min: {:.2f}ms | Avg: {:.2f}ms | Max: {:.2f}ms",
-				MTGS::GetCurrentVsyncQueueSize() - 1, // we subtract one for the current frame
-				PerformanceMetrics::GetMinimumFrameTime(),
-				PerformanceMetrics::GetAverageFrameTime(),
-				PerformanceMetrics::GetMaximumFrameTime());
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-		}
-
-		if (GSConfig.OsdShowResolution)
-		{
-			int width, height;
-			GSgetInternalResolution(&width, &height);
-
-			text.clear();
-			text.append_format("{}x{} {} {}", width, height, ReportVideoMode(), ReportInterlaceMode());
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-		}
-
-		if (GSConfig.OsdShowHardwareInfo)
-		{
-			// CPU
-			text.clear();
-			const CPUInfo& info = GetCPUInfo();
-			bool has_small = info.num_small_cores > 0;
-			bool has_ht = info.num_threads != info.num_big_cores + info.num_small_cores;
-			text.append_format("CPU: {}", info.name);
-			if (has_ht & has_small)
-				text.append_format(" ({}P/{}E/{}T)", info.num_big_cores, info.num_small_cores, info.num_threads);
-			else if (has_small)
-				text.append_format(" ({}P/{}E)", info.num_big_cores, info.num_small_cores);
-			else
-				text.append_format(" ({}C/{}T)", info.num_big_cores, info.num_threads);
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-
-			// GPU
-			text.clear();
-			text.append_format("GPU: {}{}", g_gs_device->GetName(), GSConfig.UseDebugDevice ? " (Debug)" : "");
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-		}
-
-		if (GSConfig.OsdShowCPU)
-		{
-			text.clear();
-			if (EmuConfig.Speedhacks.EECycleRate != 0 || EmuConfig.Speedhacks.EECycleSkip != 0)
-				text.append_format("EE[{}/{}]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip);
-			else
-				text = "EE: ";
-			FormatProcessorStat(text, PerformanceMetrics::GetCPUThreadUsage(), PerformanceMetrics::GetCPUThreadAverageTime());
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-
-			text = "GS: ";
-			FormatProcessorStat(text, PerformanceMetrics::GetGSThreadUsage(), PerformanceMetrics::GetGSThreadAverageTime());
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-
-			if (THREAD_VU1)
-			{
-				text = "VU: ";
-				FormatProcessorStat(text, PerformanceMetrics::GetVUThreadUsage(), PerformanceMetrics::GetVUThreadAverageTime());
-				DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
+					case PerformanceMetrics::InternalFPSMethod::None:
+					default:
+						s_speed_line.append("FPS: N/A");
+						break;
+				}
 			}
 
-			const u32 gs_sw_threads = PerformanceMetrics::GetGSSWThreadCount();
-			for (u32 i = 0; i < gs_sw_threads; i++)
+			if (GSConfig.OsdShowVPS)
+				s_speed_line.append_format("{}VPS: {:.2f}", s_speed_line.empty() ? "" : " | ", PerformanceMetrics::GetFPS());
+
+			if (GSConfig.OsdShowSpeed)
 			{
-				text.clear();
-				text.append_format("SW-{}: ", i);
-				FormatProcessorStat(text, PerformanceMetrics::GetGSSWThreadUsage(i), PerformanceMetrics::GetGSSWThreadAverageTime(i));
-				DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
+				s_speed_line.append_format("{}Speed: {}%", s_speed_line.empty() ? "" : " | ", static_cast<u32>(std::round(speed)));
+
+				const float target_speed = VMManager::GetTargetSpeed();
+				if (target_speed == 0.0f)
+					s_speed_line.append(" (T: Max)");
+				else
+					s_speed_line.append_format(" (T: {:.0f}%)", target_speed * 100.0f);
 			}
 
-			if (GSCapture::IsCapturing())
+			if (GSConfig.OsdShowVersion)
+				s_speed_line.append_format("{}PCSX2 {}", s_speed_line.empty() ? "" : " | ", BuildVersion::GitRev);
+
+			if (!s_speed_line.empty())
 			{
-				text = "CAP: ";
-				FormatProcessorStat(text, PerformanceMetrics::GetCaptureThreadUsage(), PerformanceMetrics::GetCaptureThreadAverageTime());
-				DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-			}
-		}
-
-		if (GSConfig.OsdShowGPU)
-		{
-			text = "GPU: ";
-			FormatProcessorStat(text, PerformanceMetrics::GetGPUUsage(), PerformanceMetrics::GetGPUAverageTime());
-			DRAW_LINE(fixed_font, font_size, text.c_str(), IM_COL32(255, 255, 255, 255));
-		}
-
-		if (GSConfig.OsdShowIndicators)
-		{
-			const float target_speed = VMManager::GetTargetSpeed();
-			const bool is_normal_speed = (target_speed == EmuConfig.EmulationSpeed.NominalScalar ||
-										  VMManager::IsTargetSpeedAdjustedToHost());
-			if (!is_normal_speed)
-			{
-				if (target_speed == EmuConfig.EmulationSpeed.SlomoScalar) // Slow-Motion
-					DRAW_LINE(standard_font, font_size, ICON_PF_SLOW_MOTION, IM_COL32(255, 255, 255, 255));
-				else if (target_speed == EmuConfig.EmulationSpeed.TurboScalar) // Turbo
-					DRAW_LINE(standard_font, font_size, ICON_FA_FORWARD_FAST, IM_COL32(255, 255, 255, 255));
-				else // Unlimited
-					DRAW_LINE(standard_font, font_size, ICON_FA_FORWARD, IM_COL32(255, 255, 255, 255));
+				if (speed < 95.0f)
+					s_speed_line_color = IM_COL32(255, 100, 100, 255); // red
+				else if (speed > 105.0f)
+					s_speed_line_color = IM_COL32(100, 255, 100, 255); // green
+				else
+					s_speed_line_color = white_color;
+
+				DRAW_LINE(fixed_font, font_size, s_speed_line.c_str(), s_speed_line_color);
+			}
+
+			if (GSConfig.OsdShowGSStats)
+			{
+				GSgetStats(s_gs_stats_line);
+				GSgetMemoryStats(s_gs_memory_stats_line);
+				s_gs_frame_times_line.format("{} QF | Min: {:.2f}ms | Avg: {:.2f}ms | Max: {:.2f}ms",
+					MTGS::GetCurrentVsyncQueueSize() - 1, // subtract one for the current frame
+					PerformanceMetrics::GetMinimumFrameTime(),
+					PerformanceMetrics::GetAverageFrameTime(),
+					PerformanceMetrics::GetMaximumFrameTime());
+
+				if (!s_gs_stats_line.empty())
+					DRAW_LINE(fixed_font, font_size, s_gs_stats_line.c_str(), white_color);
+				if (!s_gs_memory_stats_line.empty())
+					DRAW_LINE(fixed_font, font_size, s_gs_memory_stats_line.c_str(), white_color);
+				DRAW_LINE(fixed_font, font_size, s_gs_frame_times_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowResolution)
+			{
+				int iwidth, iheight;
+				GSgetInternalResolution(&iwidth, &iheight);
+
+				s_resolution_line.format("{}x{} {} {}", iwidth, iheight, ReportVideoMode(), ReportInterlaceMode());
+				DRAW_LINE(fixed_font, font_size, s_resolution_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowHardwareInfo)
+			{
+				// GPU can change on the fly with settings, but CPU change of any kind is a rare edge case.
+				if (s_last_update_timer_cpu_info.GetTimeNanoseconds() >= UPDATE_INTERVAL_CPU_INFO)
+				{
+					s_last_update_timer_cpu_info.Reset();
+
+					// CPU
+					const CPUInfo& info = GetCPUInfo();
+					const bool has_small = info.num_small_cores > 0;
+					const bool has_smt = info.num_threads != info.num_big_cores + info.num_small_cores;
+					s_hardware_info_cpu_line.format("CPU: {}", info.name);
+					if (has_smt && has_small)
+						s_hardware_info_cpu_line.append_format(" ({}P/{}E/{}T)", info.num_big_cores, info.num_small_cores, info.num_threads);
+					else if (has_small)
+						s_hardware_info_cpu_line.append_format(" ({}P/{}E)", info.num_big_cores, info.num_small_cores);
+					else
+						s_hardware_info_cpu_line.append_format(" ({}C/{}T)", info.num_big_cores, info.num_threads);
+				}
+
+				DRAW_LINE(fixed_font, font_size, s_hardware_info_cpu_line.c_str(), white_color);
+
+				// GPU
+				s_hardware_info_gpu_line.format("GPU: {}{}", g_gs_device->GetName(), GSConfig.UseDebugDevice ? " (Debug)" : "");
+				DRAW_LINE(fixed_font, font_size, s_hardware_info_gpu_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowCPU)
+			{
+				if (EmuConfig.Speedhacks.EECycleRate != 0 || EmuConfig.Speedhacks.EECycleSkip != 0)
+					s_cpu_usage_ee_line.format("EE[{}/{}]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip);
+				else
+					s_cpu_usage_ee_line.assign("EE: ");
+				FormatProcessorStat(s_cpu_usage_ee_line, PerformanceMetrics::GetCPUThreadUsage(), PerformanceMetrics::GetCPUThreadAverageTime());
+				DRAW_LINE(fixed_font, font_size, s_cpu_usage_ee_line.c_str(), white_color);
+
+				s_cpu_usage_gs_line.assign("GS: ");
+				FormatProcessorStat(s_cpu_usage_gs_line, PerformanceMetrics::GetGSThreadUsage(), PerformanceMetrics::GetGSThreadAverageTime());
+				DRAW_LINE(fixed_font, font_size, s_cpu_usage_gs_line.c_str(), white_color);
+
+				if (THREAD_VU1)
+				{
+					s_cpu_usage_vu_line.assign("VU: ");
+					FormatProcessorStat(s_cpu_usage_vu_line, PerformanceMetrics::GetVUThreadUsage(), PerformanceMetrics::GetVUThreadAverageTime());
+					DRAW_LINE(fixed_font, font_size, s_cpu_usage_vu_line.c_str(), white_color);
+				}
+
+				const u32 gs_sw_threads = PerformanceMetrics::GetGSSWThreadCount();
+				for (u32 thread = 0; thread < gs_sw_threads; thread++)
+				{
+					if (thread < s_software_thread_lines.size())
+						s_software_thread_lines[thread].format("SW-{}: ", thread);
+					else
+						s_software_thread_lines.push_back(SmallString("SW-{}: ", thread));
+					FormatProcessorStat(s_software_thread_lines[thread], PerformanceMetrics::GetGSSWThreadUsage(thread), PerformanceMetrics::GetGSSWThreadAverageTime(thread));
+					DRAW_LINE(fixed_font, font_size, s_software_thread_lines[thread].c_str(), white_color);
+				}
+
+				if (GSCapture::IsCapturing())
+				{
+					s_capture_line.assign("CAP: ");
+					FormatProcessorStat(s_capture_line, PerformanceMetrics::GetCaptureThreadUsage(), PerformanceMetrics::GetCaptureThreadAverageTime());
+					DRAW_LINE(fixed_font, font_size, s_capture_line.c_str(), white_color);
+				}
+			}
+
+			if (GSConfig.OsdShowGPU)
+			{
+				s_gpu_usage_line.assign("GPU: ");
+				FormatProcessorStat(s_gpu_usage_line, PerformanceMetrics::GetGPUUsage(), PerformanceMetrics::GetGPUAverageTime());
+				DRAW_LINE(fixed_font, font_size, s_gpu_usage_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowIndicators)
+			{
+				const float target_speed = VMManager::GetTargetSpeed();
+				const bool is_normal_speed = (target_speed == EmuConfig.EmulationSpeed.NominalScalar ||
+											  VMManager::IsTargetSpeedAdjustedToHost());
+				if (!is_normal_speed)
+				{
+					if (target_speed == EmuConfig.EmulationSpeed.SlomoScalar) // Slow-Motion
+						s_speed_icon = ICON_PF_SLOW_MOTION;
+					else if (target_speed == EmuConfig.EmulationSpeed.TurboScalar) // Turbo
+						s_speed_icon = ICON_FA_FORWARD_FAST;
+					else // Unlimited
+						s_speed_icon = ICON_FA_FORWARD;
+
+					DRAW_LINE(standard_font, font_size, s_speed_icon, white_color);
+				}
+			}
+		}
+		// No refresh yet. Display cached lines.
+		else
+		{
+			if (GSConfig.OsdShowFPS || GSConfig.OsdShowVPS || GSConfig.OsdShowSpeed || GSConfig.OsdShowVersion)
+				DRAW_LINE(fixed_font, font_size, s_speed_line.c_str(), s_speed_line_color);
+
+			if (GSConfig.OsdShowGSStats)
+			{
+				if (!s_gs_stats_line.empty())
+					DRAW_LINE(fixed_font, font_size, s_gs_stats_line.c_str(), white_color);
+				if (!s_gs_memory_stats_line.empty())
+					DRAW_LINE(fixed_font, font_size, s_gs_memory_stats_line.c_str(), white_color);
+				DRAW_LINE(fixed_font, font_size, s_gs_frame_times_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowResolution)
+				DRAW_LINE(fixed_font, font_size, s_resolution_line.c_str(), white_color);
+
+			if (GSConfig.OsdShowHardwareInfo)
+			{
+				DRAW_LINE(fixed_font, font_size, s_hardware_info_cpu_line.c_str(), white_color);
+				DRAW_LINE(fixed_font, font_size, s_hardware_info_gpu_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowCPU)
+			{
+				DRAW_LINE(fixed_font, font_size, s_cpu_usage_ee_line.c_str(), white_color);
+				DRAW_LINE(fixed_font, font_size, s_cpu_usage_gs_line.c_str(), white_color);
+				if (THREAD_VU1)
+					DRAW_LINE(fixed_font, font_size, s_cpu_usage_vu_line.c_str(), white_color);
+
+				const u32 thread_count = std::min(
+					PerformanceMetrics::GetGSSWThreadCount(),
+					static_cast<u32>(s_software_thread_lines.size()));
+				for (u32 thread = 0; thread < thread_count; thread++)
+					DRAW_LINE(fixed_font, font_size, s_software_thread_lines[thread].c_str(), white_color);
+
+				if (GSCapture::IsCapturing())
+					DRAW_LINE(fixed_font, font_size, s_capture_line.c_str(), white_color);
+			}
+
+			if (GSConfig.OsdShowGPU)
+				DRAW_LINE(fixed_font, font_size, s_gpu_usage_line.c_str(), white_color);
+
+			if (GSConfig.OsdShowIndicators)
+			{
+				const bool is_normal_speed = (VMManager::GetTargetSpeed() == EmuConfig.EmulationSpeed.NominalScalar ||
+											  VMManager::IsTargetSpeedAdjustedToHost());
+				if (!is_normal_speed)
+					DRAW_LINE(standard_font, font_size, s_speed_icon, white_color);
 			}
 		}
 
+		// Check every OSD frame because this is an animation.
 		if (GSConfig.OsdShowFrameTimes)
 		{
 			const ImVec2 history_size(200.0f * scale, 50.0f * scale);
@@ -426,9 +499,9 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 				ImDrawList* win_dl = ImGui::GetCurrentWindow()->DrawList;
 				const ImVec2 wpos(ImGui::GetCurrentWindow()->Pos);
 
-				text.clear();
-				text.append_format("Max: {:.1f} ms", max);
-				text_size = fixed_font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length());
+				SmallString frame_times_text;
+				frame_times_text.format("Max: {:.1f} ms", max);
+				text_size = fixed_font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 				
 				float text_x;
 				switch (GSConfig.OsdPerformancePos)
@@ -451,13 +524,12 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 						break;
 				}
 				win_dl->AddText(ImVec2(text_x + shadow_offset, wpos.y + shadow_offset),
-					IM_COL32(0, 0, 0, 100), text.c_str(), text.c_str() + text.length());
+					IM_COL32(0, 0, 0, 100), frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 				win_dl->AddText(ImVec2(text_x, wpos.y),
-					IM_COL32(255, 255, 255, 255), text.c_str(), text.c_str() + text.length());
+					white_color, frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 
-				text.clear();
-				text.append_format("Min: {:.1f} ms", min);
-				text_size = fixed_font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length());
+				frame_times_text.format("Min: {:.1f} ms", min);
+				text_size = fixed_font->CalcTextSizeA(font_size, FLT_MAX, 0.0f, frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 				
 				float min_text_x;
 				switch (GSConfig.OsdPerformancePos)
@@ -480,9 +552,9 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 						break;
 				}
 				win_dl->AddText(ImVec2(min_text_x + shadow_offset, wpos.y + history_size.y - font_size + shadow_offset),
-					IM_COL32(0, 0, 0, 100), text.c_str(), text.c_str() + text.length());
+					IM_COL32(0, 0, 0, 100), frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 				win_dl->AddText(ImVec2(min_text_x, wpos.y + history_size.y - font_size),
-					IM_COL32(255, 255, 255, 255), text.c_str(), text.c_str() + text.length());
+					white_color, frame_times_text.c_str(), frame_times_text.c_str() + frame_times_text.length());
 			}
 			ImGui::End();
 			ImGui::PopFont();
@@ -490,16 +562,15 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
 			ImGui::PopStyleColor(3);
 		}
 	}
-	else if (!fsui_active)
+	else if (!FullscreenUI::HasActiveWindow())
 	{
 		if (GSConfig.OsdShowIndicators)
 		{
 			// We should put the Pause icon in the top right regardless of performance overlay position
-			text = ICON_FA_PAUSE;
-			text_size = standard_font->CalcTextSizeA(font_size, std::numeric_limits<float>::max(), -1.0f, text.c_str(), nullptr, nullptr);
+			text_size = standard_font->CalcTextSizeA(font_size, std::numeric_limits<float>::max(), -1.0f, ICON_FA_PAUSE, nullptr, nullptr);
 			const ImVec2 pause_pos(GetWindowWidth() - margin - text_size.x, margin);
-			dl->AddText(standard_font, font_size, ImVec2(pause_pos.x + shadow_offset, pause_pos.y + shadow_offset), IM_COL32(0, 0, 0, 100), text.c_str());
-			dl->AddText(standard_font, font_size, pause_pos, IM_COL32(255, 255, 255, 255), text.c_str());
+			dl->AddText(standard_font, font_size, ImVec2(pause_pos.x + shadow_offset, pause_pos.y + shadow_offset), IM_COL32(0, 0, 0, 100), ICON_FA_PAUSE);
+			dl->AddText(standard_font, font_size, pause_pos, white_color, ICON_FA_PAUSE);
 		}
 	}
 
@@ -551,7 +622,7 @@ __ri void ImGuiManager::DrawSettingsOverlay(float scale, float margin, float spa
 		else
 			APPEND("IR={} ", static_cast<unsigned>(GSConfig.UpscaleMultiplier));
 
-		APPEND("B={} PL={} ", static_cast<unsigned>(GSConfig.AccurateBlendingUnit), static_cast<unsigned>(GSConfig.TexturePreloading));
+		APPEND("BL={} TPL={} ", static_cast<unsigned>(GSConfig.AccurateBlendingUnit), static_cast<unsigned>(GSConfig.TexturePreloading));
 		if (GSConfig.GPUPaletteConversion)
 			APPEND("PLTX ");
 
@@ -640,7 +711,7 @@ __ri void ImGuiManager::DrawSettingsOverlay(float scale, float margin, float spa
 	dl->AddText(font, font_size,
 		ImVec2(GetWindowWidth() - margin - text_size.x + shadow_offset, position_y + shadow_offset), IM_COL32(0, 0, 0, 100),
 		text.c_str(), text.c_str() + text.length());
-	dl->AddText(font, font_size, ImVec2(GetWindowWidth() - margin - text_size.x, position_y), IM_COL32(255, 255, 255, 255),
+	dl->AddText(font, font_size, ImVec2(GetWindowWidth() - margin - text_size.x, position_y), white_color,
 		text.c_str(), text.c_str() + text.length());
 }
 
@@ -868,7 +939,7 @@ __ri void ImGuiManager::DrawVideoCaptureOverlay(float& position_y, float scale,
 	dl->AddText(standard_font, font_size,
 		ImVec2(GetWindowWidth() - margin - text_size.x - icon_size.x, position_y), IM_COL32(255, 0, 0, 255), ICON);
 	dl->AddText(standard_font, font_size,
-		ImVec2(GetWindowWidth() - margin - text_size.x, position_y), IM_COL32(255, 255, 255, 255), text_msg.c_str(),
+		ImVec2(GetWindowWidth() - margin - text_size.x, position_y), white_color, text_msg.c_str(),
 		text_msg.end_ptr());
 
 	position_y += std::max(icon_size.y, text_size.y) + spacing;
@@ -893,9 +964,20 @@ namespace SaveStateSelectorUI
 	static void RefreshHotkeyLegend();
 	static void Draw();
 	static void ShowSlotOSDMessage();
+	static std::string GetSaveStateTimestampSummary(const std::time_t& modification_time);
 	bool IsOpen();
 
-	static constexpr const char* DATE_TIME_FORMAT = TRANSLATE_NOOP("ImGuiOverlays", "Saved at {0:%H:%M} on {0:%a} {0:%Y/%m/%d}.");
+	static constexpr const char* SAVED_AGO_DAYS_TIME_DATE =
+		TRANSLATE_NOOP("ImGuiOverlays", "Saved {0} days ago at {1:%H:%M} on {1:%a} {1:%Y/%m/%d}");
+	static constexpr const char* SAVED_FUTURE_TIME_DATE =
+		TRANSLATE_NOOP("ImGuiOverlays", "Saved in the future at {0:%H:%M} on {0:%a} {0:%Y/%m/%d}");
+	static constexpr const char* SAVED_AGO_HOURS_MINUTES =
+		TRANSLATE_NOOP("ImGuiOverlays", "Saved {0} hours, {1} minutes ago at {2:%H:%M}");
+	static constexpr const char* SAVED_AGO_MINUTES = TRANSLATE_NOOP("ImGuiOverlays", "Saved {0} minutes ago at {1:%H:%M}");
+	static constexpr const char* SAVED_AGO_SECONDS = TRANSLATE_NOOP("ImGuiOverlays", "Saved {} seconds ago");
+	static constexpr const char* SAVED_AGO_NOW = TRANSLATE_NOOP("ImGuiOverlays", "Saved just now");
+	static constexpr std::time_t ONE_HOUR = 60 * 60; // 3600
+	static constexpr std::time_t TWENTY_FOUR_HOURS = ONE_HOUR * 24; // 86400
 
 	static std::shared_ptr<GSTexture> s_placeholder_texture;
 	static std::string s_load_legend;
@@ -1073,14 +1155,7 @@ void SaveStateSelectorUI::InitializeListEntry(const std::string& serial, u32 crc
 	}
 
 	li->title = fmt::format(TRANSLATE_FS("ImGuiOverlays", "Save Slot {0}"), slot);
-
-	std::tm tm_local = {};
-#ifdef _MSC_VER
-	localtime_s(&tm_local, &sd.ModificationTime);
-#else
-	localtime_r(&sd.ModificationTime, &tm_local);
-#endif
-	li->summary = fmt::format(TRANSLATE_FS("ImGuiOverlays", DATE_TIME_FORMAT), tm_local);
+	li->summary = GetSaveStateTimestampSummary(sd.ModificationTime);
 	li->filename = Path::GetFileName(path);
 
 	u32 screenshot_width, screenshot_height;
@@ -1102,7 +1177,7 @@ void SaveStateSelectorUI::InitializeListEntry(const std::string& serial, u32 crc
 void SaveStateSelectorUI::InitializePlaceholderListEntry(ListEntry* li, std::string path, s32 slot)
 {
 	li->title = fmt::format(TRANSLATE_FS("ImGuiOverlays", "Save Slot {0}"), slot);
-	li->summary = TRANSLATE_STR("ImGuiOverlays", "No save present in this slot.");
+	li->summary = TRANSLATE_STR("ImGuiOverlays", "No save present in this slot");
 	li->filename = Path::GetFileName(path);
 }
 
@@ -1278,26 +1353,15 @@ void SaveStateSelectorUI::ShowSlotOSDMessage()
 	const std::string serial = VMManager::GetDiscSerial();
 	const std::string filename = VMManager::GetSaveStateFileName(serial.c_str(), crc, slot);
 	FILESYSTEM_STAT_DATA sd;
-	std::string date;
-	
-	std::tm tm_local = {};
+	std::string timestamp_summary;
 
 	if (!filename.empty() && FileSystem::StatFile(filename.c_str(), &sd))
-	{
-#ifdef _MSC_VER
-		localtime_s(&tm_local, &sd.ModificationTime);
-#else
-		localtime_r(&sd.ModificationTime, &tm_local);
-#endif
-		date = fmt::format(TRANSLATE_FS("ImGuiOverlays", DATE_TIME_FORMAT), tm_local);
-	}
+		timestamp_summary = GetSaveStateTimestampSummary(sd.ModificationTime);
 	else
-	{
-		date = TRANSLATE_STR("ImGuiOverlays", "no save yet");
-	}
+		timestamp_summary = TRANSLATE_STR("ImGuiOverlays", "no save yet");
 
 	Host::AddIconOSDMessage("ShowSlotOSDMessage", ICON_FA_MAGNIFYING_GLASS,
-		fmt::format(TRANSLATE_FS("Hotkeys", "Save slot {0} selected ({1})."), slot, date),
+		fmt::format(TRANSLATE_FS("Hotkeys", "Save slot {0} selected ({1})."), slot, timestamp_summary),
 		Host::OSD_QUICK_DURATION);
 }
 
@@ -1317,3 +1381,47 @@ void ImGuiManager::RenderOverlays()
 	if (SaveStateSelectorUI::s_open)
 		SaveStateSelectorUI::Draw();
 }
+
+std::string SaveStateSelectorUI::GetSaveStateTimestampSummary(const std::time_t& modification_time)
+{
+
+	std::tm tm_modification_local = {};
+#ifdef _MSC_VER
+	localtime_s(&tm_modification_local, &modification_time);
+#else
+	localtime_r(&modification_time, &tm_modification_local);
+#endif
+
+	const std::time_t current_time = std::time(nullptr);
+	const std::time_t time_since_save = current_time - std::mktime(&tm_modification_local);
+
+	if (time_since_save >= TWENTY_FOUR_HOURS)
+	{
+		return fmt::format(TRANSLATE_FS("ImGuiOverlays", SAVED_AGO_DAYS_TIME_DATE),
+			time_since_save / TWENTY_FOUR_HOURS, tm_modification_local);
+	}
+	else if (time_since_save >= ONE_HOUR)
+	{
+		return fmt::format(TRANSLATE_FS("ImGuiOverlays", SAVED_AGO_HOURS_MINUTES),
+			time_since_save / ONE_HOUR, (time_since_save / 60) % 60, tm_modification_local);
+	}
+	else if (time_since_save >= 60)
+	{
+		return fmt::format(TRANSLATE_FS("ImGuiOverlays", SAVED_AGO_MINUTES),
+			time_since_save / 60, tm_modification_local);
+	}
+	else if (time_since_save >= 5)
+	{
+		return fmt::format(TRANSLATE_FS("ImGuiOverlays", SAVED_AGO_SECONDS),
+			time_since_save);
+	}
+	else if (time_since_save >= 0)
+	{
+		return TRANSLATE_STR("ImGuiOverlays", SAVED_AGO_NOW);
+	}
+	else
+	{
+		return fmt::format(TRANSLATE_FS("ImGuiOverlays", SAVED_FUTURE_TIME_DATE),
+			tm_modification_local);
+	}
+}

pcsx2/Interpreter.cpp

@@ -84,7 +84,7 @@ void intBreakpoint(bool memcheck)
 void intMemcheck(u32 op, u32 bits, bool store)
 {
 	// compute accessed address
-	u32 start = cpuRegs.GPR.r[(op >> 21) & 0x1F].UD[0];
+	u32 start = cpuRegs.GPR.r[(op >> 21) & 0x1F].UL[0];
 	if (static_cast<s16>(op) != 0)
 		start += static_cast<s16>(op);
 	if (bits == 128)

pcsx2/IopBios.cpp

@@ -44,39 +44,39 @@
 
 typedef struct
 {
-	unsigned int mode;
-	unsigned int attr;
-	unsigned int size;
-	unsigned char ctime[8];
-	unsigned char atime[8];
-	unsigned char mtime[8];
-	unsigned int hisize;
+	u32 mode;
+	u32 attr;
+	u32 size;
+	u8 ctime[8];
+	u8 atime[8];
+	u8 mtime[8];
+	u32 hisize;
 } fio_stat_t;
 typedef struct
 {
 	fio_stat_t _fioStat;
 	/** Number of subs (main) / subpart number (sub) */
-	unsigned int private_0;
-	unsigned int private_1;
-	unsigned int private_2;
-	unsigned int private_3;
-	unsigned int private_4;
+	u32 private_0;
+	u32 private_1;
+	u32 private_2;
+	u32 private_3;
+	u32 private_4;
 	/** Sector start.  */
-	unsigned int private_5;
+	u32 private_5;
 } fxio_stat_t;
 
 typedef struct
 {
 	fio_stat_t stat;
 	char name[256];
-	unsigned int unknown;
+	u32 unknown;
 } fio_dirent_t;
 
 typedef struct
 {
 	fxio_stat_t stat;
 	char name[256];
-	unsigned int unknown;
+	u32 unknown;
 } fxio_dirent_t;
 
 static std::string hostRoot;
@@ -171,7 +171,7 @@ namespace R3000A
 		if (!FileSystem::StatFile(file_path.c_str(), &file_stats))
 			return -IOP_ENOENT;
 
-		host_stats->size = file_stats.st_size;
+		host_stats->size = (u32)file_stats.st_size;
 		host_stats->hisize = 0;
 
 		// Convert the mode.
@@ -315,13 +315,13 @@ namespace R3000A
 			switch (whence)
 			{
 				case IOP_SEEK_SET:
-					err = ::lseek(fd, offset, SEEK_SET);
+					err = static_cast<int>(::lseek(fd, offset, SEEK_SET));
 					break;
 				case IOP_SEEK_CUR:
-					err = ::lseek(fd, offset, SEEK_CUR);
+					err = static_cast<int>(::lseek(fd, offset, SEEK_CUR));
 					break;
 				case IOP_SEEK_END:
-					err = ::lseek(fd, offset, SEEK_END);
+					err = static_cast<int>(::lseek(fd, offset, SEEK_END));
 					break;
 				default:
 					return -IOP_EIO;
@@ -332,12 +332,12 @@ namespace R3000A
 
 		virtual int read(void* buf, u32 count) /* Flawfinder: ignore */
 		{
-			return translate_error(::read(fd, buf, count));
+			return translate_error(static_cast<int>(::read(fd, buf, count)));
 		}
 
 		virtual int write(void* buf, u32 count)
 		{
-			return translate_error(::write(fd, buf, count));
+			return translate_error(static_cast<int>(::write(fd, buf, count)));
 		}
 	};
 
@@ -762,7 +762,7 @@ namespace R3000A
 					v0 = host_stat(full_path, (fxio_stat_t*)&buf);
 
 					for (size_t i = 0; i < sizeof(fxio_stat_t); i++)
-						iopMemWrite8(data + i, buf[i]);
+						iopMemWrite8(static_cast<u32>(data + i), buf[i]);
 				}
 				else
 				{
@@ -770,7 +770,7 @@ namespace R3000A
 					v0 = host_stat(full_path, (fio_stat_t*)&buf);
 
 					for (size_t i = 0; i < sizeof(fio_stat_t); i++)
-						iopMemWrite8(data + i, buf[i]);
+						iopMemWrite8(static_cast<u32>(data + i), buf[i]);
 				}
 				pc = ra;
 				return 1;

pcsx2/MTVU.cpp

@@ -186,7 +186,7 @@ void VU_Thread::ExecuteRingBuffer()
 					break;
 				case MTVU_VIF_UNPACK:
 				{
-					u32 vif_copy_size = (uptr)&vif.StructEnd - (uptr)&vif.tag;
+					u32 vif_copy_size = static_cast<u32>((uptr)&vif.StructEnd - (uptr)&vif.tag);
 					Read(&vif.tag, vif_copy_size);
 					ReadRegs(&vifRegs);
 					u32 size = Read();
@@ -467,7 +467,7 @@ void VU_Thread::ExecuteVU(u32 vu_addr, u32 vif_top, u32 vif_itop, u32 fbrst)
 void VU_Thread::VifUnpack(vifStruct& _vif, VIFregisters& _vifRegs, const u8* data, u32 size)
 {
 	MTVU_LOG("MTVU - VifUnpack!");
-	u32 vif_copy_size = (uptr)&_vif.StructEnd - (uptr)&_vif.tag;
+	u32 vif_copy_size = (u32)((uptr)&_vif.StructEnd - (uptr)&_vif.tag);
 	ReserveSpace(1 + size_u32(vif_copy_size) + size_u32(sizeof(VIFregistersMTVU)) + 1 + size_u32(size));
 	Write(MTVU_VIF_UNPACK);
 	Write(&_vif.tag, vif_copy_size);

pcsx2/Patch.cpp

@@ -77,11 +77,11 @@ namespace Patch
 		u8* data_ptr;
 
 		// needed because of the pointer
-		PatchCommand() { std::memset(this, 0, sizeof(*this)); }
+		PatchCommand() { std::memset(static_cast<void*>(this), 0, sizeof(*this)); }
 		PatchCommand(const PatchCommand& p) = delete;
 		PatchCommand(PatchCommand&& p)
 		{
-			std::memcpy(this, &p, sizeof(*this));
+			std::memcpy(static_cast<void*>(this), &p, sizeof(*this));
 			p.data_ptr = nullptr;
 		}
 		~PatchCommand()
@@ -93,7 +93,7 @@ namespace Patch
 		PatchCommand& operator=(const PatchCommand& p) = delete;
 		PatchCommand& operator=(PatchCommand&& p)
 		{
-			std::memcpy(this, &p, sizeof(*this));
+			std::memcpy(static_cast<void*>(this), &p, sizeof(*this));
 			p.data_ptr = nullptr;
 			return *this;
 		}

pcsx2/Pcsx2Config.cpp

@@ -708,8 +708,8 @@ std::optional<bool> Pcsx2Config::GSOptions::TriStateToOptionalBoolean(int value)
 
 Pcsx2Config::GSOptions::GSOptions()
 {
-	bitset[0] = 0;
-	bitset[1] = 0;
+	bitsets[0] = 0;
+	bitsets[1] = 0;
 
 	PCRTCAntiBlur = true;
 	DisableInterlaceOffset = false;
@@ -798,7 +798,8 @@ bool Pcsx2Config::GSOptions::operator==(const GSOptions& right) const
 bool Pcsx2Config::GSOptions::OptionsAreEqual(const GSOptions& right) const
 {
 	return (
-		OpEqu(bitset) &&
+		OpEqu(bitsets[0]) &&
+		OpEqu(bitsets[1]) &&
 
 		OpEqu(InterlaceMode) &&
 		OpEqu(LinearPresent) &&
@@ -991,6 +992,8 @@ void Pcsx2Config::GSOptions::LoadSave(SettingsWrapper& wrap)
 	SettingsWrapBitBoolEx(SaveAlpha, "SaveAlpha");
 	SettingsWrapBitBoolEx(SaveInfo, "SaveInfo");
 	SettingsWrapBitBoolEx(SaveTransferImages, "SaveTransferImages");
+	SettingsWrapBitBoolEx(SaveDrawStats, "SaveDrawStats");
+	SettingsWrapBitBoolEx(SaveFrameStats, "SaveFrameStats");
 	SettingsWrapBitBool(DumpReplaceableTextures);
 	SettingsWrapBitBool(DumpReplaceableMipmaps);
 	SettingsWrapBitBool(DumpTexturesWithFMVActive);
@@ -1841,6 +1844,7 @@ bool Pcsx2Config::PadOptions::Port::operator!=(const PadOptions::Port& right) co
 
 Pcsx2Config::AchievementsOptions::AchievementsOptions()
 {
+	bitset = 0;
 	Enabled = false;
 	HardcoreMode = false;
 	EncoreMode = false;

pcsx2/PrecompiledHeader.h

@@ -9,6 +9,7 @@
 #endif
 
 #include "common/Pcsx2Defs.h"
+#include "common/VectorIntrin.h"
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Include the STL that's actually handy.

pcsx2/Recording/InputRecordingFile.cpp

@@ -66,12 +66,12 @@ const std::string& InputRecordingFile::getFilename() const noexcept
 	return m_filename;
 }
 
-unsigned long InputRecordingFile::getTotalFrames() const noexcept
+u32 InputRecordingFile::getTotalFrames() const noexcept
 {
 	return m_totalFrames;
 }
 
-unsigned long InputRecordingFile::getUndoCount() const noexcept
+u32 InputRecordingFile::getUndoCount() const noexcept
 {
 	return m_undoCount;
 }
@@ -237,7 +237,7 @@ std::vector<PadData> InputRecordingFile::bulkReadPadData(u32 frameStart, u32 fra
 	}
 
 	// TODO - no multi-tap support
-	for (uint64_t currFrame = frameStart; currFrame < frameEnd; currFrame++)
+	for (u32 currFrame = frameStart; currFrame < frameEnd; currFrame++)
 	{
 		const auto padData = readPadData(currFrame, port, 0);
 		if (padData)

pcsx2/Recording/InputRecordingFile.h

@@ -68,8 +68,8 @@ public:
 
 	// Retrieve the input recording's filename (not the path)
 	const std::string& getFilename() const noexcept;
-	unsigned long getTotalFrames() const noexcept;
-	unsigned long getUndoCount() const noexcept;
+	u32 getTotalFrames() const noexcept;
+	u32 getUndoCount() const noexcept;
 
 	void logRecordingMetadata();
 	std::vector<PadData> bulkReadPadData(u32 frameStart, u32 frameEnd, const uint port);
@@ -92,8 +92,8 @@ private:
 	bool m_savestate = false;
 
 	// An signed 32-bit frame limit is equivalent to 1.13 years of continuous 60fps footage
-	unsigned long m_totalFrames = 0;
-	unsigned long m_undoCount = 0;
+	u32 m_totalFrames = 0;
+	u32 m_undoCount = 0;
 
 	// Calculates the position of the current frame in the input recording
 	size_t getRecordingBlockSeekPoint(const u32 frame) const noexcept;

pcsx2/USB/usb-eyetoy/cam-linux.cpp

@@ -56,11 +56,10 @@ namespace usb_eyetoy
 
 		static void store_mpeg_frame(const unsigned char* data, const unsigned int len)
 		{
-			mpeg_mutex.lock();
+			std::lock_guard lock(mpeg_mutex);
 			if (len > 0)
 				memcpy(mpeg_buffer.start, data, len);
 			mpeg_buffer.length = len;
-			mpeg_mutex.unlock();
 		}
 
 		static void process_image(const unsigned char* data, int size)
@@ -642,13 +641,12 @@ namespace usb_eyetoy
 
 		int V4L2::GetImage(uint8_t* buf, size_t len)
 		{
-			mpeg_mutex.lock();
+			std::lock_guard lock(mpeg_mutex);
 			int len2 = mpeg_buffer.length;
 			if (len < mpeg_buffer.length)
 				len2 = len;
 			memcpy(buf, mpeg_buffer.start, len2);
 			mpeg_buffer.length = 0;
-			mpeg_mutex.unlock();
 			return len2;
 		};
 

pcsx2/USB/usb-eyetoy/cam-windows.cpp

@@ -374,11 +374,10 @@ namespace usb_eyetoy
 
 		void store_mpeg_frame(const unsigned char* data, const unsigned int len)
 		{
-			mpeg_mutex.lock();
+			std::lock_guard lock(mpeg_mutex);
 			if (len > 0)
 				memcpy(mpeg_buffer.start, data, len);
 			mpeg_buffer.length = len;
-			mpeg_mutex.unlock();
 		}
 
 		void dshow_callback(unsigned char* data, int len, int bitsperpixel)
@@ -593,13 +592,12 @@ namespace usb_eyetoy
 
 		int DirectShow::GetImage(uint8_t* buf, size_t len)
 		{
-			mpeg_mutex.lock();
+			std::lock_guard lock(mpeg_mutex);
 			int len2 = mpeg_buffer.length;
 			if (static_cast<size_t>(len) < mpeg_buffer.length)
 				len2 = len;
 			memcpy(buf, mpeg_buffer.start, len2);
 			mpeg_buffer.length = 0;
-			mpeg_mutex.unlock();
 			return len2;
 		};