Qt: Add Emerald theme and fix palette var names

[ci skip]

.github/ISSUE_TEMPLATE/emu_bug_report.yaml

@@ -18,6 +18,8 @@ body:
 
         Please make an effort to make sure your issue isn't already reported.
 
+        Please make sure your game is verified using the built-in game verifier.
+
         Do not create issues involving software piracy of BIOS or ISO files, our rules specifically prohibit this and your issue will be closed.
 
         ### Please Avoid Issues Pertaining to the Following:

README.md

@@ -18,7 +18,7 @@ Installers and binaries for both stable and nightly builds are available from [o
 
 PCSX2 supports Windows, Linux, and Mac platforms. Our [setup documentation page](https://pcsx2.net/docs/setup/requirements) contains additional details on software and hardware requirements.
 
-Please note that a BIOS dump from a legitimately-owned PS2 console is required to use the emulator. For more information, visit [this page](https://pcsx2.net/docs/setup/gather/#how-to-dump-your-ps2-bios).
+Please note that a BIOS dump from a legitimately-owned PS2 console is required to use the emulator. For more information, visit [this page](https://pcsx2.net/docs/setup/bios/).
 
 ## Contributing / Building
 

bin/resources/GameIndex.yaml

@@ -11186,8 +11186,6 @@ SCUS-97436:
 SCUS-97437:
   name: "ATV Offroad Fury 3 [Demo]"
   region: "NTSC-U"
-  speedHacks:
-    mtvu: 0 # Increases FPS drastically.
 SCUS-97438:
   name: "EyeToy - Antigrav [Demo]"
   region: "NTSC-U"
@@ -11583,8 +11581,6 @@ SCUS-97513:
 SCUS-97514:
   name: "ATV Offroad Fury 3 [Greatest Hits]"
   region: "NTSC-U"
-  speedHacks:
-    mtvu: 0 # Increases FPS drastically.
 SCUS-97515:
   name: "Hot Shots Golf FORE! [Greatest Hits]"
   region: "NTSC-U"
@@ -22926,8 +22922,6 @@ SLES-53753:
 SLES-53754:
   name: "ATV Offroad Fury 3"
   region: "PAL-M6"
-  speedHacks:
-    mtvu: 0 # Increases FPS drastically.
 SLES-53755:
   name: "Castlevania - Curse of Darkness"
   region: "PAL-M5"
@@ -69617,8 +69611,6 @@ SLUS-90009:
 SLUS-97405:
   name: "ATV Offroad Fury 3"
   region: "NTSC-U"
-  speedHacks:
-    mtvu: 0 # Increases FPS drastically.
 SRPM-70201:
   name: "Space Venus Starring Morning Musume."
   region: "NTSC-J"

bin/resources/game_controller_db.txt

@@ -1690,6 +1690,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 050000005e040000220b000013050000,Xbox One Elite 2 Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000050b000002090000,Xbox One Elite Series 2,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 030000005e040000ea02000011050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+050082795e040000e002000003090000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 060000005e040000ea0200000b050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 060000005e040000ea0200000d050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000120b000001050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,

pcsx2-qt/Debugger/MemoryViewWidget.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0+
 
 #include "MemoryViewWidget.h"
+#include "common/Console.h"
 
 #include "QtHost.h"
 #include "QtUtils.h"
@@ -10,7 +11,6 @@
 #include <QtWidgets/QInputDialog>
 #include <QtWidgets/QMessageBox>
 #include <QtGui/QClipboard>
-#include <QtCore/QtEndian>
 
 using namespace QtUtils;
 
@@ -67,47 +67,78 @@ void MemoryViewTable::DrawTable(QPainter& painter, const QPalette& palette, s32
 		s32 valX = valuexAxis;
 		segmentXAxis[0] = valX;
 		u32 currentSegmentAddress = currentRowAddress;
-		for (int j = 0; j < 16; j++)
+		for (int j = 0; j < 16 / (s32)displayType; j++)
 		{
-			const u32 currentByteAddress = currentRowAddress + j;
+			valX += charWidth;
+			const u32 thisSegmentsStart = currentRowAddress + (j * (s32)displayType);
 
-			if (!(j % (s32)displayType))
-			{
-				valX += charWidth;
-				currentSegmentAddress = currentByteAddress;
-			}
 			segmentXAxis[j] = valX;
 
+			bool penDefault = false;
 			if ((selectedAddress & ~0xF) == currentRowAddress)
 			{
-				if (selectedAddress == currentByteAddress)
+				if (selectedAddress >= thisSegmentsStart && selectedAddress < (thisSegmentsStart + (s32)displayType))
 				{ // If the current byte and row we are drawing is selected
 					if (!selectedText)
 					{
+						s32 charsIntoSegment = ((selectedAddress - thisSegmentsStart) * 2) + ((selectedNibbleHI ? 0 : 1) ^ littleEndian);
+						if (littleEndian)
+							charsIntoSegment = ((s32)displayType * 2) - charsIntoSegment - 1;
 						painter.setPen(QColor::fromRgb(205, 165, 0)); // SELECTED NIBBLE LINE COLOUR
-						const QPoint lineStart(valX + (selectedNibbleHI ? 0 : charWidth) + 1, y + (rowHeight * i));
+						const QPoint lineStart(valX + (charsIntoSegment * charWidth) + 1, y + (rowHeight * i));
 						painter.drawLine(lineStart, lineStart + QPoint(charWidth - 3, 0));
 					}
 					painter.setPen(QColor::fromRgb(0xaa, 0x22, 0x22)); // SELECTED BYTE COLOUR
 				}
-				// If the current selected byte is in our current segment, highlight the entire segment
-				else if (displayType != MemoryViewType::BYTE &&
-						 currentSegmentAddress <= selectedAddress && (selectedAddress <= (currentSegmentAddress + (s32)displayType - 1)))
-				{
-					painter.setPen(palette.highlight().color()); // SELECTED SEGMENT COLOUR
-				}
 				else
+				{
+					penDefault = true;
 					painter.setPen(palette.text().color()); // Default colour
+				}
 			}
 			else
+			{
+				penDefault = true;
 				painter.setPen(palette.text().color()); // Default colour
+			}
 
 			bool valid;
-			const u8 val = static_cast<u8>(m_cpu->read8(currentByteAddress, valid));
-
-			painter.drawText(valX, y + (rowHeight * i), valid ? FilledQStringFromValue(val, 16) : "??");
-
-			valX += charWidth * 2;
+			switch (displayType)
+			{
+				case MemoryViewType::BYTE:
+				{
+					const u8 val = static_cast<u8>(m_cpu->read8(thisSegmentsStart, valid));
+					if (penDefault && val == 0)
+						painter.setPen(QColor::fromRgb(145, 145, 155)); // ZERO BYTE COLOUR
+					painter.drawText(valX, y + (rowHeight * i), valid ? FilledQStringFromValue(val, 16) : "??");
+					break;
+				}
+				case MemoryViewType::BYTEHW:
+				{
+					const u16 val = convertEndian<u16>(static_cast<u16>(m_cpu->read16(thisSegmentsStart, valid)));
+					if (penDefault && val == 0)
+						painter.setPen(QColor::fromRgb(145, 145, 155)); // ZERO BYTE COLOUR
+					painter.drawText(valX, y + (rowHeight * i), valid ? FilledQStringFromValue(val, 16) : "????");
+					break;
+				}
+				case MemoryViewType::WORD:
+				{
+					const u32 val = convertEndian<u32>(m_cpu->read32(thisSegmentsStart, valid));
+					if (penDefault && val == 0)
+						painter.setPen(QColor::fromRgb(145, 145, 155)); // ZERO BYTE COLOUR
+					painter.drawText(valX, y + (rowHeight * i), valid ? FilledQStringFromValue(val, 16) : "????????");
+					break;
+				}
+				case MemoryViewType::DWORD:
+				{
+					const u64 val = convertEndian<u64>(m_cpu->read64(thisSegmentsStart, valid));
+					if (penDefault && val == 0)
+						painter.setPen(QColor::fromRgb(145, 145, 155)); // ZERO BYTE COLOUR
+					painter.drawText(valX, y + (rowHeight * i), valid ? FilledQStringFromValue(val, 16) : "????????????????");
+					break;
+				}
+			}
+			valX += charWidth * 2 * (s32)displayType;
 		}
 
 		// valX is our new X position after the hex values
@@ -146,12 +177,15 @@ void MemoryViewTable::SelectAt(QPoint pos)
 	const u32 selectedRow = (pos.y() - 2) / (rowHeight);
 	const s32 x = pos.x();
 	const s32 avgSegmentWidth = segmentXAxis[1] - segmentXAxis[0];
+	const u32 nibbleWidth = (avgSegmentWidth / (2 * (s32)displayType));
 	selectedAddress = (selectedRow * 0x10) + startAddress;
 
 	if (x <= segmentXAxis[0])
 	{
-		selectedText = false;
 		// The user clicked before the first segment
+		selectedText = false;
+		if (littleEndian)
+			selectedAddress += (s32)displayType - 1;
 		selectedNibbleHI = true;
 	}
 	else if (x > valuexAxis && x < textXAxis)
@@ -160,10 +194,13 @@ void MemoryViewTable::SelectAt(QPoint pos)
 		// The user clicked inside of the hexadecimal area
 		for (s32 i = 0; i < 16; i++)
 		{
-			if (i == 15 || (x >= segmentXAxis[i] && x < (segmentXAxis[i + 1])))
+			if (i == ((16 / (s32)displayType) - 1) || (x >= segmentXAxis[i] && x < (segmentXAxis[i + 1])))
 			{
-				selectedAddress = selectedAddress + i;
-				selectedNibbleHI = ((x - segmentXAxis[i]) < ((avgSegmentWidth / 2) - 2)); // Subtract 2 units, makes selecting nibbles feel more natural
+				u32 indexInSegment = (x - segmentXAxis[i]) / nibbleWidth;
+				if (littleEndian)
+					indexInSegment = ((s32)displayType * 2) - indexInSegment - 1;
+				selectedAddress = selectedAddress + i * (s32)displayType + (indexInSegment / 2);
+				selectedNibbleHI = littleEndian ? indexInSegment & 1 : !(indexInSegment & 1);
 				break;
 			}
 		}
@@ -185,13 +222,13 @@ u128 MemoryViewTable::GetSelectedSegment()
 			val.lo = m_cpu->read8(selectedAddress);
 			break;
 		case MemoryViewType::BYTEHW:
-			val.lo = qToBigEndian((u16)m_cpu->read16(selectedAddress & ~1));
+			val.lo = convertEndian((u16)m_cpu->read16(selectedAddress & ~1));
 			break;
 		case MemoryViewType::WORD:
-			val.lo = qToBigEndian(m_cpu->read32(selectedAddress & ~3));
+			val.lo = convertEndian(m_cpu->read32(selectedAddress & ~3));
 			break;
 		case MemoryViewType::DWORD:
-			val._u64[0] = qToBigEndian(m_cpu->read64(selectedAddress & ~7));
+			val._u64[0] = convertEndian(m_cpu->read64(selectedAddress & ~7));
 			break;
 	}
 	return val;
@@ -210,7 +247,8 @@ void MemoryViewTable::InsertIntoSelectedHexView(u8 value)
 	});
 }
 
-void MemoryViewTable::InsertAtCurrentSelection(const QString& text) {
+void MemoryViewTable::InsertAtCurrentSelection(const QString& text)
+{
 	if (!m_cpu->isValidAddress(selectedAddress))
 		return;
 
@@ -218,16 +256,89 @@ void MemoryViewTable::InsertAtCurrentSelection(const QString& text) {
 	// This approach prevents one from pasting on a nibble boundary, but that is almost always
 	// user error, and we don't have an undo function in this view, so best to stay conservative.
 	QByteArray input = selectedText ? text.toUtf8() : QByteArray::fromHex(text.toUtf8());
-
 	Host::RunOnCPUThread([this, address = selectedAddress, cpu = m_cpu, inBytes = input] {
+		u32 currAddr = address;
 		for (int i = 0; i < inBytes.size(); i++)
 		{
-			cpu->write8(address + i, inBytes[i]);
+			cpu->write8(currAddr, inBytes[i]);
+			currAddr = nextAddress(currAddr);
+			QtHost::RunOnUIThread([this] { parent->update(); });
 		}
 		QtHost::RunOnUIThread([this, inBytes] { UpdateSelectedAddress(selectedAddress + inBytes.size()); parent->update(); });
 	});
 }
 
+u32 MemoryViewTable::nextAddress(u32 addr)
+{
+	if (!littleEndian)
+	{
+		return addr + 1;
+	}
+	else
+	{
+		if (selectedAddress % (s32)displayType == 0)
+			return addr + ((s32)displayType * 2 - 1);
+		else
+			return addr - 1;
+	}
+}
+
+u32 MemoryViewTable::prevAddress(u32 addr)
+{
+	if (!littleEndian)
+	{
+		return addr - 1;
+	}
+	else
+	{
+		// It works
+		if ((addr & ((s32)displayType - 1)) == ((s32)displayType - 1))
+			return addr - ((s32)displayType * 2 - 1);
+		else
+			return selectedAddress + 1;
+	}
+}
+
+void MemoryViewTable::ForwardSelection()
+{
+	if (!littleEndian)
+	{
+		if ((selectedNibbleHI = !selectedNibbleHI))
+			UpdateSelectedAddress(selectedAddress + 1);
+	}
+	else
+	{
+		if ((selectedNibbleHI = !selectedNibbleHI))
+		{
+			if (selectedAddress % (s32)displayType == 0)
+				UpdateSelectedAddress(selectedAddress + ((s32)displayType * 2 - 1));
+			else
+				UpdateSelectedAddress(selectedAddress - 1);
+		}
+	}
+}
+
+void MemoryViewTable::BackwardSelection()
+{
+	if (!littleEndian)
+	{
+		if (!(selectedNibbleHI = !selectedNibbleHI))
+			UpdateSelectedAddress(selectedAddress - 1);
+	}
+	else
+	{
+		if (!(selectedNibbleHI = !selectedNibbleHI))
+		{
+			// It works
+			if ((selectedAddress & ((s32)displayType - 1)) == ((s32)displayType - 1))
+				UpdateSelectedAddress(selectedAddress - ((s32)displayType * 2 - 1));
+			else
+				UpdateSelectedAddress(selectedAddress + 1);
+		}
+	}
+}
+
+
 // We need both key and keychar because `key` is easy to use, but is case insensitive
 bool MemoryViewTable::KeyPress(int key, QChar keychar)
 {
@@ -255,16 +366,16 @@ bool MemoryViewTable::KeyPress(int key, QChar keychar)
 			case Qt::Key::Key_Escape:
 				Host::RunOnCPUThread([this, address = selectedAddress, cpu = m_cpu] {
 					cpu->write8(address, 0);
-					QtHost::RunOnUIThread([this] { UpdateSelectedAddress(selectedAddress - 1); parent->update(); });
+					QtHost::RunOnUIThread([this] {BackwardSelection(); parent->update(); });
 				});
 				pressHandled = true;
 				break;
 			case Qt::Key::Key_Right:
-				UpdateSelectedAddress(selectedAddress + 1);
+				ForwardSelection();
 				pressHandled = true;
 				break;
 			case Qt::Key::Key_Left:
-				UpdateSelectedAddress(selectedAddress - 1);
+				BackwardSelection();
 				pressHandled = true;
 				break;
 			default:
@@ -282,9 +393,7 @@ bool MemoryViewTable::KeyPress(int key, QChar keychar)
 			if (pressHandled)
 			{
 				InsertIntoSelectedHexView(keyPressed);
-				// Increment to the next nibble or byte
-				if ((selectedNibbleHI = !selectedNibbleHI))
-					UpdateSelectedAddress(selectedAddress + 1);
+				ForwardSelection();
 			}
 		}
 
@@ -293,19 +402,15 @@ bool MemoryViewTable::KeyPress(int key, QChar keychar)
 			case Qt::Key::Key_Backspace:
 			case Qt::Key::Key_Escape:
 				InsertIntoSelectedHexView(0);
-				// Move back a byte or nibble if it's backspace being pressed
-				if (!(selectedNibbleHI = !selectedNibbleHI))
-					UpdateSelectedAddress(selectedAddress - 1);
+				BackwardSelection();
 				pressHandled = true;
 				break;
 			case Qt::Key::Key_Right:
-				if ((selectedNibbleHI = !selectedNibbleHI))
-					UpdateSelectedAddress(selectedAddress + 1);
+				ForwardSelection();
 				pressHandled = true;
 				break;
 			case Qt::Key::Key_Left:
-				if (!(selectedNibbleHI = !selectedNibbleHI))
-					UpdateSelectedAddress(selectedAddress - 1);
+				BackwardSelection();
 				pressHandled = true;
 				break;
 			default:
@@ -403,6 +508,11 @@ void MemoryViewWidget::customMenuRequested(QPoint pos)
 
 		m_contextMenu->addSeparator();
 
+		m_actionLittleEndian = new QAction(tr("Show as Little Endian"));
+		m_actionLittleEndian->setCheckable(true);
+		m_contextMenu->addAction(m_actionLittleEndian);
+		connect(m_actionLittleEndian, &QAction::triggered, this, [this]() { m_table.SetLittleEndian(m_actionLittleEndian->isChecked()); });
+
 		// View Types
 		m_actionBYTE = new QAction(tr("Show as 1 byte"));
 		m_actionBYTE->setCheckable(true);
@@ -446,6 +556,8 @@ void MemoryViewWidget::customMenuRequested(QPoint pos)
 		m_contextMenu->addAction(action);
 		connect(action, &QAction::triggered, this, [this]() { contextPaste(); });
 	}
+	m_actionLittleEndian->setChecked(m_table.GetLittleEndian());
+
 	const MemoryViewType currentViewType = m_table.GetViewType();
 
 	m_actionBYTE->setChecked(currentViewType == MemoryViewType::BYTE);

pcsx2-qt/Debugger/MemoryViewWidget.h

@@ -12,6 +12,7 @@
 #include <QtWidgets/QMenu>
 #include <QtWidgets/QTabBar>
 #include <QtGui/QPainter>
+#include <QtCore/QtEndian>
 
 #include <vector>
 
@@ -28,22 +29,39 @@ class MemoryViewTable
 	QWidget* parent;
 	DebugInterface* m_cpu;
 	MemoryViewType displayType = MemoryViewType::BYTE;
+	bool littleEndian = true;
 	u32 rowCount;
 	u32 rowVisible;
 	s32 rowHeight;
 
 	// Stuff used for selection handling
 	// This gets set every paint and depends on the window size / current display mode (1byte,2byte,etc)
-	s32 valuexAxis;            // Where the hexadecimal view begins
-	s32 textXAxis;             // Where the text view begins
-	s32 row1YAxis;             // Where the first row starts
-	s32 segmentXAxis[16];      // Where the segments begin
+	s32 valuexAxis; // Where the hexadecimal view begins
+	s32 textXAxis; // Where the text view begins
+	s32 row1YAxis; // Where the first row starts
+	s32 segmentXAxis[16]; // Where the segments begin
 	bool selectedText = false; // Whether the user has clicked on text or hex
-	
+
 	bool selectedNibbleHI = false;
 
 	void InsertIntoSelectedHexView(u8 value);
 
+	template <class T>
+	T convertEndian(T in)
+	{
+		if (littleEndian)
+		{
+			return in;
+		}
+		else
+		{
+			return qToBigEndian(in);
+		}
+	}
+
+	u32 nextAddress(u32 addr);
+	u32 prevAddress(u32 addr);
+
 public:
 	MemoryViewTable(QWidget* parent)
 		: parent(parent){};
@@ -60,6 +78,8 @@ public:
 	void SelectAt(QPoint pos);
 	u128 GetSelectedSegment();
 	void InsertAtCurrentSelection(const QString& text);
+	void ForwardSelection();
+	void BackwardSelection();
 	// Returns true if the keypress was handled
 	bool KeyPress(int key, QChar keychar);
 
@@ -72,6 +92,16 @@ public:
 	{
 		displayType = viewType;
 	}
+
+	bool GetLittleEndian()
+	{
+		return littleEndian;
+	}
+
+	void SetLittleEndian(bool le)
+	{
+		littleEndian = le;
+	}
 };
 
 
@@ -111,6 +141,7 @@ private:
 	Ui::RegisterWidget ui;
 
 	QMenu* m_contextMenu = 0x0;
+	QAction* m_actionLittleEndian;
 	QAction* m_actionBYTE;
 	QAction* m_actionBYTEHW;
 	QAction* m_actionWORD;

pcsx2-qt/MainWindow.cpp

@@ -2664,7 +2664,7 @@ void MainWindow::setGameListEntryCoverImage(const GameList::Entry* entry)
 		return;
 
 	const QString old_filename = QString::fromStdString(GameList::GetCoverImagePathForEntry(entry));
-	const QString new_filename = QString::fromStdString(GameList::GetNewCoverImagePathForEntry(entry, filename.toUtf8().constData()));
+	const QString new_filename = QString::fromStdString(GameList::GetNewCoverImagePathForEntry(entry, filename.toUtf8().constData(), true));
 	if (new_filename.isEmpty())
 		return;
 

pcsx2-qt/Settings/GraphicsSettingsWidget.cpp

@@ -779,7 +779,7 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
 
 		dialog->registerWidgetHelp(m_ui.skipPresentingDuplicateFrames, tr("Skip Presenting Duplicate Frames"), tr("Unchecked"),
 			tr("Detects when idle frames are being presented in 25/30fps games, and skips presenting those frames. The frame is still "
-			   "rendered, it just means the GPU has more time to complete it (this is NOT frame skipping). Can smooth our frame time "
+			   "rendered, it just means the GPU has more time to complete it (this is NOT frame skipping). Can smooth out frame time "
 			   "fluctuations when the CPU/GPU are near maximum utilization, but makes frame pacing more inconsistent and can increase "
 			   "input lag."));
 

pcsx2-qt/Settings/InterfaceSettingsWidget.cpp

@@ -39,6 +39,8 @@ const char* InterfaceSettingsWidget::THEME_NAMES[] = {
 	QT_TRANSLATE_NOOP("InterfaceSettingsWidget", "Ruby (Black/Red) [Dark]"),
 	//: Ignore what Crowdin says in this string about "[Light]/[Dark]" being untouchable here, these are not variables in this case and must be translated.
 	QT_TRANSLATE_NOOP("InterfaceSettingsWidget", "Sapphire (Black/Blue) [Dark]"),
+	//: Ignore what Crowdin says in this string about "[Light]/[Dark]" being untouchable here, these are not variables in this case and must be translated.
+	QT_TRANSLATE_NOOP("InterfaceSettingsWidget", "Emerald (Black/Green) [Dark]"),
 	//: "Custom.qss" must be kept as-is.
 	QT_TRANSLATE_NOOP("InterfaceSettingsWidget", "Custom.qss [Drop in PCSX2 Folder]"),
 	nullptr};
@@ -61,6 +63,7 @@ const char* InterfaceSettingsWidget::THEME_VALUES[] = {
 	"CobaltSky",
 	"Ruby",
 	"Sapphire",
+	"Emerald",
 	"Custom",
 	nullptr};
 

pcsx2-qt/Themes.cpp

@@ -108,28 +108,28 @@ void QtHost::SetStyleFromSettings()
 		const QColor blue(198, 238, 255);
 		const QColor blue2(0, 88, 208);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, darkGray);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, black);
-		darkPalette.setColor(QPalette::AlternateBase, darkGray);
-		darkPalette.setColor(QPalette::ToolTipBase, blue2);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, darkGray);
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, blue);
-		darkPalette.setColor(QPalette::Highlight, blue2);
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
-		darkPalette.setColor(QPalette::PlaceholderText, QColor(Qt::white).darker());
+		QPalette darkBluePalette;
+		darkBluePalette.setColor(QPalette::Window, darkGray);
+		darkBluePalette.setColor(QPalette::WindowText, Qt::white);
+		darkBluePalette.setColor(QPalette::Base, black);
+		darkBluePalette.setColor(QPalette::AlternateBase, darkGray);
+		darkBluePalette.setColor(QPalette::ToolTipBase, blue2);
+		darkBluePalette.setColor(QPalette::ToolTipText, Qt::white);
+		darkBluePalette.setColor(QPalette::Text, Qt::white);
+		darkBluePalette.setColor(QPalette::Button, darkGray);
+		darkBluePalette.setColor(QPalette::ButtonText, Qt::white);
+		darkBluePalette.setColor(QPalette::Link, blue);
+		darkBluePalette.setColor(QPalette::Highlight, blue2);
+		darkBluePalette.setColor(QPalette::HighlightedText, Qt::white);
+		darkBluePalette.setColor(QPalette::PlaceholderText, QColor(Qt::white).darker());
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, darkGray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, darkGray);
+		darkBluePalette.setColor(QPalette::Active, QPalette::Button, darkGray);
+		darkBluePalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
+		darkBluePalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
+		darkBluePalette.setColor(QPalette::Disabled, QPalette::Text, gray);
+		darkBluePalette.setColor(QPalette::Disabled, QPalette::Light, darkGray);
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(darkBluePalette);
 	}
 	else if (theme == "GreyMatter")
 	{
@@ -143,28 +143,28 @@ void QtHost::SetStyleFromSettings()
 		const QColor gray(111, 111, 111);
 		const QColor blue(198, 238, 255);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, darkGray);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, lighterGray);
-		darkPalette.setColor(QPalette::AlternateBase, darkGray);
-		darkPalette.setColor(QPalette::ToolTipBase, darkGray);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, lighterGray);
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, blue);
-		darkPalette.setColor(QPalette::Highlight, lighterGray.lighter());
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
-		darkPalette.setColor(QPalette::PlaceholderText, QColor(Qt::white).darker());
+		QPalette greyMatterPalette;
+		greyMatterPalette.setColor(QPalette::Window, darkGray);
+		greyMatterPalette.setColor(QPalette::WindowText, Qt::white);
+		greyMatterPalette.setColor(QPalette::Base, lighterGray);
+		greyMatterPalette.setColor(QPalette::AlternateBase, darkGray);
+		greyMatterPalette.setColor(QPalette::ToolTipBase, darkGray);
+		greyMatterPalette.setColor(QPalette::ToolTipText, Qt::white);
+		greyMatterPalette.setColor(QPalette::Text, Qt::white);
+		greyMatterPalette.setColor(QPalette::Button, lighterGray);
+		greyMatterPalette.setColor(QPalette::ButtonText, Qt::white);
+		greyMatterPalette.setColor(QPalette::Link, blue);
+		greyMatterPalette.setColor(QPalette::Highlight, lighterGray.lighter());
+		greyMatterPalette.setColor(QPalette::HighlightedText, Qt::white);
+		greyMatterPalette.setColor(QPalette::PlaceholderText, QColor(Qt::white).darker());
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, lighterGray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray.lighter());
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray.lighter());
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, gray.lighter());
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, darkGray);
+		greyMatterPalette.setColor(QPalette::Active, QPalette::Button, lighterGray);
+		greyMatterPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray.lighter());
+		greyMatterPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray.lighter());
+		greyMatterPalette.setColor(QPalette::Disabled, QPalette::Text, gray.lighter());
+		greyMatterPalette.setColor(QPalette::Disabled, QPalette::Light, darkGray);
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(greyMatterPalette);
 	}
 	else if (theme == "UntouchedLagoon")
 	{
@@ -178,27 +178,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor tameTeal(160, 190, 185);
 		const QColor grayBlue(160, 180, 190);
 
-		QPalette standardPalette;
-		standardPalette.setColor(QPalette::Window, tameTeal);
-		standardPalette.setColor(QPalette::WindowText, black.lighter());
-		standardPalette.setColor(QPalette::Base, grayBlue);
-		standardPalette.setColor(QPalette::AlternateBase, tameTeal);
-		standardPalette.setColor(QPalette::ToolTipBase, tameTeal);
-		standardPalette.setColor(QPalette::ToolTipText, grayBlue);
-		standardPalette.setColor(QPalette::Text, black);
-		standardPalette.setColor(QPalette::Button, tameTeal);
-		standardPalette.setColor(QPalette::ButtonText, black);
-		standardPalette.setColor(QPalette::Link, black.lighter());
-		standardPalette.setColor(QPalette::Highlight, teal);
-		standardPalette.setColor(QPalette::HighlightedText, grayBlue.lighter());
+		QPalette untouchedLagoonPalette;
+		untouchedLagoonPalette.setColor(QPalette::Window, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::WindowText, black.lighter());
+		untouchedLagoonPalette.setColor(QPalette::Base, grayBlue);
+		untouchedLagoonPalette.setColor(QPalette::AlternateBase, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::ToolTipBase, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::ToolTipText, grayBlue);
+		untouchedLagoonPalette.setColor(QPalette::Text, black);
+		untouchedLagoonPalette.setColor(QPalette::Button, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::ButtonText, black);
+		untouchedLagoonPalette.setColor(QPalette::Link, black.lighter());
+		untouchedLagoonPalette.setColor(QPalette::Highlight, teal);
+		untouchedLagoonPalette.setColor(QPalette::HighlightedText, grayBlue.lighter());
 
-		standardPalette.setColor(QPalette::Active, QPalette::Button, tameTeal);
-		standardPalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkteal);
-		standardPalette.setColor(QPalette::Disabled, QPalette::WindowText, darkteal.lighter());
-		standardPalette.setColor(QPalette::Disabled, QPalette::Text, darkteal.lighter());
-		standardPalette.setColor(QPalette::Disabled, QPalette::Light, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::Active, QPalette::Button, tameTeal);
+		untouchedLagoonPalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkteal);
+		untouchedLagoonPalette.setColor(QPalette::Disabled, QPalette::WindowText, darkteal.lighter());
+		untouchedLagoonPalette.setColor(QPalette::Disabled, QPalette::Text, darkteal.lighter());
+		untouchedLagoonPalette.setColor(QPalette::Disabled, QPalette::Light, tameTeal);
 
-		qApp->setPalette(standardPalette);
+		qApp->setPalette(untouchedLagoonPalette);
 	}
 	else if (theme == "BabyPastel")
 	{
@@ -214,27 +214,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor congoPink(255, 127, 121);
 		const QColor blue(221, 225, 239);
 
-		QPalette standardPalette;
-		standardPalette.setColor(QPalette::Window, pink);
-		standardPalette.setColor(QPalette::WindowText, black);
-		standardPalette.setColor(QPalette::Base, brightPink);
-		standardPalette.setColor(QPalette::AlternateBase, blue);
-		standardPalette.setColor(QPalette::ToolTipBase, pink);
-		standardPalette.setColor(QPalette::ToolTipText, brightPink);
-		standardPalette.setColor(QPalette::Text, black);
-		standardPalette.setColor(QPalette::Button, pink);
-		standardPalette.setColor(QPalette::ButtonText, black);
-		standardPalette.setColor(QPalette::Link, black);
-		standardPalette.setColor(QPalette::Highlight, congoPink);
-		standardPalette.setColor(QPalette::HighlightedText, black);
+		QPalette babyPastelPalette;
+		babyPastelPalette.setColor(QPalette::Window, pink);
+		babyPastelPalette.setColor(QPalette::WindowText, black);
+		babyPastelPalette.setColor(QPalette::Base, brightPink);
+		babyPastelPalette.setColor(QPalette::AlternateBase, blue);
+		babyPastelPalette.setColor(QPalette::ToolTipBase, pink);
+		babyPastelPalette.setColor(QPalette::ToolTipText, brightPink);
+		babyPastelPalette.setColor(QPalette::Text, black);
+		babyPastelPalette.setColor(QPalette::Button, pink);
+		babyPastelPalette.setColor(QPalette::ButtonText, black);
+		babyPastelPalette.setColor(QPalette::Link, black);
+		babyPastelPalette.setColor(QPalette::Highlight, congoPink);
+		babyPastelPalette.setColor(QPalette::HighlightedText, black);
 
-		standardPalette.setColor(QPalette::Active, QPalette::Button, pink);
-		standardPalette.setColor(QPalette::Disabled, QPalette::ButtonText, redpinkish);
-		standardPalette.setColor(QPalette::Disabled, QPalette::WindowText, redpinkish);
-		standardPalette.setColor(QPalette::Disabled, QPalette::Text, redpinkish);
-		standardPalette.setColor(QPalette::Disabled, QPalette::Light, gray);
+		babyPastelPalette.setColor(QPalette::Active, QPalette::Button, pink);
+		babyPastelPalette.setColor(QPalette::Disabled, QPalette::ButtonText, redpinkish);
+		babyPastelPalette.setColor(QPalette::Disabled, QPalette::WindowText, redpinkish);
+		babyPastelPalette.setColor(QPalette::Disabled, QPalette::Text, redpinkish);
+		babyPastelPalette.setColor(QPalette::Disabled, QPalette::Light, gray);
 
-		qApp->setPalette(standardPalette);
+		qApp->setPalette(babyPastelPalette);
 	}
 	else if (theme == "PizzaBrown")
 	{
@@ -250,26 +250,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor comp(248, 230, 213);
 		const QColor highlight(188, 100, 60);
 
-		QPalette standardPalette;
-		standardPalette.setColor(QPalette::Window, main);
-		standardPalette.setColor(QPalette::WindowText, Qt::black);
-		standardPalette.setColor(QPalette::Base, comp);
-		standardPalette.setColor(QPalette::AlternateBase, extr);
-		standardPalette.setColor(QPalette::ToolTipBase, comp);
-		standardPalette.setColor(QPalette::ToolTipText, Qt::black);
-		standardPalette.setColor(QPalette::Text, Qt::black);
-		standardPalette.setColor(QPalette::Button, extr);
-		standardPalette.setColor(QPalette::ButtonText, Qt::black);
-		standardPalette.setColor(QPalette::Link, highlight.darker());
-		standardPalette.setColor(QPalette::Highlight, highlight);
-		standardPalette.setColor(QPalette::HighlightedText, Qt::white);
-		standardPalette.setColor(QPalette::Active, QPalette::Button, extr);
-		standardPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray.darker());
-		standardPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray.darker());
-		standardPalette.setColor(QPalette::Disabled, QPalette::Text, Qt::gray);
-		standardPalette.setColor(QPalette::Disabled, QPalette::Light, gray.lighter());
+		QPalette pizzaPalette;
+		pizzaPalette.setColor(QPalette::Window, main);
+		pizzaPalette.setColor(QPalette::WindowText, Qt::black);
+		pizzaPalette.setColor(QPalette::Base, comp);
+		pizzaPalette.setColor(QPalette::AlternateBase, extr);
+		pizzaPalette.setColor(QPalette::ToolTipBase, comp);
+		pizzaPalette.setColor(QPalette::ToolTipText, Qt::black);
+		pizzaPalette.setColor(QPalette::Text, Qt::black);
+		pizzaPalette.setColor(QPalette::Button, extr);
+		pizzaPalette.setColor(QPalette::ButtonText, Qt::black);
+		pizzaPalette.setColor(QPalette::Link, highlight.darker());
+		pizzaPalette.setColor(QPalette::Highlight, highlight);
+		pizzaPalette.setColor(QPalette::HighlightedText, Qt::white);
+		
+		pizzaPalette.setColor(QPalette::Active, QPalette::Button, extr);
+		pizzaPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray.darker());
+		pizzaPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray.darker());
+		pizzaPalette.setColor(QPalette::Disabled, QPalette::Text, Qt::gray);
+		pizzaPalette.setColor(QPalette::Disabled, QPalette::Light, gray.lighter());
 
-		qApp->setPalette(standardPalette);
+		qApp->setPalette(pizzaPalette);
 	}
 	else if (theme == "PCSX2Blue")
 	{
@@ -283,27 +284,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor blue(106, 156, 255);
 		const QColor lightBlue(130, 155, 241);
 
-		QPalette standardPalette;
-		standardPalette.setColor(QPalette::Window, blue2.lighter());
-		standardPalette.setColor(QPalette::WindowText, blackish);
-		standardPalette.setColor(QPalette::Base, lightBlue);
-		standardPalette.setColor(QPalette::AlternateBase, blue2.lighter());
-		standardPalette.setColor(QPalette::ToolTipBase, blue2);
-		standardPalette.setColor(QPalette::ToolTipText, Qt::white);
-		standardPalette.setColor(QPalette::Text, blackish);
-		standardPalette.setColor(QPalette::Button, blue);
-		standardPalette.setColor(QPalette::ButtonText, blackish);
-		standardPalette.setColor(QPalette::Link, darkBlue);
-		standardPalette.setColor(QPalette::Highlight, Qt::white);
-		standardPalette.setColor(QPalette::HighlightedText, blackish);
+		QPalette pcsx2BluePalette;
+		pcsx2BluePalette.setColor(QPalette::Window, blue2.lighter());
+		pcsx2BluePalette.setColor(QPalette::WindowText, blackish);
+		pcsx2BluePalette.setColor(QPalette::Base, lightBlue);
+		pcsx2BluePalette.setColor(QPalette::AlternateBase, blue2.lighter());
+		pcsx2BluePalette.setColor(QPalette::ToolTipBase, blue2);
+		pcsx2BluePalette.setColor(QPalette::ToolTipText, Qt::white);
+		pcsx2BluePalette.setColor(QPalette::Text, blackish);
+		pcsx2BluePalette.setColor(QPalette::Button, blue);
+		pcsx2BluePalette.setColor(QPalette::ButtonText, blackish);
+		pcsx2BluePalette.setColor(QPalette::Link, darkBlue);
+		pcsx2BluePalette.setColor(QPalette::Highlight, Qt::white);
+		pcsx2BluePalette.setColor(QPalette::HighlightedText, blackish);
 
-		standardPalette.setColor(QPalette::Active, QPalette::Button, blue);
-		standardPalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkBlue);
-		standardPalette.setColor(QPalette::Disabled, QPalette::WindowText, darkBlue);
-		standardPalette.setColor(QPalette::Disabled, QPalette::Text, darkBlue);
-		standardPalette.setColor(QPalette::Disabled, QPalette::Light, darkBlue);
+		pcsx2BluePalette.setColor(QPalette::Active, QPalette::Button, blue);
+		pcsx2BluePalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkBlue);
+		pcsx2BluePalette.setColor(QPalette::Disabled, QPalette::WindowText, darkBlue);
+		pcsx2BluePalette.setColor(QPalette::Disabled, QPalette::Text, darkBlue);
+		pcsx2BluePalette.setColor(QPalette::Disabled, QPalette::Light, darkBlue);
 
-		qApp->setPalette(standardPalette);
+		qApp->setPalette(pcsx2BluePalette);
 	}
 	else if (theme == "ScarletDevilRed")
 	{
@@ -315,27 +316,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor purplishRed(120, 45, 69);
 		const QColor brightRed(200, 45, 69);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, darkRed);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, purplishRed);
-		darkPalette.setColor(QPalette::AlternateBase, darkRed);
-		darkPalette.setColor(QPalette::ToolTipBase, darkRed);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, purplishRed.darker());
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, brightRed);
-		darkPalette.setColor(QPalette::Highlight, brightRed);
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
+		QPalette scarletDevilPalette;
+		scarletDevilPalette.setColor(QPalette::Window, darkRed);
+		scarletDevilPalette.setColor(QPalette::WindowText, Qt::white);
+		scarletDevilPalette.setColor(QPalette::Base, purplishRed);
+		scarletDevilPalette.setColor(QPalette::AlternateBase, darkRed);
+		scarletDevilPalette.setColor(QPalette::ToolTipBase, darkRed);
+		scarletDevilPalette.setColor(QPalette::ToolTipText, Qt::white);
+		scarletDevilPalette.setColor(QPalette::Text, Qt::white);
+		scarletDevilPalette.setColor(QPalette::Button, purplishRed.darker());
+		scarletDevilPalette.setColor(QPalette::ButtonText, Qt::white);
+		scarletDevilPalette.setColor(QPalette::Link, brightRed);
+		scarletDevilPalette.setColor(QPalette::Highlight, brightRed);
+		scarletDevilPalette.setColor(QPalette::HighlightedText, Qt::white);
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, purplishRed.darker());
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, brightRed);
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, brightRed);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, brightRed);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, darkRed);
+		scarletDevilPalette.setColor(QPalette::Active, QPalette::Button, purplishRed.darker());
+		scarletDevilPalette.setColor(QPalette::Disabled, QPalette::ButtonText, brightRed);
+		scarletDevilPalette.setColor(QPalette::Disabled, QPalette::WindowText, brightRed);
+		scarletDevilPalette.setColor(QPalette::Disabled, QPalette::Text, brightRed);
+		scarletDevilPalette.setColor(QPalette::Disabled, QPalette::Light, darkRed);
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(scarletDevilPalette);
 	}
 	else if (theme == "VioletAngelPurple")
 	{
@@ -347,27 +348,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor darkerPurple(90, 30, 105);
 		const QColor nauticalPurple(110, 30, 125);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, blackishblue);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, nauticalPurple);
-		darkPalette.setColor(QPalette::AlternateBase, blackishblue);
-		darkPalette.setColor(QPalette::ToolTipBase, nauticalPurple);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, nauticalPurple.darker());
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, darkerPurple.lighter());
-		darkPalette.setColor(QPalette::Highlight, darkerPurple.lighter());
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
+		QPalette violetAngelPalette;
+		violetAngelPalette.setColor(QPalette::Window, blackishblue);
+		violetAngelPalette.setColor(QPalette::WindowText, Qt::white);
+		violetAngelPalette.setColor(QPalette::Base, nauticalPurple);
+		violetAngelPalette.setColor(QPalette::AlternateBase, blackishblue);
+		violetAngelPalette.setColor(QPalette::ToolTipBase, nauticalPurple);
+		violetAngelPalette.setColor(QPalette::ToolTipText, Qt::white);
+		violetAngelPalette.setColor(QPalette::Text, Qt::white);
+		violetAngelPalette.setColor(QPalette::Button, nauticalPurple.darker());
+		violetAngelPalette.setColor(QPalette::ButtonText, Qt::white);
+		violetAngelPalette.setColor(QPalette::Link, darkerPurple.lighter());
+		violetAngelPalette.setColor(QPalette::Highlight, darkerPurple.lighter());
+		violetAngelPalette.setColor(QPalette::HighlightedText, Qt::white);
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, nauticalPurple.darker());
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkerPurple.lighter());
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, darkerPurple.lighter());
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, darkerPurple.darker());
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, nauticalPurple);
+		violetAngelPalette.setColor(QPalette::Active, QPalette::Button, nauticalPurple.darker());
+		violetAngelPalette.setColor(QPalette::Disabled, QPalette::ButtonText, darkerPurple.lighter());
+		violetAngelPalette.setColor(QPalette::Disabled, QPalette::WindowText, darkerPurple.lighter());
+		violetAngelPalette.setColor(QPalette::Disabled, QPalette::Text, darkerPurple.darker());
+		violetAngelPalette.setColor(QPalette::Disabled, QPalette::Light, nauticalPurple);
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(violetAngelPalette);
 	}
 	else if (theme == "CobaltSky")
 	{
@@ -383,27 +384,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor highlight(36, 93, 218);
 		const QColor link(0, 202, 255);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, royalBlue);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, royalBlue.lighter());
-		darkPalette.setColor(QPalette::AlternateBase, darkishBlue);
-		darkPalette.setColor(QPalette::ToolTipBase, darkishBlue);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, lighterBlue);
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, link);
-		darkPalette.setColor(QPalette::Highlight, highlight);
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
+		QPalette cobaltSkyPalette;
+		cobaltSkyPalette.setColor(QPalette::Window, royalBlue);
+		cobaltSkyPalette.setColor(QPalette::WindowText, Qt::white);
+		cobaltSkyPalette.setColor(QPalette::Base, royalBlue.lighter());
+		cobaltSkyPalette.setColor(QPalette::AlternateBase, darkishBlue);
+		cobaltSkyPalette.setColor(QPalette::ToolTipBase, darkishBlue);
+		cobaltSkyPalette.setColor(QPalette::ToolTipText, Qt::white);
+		cobaltSkyPalette.setColor(QPalette::Text, Qt::white);
+		cobaltSkyPalette.setColor(QPalette::Button, lighterBlue);
+		cobaltSkyPalette.setColor(QPalette::ButtonText, Qt::white);
+		cobaltSkyPalette.setColor(QPalette::Link, link);
+		cobaltSkyPalette.setColor(QPalette::Highlight, highlight);
+		cobaltSkyPalette.setColor(QPalette::HighlightedText, Qt::white);
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, lighterBlue);
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, gray);
+		cobaltSkyPalette.setColor(QPalette::Active, QPalette::Button, lighterBlue);
+		cobaltSkyPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
+		cobaltSkyPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
+		cobaltSkyPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
+		cobaltSkyPalette.setColor(QPalette::Disabled, QPalette::Light, gray);
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(cobaltSkyPalette);
 	}
 	else if (theme == "Ruby")
 	{
@@ -415,27 +416,27 @@ void QtHost::SetStyleFromSettings()
 		const QColor slate(18, 18, 18);
 		const QColor rubyish(172, 21, 31);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, slate);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, slate.lighter());
-		darkPalette.setColor(QPalette::AlternateBase, slate.lighter());
-		darkPalette.setColor(QPalette::ToolTipBase, slate);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, slate);
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, Qt::white);
-		darkPalette.setColor(QPalette::Highlight, rubyish);
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
+		QPalette rubyPalette;
+		rubyPalette.setColor(QPalette::Window, slate);
+		rubyPalette.setColor(QPalette::WindowText, Qt::white);
+		rubyPalette.setColor(QPalette::Base, slate.lighter());
+		rubyPalette.setColor(QPalette::AlternateBase, slate.lighter());
+		rubyPalette.setColor(QPalette::ToolTipBase, slate);
+		rubyPalette.setColor(QPalette::ToolTipText, Qt::white);
+		rubyPalette.setColor(QPalette::Text, Qt::white);
+		rubyPalette.setColor(QPalette::Button, slate);
+		rubyPalette.setColor(QPalette::ButtonText, Qt::white);
+		rubyPalette.setColor(QPalette::Link, Qt::white);
+		rubyPalette.setColor(QPalette::Highlight, rubyish);
+		rubyPalette.setColor(QPalette::HighlightedText, Qt::white);
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, slate);
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, slate.lighter());
+		rubyPalette.setColor(QPalette::Active, QPalette::Button, slate);
+		rubyPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
+		rubyPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
+		rubyPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
+		rubyPalette.setColor(QPalette::Disabled, QPalette::Light, slate.lighter());
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(rubyPalette);
 	}
 	else if (theme == "Sapphire")
 	{
@@ -447,27 +448,59 @@ void QtHost::SetStyleFromSettings()
 		const QColor slate(18, 18, 18);
 		const QColor persianBlue(32, 35, 204);
 
-		QPalette darkPalette;
-		darkPalette.setColor(QPalette::Window, slate);
-		darkPalette.setColor(QPalette::WindowText, Qt::white);
-		darkPalette.setColor(QPalette::Base, slate.lighter());
-		darkPalette.setColor(QPalette::AlternateBase, slate.lighter());
-		darkPalette.setColor(QPalette::ToolTipBase, slate);
-		darkPalette.setColor(QPalette::ToolTipText, Qt::white);
-		darkPalette.setColor(QPalette::Text, Qt::white);
-		darkPalette.setColor(QPalette::Button, slate);
-		darkPalette.setColor(QPalette::ButtonText, Qt::white);
-		darkPalette.setColor(QPalette::Link, Qt::white);
-		darkPalette.setColor(QPalette::Highlight, persianBlue);
-		darkPalette.setColor(QPalette::HighlightedText, Qt::white);
+		QPalette sapphirePalette;
+		sapphirePalette.setColor(QPalette::Window, slate);
+		sapphirePalette.setColor(QPalette::WindowText, Qt::white);
+		sapphirePalette.setColor(QPalette::Base, slate.lighter());
+		sapphirePalette.setColor(QPalette::AlternateBase, slate.lighter());
+		sapphirePalette.setColor(QPalette::ToolTipBase, slate);
+		sapphirePalette.setColor(QPalette::ToolTipText, Qt::white);
+		sapphirePalette.setColor(QPalette::Text, Qt::white);
+		sapphirePalette.setColor(QPalette::Button, slate);
+		sapphirePalette.setColor(QPalette::ButtonText, Qt::white);
+		sapphirePalette.setColor(QPalette::Link, Qt::white);
+		sapphirePalette.setColor(QPalette::Highlight, persianBlue);
+		sapphirePalette.setColor(QPalette::HighlightedText, Qt::white);
 
-		darkPalette.setColor(QPalette::Active, QPalette::Button, slate);
-		darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
-		darkPalette.setColor(QPalette::Disabled, QPalette::Light, slate.lighter());
+		sapphirePalette.setColor(QPalette::Active, QPalette::Button, slate);
+		sapphirePalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
+		sapphirePalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
+		sapphirePalette.setColor(QPalette::Disabled, QPalette::Text, gray);
+		sapphirePalette.setColor(QPalette::Disabled, QPalette::Light, slate.lighter());
 
-		qApp->setPalette(darkPalette);
+		qApp->setPalette(sapphirePalette);
+	}
+	else if (theme == "Emerald")
+	{
+		// Custom palette by RedDevilus, Black as main color and Blue as complimentary.
+		// Alternative dark (black) theme.
+		qApp->setStyle(QStyleFactory::create("Fusion"));
+
+		const QColor gray(128, 128, 128);
+		const QColor slate(18, 18, 18);
+		const QColor evergreenEmerald(15, 81, 59);
+
+		QPalette emeraldPalette;
+		emeraldPalette.setColor(QPalette::Window, slate);
+		emeraldPalette.setColor(QPalette::WindowText, Qt::white);
+		emeraldPalette.setColor(QPalette::Base, slate.lighter());
+		emeraldPalette.setColor(QPalette::AlternateBase, slate.lighter());
+		emeraldPalette.setColor(QPalette::ToolTipBase, slate);
+		emeraldPalette.setColor(QPalette::ToolTipText, Qt::white);
+		emeraldPalette.setColor(QPalette::Text, Qt::white);
+		emeraldPalette.setColor(QPalette::Button, slate);
+		emeraldPalette.setColor(QPalette::ButtonText, Qt::white);
+		emeraldPalette.setColor(QPalette::Link, Qt::white);
+		emeraldPalette.setColor(QPalette::Highlight, evergreenEmerald);
+		emeraldPalette.setColor(QPalette::HighlightedText, Qt::white);
+
+		emeraldPalette.setColor(QPalette::Active, QPalette::Button, slate);
+		emeraldPalette.setColor(QPalette::Disabled, QPalette::ButtonText, gray);
+		emeraldPalette.setColor(QPalette::Disabled, QPalette::WindowText, gray);
+		emeraldPalette.setColor(QPalette::Disabled, QPalette::Text, gray);
+		emeraldPalette.setColor(QPalette::Disabled, QPalette::Light, slate.lighter());
+
+		qApp->setPalette(emeraldPalette);
 	}
 	else if (theme == "Custom")
 	{

pcsx2/GameDatabase.cpp

@@ -640,7 +640,7 @@ bool GameDatabaseSchema::GameEntry::configMatchesHWFix(const Pcsx2Config::GSOpti
 			return (config.UpscaleMultiplier <= 1.0f || config.UserHacks_RoundSprite == value);
 
 		case GSHWFixId::NativeScaling:
-			return (static_cast<int>(config.UserHacks_NativeScaling) == value);
+			return (config.UpscaleMultiplier <= 1.0f || static_cast<int>(config.UserHacks_NativeScaling) == value);
 
 		case GSHWFixId::TexturePreloading:
 			return (static_cast<int>(config.TexturePreloading) <= value);

pcsx2/Input/InputManager.cpp

@@ -1605,7 +1605,10 @@ void InputManager::UpdateInputSourceState(SettingsInterface& si, std::unique_loc
 	{
 		if (s_input_sources[static_cast<u32>(type)])
 		{
+			settings_lock.unlock();
 			s_input_sources[static_cast<u32>(type)]->Shutdown();
+			settings_lock.lock();
+
 			s_input_sources[static_cast<u32>(type)].reset();
 		}
 	}