Interpreter: Merge broadcast min/max into one implementation

Plus some ITOF cleanup

bin/resources/GameIndex.yaml

@@ -1270,6 +1270,7 @@ SCAJ-10015:
   region: "NTSC-Unk"
   gsHWFixes:
     alignSprite: 1 # Fixes vertical lines.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SCAJ-20001:
   name: "Ratchet & Clank"
   region: "NTSC-Unk"
@@ -2236,6 +2237,7 @@ SCAJ-20163:
   gsHWFixes:
     halfPixelOffset: 2 # Fixes ghosting.
     autoFlush: 2 # Fixes post lighting.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SCAJ-20164:
   name: "Kingdom Hearts II"
   region: "NTSC-Unk"
@@ -54687,6 +54689,7 @@ SLPS-20485:
   region: "NTSC-J"
   gsHWFixes:
     alignSprite: 1 # Fixes vertical lines.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SLPS-20486:
   name: "太鼓の達人 ドカッ！と大盛り七代目 [ソフト単体]"
   name-sort: "たいこのたつじん どかっ！とおおもりななだいめ [そふとたんたい]"
@@ -54694,6 +54697,7 @@ SLPS-20486:
   region: "NTSC-J"
   gsHWFixes:
     alignSprite: 1 # Fixes vertical lines.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SLPS-20487:
   name: "パチスロキング！ 科学忍者隊ガッチャマン"
   name-sort: "ぱちすろきんぐ！ かがくにんじゃたいがっちゃまん"
@@ -58271,6 +58275,7 @@ SLPS-25586:
     halfPixelOffset: 4 # Fixes post positioning.
     nativeScaling: 1 # Fixes post effects.
     autoFlush: 2 # Fixes post lighting.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SLPS-25587:
   name: "シュガシュガルーン 恋もおしゃれもピックアップ！"
   name-sort: "しゅがしゅがるーん こいもおしゃれもぴっくあっぷ！"
@@ -61304,6 +61309,7 @@ SLPS-73252:
     halfPixelOffset: 4 # Fixes post positioning.
     nativeScaling: 1 # Fixes post effects.
     autoFlush: 2 # Fixes post lighting.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SLPS-73253:
   name: "るろうに剣心-明治剣客浪漫譚- 炎上！京都輪廻 [PlayStation2 the Best]"
   name-sort: "るろうにけんしん めいじけんかくろまんたん えんじょう きょうとりんね [PlayStation2 the Best]"
@@ -69137,6 +69143,7 @@ SLUS-21386:
     halfPixelOffset: 4 # Fixes post positioning.
     nativeScaling: 1 # Fixes post effects.
     autoFlush: 2 # Fixes post lighting.
+    getSkipCount: "GSC_Tekken5" # Fixes upscaling grid, same engine.
 SLUS-21387:
   name: "Warship Gunner 2"
   region: "NTSC-U"

common/FileSystem.cpp

@@ -1354,8 +1354,11 @@ static u32 TranslateWin32Attributes(u32 Win32Attributes)
 }
 
 static u32 RecursiveFindFiles(const char* origin_path, const char* parent_path, const char* path, const char* pattern,
-	u32 flags, FileSystem::FindResultsArray* results, std::vector<std::string>& visited)
+	u32 flags, FileSystem::FindResultsArray* results, std::vector<std::string>& visited, ProgressCallback* cancel)
 {
+	if (cancel && cancel->IsCancelled())
+		return 0;
+
 	std::string search_dir;
 	if (path)
 	{
@@ -1427,11 +1430,11 @@ static u32 RecursiveFindFiles(const char* origin_path, const char* parent_path,
 					if (parent_path)
 					{
 						const std::string recurse_dir = fmt::format("{}\\{}", parent_path, path);
-						nFiles += RecursiveFindFiles(origin_path, recurse_dir.c_str(), utf8_filename.c_str(), pattern, flags, results, visited);
+						nFiles += RecursiveFindFiles(origin_path, recurse_dir.c_str(), utf8_filename.c_str(), pattern, flags, results, visited, cancel);
 					}
 					else
 					{
-						nFiles += RecursiveFindFiles(origin_path, path, utf8_filename.c_str(), pattern, flags, results, visited);
+						nFiles += RecursiveFindFiles(origin_path, path, utf8_filename.c_str(), pattern, flags, results, visited, cancel);
 					}
 				}
 			}
@@ -1494,7 +1497,7 @@ static u32 RecursiveFindFiles(const char* origin_path, const char* parent_path,
 	return nFiles;
 }
 
-bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results)
+bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results, ProgressCallback* cancel)
 {
 	// has a path
 	if (path[0] == '\0')
@@ -1514,7 +1517,7 @@ bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, Fin
 	}
 
 	// enter the recursive function
-	if (RecursiveFindFiles(path, nullptr, nullptr, pattern, flags, results, visited) == 0)
+	if (RecursiveFindFiles(path, nullptr, nullptr, pattern, flags, results, visited, cancel) == 0)
 		return false;
 
 	if (flags & FILESYSTEM_FIND_SORT_BY_NAME)
@@ -2046,8 +2049,11 @@ bool FileSystem::DeleteSymbolicLink(const char* path, Error* error)
 static_assert(sizeof(off_t) == sizeof(s64));
 
 static u32 RecursiveFindFiles(const char* OriginPath, const char* ParentPath, const char* Path, const char* Pattern,
-	u32 Flags, FileSystem::FindResultsArray* pResults, std::vector<std::string>& visited)
+	u32 Flags, FileSystem::FindResultsArray* pResults, std::vector<std::string>& visited, ProgressCallback* cancel)
 {
+	if (cancel && cancel->IsCancelled())
+		return 0;
+
 	std::string tempStr;
 	if (Path)
 	{
@@ -2118,11 +2124,11 @@ static u32 RecursiveFindFiles(const char* OriginPath, const char* ParentPath, co
 					if (ParentPath)
 					{
 						const std::string recursive_dir = fmt::format("{}/{}", ParentPath, Path);
-						nFiles += RecursiveFindFiles(OriginPath, recursive_dir.c_str(), pDirEnt->d_name, Pattern, Flags, pResults, visited);
+						nFiles += RecursiveFindFiles(OriginPath, recursive_dir.c_str(), pDirEnt->d_name, Pattern, Flags, pResults, visited, cancel);
 					}
 					else
 					{
-						nFiles += RecursiveFindFiles(OriginPath, Path, pDirEnt->d_name, Pattern, Flags, pResults, visited);
+						nFiles += RecursiveFindFiles(OriginPath, Path, pDirEnt->d_name, Pattern, Flags, pResults, visited, cancel);
 					}
 				}
 			}
@@ -2177,7 +2183,7 @@ static u32 RecursiveFindFiles(const char* OriginPath, const char* ParentPath, co
 	return nFiles;
 }
 
-bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results)
+bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results, ProgressCallback* cancel)
 {
 	// has a path
 	if (path[0] == '\0')
@@ -2197,7 +2203,7 @@ bool FileSystem::FindFiles(const char* path, const char* pattern, u32 flags, Fin
 	}
 
 	// enter the recursive function
-	if (RecursiveFindFiles(path, nullptr, nullptr, pattern, flags, results, visited) == 0)
+	if (RecursiveFindFiles(path, nullptr, nullptr, pattern, flags, results, visited, cancel) == 0)
 		return false;
 
 	if (flags & FILESYSTEM_FIND_SORT_BY_NAME)

common/FileSystem.h

@@ -67,7 +67,7 @@ namespace FileSystem
 	std::vector<std::string> GetRootDirectoryList();
 
 	/// Search for files
-	bool FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results);
+	bool FindFiles(const char* path, const char* pattern, u32 flags, FindResultsArray* results, ProgressCallback* cancel = nullptr);
 
 	/// Stat file
 	bool StatFile(const char* path, struct stat* st);

pcsx2-qt/Debugger/BreakpointDialog.ui

@@ -212,7 +212,7 @@
          </size>
         </property>
         <property name="text">
-         <string>1</string>
+         <string>4</string>
         </property>
        </widget>
       </item>

pcsx2-qt/Debugger/MemorySearchWidget.cpp

@@ -453,7 +453,7 @@ std::vector<SearchResult> startWorker(DebugInterface* cpu, const SearchType type
 			isSigned ? searchWorker<s32>(cpu, searchResults, type, comparison, start, end, value.toInt(nullptr, base)) : searchWorker<u32>(cpu, searchResults, type, comparison, start, end, value.toUInt(nullptr, base));
 			break;
 		case SearchType::Int64Type:
-			isSigned ? searchWorker<s64>(cpu, searchResults, type, comparison, start, end, value.toLong(nullptr, base)) : searchWorker<s64>(cpu, searchResults, type, comparison, start, end, value.toULongLong(nullptr, base));
+			isSigned ? searchWorker<s64>(cpu, searchResults, type, comparison, start, end, value.toLongLong(nullptr, base)) : searchWorker<u64>(cpu, searchResults, type, comparison, start, end, value.toULongLong(nullptr, base));
 			break;
 		case SearchType::FloatType:
 			searchWorker<float>(cpu, searchResults, type, comparison, start, end, value.toFloat());

pcsx2-qt/MainWindow.cpp

@@ -99,6 +99,9 @@ static QString s_current_disc_serial;
 static quint32 s_current_disc_crc;
 static quint32 s_current_running_crc;
 
+static bool s_record_on_start = false;
+static QString s_path_to_recording_for_record_on_start;
+
 MainWindow::MainWindow()
 {
 	pxAssert(!g_main_window);
@@ -738,7 +741,48 @@ void MainWindow::updateAdvancedSettingsVisibility()
 void MainWindow::onVideoCaptureToggled(bool checked)
 {
 	if (!s_vm_valid)
+	{
+		if (!s_record_on_start)
+		{
+			QMessageBox msgbox(this);
+			msgbox.setIcon(QMessageBox::Question);
+			msgbox.setWindowIcon(QtHost::GetAppIcon());
+			msgbox.setWindowTitle(tr("Record On Boot"));
+			msgbox.setWindowModality(Qt::WindowModal);
+			msgbox.setText(tr("Did you want to start recording on boot?"));
+			msgbox.addButton(QMessageBox::Yes);
+			msgbox.addButton(QMessageBox::No);
+			msgbox.setDefaultButton(QMessageBox::Yes);
+			if (msgbox.exec() == QMessageBox::Yes)
+			{
+				const QString container(QString::fromStdString(
+					Host::GetStringSettingValue("EmuCore/GS", "CaptureContainer", Pcsx2Config::GSOptions::DEFAULT_CAPTURE_CONTAINER)));
+				const QString filter(tr("%1 Files (*.%2)").arg(container.toUpper()).arg(container));
+
+				QString temp(QStringLiteral("%1.%2").arg(QString::fromStdString(GSGetBaseVideoFilename())).arg(container));
+				temp = QDir::toNativeSeparators(QFileDialog::getSaveFileName(this, tr("Video Capture"), temp, filter));
+				s_path_to_recording_for_record_on_start = temp;
+				if (s_path_to_recording_for_record_on_start.isEmpty())
+					return;
+				s_record_on_start = true;
+			}
+		}
+		else
+		{
+			QMessageBox msgbox(this);
+			msgbox.setIcon(QMessageBox::Question);
+			msgbox.setWindowIcon(QtHost::GetAppIcon());
+			msgbox.setWindowTitle(tr("Record On Boot"));
+			msgbox.setWindowModality(Qt::WindowModal);
+			msgbox.setText(tr("Did you want to cancel recording on boot?"));
+			msgbox.addButton(QMessageBox::Yes);
+			msgbox.addButton(QMessageBox::No);
+			msgbox.setDefaultButton(QMessageBox::Yes);
+			if (msgbox.exec() == QMessageBox::Yes)
+				s_record_on_start = false;
+		}
 		return;
+	}
 
 	// Reset the checked state, we'll get updated by the GS thread.
 	QSignalBlocker sb(m_ui.actionVideoCapture);
@@ -750,16 +794,26 @@ void MainWindow::onVideoCaptureToggled(bool checked)
 		return;
 	}
 
-	const QString container(QString::fromStdString(
-		Host::GetStringSettingValue("EmuCore/GS", "CaptureContainer", Pcsx2Config::GSOptions::DEFAULT_CAPTURE_CONTAINER)));
-	const QString filter(tr("%1 Files (*.%2)").arg(container.toUpper()).arg(container));
+	if (s_record_on_start && !s_path_to_recording_for_record_on_start.isEmpty()) 
+	{
+		// We can't start recording immediately, this is called before full GS init (specifically the fps amount)
+		// and GSCapture ends up unhappy.
+		// TODO: Pass some sort of flag or callback to the GS thread to start recording on frame 0.
+		Host::AddOSDMessage(tr("Recording will start in a moment").toStdString(), 3.0f);
+		QTimer::singleShot(2000, []() { g_emu_thread->beginCapture(s_path_to_recording_for_record_on_start); });
+	}
+	else
+	{
+		const QString container(QString::fromStdString(
+			Host::GetStringSettingValue("EmuCore/GS", "CaptureContainer", Pcsx2Config::GSOptions::DEFAULT_CAPTURE_CONTAINER)));
+		const QString filter(tr("%1 Files (*.%2)").arg(container.toUpper()).arg(container));
 
-	QString path(QStringLiteral("%1.%2").arg(QString::fromStdString(GSGetBaseVideoFilename())).arg(container));
-	path = QDir::toNativeSeparators(QFileDialog::getSaveFileName(this, tr("Video Capture"), path, filter));
-	if (path.isEmpty())
-		return;
-
-	g_emu_thread->beginCapture(path);
+		QString path(QStringLiteral("%1.%2").arg(QString::fromStdString(GSGetBaseVideoFilename())).arg(container));
+		path = QDir::toNativeSeparators(QFileDialog::getSaveFileName(this, tr("Video Capture"), path, filter));
+		if (path.isEmpty())
+			return;
+		g_emu_thread->beginCapture(path);
+	}
 }
 
 void MainWindow::onCaptureStarted(const QString& filename)
@@ -904,8 +958,6 @@ void MainWindow::updateEmulationActions(bool starting, bool running, bool stoppi
 	m_ui.actionToolbarSaveState->setEnabled(running);
 
 	m_ui.actionViewGameProperties->setEnabled(running);
-
-	m_ui.actionVideoCapture->setEnabled(running);
 	if (!running && m_ui.actionVideoCapture->isChecked())
 	{
 		QSignalBlocker sb(m_ui.actionVideoCapture);
@@ -1991,6 +2043,11 @@ void MainWindow::onVMStarted()
 	updateWindowTitle();
 	updateStatusBarWidgetVisibility();
 	updateInputRecordingActions(true);
+	if (s_record_on_start)
+	{
+		m_ui.actionVideoCapture->setChecked(true);
+		s_record_on_start = false;
+	}
 }
 
 void MainWindow::onVMPaused()

pcsx2-qt/Settings/GraphicsSettingsWidget.ui

@@ -1055,7 +1055,12 @@
          </item>
          <item>
           <property name="text">
-           <string>Align To Native</string>
+           <string>Align to Native</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>Align to Native - with Texture Offset</string>
           </property>
          </item>
         </widget>

pcsx2-qt/Translations.cpp

@@ -11,6 +11,7 @@
 #include "common/SmallString.h"
 #include "common/StringUtil.h"
 
+#include "pcsx2/ImGui/FullscreenUI.h"
 #include "pcsx2/ImGui/ImGuiManager.h"
 #include "pcsx2/MTGS.h"
 
@@ -191,6 +192,13 @@ void QtHost::InstallTranslator(QWidget* dialog_parent)
 	}
 
 	UpdateGlyphRangesAndClearCache(dialog_parent, language.toStdString());
+
+	if (FullscreenUI::IsInitialized())
+	{
+		MTGS::RunOnGSThread([]() mutable {
+			FullscreenUI::LocaleChanged();
+		});
+	}
 }
 
 const char* QtHost::GetDefaultLanguage()
@@ -220,6 +228,12 @@ std::string Host::TranslatePluralToString(const char* context, const char* msg,
 	return qApp->translate(context, msg, disambiguation, count).toStdString();
 }
 
+bool Host::LocaleCircleConfirm()
+{
+	QLocale& loc = QtHost::s_current_locale;
+	return (loc.language() == QLocale::Japanese) || (loc.language() == QLocale::Chinese) || (loc.language() == QLocale::Korean);
+}
+
 std::vector<std::pair<QString, QString>> QtHost::GetAvailableLanguageList()
 {
 	return {

pcsx2/Config.h

@@ -440,6 +440,7 @@ enum class GSHalfPixelOffset : u8
 	Special,
 	SpecialAggressive,
 	Native,
+	NativeWTexOffset,
 	MaxCount
 };
 

pcsx2/Docs/GameIndex.md

@@ -179,7 +179,7 @@ The clamp modes are also numerically based.
 * bilinearUpscale            [`0` or `1` or `2`]                        {Automatic, Force Bilinear, Force Nearest}     Default: Automatic
 * skipDrawStart              [Value between `0` to `10000`]             {0-10000}                          Default: Off (`0`)
 * skipDrawEnd                [Value between `0` to `10000`]             {0-10000}                          Default: Off (`0`)
-* halfPixelOffset            [`0` or `1` or `2` or `3` or `4`] {Off, Normal Vertex, Special (Texture), Special (Texture Aggressive), Align to Native} Default: Off (`0`)
+* halfPixelOffset            [`0` or `1` or `2` or `3` or `4` or `5`] {Off, Normal Vertex, Special (Texture), Special (Texture Aggressive), Align to Native, Align to Native with Texture Offsets} Default: Off (`0`)
 * nativeScaling              [`0` or `1` or `2`]    {Normal, Aggressive or Off}             Default: Normal (`0`)
 * nativePaletteDraw          [`0` or `1`]           {Off, On}                               Default: Off (`0`)
 * roundSprite                [`0` or `1` or `2`]    {Off, Half or Full}                     Default: Off (`0`)

pcsx2/Docs/gamedb-schema.json

@@ -237,7 +237,7 @@
             "halfPixelOffset": {
               "type": "integer",
               "minimum": 0,
-              "maximum": 4
+              "maximum": 5
             },
             "nativeScaling": {
               "type": "integer",

pcsx2/GS/Renderers/HW/GSHwHack.cpp

@@ -212,10 +212,8 @@ bool GSHwHack::GSC_Tekken5(GSRendererHW& r, int& skip)
 {
 	if (skip == 0)
 	{
-		if (r.IsPossibleChannelShuffle())
+		if (r.IsPossibleChannelShuffle() && (RTBP0 & 31))
 		{
-			pxAssertMsg((RTBP0 & 31) == 0, "TEX0 should be page aligned");
-
 			GSVertex* v = &r.m_vertex.buff[0];
 
 			// Make sure we're detecting the right effect.

pcsx2/GS/Renderers/HW/GSRendererHW.cpp

@@ -732,7 +732,7 @@ void GSRendererHW::ConvertSpriteTextureShuffle(u32& process_rg, u32& process_ba,
 GSVector4 GSRendererHW::RealignTargetTextureCoordinate(const GSTextureCache::Source* tex)
 {
 	if (GSConfig.UserHacks_HalfPixelOffset <= GSHalfPixelOffset::Normal ||
-		GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::Native ||
+		GSConfig.UserHacks_HalfPixelOffset >= GSHalfPixelOffset::Native ||
 		GetUpscaleMultiplier() == 1.0f || m_downscale_source || tex->GetScale() == 1.0f)
 	{
 		return GSVector4(0.0f);
@@ -5160,6 +5160,26 @@ __ri void GSRendererHW::EmulateTextureSampler(const GSTextureCache::Target* rt,
 
 		const GSVector4 half_pixel = RealignTargetTextureCoordinate(tex);
 		m_conf.cb_vs.texture_offset = GSVector2(half_pixel.x, half_pixel.y);
+
+		// Can be seen with the cabin part of the ship in God of War, offsets are required when using FST.
+		// ST uses a normalized position so doesn't need an offset here, will break Bionicle Heroes.
+		if (GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::NativeWTexOffset)
+		{
+			if (!m_downscale_source && tex->m_scale > 1.0f)
+			{
+				const GSVertex* v = &m_vertex.buff[0];
+				if (PRIM->FST)
+				{
+					const int x1_frac = ((v[1].XYZ.X - m_context->XYOFFSET.OFX) & 0xf);
+					const int y1_frac = ((v[1].XYZ.Y - m_context->XYOFFSET.OFY) & 0xf);
+
+					if (!(x1_frac & 8))
+						m_conf.cb_vs.texture_offset.x = 6.0f + (0.25f * tex->m_scale);
+					if (!(y1_frac & 8))
+						m_conf.cb_vs.texture_offset.y = 6.0f + (0.25f * tex->m_scale);
+				}
+			}
+		}
 	}
 	else if (tex->m_target)
 	{
@@ -5211,6 +5231,33 @@ __ri void GSRendererHW::EmulateTextureSampler(const GSTextureCache::Target* rt,
 		const GSVector4 half_pixel = RealignTargetTextureCoordinate(tex);
 		m_conf.cb_vs.texture_offset = GSVector2(half_pixel.x, half_pixel.y);
 
+		if (GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::NativeWTexOffset)
+		{
+			if (!m_downscale_source && tex->m_scale > 1.0f)
+			{
+				const GSVertex* v = &m_vertex.buff[0];
+				if (PRIM->FST)
+				{
+					const int x1_frac = ((v[1].XYZ.X - m_context->XYOFFSET.OFX) & 0xf);
+					const int y1_frac = ((v[1].XYZ.Y - m_context->XYOFFSET.OFY) & 0xf);
+
+					if (!(x1_frac & 8))
+						m_conf.cb_vs.texture_offset.x = 6.0f + (0.25f * tex->m_scale);
+					if (!(y1_frac & 8))
+						m_conf.cb_vs.texture_offset.y = 6.0f + (0.25f * tex->m_scale);
+				}
+				else
+				{
+					const float tw = static_cast<float>(1 << m_cached_ctx.TEX0.TW);
+					const float th = static_cast<float>(1 << m_cached_ctx.TEX0.TH);
+					const float q = v[0].RGBAQ.Q;
+
+					m_conf.cb_vs.texture_offset.x = 0.5f * q / tw;
+					m_conf.cb_vs.texture_offset.y = 0.5f * q / th;
+				}
+			}
+		}
+
 		if (m_vt.m_primclass == GS_SPRITE_CLASS && GSLocalMemory::m_psm[m_cached_ctx.TEX0.PSM].pal > 0 && m_index.tail >= 4)
 		{
 			HandleManualDeswizzle();
@@ -5540,7 +5587,7 @@ __ri void GSRendererHW::HandleTextureHazards(const GSTextureCache::Target* rt, c
 			// When using native HPO, the top-left column/row of pixels are often not drawn. Clamp these away to avoid sampling black,
 			// causing bleeding into the edges of the downsampled texture.
 			const u32 downsample_factor = static_cast<u32>(src_target->GetScale());
-			const GSVector2i clamp_min = (GSConfig.UserHacks_HalfPixelOffset != GSHalfPixelOffset::Native) ?
+			const GSVector2i clamp_min = (GSConfig.UserHacks_HalfPixelOffset < GSHalfPixelOffset::Native) ?
 											 GSVector2i(0, 0) :
 											 GSVector2i(downsample_factor, downsample_factor);
 			GSVector4i copy_rect = tmm.coverage;
@@ -6272,7 +6319,8 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 	float sx, sy, ox2, oy2;
 	const float ox = static_cast<float>(static_cast<int>(m_context->XYOFFSET.OFX));
 	const float oy = static_cast<float>(static_cast<int>(m_context->XYOFFSET.OFY));
-	if (GSConfig.UserHacks_HalfPixelOffset != GSHalfPixelOffset::Native && rtscale > 1.0f)
+
+	if ((GSConfig.UserHacks_HalfPixelOffset < GSHalfPixelOffset::Native || m_channel_shuffle) && rtscale > 1.0f)
 	{
 		sx = 2.0f * rtscale / (rtsize.x << 4);
 		sy = 2.0f * rtscale / (rtsize.y << 4);
@@ -6301,8 +6349,31 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 		const int unscaled_y = rt_or_ds ? rt_or_ds->GetUnscaledHeight() : 0;
 		sx = 2.0f / (unscaled_x << 4);
 		sy = 2.0f / (unscaled_y << 4);
-		ox2 = -1.0f / unscaled_x;
-		oy2 = -1.0f / unscaled_y;
+		
+		if (GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::NativeWTexOffset)
+		{
+			ox2 = (-1.0f / (unscaled_x * rtscale));
+			oy2 = (-1.0f / (unscaled_y * rtscale));
+			
+			// Having the vertex negatively offset is a common thing for copying sprites but this causes problems when upscaling, so we need to further adjust the offset.
+			// This kinda screws things up when using ST, so let's not.
+			if (m_vt.m_primclass == GS_SPRITE_CLASS && rtscale > 1.0f && (!tex || PRIM->FST))
+			{
+				const GSVertex* v = &m_vertex.buff[0];
+				const int x1_frac = ((v[1].XYZ.X - m_context->XYOFFSET.OFX) & 0xf);
+				const int y1_frac = ((v[1].XYZ.Y - m_context->XYOFFSET.OFY) & 0xf);
+				if (x1_frac & 8)
+					ox2 *= 1.0f + ((static_cast<float>(16 - x1_frac) / 8.0f) * rtscale);
+
+				if (y1_frac & 8)
+					oy2 *= 1.0f + ((static_cast<float>(16 - y1_frac) / 8.0f) * rtscale);
+			}
+		}
+		else
+		{
+			ox2 = -1.0f / unscaled_x;
+			oy2 = -1.0f / unscaled_y;
+		}
 	}
 
 	m_conf.cb_vs.vertex_scale = GSVector2(sx, sy);

pcsx2/GS/Renderers/HW/GSTextureCache.cpp

@@ -2132,8 +2132,8 @@ GSTextureCache::Target* GSTextureCache::LookupTarget(GIFRegTEX0 TEX0, const GSVe
 				// And invalidate the target, we're drawing over it so we don't care what's there.
 				// We can't do this when upscaling, because of the vertex offset, the top/left rows often aren't drawn.
 				GL_INS("TC: Invalidating%s target %s[%x] because it's completely overwritten.", to_string(type),
-					(scale > 1.0f && GSConfig.UserHacks_HalfPixelOffset == GSHalfPixelOffset::Native) ? "[clearing] " : "", dst->m_TEX0.TBP0);
-				if (scale > 1.0f && GSConfig.UserHacks_HalfPixelOffset != GSHalfPixelOffset::Native)
+					(scale > 1.0f && GSConfig.UserHacks_HalfPixelOffset >= GSHalfPixelOffset::Native) ? "[clearing] " : "", dst->m_TEX0.TBP0);
+				if (scale > 1.0f && GSConfig.UserHacks_HalfPixelOffset < GSHalfPixelOffset::Native)
 				{
 					if (dst->m_type == RenderTarget)
 						g_gs_device->ClearRenderTarget(dst->m_texture, 0);

pcsx2/GameList.cpp

@@ -593,15 +593,14 @@ void GameList::ScanDirectory(const char* path, bool recursive, bool only_cache,
 	progress->PushState();
 	progress->SetStatusText(fmt::format(
 		recursive ? TRANSLATE_FS("GameList", "Scanning directory {} (recursively)...") :
-					TRANSLATE_FS("GameList", "Scanning directory {}..."),
-		path)
-								.c_str());
+		            TRANSLATE_FS("GameList", "Scanning directory {}..."),
+		path).c_str());
 
 	FileSystem::FindResultsArray files;
 	FileSystem::FindFiles(path, "*",
 		recursive ? (FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_HIDDEN_FILES | FILESYSTEM_FIND_RECURSIVE) :
-					(FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_HIDDEN_FILES),
-		&files);
+		            (FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_HIDDEN_FILES),
+		&files, progress);
 
 	u32 files_scanned = 0;
 	progress->SetProgressRange(static_cast<u32>(files.size()));

pcsx2/ImGui/FullscreenUI.cpp

@@ -237,6 +237,7 @@ namespace FullscreenUI
 	static void DrawAboutWindow();
 	static void OpenAboutWindow();
 	static void GetStandardSelectionFooterText(SmallStringBase& dest, bool back_instead_of_cancel);
+	static void ApplyConfirmSetting(const SettingsInterface* bsi = nullptr);
 
 	static MainWindowType s_current_main_window = MainWindowType::None;
 	static PauseSubMenu s_current_pause_submenu = PauseSubMenu::None;
@@ -570,6 +571,64 @@ void ImGuiFullscreen::GetInputDialogHelpText(SmallStringBase& dest)
 	}
 }
 
+void FullscreenUI::ApplyConfirmSetting(const SettingsInterface* bsi)
+{
+	ImGuiIO& io = ImGui::GetIO();
+	SmallString swap_mode;
+	if (bsi)
+		swap_mode = bsi->GetSmallStringValue("UI", "SwapOKFullscreenUI", "auto");
+	else
+		swap_mode = Host::GetBaseSmallStringSettingValue("UI", "SwapOKFullscreenUI", "auto");
+
+	if (swap_mode == "true")
+		io.ConfigNavSwapGamepadButtons = true;
+	else if (swap_mode == "false")
+		io.ConfigNavSwapGamepadButtons = false;
+	else if (swap_mode == "auto")
+	{
+		// Check language
+		if (Host::LocaleCircleConfirm())
+		{
+			io.ConfigNavSwapGamepadButtons = true;
+			return;
+		}
+
+		// Check BIOS
+		SmallString bios_selection;
+		if (bsi)
+			bios_selection = bsi->GetSmallStringValue("Filenames", "BIOS", "");
+		else
+			bios_selection = Host::GetBaseSmallStringSettingValue("Filenames", "BIOS", "");
+
+		if (bios_selection != "")
+		{
+			u32 bios_version, bios_region;
+			std::string bios_description, bios_zone;
+			if (IsBIOS(Path::Combine(EmuFolders::Bios, bios_selection).c_str(), bios_version, bios_description, bios_region, bios_zone))
+			{
+				// Japan, Asia, China
+				if (bios_region == 0 || bios_region == 4 || bios_region == 6)
+				{
+					io.ConfigNavSwapGamepadButtons = true;
+					return;
+				}
+			}
+		}
+
+		// X is confirm
+		io.ConfigNavSwapGamepadButtons = false;
+		return;
+	}
+	// Invalid setting
+	else
+		io.ConfigNavSwapGamepadButtons = false;
+}
+
+void FullscreenUI::LocaleChanged()
+{
+	ApplyConfirmSetting();
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Main
 //////////////////////////////////////////////////////////////////////////
@@ -582,9 +641,9 @@ bool FullscreenUI::Initialize()
 	if (s_tried_to_initialize)
 		return false;
 
-	ImGuiFullscreen::SetTheme(Host::GetBaseBoolSettingValue("UI", "UseLightFullscreenUITheme", false));
+	ImGuiFullscreen::SetTheme(Host::GetBaseStringSettingValue("UI", "FullscreenUITheme", "Dark"));
 	ImGuiFullscreen::UpdateLayoutScale();
-	ImGui::GetIO().ConfigNavSwapGamepadButtons = Host::GetBaseBoolSettingValue("UI", "SwapOKFullscreenUI");
+	ApplyConfirmSetting();
 
 	if (!ImGuiManager::AddFullscreenFontsIfMissing() || !ImGuiFullscreen::Initialize("fullscreenui/placeholder.png") || !LoadResources())
 	{
@@ -636,6 +695,8 @@ void FullscreenUI::CheckForConfigChanges(const Pcsx2Config& old_config)
 	if (!IsInitialized())
 		return;
 
+	ImGuiFullscreen::SetTheme(Host::GetBaseStringSettingValue("UI", "FullscreenUITheme", "Dark"));
+
 	// 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)
@@ -649,6 +710,13 @@ void FullscreenUI::CheckForConfigChanges(const Pcsx2Config& old_config)
 		});
 		MTGS::WaitGS(false, false, false);
 	}
+
+	if (old_config.FullpathToBios() != EmuConfig.FullpathToBios())
+	{
+		MTGS::RunOnGSThread([]() {
+			ApplyConfirmSetting();
+		});
+	}
 }
 
 void FullscreenUI::OnVMStarted()
@@ -933,7 +1001,7 @@ bool FullscreenUI::LoadResources()
 	s_fallback_exe_texture = LoadTexture("fullscreenui/applications-system.png");
 
 	for (u32 i = static_cast<u32>(GameDatabaseSchema::Compatibility::Nothing);
-		 i <= static_cast<u32>(GameDatabaseSchema::Compatibility::Perfect); i++)
+		i <= static_cast<u32>(GameDatabaseSchema::Compatibility::Perfect); i++)
 	{
 		s_game_compatibility_textures[i - 1] = LoadTexture(fmt::format("icons/star-{}.png", i - 1).c_str());
 	}
@@ -1317,8 +1385,7 @@ void FullscreenUI::DrawLandingWindow()
 			std::make_pair(ICON_PF_BUTTON_TRIANGLE, FSUI_VSTR("Game List")),
 			std::make_pair(ICON_PF_BUTTON_SQUARE, FSUI_VSTR("Toggle Fullscreen")),
 			std::make_pair(circleOK ? ICON_PF_BUTTON_CIRCLE : ICON_PF_BUTTON_CROSS, FSUI_VSTR("Select")),
-			std::make_pair(circleOK ? ICON_PF_BUTTON_CROSS : ICON_PF_BUTTON_CIRCLE, FSUI_VSTR("Exit"))
-		});
+			std::make_pair(circleOK ? ICON_PF_BUTTON_CROSS : ICON_PF_BUTTON_CIRCLE, FSUI_VSTR("Exit"))});
 	}
 	else
 	{
@@ -1328,8 +1395,7 @@ void FullscreenUI::DrawLandingWindow()
 			std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Navigate")),
 			std::make_pair(ICON_PF_SPACE, FSUI_VSTR("Game List")),
 			std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
-			std::make_pair(ICON_PF_ESC, FSUI_VSTR("Exit"))
-		});
+			std::make_pair(ICON_PF_ESC, FSUI_VSTR("Exit"))});
 	}
 }
 
@@ -1440,16 +1506,14 @@ void FullscreenUI::DrawExitWindow()
 		SetFullscreenFooterText(std::array{
 			std::make_pair(ICON_PF_DPAD_LEFT_RIGHT, FSUI_VSTR("Navigate")),
 			std::make_pair(circleOK ? ICON_PF_BUTTON_CIRCLE : ICON_PF_BUTTON_CROSS, FSUI_VSTR("Select")),
-			std::make_pair(circleOK ? ICON_PF_BUTTON_CROSS : ICON_PF_BUTTON_CIRCLE, FSUI_VSTR("Back"))}
-		);
+			std::make_pair(circleOK ? ICON_PF_BUTTON_CROSS : ICON_PF_BUTTON_CIRCLE, FSUI_VSTR("Back"))});
 	}
 	else
 	{
 		SetFullscreenFooterText(std::array{
 			std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Navigate")),
 			std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
-			std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))}
-		);
+			std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))});
 	}
 }
 
@@ -3147,17 +3211,50 @@ void FullscreenUI::DrawSummarySettingsPage()
 
 void FullscreenUI::DrawInterfaceSettingsPage()
 {
+	static constexpr const char* s_theme_name[] = {
+		FSUI_NSTR("Dark"),
+		FSUI_NSTR("Light"),
+		FSUI_NSTR("Grey Matter"),
+		FSUI_NSTR("Untouched Lagoon"),
+		FSUI_NSTR("Baby Pastel"),
+		FSUI_NSTR("Pizza Time!"),
+		FSUI_NSTR("PCSX2 Blue"),
+		FSUI_NSTR("Scarlet Devil"),
+		FSUI_NSTR("Violet Angel"),
+		FSUI_NSTR("Cobalt Sky"),
+		FSUI_NSTR("AMOLED"),
+	};
+
+	static constexpr const char* s_theme_value[] = {
+		"Dark",
+		"Light",
+		"GreyMatter",
+		"UntouchedLagoon",
+		"BabyPastel",
+		"PizzaBrown",
+		"PCSX2Blue",
+		"ScarletDevil",
+		"VioletAngel",
+		"CobaltSky",
+		"AMOLED",
+	};
+
 	SettingsInterface* bsi = GetEditingSettingsInterface();
 
 	BeginMenuButtons();
 
-	MenuHeading(FSUI_CSTR("Behaviour"));
+	MenuHeading(FSUI_CSTR("Appearance"));
+	DrawStringListSetting(bsi, FSUI_ICONSTR(ICON_FA_PAINT_BRUSH, "Theme"),
+		FSUI_CSTR("Selects the color style to be used for Big Picture Mode."),
+		"UI", "FullscreenUITheme", "Dark", s_theme_name, s_theme_value, std::size(s_theme_name), true);
+	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_INFO_CIRCLE, "Use Save State Selector"),
+		FSUI_CSTR("Show a save state selector UI when switching slots instead of showing a notification bubble."),
+		"EmuCore", "UseSavestateSelector", 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",
 		"InhibitScreensaver", true);
-	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_USER_CIRCLE, "Enable Discord Presence"),
-		FSUI_CSTR("Shows the game you are currently playing as part of your profile on Discord."), "UI", "DiscordPresence", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_PAUSE, "Pause On Start"), FSUI_CSTR("Pauses the emulator when a game is started."), "UI",
 		"StartPaused", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE, "Pause On Focus Loss"),
@@ -3177,22 +3274,56 @@ void FullscreenUI::DrawInterfaceSettingsPage()
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_ARCHIVE, "Create Save State Backups"),
 		FSUI_CSTR("Creates a backup copy of a save state if it already exists when the save is created. The backup copy has a .backup suffix"),
 		"EmuCore", "BackupSavestate", true);
-	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_INFO_CIRCLE, "Use Save State Selector"),
-		FSUI_CSTR("Show a save state selector UI when switching slots instead of showing a notification bubble."),
-		"EmuCore", "UseSavestateSelector", true);
-	if (DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_LIGHTBULB, "Use Light Theme"),
-			FSUI_CSTR("Uses a light coloured theme instead of the default dark theme."), "UI", "UseLightFullscreenUITheme", false))
+	// DrawStringListSetting dosn't have a callback for applying settings
+	const SmallString swap_mode = bsi->GetSmallStringValue("UI", "SwapOKFullscreenUI", "auto");
+	static constexpr const char* swap_names[] = {
+		FSUI_NSTR("Automatic"),
+		FSUI_NSTR("Enabled"),
+		FSUI_NSTR("Disabled"),
+	};
+	static constexpr const char* swap_values[] = {
+		"auto",
+		"true",
+		"false",
+	};
+	size_t swap_index = std::size(swap_values);
+	for (size_t i = 0; i < std::size(swap_values); i++)
 	{
-		ImGuiFullscreen::SetTheme(bsi->GetBoolValue("UI", "UseLightFullscreenUITheme", false));
+		if (swap_mode == swap_values[i])
+		{
+			swap_index = i;
+			break;
+		}
 	}
-	SmallStackString<256> SwapSummery;
-	SwapSummery.format(FSUI_FSTR("Uses {} as confirm when using a controller"), ICON_PF_BUTTON_CIRCLE);
-	if (DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_GAMEPAD, "Swap OK/Cancel in Big Picture Mode"),
-			SwapSummery.c_str(), "UI", "SwapOKFullscreenUI", false))
+
+	SmallStackString<256> swap_summery;
+	swap_summery.format(FSUI_FSTR("Uses {} as confirm when using a controller"), ICON_PF_BUTTON_CIRCLE);
+	if (MenuButtonWithValue(FSUI_ICONSTR(ICON_FA_GAMEPAD, "Swap OK/Cancel in Big Picture Mode"), swap_summery.c_str(),
+			(swap_index < std::size(swap_values)) ? Host::TranslateToCString(TR_CONTEXT, swap_names[swap_index]) : FSUI_CSTR("Unknown")))
 	{
-		ImGui::GetIO().ConfigNavSwapGamepadButtons = bsi->GetBoolValue("UI", "SwapOKFullscreenUI", false);
+		ImGuiFullscreen::ChoiceDialogOptions cd_options;
+		cd_options.reserve(std::size(swap_values));
+		for (size_t i = 0; i < std::size(swap_values); i++)
+			cd_options.emplace_back(Host::TranslateToString(TR_CONTEXT, swap_names[i]), i == static_cast<size_t>(swap_index));
+
+		OpenChoiceDialog(FSUI_ICONSTR(ICON_FA_GAMEPAD, "Swap OK/Cancel in Big Picture Mode"), false, std::move(cd_options), [](s32 index, const std::string& title, bool checked) {
+			if (index >= 0)
+			{
+				auto lock = Host::GetSettingsLock();
+				SettingsInterface* bsi = GetEditingSettingsInterface(false);
+				bsi->SetStringValue("UI", "SwapOKFullscreenUI", swap_values[index]);
+				SetSettingsChanged(bsi);
+				ApplyConfirmSetting(bsi);
+			}
+
+			CloseChoiceDialog();
+		});
 	}
 
+	MenuHeading(FSUI_CSTR("Integration"));
+	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_USER_CIRCLE, "Enable Discord Presence"),
+		FSUI_CSTR("Shows the game you are currently playing as part of your profile on Discord."), "UI", "DiscordPresence", false);
+
 	MenuHeading(FSUI_CSTR("Game Display"));
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Start Fullscreen"),
 		FSUI_CSTR("Automatically switches to fullscreen mode when a game is started."), "UI", "StartFullscreen", false);
@@ -3306,6 +3437,7 @@ void FullscreenUI::DrawBIOSSettingsPage()
 				SettingsInterface* bsi = GetEditingSettingsInterface(game_settings);
 				bsi->SetStringValue("Filenames", "BIOS", values[index].c_str());
 				SetSettingsChanged(bsi);
+				ApplyConfirmSetting(bsi);
 				CloseChoiceDialog();
 			});
 	}
@@ -3824,7 +3956,8 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 				FSUI_NSTR("Normal (Vertex)"),
 				FSUI_NSTR("Special (Texture)"),
 				FSUI_NSTR("Special (Texture - Aggressive)"),
-				FSUI_NSTR("Align To Native"),
+				FSUI_NSTR("Align to Native"),
+				FSUI_NSTR("Align to Native - with Texture Offset"),
 			};
 			static constexpr const char* s_native_scaling_options[] = {
 				FSUI_NSTR("Normal (Default)"),
@@ -3992,8 +4125,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 	static constexpr const char* s_gsdump_compression[] = {
 		FSUI_NSTR("Uncompressed"),
 		FSUI_NSTR("LZMA (xz)"),
-		FSUI_NSTR("Zstandard (zst)")
-		};
+		FSUI_NSTR("Zstandard (zst)")};
 
 	if (show_advanced_settings)
 	{
@@ -4783,15 +4915,13 @@ void FullscreenUI::DrawAdvancedSettingsPage()
 		FSUI_NSTR("Uncompressed"),
 		FSUI_NSTR("Deflate64"),
 		FSUI_NSTR("Zstandard"),
-		FSUI_NSTR("LZMA2")
-	};
+		FSUI_NSTR("LZMA2")};
 
 	static constexpr const char* s_savestate_compression_ratio[] = {
 		FSUI_NSTR("Low (Fast)"),
 		FSUI_NSTR("Medium (Recommended)"),
 		FSUI_NSTR("High"),
-		FSUI_NSTR("Very High (Slow, Not Recommended)")
-	};
+		FSUI_NSTR("Very High (Slow, Not Recommended)")};
 
 	if (show_advanced_settings)
 	{
@@ -7575,7 +7705,8 @@ TRANSLATE_NOOP("FullscreenUI", "Merge Targets");
 TRANSLATE_NOOP("FullscreenUI", "Normal (Vertex)");
 TRANSLATE_NOOP("FullscreenUI", "Special (Texture)");
 TRANSLATE_NOOP("FullscreenUI", "Special (Texture - Aggressive)");
-TRANSLATE_NOOP("FullscreenUI", "Align To Native");
+TRANSLATE_NOOP("FullscreenUI", "Align to Native");
+TRANSLATE_NOOP("FullscreenUI", "Align to Native - with Texture Offset");
 TRANSLATE_NOOP("FullscreenUI", "Aggressive");
 TRANSLATE_NOOP("FullscreenUI", "Half");
 TRANSLATE_NOOP("FullscreenUI", "Force Bilinear");

pcsx2/ImGui/FullscreenUI.h

@@ -32,6 +32,7 @@ namespace FullscreenUI
 	void ReturnToPreviousWindow();
 	void ReturnToMainWindow();
 	void SetStandardSelectionFooterText(bool back_instead_of_cancel);
+	void LocaleChanged();
 
 	void Shutdown(bool clear_state);
 	void Render();
@@ -51,4 +52,7 @@ namespace Host
 
 	void OnCoverDownloaderOpenRequested();
 	void OnCreateMemoryCardOpenRequested();
+
+	/// Did Playstation in the currently selected locale use circle as confirm
+	bool LocaleCircleConfirm();
 } // namespace Host

pcsx2/ImGui/ImGuiFullscreen.cpp

@@ -86,7 +86,6 @@ namespace ImGuiFullscreen
 	static u32 s_menu_button_index = 0;
 	static u32 s_close_button_state = 0;
 	static FocusResetType s_focus_reset_queued = FocusResetType::None;
-	static bool s_light_theme = false;
 
 	static LRUCache<std::string, std::shared_ptr<GSTexture>> s_texture_cache(128, true);
 	static std::shared_ptr<GSTexture> s_placeholder_texture;
@@ -2668,10 +2667,10 @@ void ImGuiFullscreen::DrawNotifications(ImVec2& position, float spacing)
 	ImFont* const title_font = ImGuiFullscreen::g_large_font;
 	ImFont* const text_font = ImGuiFullscreen::g_medium_font;
 
-	const u32 toast_background_color = s_light_theme ? IM_COL32(241, 241, 241, 255) : IM_COL32(0x21, 0x21, 0x21, 255);
-	const u32 toast_border_color = s_light_theme ? IM_COL32(0x88, 0x88, 0x88, 255) : IM_COL32(0x48, 0x48, 0x48, 255);
-	const u32 toast_title_color = s_light_theme ? IM_COL32(1, 1, 1, 255) : IM_COL32(0xff, 0xff, 0xff, 255);
-	const u32 toast_text_color = s_light_theme ? IM_COL32(0, 0, 0, 255) : IM_COL32(0xff, 0xff, 0xff, 255);
+	const u32 toast_background_color = IM_COL32(0x21, 0x21, 0x21, 255);
+	const u32 toast_border_color = IM_COL32(0x48, 0x48, 0x48, 255);
+	const u32 toast_title_color = IM_COL32(0xff, 0xff, 0xff, 255);
+	const u32 toast_text_color = IM_COL32(0xff, 0xff, 0xff, 255);
 
 	for (u32 index = 0; index < static_cast<u32>(s_notifications.size());)
 	{
@@ -2839,13 +2838,10 @@ void ImGuiFullscreen::DrawToast()
 	}
 }
 
-void ImGuiFullscreen::SetTheme(bool light)
+void ImGuiFullscreen::SetTheme(std::string_view theme)
 {
-	s_light_theme = light;
-
-	if (!light)
+	if (theme == "Dark")
 	{
-		// dark
 		UIBackgroundColor = HEX_TO_IMVEC4(0x212121, 0xff);
 		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
 		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
@@ -2863,9 +2859,8 @@ void ImGuiFullscreen::SetTheme(bool light)
 		UISecondaryWeakColor = HEX_TO_IMVEC4(0x002171, 0xff);
 		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
 	}
-	else
+	else if (theme == "Light")
 	{
-		// light
 		UIBackgroundColor = HEX_TO_IMVEC4(0xc8c8c8, 0xff);
 		UIBackgroundTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
 		UIBackgroundLineColor = HEX_TO_IMVEC4(0xe1e2e1, 0xff);
@@ -2883,4 +2878,175 @@ void ImGuiFullscreen::SetTheme(bool light)
 		UISecondaryWeakColor = HEX_TO_IMVEC4(0xc0cfff, 0xff);
 		UISecondaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
 	}
+	else if (theme == "AMOLED")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0x0c0c0c, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x212121, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x0a0a0a, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xb5b5b5, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x8d8d8d, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0x191919, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x474747, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+	}
+	else if (theme == "CobaltSky")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x2b3760, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0x3b54ac, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x2b3760, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x202e5a, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xb5b5b5, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x222c4d, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x8d8d8d, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0x245dda, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x3a3d7b, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+	}
+	else if (theme == "GreyMatter")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x353944, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0x484d57, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x212121, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x292d35, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xb5b5b5, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x212121, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x8d8d8d, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0x191919, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x2a2e36, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+	}
+	else if (theme == "UntouchedLagoon")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x9db1bb, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0x1b7f7f, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x488c8c, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0xa2c2bc, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xadcfc8, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x488c8c, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x4b4b4b, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0x2a5151, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x475055, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+	}
+	else if (theme == "BabyPastel")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0xf1d9ee, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xe05885, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0xe05885, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0xeba0b9, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0xffaec9, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xe05885, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0xc3859a, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x4b4b4b, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0xeba0b9, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0xe05885, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0xdc6c68, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0xab5451, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+	}
+	else if (theme == "PizzaBrown")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0xd9c9ba, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0xaa5a36, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0xefad42, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0xe9bb93, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xf9e7ac, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0xefad42, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x4b4b4b, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0xaf1c2f, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0xab5451, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+	}
+	else if (theme == "ScarletDevil")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x782c44, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0xf0f0f0, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0xa73e5f, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x88475d, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x4f2c44, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0xb5b5b5, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x632438, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0xc80000, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x8a334e, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+	}
+	else if (theme == "VioletAngel")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x6e1e7d, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0x862c9c, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0x862c9c, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0x502657, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x321846, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0x9833d6, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x70269e, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x969696, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0xe200cb, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0xff00e6, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x561d79, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+	}
+	else if (theme == "PCSX2Blue")
+	{
+		UIBackgroundColor = HEX_TO_IMVEC4(0x819af0, 0xff);
+		UIBackgroundTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIBackgroundLineColor = HEX_TO_IMVEC4(0x89a5ff, 0xff);
+		UIBackgroundHighlightColor = HEX_TO_IMVEC4(0xfefffe, 0xff);
+		UIPopupBackgroundColor = HEX_TO_IMVEC4(0xb4cffe, 0xf2);
+		UIPrimaryColor = HEX_TO_IMVEC4(0x92b6fe, 0xff);
+		UIPrimaryLightColor = HEX_TO_IMVEC4(0x89a5ff, 0xff);
+		UIPrimaryDarkColor = HEX_TO_IMVEC4(0x7c8ef3, 0xff);
+		UIPrimaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+		UIDisabledColor = HEX_TO_IMVEC4(0x4b4b4b, 0xff);
+		UITextHighlightColor = HEX_TO_IMVEC4(0x676767, 0xff);
+		UIPrimaryLineColor = HEX_TO_IMVEC4(0xffffff, 0xff);
+		UISecondaryColor = HEX_TO_IMVEC4(0x92b6fe, 0xff);
+		UISecondaryStrongColor = HEX_TO_IMVEC4(0x0c53c5, 0xff);
+		UISecondaryWeakColor = HEX_TO_IMVEC4(0x819af0, 0xff);
+		UISecondaryTextColor = HEX_TO_IMVEC4(0x000000, 0xff);
+	}
 }

pcsx2/ImGui/ImGuiFullscreen.h

@@ -91,7 +91,7 @@ namespace ImGuiFullscreen
 	/// Initializes, setting up any state.
 	bool Initialize(const char* placeholder_image_path);
 
-	void SetTheme(bool light);
+	void SetTheme(std::string_view theme);
 	void SetFonts(ImFont* standard_font, ImFont* medium_font, ImFont* large_font);
 	bool UpdateLayoutScale();
 

pcsx2/Input/InputManager.cpp

@@ -92,7 +92,6 @@ namespace InputManager
 	static std::optional<InputBindingKey> ParseHostKeyboardKey(const std::string_view source, const std::string_view sub_binding);
 	static std::optional<InputBindingKey> ParsePointerKey(const std::string_view source, const std::string_view sub_binding);
 
-	static std::vector<std::string_view> SplitChord(const std::string_view binding);
 	static bool SplitBinding(const std::string_view binding, std::string_view* source, std::string_view* sub_binding);
 	static void PrettifyInputBindingPart(const std::string_view binding, SmallString& ret, bool& changed);
 	static void AddBinding(const std::string_view binding, const InputEventHandler& handler);
@@ -752,7 +751,7 @@ void InputManager::AddPadBindings(SettingsInterface& si, u32 pad_index)
 					const float sensitivity = si.GetFloatValue(section.c_str(), fmt::format("{}Scale", bi.name).c_str(), 1.0f);
 					const float deadzone = si.GetFloatValue(section.c_str(), fmt::format("{}Deadzone", bi.name).c_str(), 0.0f);
 					AddBindings(
-						bindings, InputAxisEventHandler{[pad_index, bind_index = bi.bind_index, sensitivity, deadzone](float value) {
+						bindings, InputAxisEventHandler{[pad_index, bind_index = bi.bind_index, sensitivity, deadzone](InputBindingKey key, float value) {
 							Pad::SetControllerState(pad_index, bind_index, ApplySingleBindingScale(sensitivity, deadzone, value));
 						}});
 				}
@@ -772,9 +771,9 @@ void InputManager::AddPadBindings(SettingsInterface& si, u32 pad_index)
 		if (!bindings.empty())
 		{
 			const float deadzone = si.GetFloatValue(section.c_str(), fmt::format("Macro{}Deadzone", macro_button_index + 1).c_str(), 0.0f);
-			AddBindings(bindings, InputAxisEventHandler{[pad_index, macro_button_index, deadzone](float value) {
+			AddBindings(bindings, InputAxisEventHandler{[pad_index, macro_button_index, deadzone](InputBindingKey key, float value) {
 				const bool state = (value > deadzone);
-				Pad::SetMacroButtonState(pad_index, macro_button_index, state);
+				Pad::SetMacroButtonState(key, pad_index, macro_button_index, state);
 			}});
 		}
 	}
@@ -836,7 +835,7 @@ void InputManager::AddUSBBindings(SettingsInterface& si, u32 port)
 				{
 					const float sensitivity = si.GetFloatValue(section.c_str(), fmt::format("{}Scale", bi.name).c_str(), 1.0f);
 					const float deadzone = si.GetFloatValue(section.c_str(), fmt::format("{}Deadzone", bi.name).c_str(), 0.0f);
-					AddBindings(bindings, InputAxisEventHandler{[port, bind_index = bi.bind_index, sensitivity, deadzone](float value) {
+					AddBindings(bindings, InputAxisEventHandler{[port, bind_index = bi.bind_index, sensitivity, deadzone](InputBindingKey key, float value) {
 						USB::SetDeviceBindValue(port, bind_index, ApplySingleBindingScale(sensitivity, deadzone, value));
 					}});
 				}
@@ -977,7 +976,7 @@ bool InputManager::ProcessEvent(InputBindingKey key, float value, bool skip_butt
 			if (IsAxisHandler(binding->handler))
 			{
 				if (value_to_pass >= 0.0f && (!skip_button_handlers || value_to_pass == 0.0f))
-					std::get<InputAxisEventHandler>(binding->handler)(value_to_pass);
+					std::get<InputAxisEventHandler>(binding->handler)(key, value_to_pass);
 			}
 			else if (binding->num_keys >= min_num_keys)
 			{
@@ -1056,7 +1055,7 @@ void InputManager::ClearBindStateFromSource(InputBindingKey key)
 			if (binding->keys[i].MaskDirection() != match_key)
 				continue;
 
-			std::get<InputAxisEventHandler>(binding->handler)(0.0f);
+			std::get<InputAxisEventHandler>(binding->handler)(key, 0.0f);
 			break;
 		}
 	}

pcsx2/Input/InputManager.h

@@ -95,7 +95,7 @@ struct InputBindingKeyHash
 using InputButtonEventHandler = std::function<void(s32 value)>;
 
 /// Callback types for a normalized event. Usually used for pads.
-using InputAxisEventHandler = std::function<void(float value)>;
+using InputAxisEventHandler = std::function<void(InputBindingKey key, float value)>;
 
 /// Input monitoring for external access.
 struct InputInterceptHook
@@ -211,6 +211,9 @@ namespace InputManager
 	/// Represents a binding with icon fonts, if available.
 	bool PrettifyInputBinding(SmallStringBase& binding);
 
+	/// Splits a chord into individual bindings.
+	std::vector<std::string_view> SplitChord(const std::string_view binding);
+
 	/// Returns a list of all hotkeys.
 	std::vector<const HotkeyInfo*> GetHotkeyList();
 

pcsx2/SIO/Pad/Pad.cpp

@@ -28,11 +28,15 @@
 
 #include <vector>
 
+//Map of actively pressed keys so that chords work
+using KeyMap = std::unordered_multimap<u64, bool>;
+
 namespace Pad
 {
 	struct MacroButton
 	{
 		std::vector<u32> buttons; ///< Buttons to activate.
+		KeyMap active_buttons; ///< Currently active buttons.
 		float pressure; ///< Pressure to apply when macro is active.
 		u16 toggle_frequency; ///< Interval at which the buttons will be toggled, if not 0.
 		u16 toggle_counter; ///< When this counter reaches zero, buttons will be toggled.
@@ -670,8 +674,12 @@ void Pad::LoadMacroButtonConfig(const SettingsInterface& si, u32 pad, const Cont
 	}
 }
 
-void Pad::SetMacroButtonState(u32 pad, u32 index, bool state)
+void Pad::SetMacroButtonState(InputBindingKey& key, u32 pad, u32 index, bool state)
 {
+	//0 appears for some reason and breaks mb.active_buttons.size() != binding_count
+	if (key.bits == 0)
+		return;
+
 	if (pad >= Pad::NUM_CONTROLLER_PORTS || index >= NUM_MACRO_BUTTONS_PER_CONTROLLER)
 		return;
 
@@ -679,6 +687,30 @@ void Pad::SetMacroButtonState(u32 pad, u32 index, bool state)
 	if (mb.buttons.empty())
 		return;
 
+	SettingsInterface& sif = *Host::GetSettingsInterface();
+	std::vector<std::string> data = sif.GetStringList(fmt::format("Pad{}", pad+1).c_str(), fmt::format("Macro{}", index+1).c_str());
+	size_t binding_count = 0;
+	//just in case there's more than one index
+	for (std::string bind : data)
+	{
+		binding_count += InputManager::SplitChord(bind).size();
+	}
+	if (mb.active_buttons.find(key.bits) != mb.active_buttons.end())
+		mb.active_buttons.erase(key.bits);
+	
+	mb.active_buttons.emplace(key.bits, state);
+
+	if (mb.active_buttons.size() != binding_count)
+		return;
+
+	if (mb.active_buttons.size() > 1 && state)
+	{
+		for (auto it = mb.active_buttons.begin(); it != mb.active_buttons.end(); ++it)
+		{
+			if (!it->second)
+				return;
+		}
+	}
 	const bool trigger_state = (mb.trigger_toggle ? (state ? !mb.trigger_state : mb.trigger_state) : state);
 	if (mb.trigger_state == trigger_state)
 		return;

pcsx2/SIO/Pad/Pad.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "Config.h"
+#include "Input/InputManager.h"
 #include "SIO/Pad/PadTypes.h"
 
 #include <memory>
@@ -68,6 +69,6 @@ namespace Pad
 	bool Freeze(StateWrapper& sw);
 
 	// Sets the state of the specified macro button.
-	void SetMacroButtonState(u32 pad, u32 index, bool state);
+	void SetMacroButtonState(InputBindingKey& key, u32 pad, u32 index, bool state);
 	void UpdateMacroButtons();
 }; // namespace Pad

pcsx2/VMManager.cpp

@@ -3610,7 +3610,7 @@ void VMManager::ReloadPINE()
 	PINEServer::Deinitialize();
 
 	if (EmuConfig.EnablePINE)
-		PINEServer::Initialize();
+		PINEServer::Initialize(EmuConfig.PINESlot);
 }
 
 void VMManager::InitializeDiscordPresence()

pcsx2/VU0.cpp

@@ -198,6 +198,8 @@ void CTC2() {
 			vu1Finish(true);
 			vu1ExecMicro(cpuRegs.GPR.r[_Rt_].US[0]);	// Execute VU1 Micro SubRoutine
 			break;
+		case REG_CLIP_FLAG:
+			VU0.clipflag = cpuRegs.GPR.r[_Rt_].UL[0];
 		default:
 			VU0.VI[_Fs_].UL = cpuRegs.GPR.r[_Rt_].UL[0];
 			break;

pcsx2/VUops.h

@@ -5,14 +5,6 @@
 #include "VU.h"
 #include "VUflags.h"
 
-#define float_to_int4(x)	((float)x * (1.0f / 0.0625f))
-#define float_to_int12(x)	((float)x * (1.0f / 0.000244140625f))
-#define float_to_int15(x)	((float)x * (1.0f / 0.000030517578125))
-
-#define int4_to_float(x)	(float)((float)x * 0.0625f)
-#define int12_to_float(x)	(float)((float)x * 0.000244140625f)
-#define int15_to_float(x)	(float)((float)x * 0.000030517578125)
-
 struct _VURegsNum {
 	u8 pipe; // if 0xff, COP2
 	u8 VFwrite;

pcsx2/x86/iCore.h

@@ -109,7 +109,7 @@ void _freeX86reg(int x86reg);
 void _freeX86regWithoutWriteback(int x86reg);
 void _freeX86regs();
 void _flushX86regs();
-void _flushConstRegs();
+void _flushConstRegs(bool delete_const);
 void _flushConstReg(int reg);
 void _validateRegs();
 void _writebackX86Reg(int x86reg);

pcsx2/x86/ix86-32/iCore.cpp

@@ -105,7 +105,7 @@ void _flushConstReg(int reg)
 	}
 }
 
-void _flushConstRegs()
+void _flushConstRegs(bool delete_const)
 {
 	int zero_reg_count = 0;
 	int minusone_reg_count = 0;
@@ -134,6 +134,8 @@ void _flushConstRegs()
 			{
 				xMOV(ptr64[&cpuRegs.GPR.r[i].UD[0]], rax);
 				g_cpuFlushedConstReg |= 1u << i;
+				if (delete_const)
+					g_cpuHasConstReg &= ~(1u << i);
 			}
 		}
 		rax_is_zero = true;
@@ -154,6 +156,8 @@ void _flushConstRegs()
 			{
 				xMOV(ptr64[&cpuRegs.GPR.r[i].UD[0]], rax);
 				g_cpuFlushedConstReg |= 1u << i;
+				if (delete_const)
+					g_cpuHasConstReg &= ~(1u << i);
 			}
 		}
 	}
@@ -166,6 +170,8 @@ void _flushConstRegs()
 
 		xWriteImm64ToMem(&cpuRegs.GPR.r[i].UD[0], rax, g_cpuConstRegs[i].UD[0]);
 		g_cpuFlushedConstReg |= 1u << i;
+		if (delete_const)
+			g_cpuHasConstReg &= ~(1u << i);
 	}
 }
 

pcsx2/x86/ix86-32/iR5900.cpp

@@ -227,7 +227,7 @@ void _eeFlushAllDirty()
 	_flushX86regs();
 
 	// flush constants, do them all at once for slightly better codegen
-	_flushConstRegs();
+	_flushConstRegs(false);
 }
 
 void _eeMoveGPRtoR(const xRegister32& to, int fromgpr, bool allow_preload)
@@ -1225,7 +1225,7 @@ void iFlushCall(int flushtype)
 		_flushXMMregs();
 
 	if (flushtype & FLUSH_CONSTANT_REGS)
-		_flushConstRegs();
+		_flushConstRegs(true);
 
 	if ((flushtype & FLUSH_PC) && !g_cpuFlushedPC)
 	{

tests/ctest/core/StubHost.cpp

@@ -238,6 +238,11 @@ void Host::OnCreateMemoryCardOpenRequested()
 {
 }
 
+bool Host::LocaleCircleConfirm()
+{
+	return false;
+}
+
 bool Host::ShouldPreferHostFileSelector()
 {
 	return false;