Qt: fix renderer translation

move render creator to own class

rpcs3/rpcs3.vcxproj

@@ -523,6 +523,11 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug - LLVM\moc_render_creator.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Debug - LLVM\moc_rsx_debugger.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -798,6 +803,11 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug\moc_render_creator.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Debug\moc_rsx_debugger.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
@@ -1093,6 +1103,11 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release - LLVM\moc_render_creator.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Release - LLVM\moc_rsx_debugger.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
@@ -1368,6 +1383,11 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release\moc_render_creator.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Release\moc_rsx_debugger.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -1475,6 +1495,7 @@
     <ClCompile Include="rpcs3qt\pad_led_settings_dialog.cpp" />
     <ClCompile Include="rpcs3qt\pkg_install_dialog.cpp" />
     <ClCompile Include="rpcs3qt\persistent_settings.cpp" />
+    <ClCompile Include="rpcs3qt\render_creator.cpp" />
     <ClCompile Include="rpcs3qt\screenshot_manager_dialog.cpp" />
     <ClCompile Include="rpcs3qt\screenshot_preview.cpp" />
     <ClCompile Include="rpcs3qt\settings.cpp" />
@@ -2223,6 +2244,25 @@
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WINEXTRAS_LIB -DQT_CONCURRENT_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\wolfssl" "-I.\..\3rdparty\curl\include" "-I.\..\3rdparty\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I.\..\3rdparty\XAudio2Redist\include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtANGLE" "-I$(QTDIR)\include\QtCore" "-I.\debug" "-I$(QTDIR)\mkspecs\win32-msvc2015" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtWinExtras" "-I$(QTDIR)\include\QtConcurrent"</Command>
     </CustomBuild>
+    <ClInclude Include="rpcs3qt\emu_settings_type.h" />
+    <CustomBuild Include="rpcs3qt\render_creator.h">
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DWITH_DISCORD_RPC -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DNDEBUG -DQT_WINEXTRAS_LIB -DQT_CONCURRENT_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\wolfssl" "-I.\..\3rdparty\curl\include" "-I.\..\3rdparty\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I.\..\3rdparty\XAudio2Redist\include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtANGLE" "-I$(QTDIR)\include\QtCore" "-I.\release" "-I$(QTDIR)\mkspecs\win32-msvc2015" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtWinExtras" "-I$(QTDIR)\include\QtConcurrent"</Command>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WINEXTRAS_LIB -DQT_CONCURRENT_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\wolfssl" "-I.\..\3rdparty\curl\include" "-I.\..\3rdparty\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I.\..\3rdparty\XAudio2Redist\include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtANGLE" "-I$(QTDIR)\include\QtCore" "-I.\debug" "-I$(QTDIR)\mkspecs\win32-msvc2015" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtWinExtras" "-I$(QTDIR)\include\QtConcurrent"</Command>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DWITH_DISCORD_RPC -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DNDEBUG -DQT_WINEXTRAS_LIB -DQT_CONCURRENT_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\wolfssl" "-I.\..\3rdparty\curl\include" "-I.\..\3rdparty\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I.\..\3rdparty\XAudio2Redist\include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtANGLE" "-I$(QTDIR)\include\QtCore" "-I.\release" "-I$(QTDIR)\mkspecs\win32-msvc2015" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtWinExtras" "-I$(QTDIR)\include\QtConcurrent"</Command>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WINEXTRAS_LIB -DQT_CONCURRENT_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\wolfssl" "-I.\..\3rdparty\curl\include" "-I.\..\3rdparty\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I.\..\3rdparty\XAudio2Redist\include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtANGLE" "-I$(QTDIR)\include\QtCore" "-I.\debug" "-I$(QTDIR)\mkspecs\win32-msvc2015" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtWinExtras" "-I$(QTDIR)\include\QtConcurrent"</Command>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+    </CustomBuild>
     <ClInclude Include="rpcs3qt\stylesheets.h" />
     <CustomBuild Include="rpcs3qt\skylander_dialog.h">
       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

rpcs3/rpcs3.vcxproj.filters

@@ -1024,6 +1024,21 @@
     <ClCompile Include="QTGeneratedFiles\Debug - LLVM\moc_microphone_creator.cpp">
       <Filter>Generated Files\Debug - LLVM</Filter>
     </ClCompile>
+    <ClCompile Include="rpcs3qt\render_creator.cpp">
+      <Filter>Gui\settings</Filter>
+    </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release - LLVM\moc_render_creator.cpp">
+      <Filter>Generated Files\Release - LLVM</Filter>
+    </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug\moc_render_creator.cpp">
+      <Filter>Generated Files\Debug</Filter>
+    </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release\moc_render_creator.cpp">
+      <Filter>Generated Files\Release</Filter>
+    </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug - LLVM\moc_render_creator.cpp">
+      <Filter>Generated Files\Debug - LLVM</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="\rpcs3qt\*.h">
@@ -1113,6 +1128,9 @@
     <ClInclude Include="rpcs3qt\curl_handle.h">
       <Filter>rpcs3</Filter>
     </ClInclude>
+    <ClInclude Include="rpcs3qt\emu_settings_type.h">
+      <Filter>Gui\settings</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="debug\moc_predefs.h.cbt">
@@ -1322,6 +1340,9 @@
     <CustomBuild Include="rpcs3qt\microphone_creator.h">
       <Filter>Gui\settings</Filter>
     </CustomBuild>
+    <CustomBuild Include="rpcs3qt\render_creator.h">
+      <Filter>Gui\settings</Filter>
+    </CustomBuild>
   </ItemGroup>
   <ItemGroup>
     <Image Include="rpcs3.ico" />

rpcs3/rpcs3qt/CMakeLists.txt

@@ -40,6 +40,7 @@
 	progress_dialog.cpp
 	qt_utils.cpp
 	register_editor_dialog.cpp
+	render_creator.cpp
 	rsx_debugger.cpp
 	save_data_dialog.cpp
 	save_data_info_dialog.cpp

rpcs3/rpcs3qt/emu_settings.cpp

@@ -1,21 +1,12 @@
 #include "emu_settings.h"
 
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-
 #include "Utilities/Config.h"
-#include "Utilities/Thread.h"
 
 #include <QMessageBox>
 #include <QLineEdit>
 
 #include "Emu/System.h"
 #include "Emu/system_config.h"
-#if defined(_WIN32) || defined(HAVE_VULKAN)
-#include "Emu/RSX/VK/VKHelpers.h"
-#endif
 
 LOG_CHANNEL(cfg_log, "CFG");
 
@@ -114,94 +105,9 @@ static QStringList getOptions(cfg_location location)
 	return values;
 }
 
-emu_settings::Render_Creator::Render_Creator(const QString& name_null, const QString& name_vulkan, const QString& name_openGL)
-	: name_Null(name_null)
-	, name_Vulkan(name_vulkan)
-	, name_OpenGL(name_openGL)
-{
-#if defined(WIN32) || defined(HAVE_VULKAN)
-	// Some drivers can get stuck when checking for vulkan-compatible gpus, f.ex. if they're waiting for one to get
-	// plugged in. This whole contraption is for showing an error message in case that happens, so that user has
-	// some idea about why the emulator window isn't showing up.
-
-	static std::atomic<bool> was_called = false;
-	if (was_called.exchange(true))
-		fmt::throw_exception("Render_Creator cannot be created more than once" HERE);
-
-	static std::mutex mtx;
-	static std::condition_variable cond;
-	static bool thread_running = true;
-	static bool device_found = false;
-
-	static QStringList compatible_gpus;
-
-	std::thread enum_thread = std::thread([&]
-	{
-		thread_ctrl::set_native_priority(-1);
-
-		vk::context device_enum_context;
-		if (device_enum_context.createInstance("RPCS3", true))
-		{
-			device_enum_context.makeCurrentInstance();
-			std::vector<vk::physical_device> &gpus = device_enum_context.enumerateDevices();
-
-			if (!gpus.empty())
-			{
-				device_found = true;
-
-				for (auto &gpu : gpus)
-				{
-					compatible_gpus.append(qstr(gpu.get_name()));
-				}
-			}
-		}
-
-		std::scoped_lock{mtx}, thread_running = false;
-		cond.notify_all();
-	});
-
-	{
-		std::unique_lock lck(mtx);
-		cond.wait_for(lck, std::chrono::seconds(10), [&]{ return !thread_running; });
-	}
-
-	if (thread_running)
-	{
-		cfg_log.error("Vulkan device enumeration timed out");
-		const auto button = QMessageBox::critical(nullptr, tr("Vulkan Check Timeout"),
-			tr("Querying for Vulkan-compatible devices is taking too long. This is usually caused by malfunctioning "
-			"graphics drivers, reinstalling them could fix the issue.\n\n"
-			"Selecting ignore starts the emulator without Vulkan support."),
-			QMessageBox::Ignore | QMessageBox::Abort, QMessageBox::Abort);
-
-		enum_thread.detach();
-		if (button != QMessageBox::Ignore)
-			std::exit(1);
-
-		supportsVulkan = false;
-	}
-	else
-	{
-		supportsVulkan = device_found;
-		vulkanAdapters = std::move(compatible_gpus);
-		enum_thread.join();
-	}
-#endif
-
-	// Graphics Adapter
-	Vulkan = Render_Info(name_Vulkan, vulkanAdapters, supportsVulkan, emu_settings::VulkanAdapter, true);
-	OpenGL = Render_Info(name_OpenGL);
-	NullRender = Render_Info(name_Null);
-
-	renderers = { &Vulkan, &OpenGL, &NullRender };
-}
-
 emu_settings::emu_settings()
 	: QObject()
-	, m_render_creator(
-		GetLocalizedSetting("Null", emu_settings::Renderer, static_cast<int>(video_renderer::null)),
-		GetLocalizedSetting("Vulkan", emu_settings::Renderer, static_cast<int>(video_renderer::vulkan)),
-		GetLocalizedSetting("OpenGl", emu_settings::Renderer, static_cast<int>(video_renderer::opengl)))
+	, m_render_creator(new render_creator(this))
 {
 }
 
@@ -285,7 +191,7 @@ void emu_settings::SaveSettings()
 	config.close();
 }
 
-void emu_settings::EnhanceComboBox(QComboBox* combobox, SettingsType type, bool is_ranged, bool use_max, int max, bool sorted)
+void emu_settings::EnhanceComboBox(QComboBox* combobox, emu_settings_type type, bool is_ranged, bool use_max, int max, bool sorted)
 {
 	if (!combobox)
 	{
@@ -346,7 +252,7 @@ void emu_settings::EnhanceComboBox(QComboBox* combobox, SettingsType type, bool
 	});
 }
 
-void emu_settings::EnhanceCheckBox(QCheckBox* checkbox, SettingsType type)
+void emu_settings::EnhanceCheckBox(QCheckBox* checkbox, emu_settings_type type)
 {
 	if (!checkbox)
 	{
@@ -359,7 +265,7 @@ void emu_settings::EnhanceCheckBox(QCheckBox* checkbox, SettingsType type)
 
 	if (def != "true" && def != "false")
 	{
-		cfg_log.fatal("EnhanceCheckBox '%s' was used with an invalid SettingsType", GetSettingName(type));
+		cfg_log.fatal("EnhanceCheckBox '%s' was used with an invalid emu_settings_type", GetSettingName(type));
 		return;
 	}
 
@@ -384,7 +290,7 @@ void emu_settings::EnhanceCheckBox(QCheckBox* checkbox, SettingsType type)
 	});
 }
 
-void emu_settings::EnhanceSlider(QSlider* slider, SettingsType type)
+void emu_settings::EnhanceSlider(QSlider* slider, emu_settings_type type)
 {
 	if (!slider)
 	{
@@ -401,7 +307,7 @@ void emu_settings::EnhanceSlider(QSlider* slider, SettingsType type)
 
 	if (!ok_def || !ok_min || !ok_max)
 	{
-		cfg_log.fatal("EnhanceSlider '%s' was used with an invalid SettingsType", GetSettingName(type));
+		cfg_log.fatal("EnhanceSlider '%s' was used with an invalid emu_settings_type", GetSettingName(type));
 		return;
 	}
 
@@ -424,7 +330,7 @@ void emu_settings::EnhanceSlider(QSlider* slider, SettingsType type)
 	});
 }
 
-void emu_settings::EnhanceSpinBox(QSpinBox* spinbox, SettingsType type, const QString& prefix, const QString& suffix)
+void emu_settings::EnhanceSpinBox(QSpinBox* spinbox, emu_settings_type type, const QString& prefix, const QString& suffix)
 {
 	if (!spinbox)
 	{
@@ -466,7 +372,7 @@ void emu_settings::EnhanceSpinBox(QSpinBox* spinbox, SettingsType type, const QS
 	});
 }
 
-void emu_settings::EnhanceDoubleSpinBox(QDoubleSpinBox* spinbox, SettingsType type, const QString& prefix, const QString& suffix)
+void emu_settings::EnhanceDoubleSpinBox(QDoubleSpinBox* spinbox, emu_settings_type type, const QString& prefix, const QString& suffix)
 {
 	if (!spinbox)
 	{
@@ -508,7 +414,7 @@ void emu_settings::EnhanceDoubleSpinBox(QDoubleSpinBox* spinbox, SettingsType ty
 	});
 }
 
-void emu_settings::EnhanceEdit(QLineEdit* edit, SettingsType type)
+void emu_settings::EnhanceEdit(QLineEdit* edit, emu_settings_type type)
 {
 	if (!edit)
 	{
@@ -525,7 +431,7 @@ void emu_settings::EnhanceEdit(QLineEdit* edit, SettingsType type)
 	});
 }
 
-void emu_settings::EnhanceRadioButton(QButtonGroup* button_group, SettingsType type)
+void emu_settings::EnhanceRadioButton(QButtonGroup* button_group, emu_settings_type type)
 {
 	if (!button_group)
 	{
@@ -570,28 +476,28 @@ void emu_settings::SaveSelectedLibraries(const std::vector<std::string>& libs)
 	m_currentSettings["Core"]["Load libraries"] = libs;
 }
 
-QStringList emu_settings::GetSettingOptions(SettingsType type) const
+QStringList emu_settings::GetSettingOptions(emu_settings_type type) const
 {
 	return getOptions(const_cast<cfg_location&&>(m_settings_location[type]));
 }
 
-std::string emu_settings::GetSettingName(SettingsType type) const
+std::string emu_settings::GetSettingName(emu_settings_type type) const
 {
 	const cfg_location loc = m_settings_location[type];
 	return loc[loc.size() - 1];
 }
 
-std::string emu_settings::GetSettingDefault(SettingsType type) const
+std::string emu_settings::GetSettingDefault(emu_settings_type type) const
 {
 	return cfg_adapter::get_node(m_defaultSettings, m_settings_location[type]).Scalar();
 }
 
-std::string emu_settings::GetSetting(SettingsType type) const
+std::string emu_settings::GetSetting(emu_settings_type type) const
 {
 	return cfg_adapter::get_node(m_currentSettings, m_settings_location[type]).Scalar();
 }
 
-void emu_settings::SetSetting(SettingsType type, const std::string& val)
+void emu_settings::SetSetting(emu_settings_type type, const std::string& val)
 {
 	cfg_adapter::get_node(m_currentSettings, m_settings_location[type]) = val;
 }
@@ -622,11 +528,11 @@ void emu_settings::OpenCorrectionDialog(QWidget* parent)
 	}
 }
 
-QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType type, int index) const
+QString emu_settings::GetLocalizedSetting(const QString& original, emu_settings_type type, int index) const
 {
 	switch (type)
 	{
-	case emu_settings::SPUBlockSize:
+	case emu_settings_type::SPUBlockSize:
 		switch (static_cast<spu_block_size_type>(index))
 		{
 		case spu_block_size_type::safe: return tr("Safe", "SPU block size");
@@ -634,7 +540,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case spu_block_size_type::giga: return tr("Giga", "SPU block size");
 		}
 		break;
-	case emu_settings::EnableTSX:
+	case emu_settings_type::EnableTSX:
 		switch (static_cast<tsx_usage>(index))
 		{
 		case tsx_usage::disabled: return tr("Disabled", "Enable TSX");
@@ -642,7 +548,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case tsx_usage::forced: return tr("Forced", "Enable TSX");
 		}
 		break;
-	case emu_settings::Renderer:
+	case emu_settings_type::Renderer:
 		switch (static_cast<video_renderer>(index))
 		{
 		case video_renderer::null: return tr("Disable Video Output", "Video renderer");
@@ -650,7 +556,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case video_renderer::vulkan: return tr("Vulkan", "Video renderer");
 		}
 		break;
-	case emu_settings::FrameLimit:
+	case emu_settings_type::FrameLimit:
 		switch (static_cast<frame_limit_type>(index))
 		{
 		case frame_limit_type::none: return tr("Off", "Frame limit");
@@ -661,14 +567,14 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case frame_limit_type::_auto: return tr("Auto", "Frame limit");
 		}
 		break;
-	case emu_settings::MSAA:
+	case emu_settings_type::MSAA:
 		switch (static_cast<msaa_level>(index))
 		{
 		case msaa_level::none: return tr("Disabled", "MSAA");
 		case msaa_level::_auto: return tr("Auto", "MSAA");
 		}
 		break;
-	case emu_settings::AudioRenderer:
+	case emu_settings_type::AudioRenderer:
 		switch (static_cast<audio_renderer>(index))
 		{
 		case audio_renderer::null: return tr("Disable Audio Output", "Audio renderer");
@@ -687,7 +593,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 #endif
 		}
 		break;
-	case emu_settings::MicrophoneType:
+	case emu_settings_type::MicrophoneType:
 		switch (static_cast<microphone_handler>(index))
 		{
 		case microphone_handler::null: return tr("Disabled", "Microphone handler");
@@ -697,21 +603,21 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case microphone_handler::rocksmith: return tr("Rocksmith", "Microphone handler");
 		}
 		break;
-	case emu_settings::KeyboardHandler:
+	case emu_settings_type::KeyboardHandler:
 		switch (static_cast<keyboard_handler>(index))
 		{
 		case keyboard_handler::null: return tr("Null", "Keyboard handler");
 		case keyboard_handler::basic: return tr("Basic", "Keyboard handler");
 		}
 		break;
-	case emu_settings::MouseHandler:
+	case emu_settings_type::MouseHandler:
 		switch (static_cast<mouse_handler>(index))
 		{
 		case mouse_handler::null: return tr("Null", "Mouse handler");
 		case mouse_handler::basic: return tr("Basic", "Mouse handler");
 		}
 		break;
-	case emu_settings::CameraType:
+	case emu_settings_type::CameraType:
 		switch (static_cast<fake_camera_type>(index))
 		{
 		case fake_camera_type::unknown: return tr("Unknown", "Camera type");
@@ -720,14 +626,14 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case fake_camera_type::uvc1_1: return tr("UVC 1.1", "Camera type");
 		}
 		break;
-	case emu_settings::Camera:
+	case emu_settings_type::Camera:
 		switch (static_cast<camera_handler>(index))
 		{
 		case camera_handler::null: return tr("Null", "Camera handler");
 		case camera_handler::fake: return tr("Fake", "Camera handler");
 		}
 		break;
-	case emu_settings::Move:
+	case emu_settings_type::Move:
 		switch (static_cast<move_handler>(index))
 		{
 		case move_handler::null: return tr("Null", "Move handler");
@@ -735,21 +641,21 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case move_handler::mouse: return tr("Mouse", "Move handler");
 		}
 		break;
-	case emu_settings::InternetStatus:
+	case emu_settings_type::InternetStatus:
 		switch (static_cast<np_internet_status>(index))
 		{
 		case np_internet_status::disabled: return tr("Disconnected", "Internet Status");
 		case np_internet_status::enabled: return tr("Connected", "Internet Status");
 		}
 		break;
-	case emu_settings::PSNStatus:
+	case emu_settings_type::PSNStatus:
 		switch (static_cast<np_psn_status>(index))
 		{
 		case np_psn_status::disabled: return tr("Disconnected", "PSN Status");
 		case np_psn_status::fake: return tr("Simulated", "PSN Status");
 		}
 		break;
-	case emu_settings::SleepTimersAccuracy:
+	case emu_settings_type::SleepTimersAccuracy:
 		switch (static_cast<sleep_timers_accuracy_level>(index))
 		{
 		case sleep_timers_accuracy_level::_as_host: return tr("As Host", "Sleep timers accuracy");
@@ -757,7 +663,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case sleep_timers_accuracy_level::_all_timers: return tr("All Timers", "Sleep timers accuracy");
 		}
 		break;
-	case emu_settings::PerfOverlayDetailLevel:
+	case emu_settings_type::PerfOverlayDetailLevel:
 		switch (static_cast<detail_level>(index))
 		{
 		case detail_level::minimal: return tr("Minimal", "Detail Level");
@@ -766,7 +672,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case detail_level::high: return tr("High", "Detail Level");
 		}
 		break;
-	case emu_settings::PerfOverlayPosition:
+	case emu_settings_type::PerfOverlayPosition:
 		switch (static_cast<screen_quadrant>(index))
 		{
 		case screen_quadrant::top_left: return tr("Top Left", "Performance overlay position");
@@ -775,7 +681,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case screen_quadrant::bottom_right: return tr("Bottom Right", "Performance overlay position");
 		}
 		break;
-	case emu_settings::LibLoadOptions:
+	case emu_settings_type::LibLoadOptions:
 		switch (static_cast<lib_loading_type>(index))
 		{
 		case lib_loading_type::manual: return tr("Manually load selected libraries", "Libraries");
@@ -785,7 +691,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case lib_loading_type::liblv2list: return tr("Load liblv2.sprx and strict selection", "Libraries");
 		}
 		break;
-	case emu_settings::PPUDecoder:
+	case emu_settings_type::PPUDecoder:
 		switch (static_cast<ppu_decoder_type>(index))
 		{
 		case ppu_decoder_type::precise: return tr("Interpreter (precise)", "PPU decoder");
@@ -793,7 +699,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case ppu_decoder_type::llvm: return tr("Recompiler (LLVM)", "PPU decoder");
 		}
 		break;
-	case emu_settings::SPUDecoder:
+	case emu_settings_type::SPUDecoder:
 		switch (static_cast<spu_decoder_type>(index))
 		{
 		case spu_decoder_type::precise: return tr("Interpreter (precise)", "SPU decoder");
@@ -802,7 +708,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, SettingsType
 		case spu_decoder_type::llvm: return tr("Recompiler (LLVM)", "SPU decoder");
 		}
 		break;
-	case emu_settings::EnterButtonAssignment:
+	case emu_settings_type::EnterButtonAssignment:
 		switch (static_cast<enter_button_assign>(index))
 		{
 		case enter_button_assign::circle: return tr("Enter with circle", "Enter button assignment");

rpcs3/rpcs3qt/emu_settings.h

@@ -5,6 +5,8 @@
 #include "stdafx.h"
 
 #include "microphone_creator.h"
+#include "render_creator.h"
+#include "emu_settings_type.h"
 
 #include <QButtonGroup>
 #include <QCheckBox>
@@ -25,184 +27,7 @@ class emu_settings : public QObject
 	*/
 	Q_OBJECT
 public:
-	enum SettingsType
-	{
-		// Core
-		PPUDecoder,
-		SPUDecoder,
-		LibLoadOptions,
-		HookStaticFuncs,
-		EnableThreadScheduler,
-		LowerSPUThreadPrio,
-		SPULoopDetection,
-		PreferredSPUThreads,
-		PPUDebug,
-		SPUDebug,
-		MaxLLVMThreads,
-		EnableTSX,
-		AccurateGETLLAR,
-		AccuratePUTLLUC,
-		AccuratePPUfma,
-		AccurateRSXAccess,
-		AccurateXFloat,
-		SetDAZandFTZ,
-		SPUBlockSize,
-		SPUCache,
-		DebugConsoleMode,
-		SilenceAllLogs,
-		MaxSPURSThreads,
-		SleepTimersAccuracy,
-		ClocksScale,
-
-		// Graphics
-		Renderer,
-		Resolution,
-		AspectRatio,
-		FrameLimit,
-		MSAA,
-		LogShaderPrograms,
-		WriteDepthBuffer,
-		WriteColorBuffers,
-		ReadColorBuffers,
-		ReadDepthBuffer,
-		VSync,
-		DebugOutput,
-		DebugOverlay,
-		LegacyBuffers,
-		GPUTextureScaling,
-		StretchToDisplayArea,
-		VulkanAdapter,
-		ForceHighpZ,
-		StrictRenderingMode,
-		DisableVertexCache,
-		DisableOcclusionQueries,
-		DisableFIFOReordering,
-		StrictTextureFlushing,
-		AnisotropicFilterOverride,
-		ResolutionScale,
-		MinimumScalableDimension,
-		ForceCPUBlitEmulation,
-		DisableOnDiskShaderCache,
-		DisableVulkanMemAllocator,
-		DisableAsyncShaderCompiler,
-		MultithreadedRSX,
-		VBlankRate,
-		RelaxedZCULL,
-		DriverWakeUpDelay,
-
-		// Performance Overlay
-		PerfOverlayEnabled,
-		PerfOverlayFramerateGraphEnabled,
-		PerfOverlayFrametimeGraphEnabled,
-		PerfOverlayDetailLevel,
-		PerfOverlayPosition,
-		PerfOverlayUpdateInterval,
-		PerfOverlayFontSize,
-		PerfOverlayOpacity,
-		PerfOverlayMarginX,
-		PerfOverlayMarginY,
-		PerfOverlayCenterX,
-		PerfOverlayCenterY,
-
-		// Shader Loading Dialog
-		ShaderLoadBgEnabled,
-		ShaderLoadBgDarkening,
-		ShaderLoadBgBlur,
-
-		// Audio
-		AudioRenderer,
-		DumpToFile,
-		ConvertTo16Bit,
-		DownmixStereo,
-		MasterVolume,
-		EnableBuffering,
-		AudioBufferDuration,
-		EnableTimeStretching,
-		TimeStretchingThreshold,
-		MicrophoneType,
-		MicrophoneDevices,
-
-		// Input / Output
-		PadHandler,
-		KeyboardHandler,
-		MouseHandler,
-		Camera,
-		CameraType,
-		Move,
-
-		// Misc
-		ExitRPCS3OnFinish,
-		StartOnBoot,
-		StartGameFullscreen,
-		PreventDisplaySleep,
-		ShowTrophyPopups,
-		ShowWelcomeScreen,
-		UseNativeInterface,
-		ShowShaderCompilationHint,
-		WindowTitleFormat,
-
-		// Network
-		InternetStatus,
-		DNSAddress,
-		IpSwapList,
-		PSNStatus,
-		PSNNPID,
-
-		// System
-		Language,
-		KeyboardType,
-		EnterButtonAssignment,
-		EnableHostRoot,
-		LimitCacheSize,
-		MaximumCacheSize,
-
-		// Virtual File System
-		emulatorLocation,
-		dev_hdd0Location,
-		dev_hdd1Location,
-		dev_flashLocation,
-		dev_usb000Location,
-	};
-
-	struct Render_Info
-	{
-		QString name;
-		QString old_adapter;
-		QStringList adapters;
-		SettingsType type = VulkanAdapter;
-		bool supported = true;
-		bool has_adapters = true;
-		bool has_msaa = false;
-
-		Render_Info() = default;
-		explicit Render_Info(QString name)
-			: name(std::move(name))
-			, has_adapters(false) {}
-
-		Render_Info(QString name, QStringList adapters, bool supported, SettingsType type, bool has_msaa)
-			: name(std::move(name))
-			, adapters(std::move(adapters))
-			, type(type)
-			, supported(supported)
-			, has_msaa(has_msaa) {}
-	};
-
-	struct Render_Creator
-	{
-		bool supportsVulkan = false;
-		QStringList vulkanAdapters;
-		QString name_Null;
-		QString name_Vulkan;
-		QString name_OpenGL;
-		Render_Info Vulkan;
-		Render_Info OpenGL;
-		Render_Info NullRender;
-		std::vector<Render_Info*> renderers;
-
-		Render_Creator(const QString& name_null, const QString& name_vulkan, const QString& name_openGL);
-	};
-
-	std::set<SettingsType> m_broken_types; // list of broken settings
+	std::set<emu_settings_type> m_broken_types; // list of broken settings
 
 	/** Creates a settings object which reads in the config.yml file at rpcs3/bin/%path%/config.yml
 	* Settings are only written when SaveSettings is called.
@@ -211,46 +36,46 @@ public:
 	~emu_settings();
 
 	/** Connects a combo box with the target settings type*/
-	void EnhanceComboBox(QComboBox* combobox, SettingsType type, bool is_ranged = false, bool use_max = false, int max = 0, bool sorted = false);
+	void EnhanceComboBox(QComboBox* combobox, emu_settings_type type, bool is_ranged = false, bool use_max = false, int max = 0, bool sorted = false);
 
 	/** Connects a check box with the target settings type*/
-	void EnhanceCheckBox(QCheckBox* checkbox, SettingsType type);
+	void EnhanceCheckBox(QCheckBox* checkbox, emu_settings_type type);
 
 	/** Connects a slider with the target settings type*/
-	void EnhanceSlider(QSlider* slider, SettingsType type);
+	void EnhanceSlider(QSlider* slider, emu_settings_type type);
 
 	/** Connects an integer spin box with the target settings type*/
-	void EnhanceSpinBox(QSpinBox* slider, SettingsType type, const QString& prefix = "", const QString& suffix = "");
+	void EnhanceSpinBox(QSpinBox* slider, emu_settings_type type, const QString& prefix = "", const QString& suffix = "");
 
 	/** Connects a double spin box with the target settings type*/
-	void EnhanceDoubleSpinBox(QDoubleSpinBox* slider, SettingsType type, const QString& prefix = "", const QString& suffix = "");
+	void EnhanceDoubleSpinBox(QDoubleSpinBox* slider, emu_settings_type type, const QString& prefix = "", const QString& suffix = "");
 
 	/** Connects a line edit with the target settings type*/
-	void EnhanceEdit(QLineEdit* edit, SettingsType type);
+	void EnhanceEdit(QLineEdit* edit, emu_settings_type type);
 
 	/** Connects a button group with the target settings type*/
-	void EnhanceRadioButton(QButtonGroup* button_group, SettingsType type);
+	void EnhanceRadioButton(QButtonGroup* button_group, emu_settings_type type);
 
 	std::vector<std::string> GetLoadedLibraries();
 	void SaveSelectedLibraries(const std::vector<std::string>& libs);
 
 	/** Returns the valid options for a given setting.*/
-	QStringList GetSettingOptions(SettingsType type) const;
+	QStringList GetSettingOptions(emu_settings_type type) const;
 
 	/** Returns the string for a given setting.*/
-	std::string GetSettingName(SettingsType type) const;
+	std::string GetSettingName(emu_settings_type type) const;
 
 	/** Returns the default value of the setting type.*/
-	std::string GetSettingDefault(SettingsType type) const;
+	std::string GetSettingDefault(emu_settings_type type) const;
 
 	/** Returns the value of the setting type.*/
-	std::string GetSetting(SettingsType type) const;
+	std::string GetSetting(emu_settings_type type) const;
 
 	/** Sets the setting type to a given value.*/
-	void SetSetting(SettingsType type, const std::string& val);
+	void SetSetting(emu_settings_type type, const std::string& val);
 
 	/** Gets all the renderer info for gpu settings.*/
-	Render_Creator m_render_creator;
+	render_creator* m_render_creator;
 
 	/** Gets a list of all the microphones available.*/
 	microphone_creator m_microphone_creator;
@@ -262,150 +87,150 @@ public:
 	void OpenCorrectionDialog(QWidget* parent = Q_NULLPTR);
 
 	/** Get a localized and therefore freely adjustable version of the string used in config.yml.*/
-	QString GetLocalizedSetting(const QString& original, SettingsType type, int index) const;
+	QString GetLocalizedSetting(const QString& original, emu_settings_type type, int index) const;
 
 public Q_SLOTS:
 	/** Writes the unsaved settings to file.  Used in settings dialog on accept.*/
 	void SaveSettings();
 private:
 	/** A helper map that keeps track of where a given setting type is located*/
-	const QMap<SettingsType, cfg_location> m_settings_location =
+	const QMap<emu_settings_type, cfg_location> m_settings_location =
 	{
 		// Core Tab
-		{ PPUDecoder,               { "Core", "PPU Decoder"}},
-		{ SPUDecoder,               { "Core", "SPU Decoder"}},
-		{ LibLoadOptions,           { "Core", "Lib Loader"}},
-		{ HookStaticFuncs,          { "Core", "Hook static functions"}},
-		{ EnableThreadScheduler,    { "Core", "Enable thread scheduler"}},
-		{ LowerSPUThreadPrio,       { "Core", "Lower SPU thread priority"}},
-		{ SPULoopDetection,         { "Core", "SPU loop detection"}},
-		{ PreferredSPUThreads,      { "Core", "Preferred SPU Threads"}},
-		{ PPUDebug,                 { "Core", "PPU Debug"}},
-		{ SPUDebug,                 { "Core", "SPU Debug"}},
-		{ MaxLLVMThreads,           { "Core", "Max LLVM Compile Threads"}},
-		{ EnableTSX,                { "Core", "Enable TSX"}},
-		{ AccurateGETLLAR,          { "Core", "Accurate GETLLAR"}},
-		{ AccuratePUTLLUC,          { "Core", "Accurate PUTLLUC"}},
-		{ AccuratePPUfma,           { "Core", "PPU Accurate FMA"}},
-		{ AccurateRSXAccess,        { "Core", "Accurate RSX reservation access"}},
-		{ AccurateXFloat,           { "Core", "Accurate xfloat"}},
-		{ SetDAZandFTZ,             { "Core", "Set DAZ and FTZ"}},
-		{ SPUBlockSize,             { "Core", "SPU Block Size"}},
-		{ SPUCache,                 { "Core", "SPU Cache"}},
-		{ DebugConsoleMode,         { "Core", "Debug Console Mode"}},
-		{ MaxSPURSThreads,          { "Core", "Max SPURS Threads"}},
-		{ SleepTimersAccuracy,      { "Core", "Sleep Timers Accuracy"}},
-		{ ClocksScale,              { "Core", "Clocks scale"}},
+		{ emu_settings_type::PPUDecoder,               { "Core", "PPU Decoder"}},
+		{ emu_settings_type::SPUDecoder,               { "Core", "SPU Decoder"}},
+		{ emu_settings_type::LibLoadOptions,           { "Core", "Lib Loader"}},
+		{ emu_settings_type::HookStaticFuncs,          { "Core", "Hook static functions"}},
+		{ emu_settings_type::EnableThreadScheduler,    { "Core", "Enable thread scheduler"}},
+		{ emu_settings_type::LowerSPUThreadPrio,       { "Core", "Lower SPU thread priority"}},
+		{ emu_settings_type::SPULoopDetection,         { "Core", "SPU loop detection"}},
+		{ emu_settings_type::PreferredSPUThreads,      { "Core", "Preferred SPU Threads"}},
+		{ emu_settings_type::PPUDebug,                 { "Core", "PPU Debug"}},
+		{ emu_settings_type::SPUDebug,                 { "Core", "SPU Debug"}},
+		{ emu_settings_type::MaxLLVMThreads,           { "Core", "Max LLVM Compile Threads"}},
+		{ emu_settings_type::EnableTSX,                { "Core", "Enable TSX"}},
+		{ emu_settings_type::AccurateGETLLAR,          { "Core", "Accurate GETLLAR"}},
+		{ emu_settings_type::AccuratePUTLLUC,          { "Core", "Accurate PUTLLUC"}},
+		{ emu_settings_type::AccuratePPUfma,           { "Core", "PPU Accurate FMA"}},
+		{ emu_settings_type::AccurateRSXAccess,        { "Core", "Accurate RSX reservation access"}},
+		{ emu_settings_type::AccurateXFloat,           { "Core", "Accurate xfloat"}},
+		{ emu_settings_type::SetDAZandFTZ,             { "Core", "Set DAZ and FTZ"}},
+		{ emu_settings_type::SPUBlockSize,             { "Core", "SPU Block Size"}},
+		{ emu_settings_type::SPUCache,                 { "Core", "SPU Cache"}},
+		{ emu_settings_type::DebugConsoleMode,         { "Core", "Debug Console Mode"}},
+		{ emu_settings_type::MaxSPURSThreads,          { "Core", "Max SPURS Threads"}},
+		{ emu_settings_type::SleepTimersAccuracy,      { "Core", "Sleep Timers Accuracy"}},
+		{ emu_settings_type::ClocksScale,              { "Core", "Clocks scale"}},
 
 		// Graphics Tab
-		{ Renderer,                   { "Video", "Renderer"}},
-		{ Resolution,                 { "Video", "Resolution"}},
-		{ AspectRatio,                { "Video", "Aspect ratio"}},
-		{ FrameLimit,                 { "Video", "Frame limit"}},
-		{ MSAA,                       { "Video", "MSAA"}},
-		{ LogShaderPrograms,          { "Video", "Log shader programs"}},
-		{ WriteDepthBuffer,           { "Video", "Write Depth Buffer"}},
-		{ WriteColorBuffers,          { "Video", "Write Color Buffers"}},
-		{ ReadColorBuffers,           { "Video", "Read Color Buffers"}},
-		{ ReadDepthBuffer,            { "Video", "Read Depth Buffer"}},
-		{ VSync,                      { "Video", "VSync"}},
-		{ DebugOutput,                { "Video", "Debug output"}},
-		{ DebugOverlay,               { "Video", "Debug overlay"}},
-		{ LegacyBuffers,              { "Video", "Use Legacy OpenGL Buffers"}},
-		{ GPUTextureScaling,          { "Video", "Use GPU texture scaling"}},
-		{ StretchToDisplayArea,       { "Video", "Stretch To Display Area"}},
-		{ ForceHighpZ,                { "Video", "Force High Precision Z buffer"}},
-		{ StrictRenderingMode,        { "Video", "Strict Rendering Mode"}},
-		{ DisableVertexCache,         { "Video", "Disable Vertex Cache"}},
-		{ DisableOcclusionQueries,    { "Video", "Disable ZCull Occlusion Queries"}},
-		{ DisableFIFOReordering,      { "Video", "Disable FIFO Reordering"}},
-		{ StrictTextureFlushing,      { "Video", "Strict Texture Flushing"}},
-		{ ForceCPUBlitEmulation,      { "Video", "Force CPU Blit"}},
-		{ DisableOnDiskShaderCache,   { "Video", "Disable On-Disk Shader Cache"}},
-		{ DisableVulkanMemAllocator,  { "Video", "Disable Vulkan Memory Allocator"}},
-		{ DisableAsyncShaderCompiler, { "Video", "Disable Asynchronous Shader Compiler"}},
-		{ MultithreadedRSX,           { "Video", "Multithreaded RSX"}},
-		{ RelaxedZCULL,               { "Video", "Relaxed ZCULL Sync"}},
-		{ AnisotropicFilterOverride,  { "Video", "Anisotropic Filter Override"}},
-		{ ResolutionScale,            { "Video", "Resolution Scale"}},
-		{ MinimumScalableDimension,   { "Video", "Minimum Scalable Dimension"}},
-		{ VulkanAdapter,              { "Video", "Vulkan", "Adapter"}},
-		{ VBlankRate,                 { "Video", "Vblank Rate"}},
-		{ DriverWakeUpDelay,          { "Video", "Driver Wake-Up Delay"}},
+		{ emu_settings_type::Renderer,                   { "Video", "Renderer"}},
+		{ emu_settings_type::Resolution,                 { "Video", "Resolution"}},
+		{ emu_settings_type::AspectRatio,                { "Video", "Aspect ratio"}},
+		{ emu_settings_type::FrameLimit,                 { "Video", "Frame limit"}},
+		{ emu_settings_type::MSAA,                       { "Video", "MSAA"}},
+		{ emu_settings_type::LogShaderPrograms,          { "Video", "Log shader programs"}},
+		{ emu_settings_type::WriteDepthBuffer,           { "Video", "Write Depth Buffer"}},
+		{ emu_settings_type::WriteColorBuffers,          { "Video", "Write Color Buffers"}},
+		{ emu_settings_type::ReadColorBuffers,           { "Video", "Read Color Buffers"}},
+		{ emu_settings_type::ReadDepthBuffer,            { "Video", "Read Depth Buffer"}},
+		{ emu_settings_type::VSync,                      { "Video", "VSync"}},
+		{ emu_settings_type::DebugOutput,                { "Video", "Debug output"}},
+		{ emu_settings_type::DebugOverlay,               { "Video", "Debug overlay"}},
+		{ emu_settings_type::LegacyBuffers,              { "Video", "Use Legacy OpenGL Buffers"}},
+		{ emu_settings_type::GPUTextureScaling,          { "Video", "Use GPU texture scaling"}},
+		{ emu_settings_type::StretchToDisplayArea,       { "Video", "Stretch To Display Area"}},
+		{ emu_settings_type::ForceHighpZ,                { "Video", "Force High Precision Z buffer"}},
+		{ emu_settings_type::StrictRenderingMode,        { "Video", "Strict Rendering Mode"}},
+		{ emu_settings_type::DisableVertexCache,         { "Video", "Disable Vertex Cache"}},
+		{ emu_settings_type::DisableOcclusionQueries,    { "Video", "Disable ZCull Occlusion Queries"}},
+		{ emu_settings_type::DisableFIFOReordering,      { "Video", "Disable FIFO Reordering"}},
+		{ emu_settings_type::StrictTextureFlushing,      { "Video", "Strict Texture Flushing"}},
+		{ emu_settings_type::ForceCPUBlitEmulation,      { "Video", "Force CPU Blit"}},
+		{ emu_settings_type::DisableOnDiskShaderCache,   { "Video", "Disable On-Disk Shader Cache"}},
+		{ emu_settings_type::DisableVulkanMemAllocator,  { "Video", "Disable Vulkan Memory Allocator"}},
+		{ emu_settings_type::DisableAsyncShaderCompiler, { "Video", "Disable Asynchronous Shader Compiler"}},
+		{ emu_settings_type::MultithreadedRSX,           { "Video", "Multithreaded RSX"}},
+		{ emu_settings_type::RelaxedZCULL,               { "Video", "Relaxed ZCULL Sync"}},
+		{ emu_settings_type::AnisotropicFilterOverride,  { "Video", "Anisotropic Filter Override"}},
+		{ emu_settings_type::ResolutionScale,            { "Video", "Resolution Scale"}},
+		{ emu_settings_type::MinimumScalableDimension,   { "Video", "Minimum Scalable Dimension"}},
+		{ emu_settings_type::VulkanAdapter,              { "Video", "Vulkan", "Adapter"}},
+		{ emu_settings_type::VBlankRate,                 { "Video", "Vblank Rate"}},
+		{ emu_settings_type::DriverWakeUpDelay,          { "Video", "Driver Wake-Up Delay"}},
 
 		// Performance Overlay
-		{ PerfOverlayEnabled,               { "Video", "Performance Overlay", "Enabled" } },
-		{ PerfOverlayFramerateGraphEnabled, { "Video", "Performance Overlay", "Enable Framerate Graph" } },
-		{ PerfOverlayFrametimeGraphEnabled, { "Video", "Performance Overlay", "Enable Frametime Graph" } },
-		{ PerfOverlayDetailLevel,           { "Video", "Performance Overlay", "Detail level" } },
-		{ PerfOverlayPosition,              { "Video", "Performance Overlay", "Position" } },
-		{ PerfOverlayUpdateInterval,        { "Video", "Performance Overlay", "Metrics update interval (ms)" } },
-		{ PerfOverlayFontSize,              { "Video", "Performance Overlay", "Font size (px)" } },
-		{ PerfOverlayOpacity,               { "Video", "Performance Overlay", "Opacity (%)" } },
-		{ PerfOverlayMarginX,               { "Video", "Performance Overlay", "Horizontal Margin (px)" } },
-		{ PerfOverlayMarginY,               { "Video", "Performance Overlay", "Vertical Margin (px)" } },
-		{ PerfOverlayCenterX,               { "Video", "Performance Overlay", "Center Horizontally" } },
-		{ PerfOverlayCenterY,               { "Video", "Performance Overlay", "Center Vertically" } },
+		{ emu_settings_type::PerfOverlayEnabled,               { "Video", "Performance Overlay", "Enabled" } },
+		{ emu_settings_type::PerfOverlayFramerateGraphEnabled, { "Video", "Performance Overlay", "Enable Framerate Graph" } },
+		{ emu_settings_type::PerfOverlayFrametimeGraphEnabled, { "Video", "Performance Overlay", "Enable Frametime Graph" } },
+		{ emu_settings_type::PerfOverlayDetailLevel,           { "Video", "Performance Overlay", "Detail level" } },
+		{ emu_settings_type::PerfOverlayPosition,              { "Video", "Performance Overlay", "Position" } },
+		{ emu_settings_type::PerfOverlayUpdateInterval,        { "Video", "Performance Overlay", "Metrics update interval (ms)" } },
+		{ emu_settings_type::PerfOverlayFontSize,              { "Video", "Performance Overlay", "Font size (px)" } },
+		{ emu_settings_type::PerfOverlayOpacity,               { "Video", "Performance Overlay", "Opacity (%)" } },
+		{ emu_settings_type::PerfOverlayMarginX,               { "Video", "Performance Overlay", "Horizontal Margin (px)" } },
+		{ emu_settings_type::PerfOverlayMarginY,               { "Video", "Performance Overlay", "Vertical Margin (px)" } },
+		{ emu_settings_type::PerfOverlayCenterX,               { "Video", "Performance Overlay", "Center Horizontally" } },
+		{ emu_settings_type::PerfOverlayCenterY,               { "Video", "Performance Overlay", "Center Vertically" } },
 
 		// Shader Loading Dialog
-		{ ShaderLoadBgEnabled,      { "Video", "Shader Loading Dialog", "Allow custom background" } },
-		{ ShaderLoadBgDarkening,    { "Video", "Shader Loading Dialog", "Darkening effect strength" } },
-		{ ShaderLoadBgBlur,         { "Video", "Shader Loading Dialog", "Blur effect strength" } },
+		{ emu_settings_type::ShaderLoadBgEnabled,      { "Video", "Shader Loading Dialog", "Allow custom background" } },
+		{ emu_settings_type::ShaderLoadBgDarkening,    { "Video", "Shader Loading Dialog", "Darkening effect strength" } },
+		{ emu_settings_type::ShaderLoadBgBlur,         { "Video", "Shader Loading Dialog", "Blur effect strength" } },
 
 		// Audio
-		{ AudioRenderer,           { "Audio", "Renderer"}},
-		{ DumpToFile,              { "Audio", "Dump to file"}},
-		{ ConvertTo16Bit,          { "Audio", "Convert to 16 bit"}},
-		{ DownmixStereo,           { "Audio", "Downmix to Stereo"}},
-		{ MasterVolume,            { "Audio", "Master Volume"}},
-		{ EnableBuffering,         { "Audio", "Enable Buffering"}},
-		{ AudioBufferDuration,     { "Audio", "Desired Audio Buffer Duration"}},
-		{ EnableTimeStretching,    { "Audio", "Enable Time Stretching"}},
-		{ TimeStretchingThreshold, { "Audio", "Time Stretching Threshold"}},
-		{ MicrophoneType,          { "Audio", "Microphone Type" }},
-		{ MicrophoneDevices,       { "Audio", "Microphone Devices" }},
+		{ emu_settings_type::AudioRenderer,           { "Audio", "Renderer"}},
+		{ emu_settings_type::DumpToFile,              { "Audio", "Dump to file"}},
+		{ emu_settings_type::ConvertTo16Bit,          { "Audio", "Convert to 16 bit"}},
+		{ emu_settings_type::DownmixStereo,           { "Audio", "Downmix to Stereo"}},
+		{ emu_settings_type::MasterVolume,            { "Audio", "Master Volume"}},
+		{ emu_settings_type::EnableBuffering,         { "Audio", "Enable Buffering"}},
+		{ emu_settings_type::AudioBufferDuration,     { "Audio", "Desired Audio Buffer Duration"}},
+		{ emu_settings_type::EnableTimeStretching,    { "Audio", "Enable Time Stretching"}},
+		{ emu_settings_type::TimeStretchingThreshold, { "Audio", "Time Stretching Threshold"}},
+		{ emu_settings_type::MicrophoneType,          { "Audio", "Microphone Type" }},
+		{ emu_settings_type::MicrophoneDevices,       { "Audio", "Microphone Devices" }},
 
 		// Input / Output
-		{ PadHandler,      { "Input/Output", "Pad"}},
-		{ KeyboardHandler, { "Input/Output", "Keyboard"}},
-		{ MouseHandler,    { "Input/Output", "Mouse"}},
-		{ Camera,          { "Input/Output", "Camera"}},
-		{ CameraType,      { "Input/Output", "Camera type"}},
-		{ Move,            { "Input/Output", "Move" }},
+		{ emu_settings_type::PadHandler,      { "Input/Output", "Pad"}},
+		{ emu_settings_type::KeyboardHandler, { "Input/Output", "Keyboard"}},
+		{ emu_settings_type::MouseHandler,    { "Input/Output", "Mouse"}},
+		{ emu_settings_type::Camera,          { "Input/Output", "Camera"}},
+		{ emu_settings_type::CameraType,      { "Input/Output", "Camera type"}},
+		{ emu_settings_type::Move,            { "Input/Output", "Move" }},
 
 		// Misc
-		{ ExitRPCS3OnFinish,         { "Miscellaneous", "Exit RPCS3 when process finishes" }},
-		{ StartOnBoot,               { "Miscellaneous", "Automatically start games after boot" }},
-		{ StartGameFullscreen,       { "Miscellaneous", "Start games in fullscreen mode"}},
-		{ PreventDisplaySleep,       { "Miscellaneous", "Prevent display sleep while running games"}},
-		{ ShowTrophyPopups,          { "Miscellaneous", "Show trophy popups"}},
-		{ ShowWelcomeScreen,         { "Miscellaneous", "Show Welcome Screen"}},
-		{ UseNativeInterface,        { "Miscellaneous", "Use native user interface"}},
-		{ ShowShaderCompilationHint, { "Miscellaneous", "Show shader compilation hint"}},
-		{ SilenceAllLogs,            { "Miscellaneous", "Silence All Logs" }},
-		{ WindowTitleFormat,         { "Miscellaneous", "Window Title Format" }},
+		{ emu_settings_type::ExitRPCS3OnFinish,         { "Miscellaneous", "Exit RPCS3 when process finishes" }},
+		{ emu_settings_type::StartOnBoot,               { "Miscellaneous", "Automatically start games after boot" }},
+		{ emu_settings_type::StartGameFullscreen,       { "Miscellaneous", "Start games in fullscreen mode"}},
+		{ emu_settings_type::PreventDisplaySleep,       { "Miscellaneous", "Prevent display sleep while running games"}},
+		{ emu_settings_type::ShowTrophyPopups,          { "Miscellaneous", "Show trophy popups"}},
+		{ emu_settings_type::ShowWelcomeScreen,         { "Miscellaneous", "Show Welcome Screen"}},
+		{ emu_settings_type::UseNativeInterface,        { "Miscellaneous", "Use native user interface"}},
+		{ emu_settings_type::ShowShaderCompilationHint, { "Miscellaneous", "Show shader compilation hint"}},
+		{ emu_settings_type::SilenceAllLogs,            { "Miscellaneous", "Silence All Logs" }},
+		{ emu_settings_type::WindowTitleFormat,         { "Miscellaneous", "Window Title Format" }},
 
 		// Networking
-		{ InternetStatus, { "Net", "Internet enabled"}},
-		{ DNSAddress,     { "Net", "DNS address"}},
-		{ IpSwapList,     { "Net", "IP swap list"}},
-		{ PSNStatus,      { "Net", "PSN status"}},
-		{ PSNNPID,        { "Net", "NPID"}},
+		{ emu_settings_type::InternetStatus, { "Net", "Internet enabled"}},
+		{ emu_settings_type::DNSAddress,     { "Net", "DNS address"}},
+		{ emu_settings_type::IpSwapList,     { "Net", "IP swap list"}},
+		{ emu_settings_type::PSNStatus,      { "Net", "PSN status"}},
+		{ emu_settings_type::PSNNPID,        { "Net", "NPID"}},
 
 		// System
-		{ Language,              { "System", "Language"}},
-		{ KeyboardType,          { "System", "Keyboard Type"} },
-		{ EnterButtonAssignment, { "System", "Enter button assignment"}},
-		{ EnableHostRoot,        { "VFS", "Enable /host_root/"}},
-		{ LimitCacheSize,        { "VFS", "Limit disk cache size"}},
-		{ MaximumCacheSize,      { "VFS", "Disk cache maximum size (MB)"}},
+		{ emu_settings_type::Language,              { "System", "Language"}},
+		{ emu_settings_type::KeyboardType,          { "System", "Keyboard Type"} },
+		{ emu_settings_type::EnterButtonAssignment, { "System", "Enter button assignment"}},
+		{ emu_settings_type::EnableHostRoot,        { "VFS", "Enable /host_root/"}},
+		{ emu_settings_type::LimitCacheSize,        { "VFS", "Limit disk cache size"}},
+		{ emu_settings_type::MaximumCacheSize,      { "VFS", "Disk cache maximum size (MB)"}},
 
 		// Virtual File System
-		{ emulatorLocation,   { "VFS", "$(EmulatorDir)"}},
-		{ dev_hdd0Location,   { "VFS", "/dev_hdd0/" }},
-		{ dev_hdd1Location,   { "VFS", "/dev_hdd1/" }},
-		{ dev_flashLocation,  { "VFS", "/dev_flash/"}},
-		{ dev_usb000Location, { "VFS", "/dev_usb000/"}},
+		{ emu_settings_type::emulatorLocation,   { "VFS", "$(EmulatorDir)"}},
+		{ emu_settings_type::dev_hdd0Location,   { "VFS", "/dev_hdd0/" }},
+		{ emu_settings_type::dev_hdd1Location,   { "VFS", "/dev_hdd1/" }},
+		{ emu_settings_type::dev_flashLocation,  { "VFS", "/dev_flash/"}},
+		{ emu_settings_type::dev_usb000Location, { "VFS", "/dev_usb000/"}},
 	};
 
 	YAML::Node m_defaultSettings; // The default settings as a YAML node.

rpcs3/rpcs3qt/emu_settings_type.h

@@ -0,0 +1,140 @@
+#pragma once
+
+enum class emu_settings_type
+{
+	// Core
+	PPUDecoder,
+	SPUDecoder,
+	LibLoadOptions,
+	HookStaticFuncs,
+	EnableThreadScheduler,
+	LowerSPUThreadPrio,
+	SPULoopDetection,
+	PreferredSPUThreads,
+	PPUDebug,
+	SPUDebug,
+	MaxLLVMThreads,
+	EnableTSX,
+	AccurateGETLLAR,
+	AccuratePUTLLUC,
+	AccuratePPUfma,
+	AccurateRSXAccess,
+	AccurateXFloat,
+	SetDAZandFTZ,
+	SPUBlockSize,
+	SPUCache,
+	DebugConsoleMode,
+	SilenceAllLogs,
+	MaxSPURSThreads,
+	SleepTimersAccuracy,
+	ClocksScale,
+
+	// Graphics
+	Renderer,
+	Resolution,
+	AspectRatio,
+	FrameLimit,
+	MSAA,
+	LogShaderPrograms,
+	WriteDepthBuffer,
+	WriteColorBuffers,
+	ReadColorBuffers,
+	ReadDepthBuffer,
+	VSync,
+	DebugOutput,
+	DebugOverlay,
+	LegacyBuffers,
+	GPUTextureScaling,
+	StretchToDisplayArea,
+	VulkanAdapter,
+	ForceHighpZ,
+	StrictRenderingMode,
+	DisableVertexCache,
+	DisableOcclusionQueries,
+	DisableFIFOReordering,
+	StrictTextureFlushing,
+	AnisotropicFilterOverride,
+	ResolutionScale,
+	MinimumScalableDimension,
+	ForceCPUBlitEmulation,
+	DisableOnDiskShaderCache,
+	DisableVulkanMemAllocator,
+	DisableAsyncShaderCompiler,
+	MultithreadedRSX,
+	VBlankRate,
+	RelaxedZCULL,
+	DriverWakeUpDelay,
+
+	// Performance Overlay
+	PerfOverlayEnabled,
+	PerfOverlayFramerateGraphEnabled,
+	PerfOverlayFrametimeGraphEnabled,
+	PerfOverlayDetailLevel,
+	PerfOverlayPosition,
+	PerfOverlayUpdateInterval,
+	PerfOverlayFontSize,
+	PerfOverlayOpacity,
+	PerfOverlayMarginX,
+	PerfOverlayMarginY,
+	PerfOverlayCenterX,
+	PerfOverlayCenterY,
+
+	// Shader Loading Dialog
+	ShaderLoadBgEnabled,
+	ShaderLoadBgDarkening,
+	ShaderLoadBgBlur,
+
+	// Audio
+	AudioRenderer,
+	DumpToFile,
+	ConvertTo16Bit,
+	DownmixStereo,
+	MasterVolume,
+	EnableBuffering,
+	AudioBufferDuration,
+	EnableTimeStretching,
+	TimeStretchingThreshold,
+	MicrophoneType,
+	MicrophoneDevices,
+
+	// Input / Output
+	PadHandler,
+	KeyboardHandler,
+	MouseHandler,
+	Camera,
+	CameraType,
+	Move,
+
+	// Misc
+	ExitRPCS3OnFinish,
+	StartOnBoot,
+	StartGameFullscreen,
+	PreventDisplaySleep,
+	ShowTrophyPopups,
+	ShowWelcomeScreen,
+	UseNativeInterface,
+	ShowShaderCompilationHint,
+	WindowTitleFormat,
+
+	// Network
+	InternetStatus,
+	DNSAddress,
+	IpSwapList,
+	PSNStatus,
+	PSNNPID,
+
+	// System
+	Language,
+	KeyboardType,
+	EnterButtonAssignment,
+	EnableHostRoot,
+	LimitCacheSize,
+	MaximumCacheSize,
+
+	// Virtual File System
+	emulatorLocation,
+	dev_hdd0Location,
+	dev_hdd1Location,
+	dev_flashLocation,
+	dev_usb000Location,
+};

rpcs3/rpcs3qt/render_creator.cpp

@@ -0,0 +1,112 @@
+#include "render_creator.h"
+
+#include <QMessageBox>
+
+#include "Utilities/Config.h"
+#include "Utilities/Thread.h"
+
+#if defined(_WIN32) || defined(HAVE_VULKAN)
+#include "Emu/RSX/VK/VKHelpers.h"
+#endif
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+LOG_CHANNEL(cfg_log, "CFG");
+
+constexpr auto qstr = QString::fromStdString;
+
+render_creator::render_creator(QObject *parent) : QObject(parent)
+{
+#if defined(WIN32) || defined(HAVE_VULKAN)
+	// Some drivers can get stuck when checking for vulkan-compatible gpus, f.ex. if they're waiting for one to get
+	// plugged in. This whole contraption is for showing an error message in case that happens, so that user has
+	// some idea about why the emulator window isn't showing up.
+
+	static std::atomic<bool> was_called = false;
+	if (was_called.exchange(true))
+		fmt::throw_exception("Render_Creator cannot be created more than once" HERE);
+
+	static std::mutex mtx;
+	static std::condition_variable cond;
+	static bool thread_running = true;
+	static bool device_found = false;
+
+	static QStringList compatible_gpus;
+
+	std::thread enum_thread = std::thread([&]
+	{
+		thread_ctrl::set_native_priority(-1);
+
+		vk::context device_enum_context;
+		if (device_enum_context.createInstance("RPCS3", true))
+		{
+			device_enum_context.makeCurrentInstance();
+			std::vector<vk::physical_device>& gpus = device_enum_context.enumerateDevices();
+
+			if (!gpus.empty())
+			{
+				device_found = true;
+
+				for (auto& gpu : gpus)
+				{
+					compatible_gpus.append(qstr(gpu.get_name()));
+				}
+			}
+		}
+
+		std::scoped_lock{ mtx }, thread_running = false;
+		cond.notify_all();
+	});
+
+	{
+		std::unique_lock lck(mtx);
+		cond.wait_for(lck, std::chrono::seconds(10), [&] { return !thread_running; });
+	}
+
+	if (thread_running)
+	{
+		cfg_log.error("Vulkan device enumeration timed out");
+		const auto button = QMessageBox::critical(nullptr, tr("Vulkan Check Timeout"),
+			tr("Querying for Vulkan-compatible devices is taking too long. This is usually caused by malfunctioning "
+				"graphics drivers, reinstalling them could fix the issue.\n\n"
+				"Selecting ignore starts the emulator without Vulkan support."),
+			QMessageBox::Ignore | QMessageBox::Abort, QMessageBox::Abort);
+
+		enum_thread.detach();
+		if (button != QMessageBox::Ignore)
+			std::exit(1);
+
+		supports_vulkan = false;
+	}
+	else
+	{
+		supports_vulkan = device_found;
+		vulkan_adapters = std::move(compatible_gpus);
+		enum_thread.join();
+	}
+#endif
+
+	// Graphics Adapter
+	Vulkan = render_info(vulkan_adapters, supports_vulkan, emu_settings_type::VulkanAdapter, true);
+	OpenGL = render_info();
+	NullRender = render_info();
+
+	renderers = { &Vulkan, &OpenGL, &NullRender };
+}
+
+void render_creator::update_names(const QStringList& names)
+{
+	for (int i = 0; i < names.size(); i++)
+	{
+		if (static_cast<size_t>(i) >= renderers.size() || !renderers[i])
+		{
+			cfg_log.error("render_creator::update_names could not update renderer %d", i);
+			return;
+		}
+
+		renderers[i]->name = names[i];
+	}
+}

rpcs3/rpcs3qt/render_creator.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "emu_settings_type.h"
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class render_creator : public QObject
+{
+	Q_OBJECT
+
+public:
+	struct render_info
+	{
+		QString name;
+		QString old_adapter;
+		QStringList adapters;
+		emu_settings_type type = emu_settings_type::VulkanAdapter;
+		bool supported = true;
+		bool has_adapters = true;
+		bool has_msaa = false;
+
+		render_info()
+			: has_adapters(false) {}
+
+		render_info(QStringList adapters, bool supported, emu_settings_type type, bool has_msaa)
+			: adapters(std::move(adapters))
+			, type(type)
+			, supported(supported)
+			, has_msaa(has_msaa) {}
+	};
+
+	bool supports_vulkan = false;
+	QStringList vulkan_adapters;
+	render_info Vulkan;
+	render_info OpenGL;
+	render_info NullRender;
+	std::vector<render_info*> renderers;
+
+	render_creator(QObject *parent);
+
+	void update_names(const QStringList& names);
+};

rpcs3/rpcs3qt/settings_dialog.cpp

@@ -18,6 +18,9 @@
 #include "ui_settings_dialog.h"
 #include "tooltips.h"
 #include "input_dialog.h"
+#include "emu_settings_type.h"
+#include "render_creator.h"
+#include "microphone_creator.h"
 
 #include "stdafx.h"
 #include "Emu/GameInfo.h"
@@ -172,37 +175,37 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Checkboxes
 
-	m_emu_settings->EnhanceCheckBox(ui->spuCache, emu_settings::SPUCache);
+	m_emu_settings->EnhanceCheckBox(ui->spuCache, emu_settings_type::SPUCache);
 	SubscribeTooltip(ui->spuCache, tooltips.settings.spu_cache);
 
-	m_emu_settings->EnhanceCheckBox(ui->enableScheduler, emu_settings::EnableThreadScheduler);
+	m_emu_settings->EnhanceCheckBox(ui->enableScheduler, emu_settings_type::EnableThreadScheduler);
 	SubscribeTooltip(ui->enableScheduler, tooltips.settings.enable_thread_scheduler);
 
-	m_emu_settings->EnhanceCheckBox(ui->lowerSPUThrPrio, emu_settings::LowerSPUThreadPrio);
+	m_emu_settings->EnhanceCheckBox(ui->lowerSPUThrPrio, emu_settings_type::LowerSPUThreadPrio);
 	SubscribeTooltip(ui->lowerSPUThrPrio, tooltips.settings.lower_spu_thread_priority);
 
-	m_emu_settings->EnhanceCheckBox(ui->spuLoopDetection, emu_settings::SPULoopDetection);
+	m_emu_settings->EnhanceCheckBox(ui->spuLoopDetection, emu_settings_type::SPULoopDetection);
 	SubscribeTooltip(ui->spuLoopDetection, tooltips.settings.spu_loop_detection);
 
-	m_emu_settings->EnhanceCheckBox(ui->accurateXFloat, emu_settings::AccurateXFloat);
+	m_emu_settings->EnhanceCheckBox(ui->accurateXFloat, emu_settings_type::AccurateXFloat);
 	SubscribeTooltip(ui->accurateXFloat, tooltips.settings.accurate_xfloat);
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->spuBlockSize, emu_settings::SPUBlockSize);
+	m_emu_settings->EnhanceComboBox(ui->spuBlockSize, emu_settings_type::SPUBlockSize);
 	SubscribeTooltip(ui->gb_spuBlockSize, tooltips.settings.spu_block_size);
 
-	m_emu_settings->EnhanceComboBox(ui->preferredSPUThreads, emu_settings::PreferredSPUThreads, true);
+	m_emu_settings->EnhanceComboBox(ui->preferredSPUThreads, emu_settings_type::PreferredSPUThreads, true);
 	SubscribeTooltip(ui->gb_spu_threads, tooltips.settings.preferred_spu_threads);
 	ui->preferredSPUThreads->setItemText(ui->preferredSPUThreads->findData("0"), tr("Auto", "Preferred SPU threads"));
 
 	if (utils::has_rtm())
 	{
-		m_emu_settings->EnhanceComboBox(ui->enableTSX, emu_settings::EnableTSX);
+		m_emu_settings->EnhanceComboBox(ui->enableTSX, emu_settings_type::EnableTSX);
 		SubscribeTooltip(ui->gb_tsx, tooltips.settings.enable_tsx);
 
 		static const QString tsx_forced = qstr(fmt::format("%s", tsx_usage::forced));
-		static const QString tsx_default = qstr(m_emu_settings->GetSettingDefault(emu_settings::EnableTSX));
+		static const QString tsx_default = qstr(m_emu_settings->GetSettingDefault(emu_settings_type::EnableTSX));
 
 		// connect the toogled signal so that the stateChanged signal in EnhanceCheckBox can be prevented
 		connect(ui->enableTSX, &QComboBox::currentTextChanged, [this](const QString& text)
@@ -241,7 +244,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	ppu_bg->addButton(ui->ppu_fast,    static_cast<int>(ppu_decoder_type::fast));
 	ppu_bg->addButton(ui->ppu_llvm,    static_cast<int>(ppu_decoder_type::llvm));
 
-	m_emu_settings->EnhanceRadioButton(ppu_bg, emu_settings::PPUDecoder);
+	m_emu_settings->EnhanceRadioButton(ppu_bg, emu_settings_type::PPUDecoder);
 
 	// SPU tool tips
 	SubscribeTooltip(ui->spu_precise, tooltips.settings.spu_precise);
@@ -255,7 +258,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	spu_bg->addButton(ui->spu_asmjit,  static_cast<int>(spu_decoder_type::asmjit));
 	spu_bg->addButton(ui->spu_llvm,    static_cast<int>(spu_decoder_type::llvm));
 
-	m_emu_settings->EnhanceRadioButton(spu_bg, emu_settings::SPUDecoder);
+	m_emu_settings->EnhanceRadioButton(spu_bg, emu_settings_type::SPUDecoder);
 
 	connect(ui->spu_llvm, &QAbstractButton::toggled, [this](bool checked)
 	{
@@ -281,14 +284,27 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	//   | |__| | |    | |__| |    | | (_| | |_) |
 	//    \_____|_|     \____/     |_|\__,_|_.__/
 
-	emu_settings::Render_Creator render_creator = m_emu_settings.get()->m_render_creator;
+	render_creator* r_creator = m_emu_settings->m_render_creator;
+
+	if (!r_creator)
+	{
+		cfg_log.error("settings_dialog::settings_dialog render_creator is null");
+		return;
+	}
+
+	r_creator->update_names(
+	{
+		m_emu_settings->GetLocalizedSetting("Vulkan", emu_settings_type::Renderer, static_cast<int>(video_renderer::vulkan)),
+		m_emu_settings->GetLocalizedSetting("OpenGl", emu_settings_type::Renderer, static_cast<int>(video_renderer::opengl)),
+		m_emu_settings->GetLocalizedSetting("Null", emu_settings_type::Renderer, static_cast<int>(video_renderer::null))
+	});
 
 	// Comboboxes
-	m_emu_settings->EnhanceComboBox(ui->renderBox, emu_settings::Renderer);
+	m_emu_settings->EnhanceComboBox(ui->renderBox, emu_settings_type::Renderer);
 	SubscribeTooltip(ui->gb_renderer, tooltips.settings.renderer);
 	SubscribeTooltip(ui->gb_graphicsAdapter, tooltips.settings.graphics_adapter);
 
-	m_emu_settings->EnhanceComboBox(ui->resBox, emu_settings::Resolution);
+	m_emu_settings->EnhanceComboBox(ui->resBox, emu_settings_type::Resolution);
 	SubscribeTooltip(ui->gb_default_resolution, tooltips.settings.resolution);
 	// remove unsupported resolutions from the dropdown
 	const int saved_index = ui->resBox->currentIndex();
@@ -339,16 +355,16 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		}
 	}
 
-	m_emu_settings->EnhanceComboBox(ui->aspectBox, emu_settings::AspectRatio);
+	m_emu_settings->EnhanceComboBox(ui->aspectBox, emu_settings_type::AspectRatio);
 	SubscribeTooltip(ui->gb_aspectRatio, tooltips.settings.aspect_ratio);
 
-	m_emu_settings->EnhanceComboBox(ui->frameLimitBox, emu_settings::FrameLimit);
+	m_emu_settings->EnhanceComboBox(ui->frameLimitBox, emu_settings_type::FrameLimit);
 	SubscribeTooltip(ui->gb_frameLimit, tooltips.settings.frame_limit);
 
-	m_emu_settings->EnhanceComboBox(ui->antiAliasing, emu_settings::MSAA);
+	m_emu_settings->EnhanceComboBox(ui->antiAliasing, emu_settings_type::MSAA);
 	SubscribeTooltip(ui->gb_antiAliasing, tooltips.settings.anti_aliasing);
 
-	m_emu_settings->EnhanceComboBox(ui->anisotropicFilterOverride, emu_settings::AnisotropicFilterOverride, true);
+	m_emu_settings->EnhanceComboBox(ui->anisotropicFilterOverride, emu_settings_type::AnisotropicFilterOverride, true);
 	SubscribeTooltip(ui->gb_anisotropicFilter, tooltips.settings.anisotropic_filter);
 	// only allow values 0,2,4,8,16
 	for (int i = ui->anisotropicFilterOverride->count() - 1; i >= 0; i--)
@@ -371,19 +387,19 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	}
 
 	// Checkboxes: main options
-	m_emu_settings->EnhanceCheckBox(ui->dumpColor, emu_settings::WriteColorBuffers);
+	m_emu_settings->EnhanceCheckBox(ui->dumpColor, emu_settings_type::WriteColorBuffers);
 	SubscribeTooltip(ui->dumpColor, tooltips.settings.dump_color);
 
-	m_emu_settings->EnhanceCheckBox(ui->vsync, emu_settings::VSync);
+	m_emu_settings->EnhanceCheckBox(ui->vsync, emu_settings_type::VSync);
 	SubscribeTooltip(ui->vsync, tooltips.settings.vsync);
 
-	m_emu_settings->EnhanceCheckBox(ui->stretchToDisplayArea, emu_settings::StretchToDisplayArea);
+	m_emu_settings->EnhanceCheckBox(ui->stretchToDisplayArea, emu_settings_type::StretchToDisplayArea);
 	SubscribeTooltip(ui->stretchToDisplayArea, tooltips.settings.stretch_to_display_area);
 
-	m_emu_settings->EnhanceCheckBox(ui->disableVertexCache, emu_settings::DisableVertexCache);
+	m_emu_settings->EnhanceCheckBox(ui->disableVertexCache, emu_settings_type::DisableVertexCache);
 	SubscribeTooltip(ui->disableVertexCache, tooltips.settings.disable_vertex_cache);
 
-	m_emu_settings->EnhanceCheckBox(ui->multithreadedRSX, emu_settings::MultithreadedRSX);
+	m_emu_settings->EnhanceCheckBox(ui->multithreadedRSX, emu_settings_type::MultithreadedRSX);
 	SubscribeTooltip(ui->multithreadedRSX, tooltips.settings.multithreaded_rsx);
 	connect(ui->multithreadedRSX, &QCheckBox::clicked, [this](bool checked)
 	{
@@ -391,10 +407,10 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 	ui->disableVertexCache->setEnabled(!ui->multithreadedRSX->isChecked());
 
-	m_emu_settings->EnhanceCheckBox(ui->disableAsyncShaders, emu_settings::DisableAsyncShaderCompiler);
+	m_emu_settings->EnhanceCheckBox(ui->disableAsyncShaders, emu_settings_type::DisableAsyncShaderCompiler);
 	SubscribeTooltip(ui->disableAsyncShaders, tooltips.settings.disable_async_shaders);
 
-	m_emu_settings->EnhanceCheckBox(ui->scrictModeRendering, emu_settings::StrictRenderingMode);
+	m_emu_settings->EnhanceCheckBox(ui->scrictModeRendering, emu_settings_type::StrictRenderingMode);
 	SubscribeTooltip(ui->scrictModeRendering, tooltips.settings.strict_rendering_mode);
 	connect(ui->scrictModeRendering, &QCheckBox::clicked, [this](bool checked)
 	{
@@ -409,11 +425,11 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		return QLabel(sizer).sizeHint().width();
 	};
 
-	m_emu_settings->EnhanceSlider(ui->resolutionScale, emu_settings::ResolutionScale);
+	m_emu_settings->EnhanceSlider(ui->resolutionScale, emu_settings_type::ResolutionScale);
 	SubscribeTooltip(ui->gb_resolutionScale, tooltips.settings.resolution_scale);
 	ui->gb_resolutionScale->setEnabled(!ui->scrictModeRendering->isChecked());
 	// rename label texts to fit current state of Resolution Scale
-	const int resolution_scale_def = stoi(m_emu_settings->GetSettingDefault(emu_settings::ResolutionScale));
+	const int resolution_scale_def = stoi(m_emu_settings->GetSettingDefault(emu_settings_type::ResolutionScale));
 	auto scaled_resolution = [resolution_scale_def](int percentage)
 	{
 		if (percentage == resolution_scale_def)
@@ -438,11 +454,11 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 	SnapSlider(ui->resolutionScale, 25);
 
-	m_emu_settings->EnhanceSlider(ui->minimumScalableDimension, emu_settings::MinimumScalableDimension);
+	m_emu_settings->EnhanceSlider(ui->minimumScalableDimension, emu_settings_type::MinimumScalableDimension);
 	SubscribeTooltip(ui->gb_minimumScalableDimension, tooltips.settings.minimum_scalable_dimension);
 	ui->gb_minimumScalableDimension->setEnabled(!ui->scrictModeRendering->isChecked());
 	// rename label texts to fit current state of Minimum Scalable Dimension
-	const int minimum_scalable_dimension_def = stoi(m_emu_settings->GetSettingDefault(emu_settings::MinimumScalableDimension));
+	const int minimum_scalable_dimension_def = stoi(m_emu_settings->GetSettingDefault(emu_settings_type::MinimumScalableDimension));
 	auto min_scalable_dimension = [minimum_scalable_dimension_def](int dim)
 	{
 		if (dim == minimum_scalable_dimension_def)
@@ -467,7 +483,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 
 	// Remove renderers from the renderer Combobox if not supported
-	for (const auto& renderer : render_creator.renderers)
+	for (const auto& renderer : r_creator->renderers)
 	{
 		if (renderer->supported)
 		{
@@ -497,10 +513,10 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 			return;
 		}
 
-		auto switchTo = [=, this](emu_settings::Render_Info renderer)
+		auto switchTo = [=, this](render_creator::render_info renderer)
 		{
 			// Reset other adapters to old config
-			for (const auto& render : render_creator.renderers)
+			for (const auto& render : r_creator->renderers)
 			{
 				if (renderer.name != render->name && render->has_adapters && render->supported)
 				{
@@ -511,7 +527,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 			// Enable/disable MSAA depending on renderer
 			ui->antiAliasing->setEnabled(renderer.has_msaa);
 			ui->antiAliasing->blockSignals(true);
-			ui->antiAliasing->setCurrentText(renderer.has_msaa ? qstr(m_emu_settings->GetSetting(emu_settings::MSAA)) : tr("Disabled", "MSAA"));
+			ui->antiAliasing->setCurrentText(renderer.has_msaa ? qstr(m_emu_settings->GetSetting(emu_settings_type::MSAA)) : tr("Disabled", "MSAA"));
 			ui->antiAliasing->blockSignals(false);
 
 			// Fill combobox with placeholder if no adapters needed
@@ -545,7 +561,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 			m_emu_settings->SetSetting(renderer.type, sstr(ui->graphicsAdapterBox->currentText()));
 		};
 
-		for (const auto& renderer : render_creator.renderers)
+		for (const auto& renderer : r_creator->renderers)
 		{
 			if (renderer->name == text)
 			{
@@ -569,7 +585,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 			m_old_renderer = new_renderer;
 			return;
 		}
-		for (const auto& render : render_creator.renderers)
+		for (const auto& render : r_creator->renderers)
 		{
 			if (render->name == new_renderer && render->has_adapters && render->adapters.contains(text))
 			{
@@ -589,7 +605,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	auto fix_gl_legacy = [=, this](const QString& text)
 	{
-		ui->glLegacyBuffers->setEnabled(text == render_creator.name_OpenGL);
+		ui->glLegacyBuffers->setEnabled(text == r_creator->OpenGL.name);
 	};
 
 	// Handle connects to disable specific checkboxes that depend on GUI state.
@@ -698,7 +714,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	auto change_microphone_device = [=, this](u32 next_index, QString text)
 	{
-		m_emu_settings->SetSetting(emu_settings::MicrophoneDevices, m_emu_settings->m_microphone_creator.set_device(next_index, text));
+		m_emu_settings->SetSetting(emu_settings_type::MicrophoneDevices, m_emu_settings->m_microphone_creator.set_device(next_index, text));
 		if (next_index < 4 && text == mic_none)
 			mics_combo[next_index]->setCurrentText(mic_none);
 		propagate_used_devices();
@@ -706,7 +722,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->audioOutBox, emu_settings::AudioRenderer);
+	m_emu_settings->EnhanceComboBox(ui->audioOutBox, emu_settings_type::AudioRenderer);
 #ifdef WIN32
 	SubscribeTooltip(ui->gb_audio_out, tooltips.settings.audio_out);
 #else
@@ -726,7 +742,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	m_emu_settings->m_microphone_creator.refresh_list();
 	propagate_used_devices(); // Fills comboboxes list
 
-	m_emu_settings->m_microphone_creator.parse_devices(m_emu_settings->GetSetting(emu_settings::MicrophoneDevices));
+	m_emu_settings->m_microphone_creator.parse_devices(m_emu_settings->GetSetting(emu_settings_type::MicrophoneDevices));
 
 	const auto mic_sel_list = m_emu_settings->m_microphone_creator.get_selection_list();
 
@@ -746,27 +762,27 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		}
 	}
 
-	m_emu_settings->EnhanceComboBox(ui->microphoneBox, emu_settings::MicrophoneType);
+	m_emu_settings->EnhanceComboBox(ui->microphoneBox, emu_settings_type::MicrophoneType);
 	SubscribeTooltip(ui->microphoneBox, tooltips.settings.microphone);
 	connect(ui->microphoneBox, &QComboBox::currentTextChanged, change_microphone_type);
 	propagate_used_devices(); // Enables/Disables comboboxes and checks values from config for sanity
 
 	// Checkboxes
 
-	m_emu_settings->EnhanceCheckBox(ui->audioDump, emu_settings::DumpToFile);
+	m_emu_settings->EnhanceCheckBox(ui->audioDump, emu_settings_type::DumpToFile);
 	SubscribeTooltip(ui->audioDump, tooltips.settings.audio_dump);
 
-	m_emu_settings->EnhanceCheckBox(ui->convert, emu_settings::ConvertTo16Bit);
+	m_emu_settings->EnhanceCheckBox(ui->convert, emu_settings_type::ConvertTo16Bit);
 	SubscribeTooltip(ui->convert, tooltips.settings.convert);
 
-	m_emu_settings->EnhanceCheckBox(ui->downmix, emu_settings::DownmixStereo);
+	m_emu_settings->EnhanceCheckBox(ui->downmix, emu_settings_type::DownmixStereo);
 	SubscribeTooltip(ui->downmix, tooltips.settings.downmix);
 
-	m_emu_settings->EnhanceCheckBox(ui->enableBuffering, emu_settings::EnableBuffering);
+	m_emu_settings->EnhanceCheckBox(ui->enableBuffering, emu_settings_type::EnableBuffering);
 	SubscribeTooltip(ui->enableBuffering, tooltips.settings.enable_buffering);
 	connect(ui->enableBuffering, &QCheckBox::clicked, enable_buffering_options);
 
-	m_emu_settings->EnhanceCheckBox(ui->enableTimeStretching, emu_settings::EnableTimeStretching);
+	m_emu_settings->EnhanceCheckBox(ui->enableTimeStretching, emu_settings_type::EnableTimeStretching);
 	SubscribeTooltip(ui->enableTimeStretching, tooltips.settings.enable_time_stretching);
 	connect(ui->enableTimeStretching, &QCheckBox::clicked, enable_time_stretching_options);
 
@@ -774,13 +790,13 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Sliders
 
-	EnhanceSlider(emu_settings::MasterVolume, ui->masterVolume, ui->masterVolumeLabel, tr("Master: %0 %", "Master volume"));
+	EnhanceSlider(emu_settings_type::MasterVolume, ui->masterVolume, ui->masterVolumeLabel, tr("Master: %0 %", "Master volume"));
 	SubscribeTooltip(ui->master_volume, tooltips.settings.master_volume);
 
-	EnhanceSlider(emu_settings::AudioBufferDuration, ui->audioBufferDuration, ui->audioBufferDurationLabel, tr("Audio Buffer Duration: %0 ms", "Audio buffer duration"));
+	EnhanceSlider(emu_settings_type::AudioBufferDuration, ui->audioBufferDuration, ui->audioBufferDurationLabel, tr("Audio Buffer Duration: %0 ms", "Audio buffer duration"));
 	SubscribeTooltip(ui->audio_buffer_duration, tooltips.settings.audio_buffer_duration);
 
-	EnhanceSlider(emu_settings::TimeStretchingThreshold, ui->timeStretchingThreshold, ui->timeStretchingThresholdLabel, tr("Time Stretching Threshold: %0 %", "Time stretching threshold"));
+	EnhanceSlider(emu_settings_type::TimeStretchingThreshold, ui->timeStretchingThreshold, ui->timeStretchingThresholdLabel, tr("Time Stretching Threshold: %0 %", "Time stretching threshold"));
 	SubscribeTooltip(ui->time_stretching_threshold, tooltips.settings.time_stretching_threshold);
 
 	//    _____       __   ____    _______    _
@@ -792,19 +808,19 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->keyboardHandlerBox, emu_settings::KeyboardHandler);
+	m_emu_settings->EnhanceComboBox(ui->keyboardHandlerBox, emu_settings_type::KeyboardHandler);
 	SubscribeTooltip(ui->gb_keyboard_handler, tooltips.settings.keyboard_handler);
 
-	m_emu_settings->EnhanceComboBox(ui->mouseHandlerBox, emu_settings::MouseHandler);
+	m_emu_settings->EnhanceComboBox(ui->mouseHandlerBox, emu_settings_type::MouseHandler);
 	SubscribeTooltip(ui->gb_mouse_handler, tooltips.settings.mouse_handler);
 
-	m_emu_settings->EnhanceComboBox(ui->cameraTypeBox, emu_settings::CameraType);
+	m_emu_settings->EnhanceComboBox(ui->cameraTypeBox, emu_settings_type::CameraType);
 	SubscribeTooltip(ui->gb_camera_type, tooltips.settings.camera_type);
 
-	m_emu_settings->EnhanceComboBox(ui->cameraBox, emu_settings::Camera);
+	m_emu_settings->EnhanceComboBox(ui->cameraBox, emu_settings_type::Camera);
 	SubscribeTooltip(ui->gb_camera_setting, tooltips.settings.camera);
 
-	m_emu_settings->EnhanceComboBox(ui->moveBox, emu_settings::Move);
+	m_emu_settings->EnhanceComboBox(ui->moveBox, emu_settings_type::Move);
 	SubscribeTooltip(ui->gb_move_handler, tooltips.settings.move);
 
 	//     _____           _                   _______    _
@@ -818,24 +834,24 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->sysLangBox, emu_settings::Language, false, false, 0, true);
+	m_emu_settings->EnhanceComboBox(ui->sysLangBox, emu_settings_type::Language, false, false, 0, true);
 	SubscribeTooltip(ui->gb_sysLang, tooltips.settings.system_language);
 
-	m_emu_settings->EnhanceComboBox(ui->keyboardType, emu_settings::KeyboardType, false, false, 0, true);
+	m_emu_settings->EnhanceComboBox(ui->keyboardType, emu_settings_type::KeyboardType, false, false, 0, true);
 	SubscribeTooltip(ui->gb_keyboardType, tooltips.settings.keyboard_type);
 
 	// Checkboxes
 
-	m_emu_settings->EnhanceCheckBox(ui->enableHostRoot, emu_settings::EnableHostRoot);
+	m_emu_settings->EnhanceCheckBox(ui->enableHostRoot, emu_settings_type::EnableHostRoot);
 	SubscribeTooltip(ui->enableHostRoot, tooltips.settings.enable_host_root);
 
-	m_emu_settings->EnhanceCheckBox(ui->enableCacheClearing, emu_settings::LimitCacheSize);
+	m_emu_settings->EnhanceCheckBox(ui->enableCacheClearing, emu_settings_type::LimitCacheSize);
 	SubscribeTooltip(ui->gb_DiskCacheClearing, tooltips.settings.limit_cache_size);
 	connect(ui->enableCacheClearing, &QCheckBox::stateChanged, ui->maximumCacheSize, &QSlider::setEnabled);
 
 	// Sliders
 
-	EnhanceSlider(emu_settings::MaximumCacheSize, ui->maximumCacheSize, ui->maximumCacheSizeLabel, tr("Maximum size: %0 MB", "Maximum cache size"));
+	EnhanceSlider(emu_settings_type::MaximumCacheSize, ui->maximumCacheSize, ui->maximumCacheSizeLabel, tr("Maximum size: %0 MB", "Maximum cache size"));
 	ui->maximumCacheSize->setEnabled(ui->enableCacheClearing->isChecked());
 
 	// Radio Buttons
@@ -845,7 +861,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	enter_button_assignment_bg->addButton(ui->enterButtonAssignCircle, 0);
 	enter_button_assignment_bg->addButton(ui->enterButtonAssignCross, 1);
 
-	m_emu_settings->EnhanceRadioButton(enter_button_assignment_bg, emu_settings::EnterButtonAssignment);
+	m_emu_settings->EnhanceRadioButton(enter_button_assignment_bg, emu_settings_type::EnterButtonAssignment);
 	SubscribeTooltip(ui->gb_enterButtonAssignment, tooltips.settings.enter_button_assignment);
 
 	//    _   _      _                      _      _______    _
@@ -857,18 +873,18 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Edits
 
-	m_emu_settings->EnhanceEdit(ui->edit_dns, emu_settings::DNSAddress);
+	m_emu_settings->EnhanceEdit(ui->edit_dns, emu_settings_type::DNSAddress);
 	SubscribeTooltip(ui->gb_edit_dns, tooltips.settings.dns);
 
-	m_emu_settings->EnhanceEdit(ui->edit_npid, emu_settings::PSNNPID);
+	m_emu_settings->EnhanceEdit(ui->edit_npid, emu_settings_type::PSNNPID);
 	SubscribeTooltip(ui->gb_edit_npid, tooltips.settings.psn_npid);
 
-	m_emu_settings->EnhanceEdit(ui->edit_swaps, emu_settings::IpSwapList);
+	m_emu_settings->EnhanceEdit(ui->edit_swaps, emu_settings_type::IpSwapList);
 	SubscribeTooltip(ui->gb_edit_swaps, tooltips.settings.dns_swap);
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->netStatusBox, emu_settings::InternetStatus);
+	m_emu_settings->EnhanceComboBox(ui->netStatusBox, emu_settings_type::InternetStatus);
 	SubscribeTooltip(ui->gb_netStatusBox, tooltips.settings.net_status);
 
 	connect(ui->netStatusBox, QOverload<int>::of(&QComboBox::currentIndexChanged), [this](int index)
@@ -899,7 +915,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		}
 	});
 
-	m_emu_settings->EnhanceComboBox(ui->psnStatusBox, emu_settings::PSNStatus);
+	m_emu_settings->EnhanceComboBox(ui->psnStatusBox, emu_settings_type::PSNStatus);
 	SubscribeTooltip(ui->gb_psnStatusBox, tooltips.settings.psn_status);
 
 	//                _                               _   _______    _
@@ -912,64 +928,64 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Checkboxes
 
-	m_emu_settings->EnhanceCheckBox(ui->debugConsoleMode, emu_settings::DebugConsoleMode);
+	m_emu_settings->EnhanceCheckBox(ui->debugConsoleMode, emu_settings_type::DebugConsoleMode);
 	SubscribeTooltip(ui->debugConsoleMode, tooltips.settings.debug_console_mode);
 
-	m_emu_settings->EnhanceCheckBox(ui->accuratePPUfma, emu_settings::AccuratePPUfma);
+	m_emu_settings->EnhanceCheckBox(ui->accuratePPUfma, emu_settings_type::AccuratePPUfma);
 	SubscribeTooltip(ui->accuratePPUfma, tooltips.settings.accurate_ppu_fma);
 
-	m_emu_settings->EnhanceCheckBox(ui->silenceAllLogs, emu_settings::SilenceAllLogs);
+	m_emu_settings->EnhanceCheckBox(ui->silenceAllLogs, emu_settings_type::SilenceAllLogs);
 	SubscribeTooltip(ui->silenceAllLogs, tooltips.settings.silence_all_logs);
 
-	m_emu_settings->EnhanceCheckBox(ui->readColor, emu_settings::ReadColorBuffers);
+	m_emu_settings->EnhanceCheckBox(ui->readColor, emu_settings_type::ReadColorBuffers);
 	SubscribeTooltip(ui->readColor, tooltips.settings.read_color);
 
-	m_emu_settings->EnhanceCheckBox(ui->readDepth, emu_settings::ReadDepthBuffer);
+	m_emu_settings->EnhanceCheckBox(ui->readDepth, emu_settings_type::ReadDepthBuffer);
 	SubscribeTooltip(ui->readDepth, tooltips.settings.read_depth);
 
-	m_emu_settings->EnhanceCheckBox(ui->dumpDepth, emu_settings::WriteDepthBuffer);
+	m_emu_settings->EnhanceCheckBox(ui->dumpDepth, emu_settings_type::WriteDepthBuffer);
 	SubscribeTooltip(ui->dumpDepth, tooltips.settings.dump_depth);
 
-	m_emu_settings->EnhanceCheckBox(ui->disableOnDiskShaderCache, emu_settings::DisableOnDiskShaderCache);
+	m_emu_settings->EnhanceCheckBox(ui->disableOnDiskShaderCache, emu_settings_type::DisableOnDiskShaderCache);
 	SubscribeTooltip(ui->disableOnDiskShaderCache, tooltips.settings.disable_on_disk_shader_cache);
 
-	m_emu_settings->EnhanceCheckBox(ui->relaxedZCULL, emu_settings::RelaxedZCULL);
+	m_emu_settings->EnhanceCheckBox(ui->relaxedZCULL, emu_settings_type::RelaxedZCULL);
 	SubscribeTooltip(ui->relaxedZCULL, tooltips.settings.relaxed_zcull);
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->maxSPURSThreads, emu_settings::MaxSPURSThreads, true);
+	m_emu_settings->EnhanceComboBox(ui->maxSPURSThreads, emu_settings_type::MaxSPURSThreads, true);
 	ui->maxSPURSThreads->setItemText(ui->maxSPURSThreads->findData("6"), tr("Unlimited (Default)", "Max SPURS threads"));
 	SubscribeTooltip(ui->gb_max_spurs_threads, tooltips.settings.max_spurs_threads);
 
-	m_emu_settings->EnhanceComboBox(ui->sleepTimersAccuracy, emu_settings::SleepTimersAccuracy);
+	m_emu_settings->EnhanceComboBox(ui->sleepTimersAccuracy, emu_settings_type::SleepTimersAccuracy);
 	SubscribeTooltip(ui->gb_sleep_timers_accuracy, tooltips.settings.sleep_timers_accuracy);
 
 	// Sliders
 
-	EnhanceSlider(emu_settings::DriverWakeUpDelay, ui->wakeupDelay, ui->wakeupText, tr(reinterpret_cast<const char*>(u8"%0 µs"), "Driver wake up delay"));
+	EnhanceSlider(emu_settings_type::DriverWakeUpDelay, ui->wakeupDelay, ui->wakeupText, tr(reinterpret_cast<const char*>(u8"%0 µs"), "Driver wake up delay"));
 	SnapSlider(ui->wakeupDelay, 200);
 	ui->wakeupDelay->setMaximum(7000); // Very large values must be entered with config.yml changes
 	ui->wakeupDelay->setPageStep(200);
-	const int wakeup_def = stoi(m_emu_settings->GetSettingDefault(emu_settings::DriverWakeUpDelay));
+	const int wakeup_def = stoi(m_emu_settings->GetSettingDefault(emu_settings_type::DriverWakeUpDelay));
 	connect(ui->wakeupReset, &QAbstractButton::clicked, [=, this]()
 	{
 		ui->wakeupDelay->setValue(wakeup_def);
 	});
 
-	EnhanceSlider(emu_settings::VBlankRate, ui->vblank, ui->vblankText, tr("%0 Hz", "VBlank rate"));
+	EnhanceSlider(emu_settings_type::VBlankRate, ui->vblank, ui->vblankText, tr("%0 Hz", "VBlank rate"));
 	SnapSlider(ui->vblank, 30);
 	ui->vblank->setPageStep(60);
-	const int vblank_def = stoi(m_emu_settings->GetSettingDefault(emu_settings::VBlankRate));
+	const int vblank_def = stoi(m_emu_settings->GetSettingDefault(emu_settings_type::VBlankRate));
 	connect(ui->vblankReset, &QAbstractButton::clicked, [=, this]()
 	{
 		ui->vblank->setValue(vblank_def);
 	});
 
-	EnhanceSlider(emu_settings::ClocksScale, ui->clockScale, ui->clockScaleText, tr("%0 %", "Clocks scale"));
+	EnhanceSlider(emu_settings_type::ClocksScale, ui->clockScale, ui->clockScaleText, tr("%0 %", "Clocks scale"));
 	SnapSlider(ui->clockScale, 10);
 	ui->clockScale->setPageStep(50);
-	const int clocks_scale_def = stoi(m_emu_settings->GetSettingDefault(emu_settings::ResolutionScale));
+	const int clocks_scale_def = stoi(m_emu_settings->GetSettingDefault(emu_settings_type::ResolutionScale));
 	connect(ui->clockScaleReset, &QAbstractButton::clicked, [=, this]()
 	{
 		ui->clockScale->setValue(clocks_scale_def);
@@ -1009,7 +1025,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	lib_mode_bg->addButton(ui->lib_lv2b, static_cast<int>(lib_loading_type::liblv2both));
 	lib_mode_bg->addButton(ui->lib_lv2l, static_cast<int>(lib_loading_type::liblv2list));
 
-	m_emu_settings->EnhanceRadioButton(lib_mode_bg, emu_settings::LibLoadOptions);
+	m_emu_settings->EnhanceRadioButton(lib_mode_bg, emu_settings_type::LibLoadOptions);
 
 	// Sort string vector alphabetically
 	static const auto sort_string_vector = [](std::vector<std::string>& vec)
@@ -1129,41 +1145,41 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Comboboxes
 
-	m_emu_settings->EnhanceComboBox(ui->maxLLVMThreads, emu_settings::MaxLLVMThreads, true, true, std::thread::hardware_concurrency());
+	m_emu_settings->EnhanceComboBox(ui->maxLLVMThreads, emu_settings_type::MaxLLVMThreads, true, true, std::thread::hardware_concurrency());
 	SubscribeTooltip(ui->gb_max_llvm, tooltips.settings.max_llvm_threads);
 	ui->maxLLVMThreads->setItemText(ui->maxLLVMThreads->findData("0"), tr("All (%1)", "Max LLVM threads").arg(std::thread::hardware_concurrency()));
 
-	m_emu_settings->EnhanceComboBox(ui->perfOverlayDetailLevel, emu_settings::PerfOverlayDetailLevel);
+	m_emu_settings->EnhanceComboBox(ui->perfOverlayDetailLevel, emu_settings_type::PerfOverlayDetailLevel);
 	SubscribeTooltip(ui->perf_overlay_detail_level, tooltips.settings.perf_overlay_detail_level);
 
-	m_emu_settings->EnhanceComboBox(ui->perfOverlayPosition, emu_settings::PerfOverlayPosition);
+	m_emu_settings->EnhanceComboBox(ui->perfOverlayPosition, emu_settings_type::PerfOverlayPosition);
 	SubscribeTooltip(ui->perf_overlay_position, tooltips.settings.perf_overlay_position);
 
 	// Checkboxes
 
-	m_emu_settings->EnhanceCheckBox(ui->exitOnStop, emu_settings::ExitRPCS3OnFinish);
+	m_emu_settings->EnhanceCheckBox(ui->exitOnStop, emu_settings_type::ExitRPCS3OnFinish);
 	SubscribeTooltip(ui->exitOnStop, tooltips.settings.exit_on_stop);
 
-	m_emu_settings->EnhanceCheckBox(ui->alwaysStart, emu_settings::StartOnBoot);
+	m_emu_settings->EnhanceCheckBox(ui->alwaysStart, emu_settings_type::StartOnBoot);
 	SubscribeTooltip(ui->alwaysStart, tooltips.settings.start_on_boot);
 
-	m_emu_settings->EnhanceCheckBox(ui->startGameFullscreen, emu_settings::StartGameFullscreen);
+	m_emu_settings->EnhanceCheckBox(ui->startGameFullscreen, emu_settings_type::StartGameFullscreen);
 	SubscribeTooltip(ui->startGameFullscreen, tooltips.settings.start_game_fullscreen);
 
-	m_emu_settings->EnhanceCheckBox(ui->preventDisplaySleep, emu_settings::PreventDisplaySleep);
+	m_emu_settings->EnhanceCheckBox(ui->preventDisplaySleep, emu_settings_type::PreventDisplaySleep);
 	SubscribeTooltip(ui->preventDisplaySleep, tooltips.settings.prevent_display_sleep);
 	ui->preventDisplaySleep->setEnabled(display_sleep_control_supported());
 
-	m_emu_settings->EnhanceCheckBox(ui->showTrophyPopups, emu_settings::ShowTrophyPopups);
+	m_emu_settings->EnhanceCheckBox(ui->showTrophyPopups, emu_settings_type::ShowTrophyPopups);
 	SubscribeTooltip(ui->showTrophyPopups, tooltips.settings.show_trophy_popups);
 
-	m_emu_settings->EnhanceCheckBox(ui->useNativeInterface, emu_settings::UseNativeInterface);
+	m_emu_settings->EnhanceCheckBox(ui->useNativeInterface, emu_settings_type::UseNativeInterface);
 	SubscribeTooltip(ui->useNativeInterface, tooltips.settings.use_native_interface);
 
-	m_emu_settings->EnhanceCheckBox(ui->showShaderCompilationHint, emu_settings::ShowShaderCompilationHint);
+	m_emu_settings->EnhanceCheckBox(ui->showShaderCompilationHint, emu_settings_type::ShowShaderCompilationHint);
 	SubscribeTooltip(ui->showShaderCompilationHint, tooltips.settings.show_shader_compilation_hint);
 
-	m_emu_settings->EnhanceCheckBox(ui->perfOverlayCenterX, emu_settings::PerfOverlayCenterX);
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayCenterX, emu_settings_type::PerfOverlayCenterX);
 	SubscribeTooltip(ui->perfOverlayCenterX, tooltips.settings.perf_overlay_center_x);
 	connect(ui->perfOverlayCenterX, &QCheckBox::clicked, [this](bool checked)
 	{
@@ -1171,7 +1187,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 	ui->perfOverlayMarginX->setEnabled(!ui->perfOverlayCenterX->isChecked());
 
-	m_emu_settings->EnhanceCheckBox(ui->perfOverlayCenterY, emu_settings::PerfOverlayCenterY);
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayCenterY, emu_settings_type::PerfOverlayCenterY);
 	SubscribeTooltip(ui->perfOverlayCenterY, tooltips.settings.perf_overlay_center_y);
 	connect(ui->perfOverlayCenterY, &QCheckBox::clicked, [this](bool checked)
 	{
@@ -1179,13 +1195,13 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 	ui->perfOverlayMarginY->setEnabled(!ui->perfOverlayCenterY->isChecked());
 
-	m_emu_settings->EnhanceCheckBox(ui->perfOverlayFramerateGraphEnabled, emu_settings::PerfOverlayFramerateGraphEnabled);
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayFramerateGraphEnabled, emu_settings_type::PerfOverlayFramerateGraphEnabled);
 	SubscribeTooltip(ui->perfOverlayFramerateGraphEnabled, tooltips.settings.perf_overlay_framerate_graph_enabled);
 
-	m_emu_settings->EnhanceCheckBox(ui->perfOverlayFrametimeGraphEnabled, emu_settings::PerfOverlayFrametimeGraphEnabled);
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayFrametimeGraphEnabled, emu_settings_type::PerfOverlayFrametimeGraphEnabled);
 	SubscribeTooltip(ui->perfOverlayFrametimeGraphEnabled, tooltips.settings.perf_overlay_frametime_graph_enabled);
 
-	m_emu_settings->EnhanceCheckBox(ui->perfOverlayEnabled, emu_settings::PerfOverlayEnabled);
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayEnabled, emu_settings_type::PerfOverlayEnabled);
 	SubscribeTooltip(ui->perfOverlayEnabled, tooltips.settings.perf_overlay_enabled);
 	auto enable_perf_overlay_options = [this](bool enabled)
 	{
@@ -1211,7 +1227,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	enable_perf_overlay_options(ui->perfOverlayEnabled->isChecked());
 	connect(ui->perfOverlayEnabled, &QCheckBox::clicked, enable_perf_overlay_options);
 
-	m_emu_settings->EnhanceCheckBox(ui->shaderLoadBgEnabled, emu_settings::ShaderLoadBgEnabled);
+	m_emu_settings->EnhanceCheckBox(ui->shaderLoadBgEnabled, emu_settings_type::ShaderLoadBgEnabled);
 	SubscribeTooltip(ui->shaderLoadBgEnabled, tooltips.settings.shader_load_bg_enabled);
 	auto enable_shader_loader_options = [this](bool enabled)
 	{
@@ -1225,27 +1241,27 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// Sliders
 
-	EnhanceSlider(emu_settings::PerfOverlayUpdateInterval, ui->perfOverlayUpdateInterval, ui->label_update_interval, tr("Update Interval: %0 ms", "Performance overlay update interval"));
+	EnhanceSlider(emu_settings_type::PerfOverlayUpdateInterval, ui->perfOverlayUpdateInterval, ui->label_update_interval, tr("Update Interval: %0 ms", "Performance overlay update interval"));
 	SubscribeTooltip(ui->perf_overlay_update_interval, tooltips.settings.perf_overlay_update_interval);
 
-	EnhanceSlider(emu_settings::PerfOverlayFontSize, ui->perfOverlayFontSize, ui->label_font_size, tr("Font Size: %0 px", "Performance overlay font size"));
+	EnhanceSlider(emu_settings_type::PerfOverlayFontSize, ui->perfOverlayFontSize, ui->label_font_size, tr("Font Size: %0 px", "Performance overlay font size"));
 	SubscribeTooltip(ui->perf_overlay_font_size, tooltips.settings.perf_overlay_font_size);
 
-	EnhanceSlider(emu_settings::PerfOverlayOpacity, ui->perfOverlayOpacity, ui->label_opacity, tr("Opacity: %0 %", "Performance overlay opacity"));
+	EnhanceSlider(emu_settings_type::PerfOverlayOpacity, ui->perfOverlayOpacity, ui->label_opacity, tr("Opacity: %0 %", "Performance overlay opacity"));
 	SubscribeTooltip(ui->perf_overlay_opacity, tooltips.settings.perf_overlay_opacity);
 
-	EnhanceSlider(emu_settings::ShaderLoadBgDarkening, ui->shaderLoadBgDarkening, ui->label_shaderLoadBgDarkening, tr("Background darkening: %0 %", "Shader load background darkening"));
+	EnhanceSlider(emu_settings_type::ShaderLoadBgDarkening, ui->shaderLoadBgDarkening, ui->label_shaderLoadBgDarkening, tr("Background darkening: %0 %", "Shader load background darkening"));
 	SubscribeTooltip(ui->shaderLoadBgDarkening, tooltips.settings.shader_load_bg_darkening);
 
-	EnhanceSlider(emu_settings::ShaderLoadBgBlur, ui->shaderLoadBgBlur, ui->label_shaderLoadBgBlur, tr("Background blur: %0 %", "Shader load background blur"));
+	EnhanceSlider(emu_settings_type::ShaderLoadBgBlur, ui->shaderLoadBgBlur, ui->label_shaderLoadBgBlur, tr("Background blur: %0 %", "Shader load background blur"));
 	SubscribeTooltip(ui->shaderLoadBgBlur, tooltips.settings.shader_load_bg_blur);
 
 	// SpinBoxes
 
-	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginX, emu_settings::PerfOverlayMarginX, "", tr("px", "Performance overlay margin x"));
+	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginX, emu_settings_type::PerfOverlayMarginX, "", tr("px", "Performance overlay margin x"));
 	SubscribeTooltip(ui->perfOverlayMarginX, tooltips.settings.perf_overlay_margin_x);
 
-	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginY, emu_settings::PerfOverlayMarginY, "", tr("px", "Performance overlay margin y"));
+	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginY, emu_settings_type::PerfOverlayMarginY, "", tr("px", "Performance overlay margin y"));
 	SubscribeTooltip(ui->perfOverlayMarginY, tooltips.settings.perf_overlay_margin_y);
 
 	// Global settings (gui_settings)
@@ -1301,8 +1317,8 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	{
 		rpcs3::title_format_data title_data;
 		title_data.format = sstr(format);
-		title_data.renderer = m_emu_settings->GetSetting(emu_settings::Renderer);
-		title_data.vulkan_adapter = m_emu_settings->GetSetting(emu_settings::VulkanAdapter);
+		title_data.renderer = m_emu_settings->GetSetting(emu_settings_type::Renderer);
+		title_data.vulkan_adapter = m_emu_settings->GetSetting(emu_settings_type::VulkanAdapter);
 		title_data.fps = 60.;
 
 		if (game)
@@ -1368,7 +1384,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 			return tr("Glossary:\n\n%0\nPreview:\n\n%1\n", "Game window title").arg(glossary).arg(game_window_title);
 		};
 
-		const std::string game_title_format = m_emu_settings->GetSetting(emu_settings::WindowTitleFormat);
+		const std::string game_title_format = m_emu_settings->GetSetting(emu_settings_type::WindowTitleFormat);
 
 		QString edited_format = qstr(game_title_format);
 
@@ -1383,20 +1399,20 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 		if (dlg.exec() == QDialog::Accepted)
 		{
-			m_emu_settings->SetSetting(emu_settings::WindowTitleFormat, sstr(edited_format));
-			set_game_window_title(m_emu_settings->GetSetting(emu_settings::WindowTitleFormat));
+			m_emu_settings->SetSetting(emu_settings_type::WindowTitleFormat, sstr(edited_format));
+			set_game_window_title(m_emu_settings->GetSetting(emu_settings_type::WindowTitleFormat));
 		}
 	});
 
 	connect(ui->reset_button_game_window_title_format, &QAbstractButton::clicked, [=, this]()
 	{
-		const std::string default_game_title_format = m_emu_settings->GetSettingDefault(emu_settings::WindowTitleFormat);
-		m_emu_settings->SetSetting(emu_settings::WindowTitleFormat, default_game_title_format);
+		const std::string default_game_title_format = m_emu_settings->GetSettingDefault(emu_settings_type::WindowTitleFormat);
+		m_emu_settings->SetSetting(emu_settings_type::WindowTitleFormat, default_game_title_format);
 		set_game_window_title(default_game_title_format);
 	});
 
 	// Load and apply the configured game window title format
-	set_game_window_title(m_emu_settings->GetSetting(emu_settings::WindowTitleFormat));
+	set_game_window_title(m_emu_settings->GetSetting(emu_settings_type::WindowTitleFormat));
 
 	SubscribeTooltip(ui->gb_game_window_title, tooltips.settings.game_window_title_format);
 
@@ -1644,59 +1660,59 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	//                            |___/
 
 	// Checkboxes: gpu debug options
-	m_emu_settings->EnhanceCheckBox(ui->glLegacyBuffers, emu_settings::LegacyBuffers);
+	m_emu_settings->EnhanceCheckBox(ui->glLegacyBuffers, emu_settings_type::LegacyBuffers);
 	SubscribeTooltip(ui->glLegacyBuffers, tooltips.settings.gl_legacy_buffers);
 
-	m_emu_settings->EnhanceCheckBox(ui->forceHighpZ, emu_settings::ForceHighpZ);
+	m_emu_settings->EnhanceCheckBox(ui->forceHighpZ, emu_settings_type::ForceHighpZ);
 	SubscribeTooltip(ui->forceHighpZ, tooltips.settings.force_high_pz);
 
-	m_emu_settings->EnhanceCheckBox(ui->debugOutput, emu_settings::DebugOutput);
+	m_emu_settings->EnhanceCheckBox(ui->debugOutput, emu_settings_type::DebugOutput);
 	SubscribeTooltip(ui->debugOutput, tooltips.settings.debug_output);
 
-	m_emu_settings->EnhanceCheckBox(ui->debugOverlay, emu_settings::DebugOverlay);
+	m_emu_settings->EnhanceCheckBox(ui->debugOverlay, emu_settings_type::DebugOverlay);
 	SubscribeTooltip(ui->debugOverlay, tooltips.settings.debug_overlay);
 
-	m_emu_settings->EnhanceCheckBox(ui->logProg, emu_settings::LogShaderPrograms);
+	m_emu_settings->EnhanceCheckBox(ui->logProg, emu_settings_type::LogShaderPrograms);
 	SubscribeTooltip(ui->logProg, tooltips.settings.log_shader_programs);
 
-	m_emu_settings->EnhanceCheckBox(ui->disableHwOcclusionQueries, emu_settings::DisableOcclusionQueries);
+	m_emu_settings->EnhanceCheckBox(ui->disableHwOcclusionQueries, emu_settings_type::DisableOcclusionQueries);
 	SubscribeTooltip(ui->disableHwOcclusionQueries, tooltips.settings.disable_occlusion_queries);
 
-	m_emu_settings->EnhanceCheckBox(ui->forceCpuBlitEmulation, emu_settings::ForceCPUBlitEmulation);
+	m_emu_settings->EnhanceCheckBox(ui->forceCpuBlitEmulation, emu_settings_type::ForceCPUBlitEmulation);
 	SubscribeTooltip(ui->forceCpuBlitEmulation, tooltips.settings.force_cpu_blit_emulation);
 
-	m_emu_settings->EnhanceCheckBox(ui->disableVulkanMemAllocator, emu_settings::DisableVulkanMemAllocator);
+	m_emu_settings->EnhanceCheckBox(ui->disableVulkanMemAllocator, emu_settings_type::DisableVulkanMemAllocator);
 	SubscribeTooltip(ui->disableVulkanMemAllocator, tooltips.settings.disable_vulkan_mem_allocator);
 
-	m_emu_settings->EnhanceCheckBox(ui->disableFIFOReordering, emu_settings::DisableFIFOReordering);
+	m_emu_settings->EnhanceCheckBox(ui->disableFIFOReordering, emu_settings_type::DisableFIFOReordering);
 	SubscribeTooltip(ui->disableFIFOReordering, tooltips.settings.disable_fifo_reordering);
 
-	m_emu_settings->EnhanceCheckBox(ui->strictTextureFlushing, emu_settings::StrictTextureFlushing);
+	m_emu_settings->EnhanceCheckBox(ui->strictTextureFlushing, emu_settings_type::StrictTextureFlushing);
 	SubscribeTooltip(ui->strictTextureFlushing, tooltips.settings.strict_texture_flushing);
 
-	m_emu_settings->EnhanceCheckBox(ui->gpuTextureScaling, emu_settings::GPUTextureScaling);
+	m_emu_settings->EnhanceCheckBox(ui->gpuTextureScaling, emu_settings_type::GPUTextureScaling);
 	SubscribeTooltip(ui->gpuTextureScaling, tooltips.settings.gpu_texture_scaling);
 
 	// Checkboxes: core debug options
-	m_emu_settings->EnhanceCheckBox(ui->ppuDebug, emu_settings::PPUDebug);
+	m_emu_settings->EnhanceCheckBox(ui->ppuDebug, emu_settings_type::PPUDebug);
 	SubscribeTooltip(ui->ppuDebug, tooltips.settings.ppu_debug);
 
-	m_emu_settings->EnhanceCheckBox(ui->spuDebug, emu_settings::SPUDebug);
+	m_emu_settings->EnhanceCheckBox(ui->spuDebug, emu_settings_type::SPUDebug);
 	SubscribeTooltip(ui->spuDebug, tooltips.settings.spu_debug);
 
-	m_emu_settings->EnhanceCheckBox(ui->setDAZandFTZ, emu_settings::SetDAZandFTZ);
+	m_emu_settings->EnhanceCheckBox(ui->setDAZandFTZ, emu_settings_type::SetDAZandFTZ);
 	SubscribeTooltip(ui->setDAZandFTZ, tooltips.settings.set_daz_and_ftz);
 
-	m_emu_settings->EnhanceCheckBox(ui->accurateGETLLAR, emu_settings::AccurateGETLLAR);
+	m_emu_settings->EnhanceCheckBox(ui->accurateGETLLAR, emu_settings_type::AccurateGETLLAR);
 	SubscribeTooltip(ui->accurateGETLLAR, tooltips.settings.accurate_getllar);
 
-	m_emu_settings->EnhanceCheckBox(ui->accuratePUTLLUC, emu_settings::AccuratePUTLLUC);
+	m_emu_settings->EnhanceCheckBox(ui->accuratePUTLLUC, emu_settings_type::AccuratePUTLLUC);
 	SubscribeTooltip(ui->accuratePUTLLUC, tooltips.settings.accurate_putlluc);
 
-	m_emu_settings->EnhanceCheckBox(ui->accurateRSXAccess, emu_settings::AccurateRSXAccess);
+	m_emu_settings->EnhanceCheckBox(ui->accurateRSXAccess, emu_settings_type::AccurateRSXAccess);
 	SubscribeTooltip(ui->accurateRSXAccess, tooltips.settings.accurate_rsx_access);
 
-	m_emu_settings->EnhanceCheckBox(ui->hookStFunc, emu_settings::HookStaticFuncs);
+	m_emu_settings->EnhanceCheckBox(ui->hookStFunc, emu_settings_type::HookStaticFuncs);
 	SubscribeTooltip(ui->hookStFunc, tooltips.settings.hook_static_functions);
 
 	// Layout fix for High Dpi
@@ -1708,7 +1724,7 @@ settings_dialog::~settings_dialog()
 	delete ui;
 }
 
-void settings_dialog::EnhanceSlider(emu_settings::SettingsType settings_type, QSlider* slider, QLabel* label, const QString& label_text)
+void settings_dialog::EnhanceSlider(emu_settings_type settings_type, QSlider* slider, QLabel* label, const QString& label_text)
 {
 	m_emu_settings->EnhanceSlider(slider, settings_type);
 

rpcs3/rpcs3qt/settings_dialog.h

@@ -35,7 +35,7 @@ private Q_SLOTS:
 	void OnApplyConfig();
 	void OnApplyStylesheet();
 private:
-	void EnhanceSlider(emu_settings::SettingsType settings_type, QSlider* slider, QLabel* label, const QString& label_text);
+	void EnhanceSlider(emu_settings_type settings_type, QSlider* slider, QLabel* label, const QString& label_text);
 
 	// Snapping of sliders when moved with mouse
 	void SnapSlider(QSlider* slider, int interval);

rpcs3/rpcs3qt/vfs_dialog.cpp

@@ -1,6 +1,7 @@
 #include "vfs_dialog.h"
 #include "vfs_dialog_tab.h"
 #include "gui_settings.h"
+#include "emu_settings_type.h"
 
 #include <QTabWidget>
 #include <QDialogButtonBox>
@@ -22,19 +23,19 @@ vfs_dialog::vfs_dialog(std::shared_ptr<gui_settings> guiSettings, std::shared_pt
 	m_emu_settings->LoadSettings();
 
 	// Create tabs
-	vfs_dialog_tab* emulator_tab = new vfs_dialog_tab({ "$(EmulatorDir)", emu_settings::emulatorLocation, gui::fs_emulator_dir_list, &g_cfg.vfs.emulator_dir },
+	vfs_dialog_tab* emulator_tab = new vfs_dialog_tab({ "$(EmulatorDir)", emu_settings_type::emulatorLocation, gui::fs_emulator_dir_list, &g_cfg.vfs.emulator_dir },
 		m_gui_settings, m_emu_settings, this);
 
-	vfs_dialog_tab* dev_hdd0_tab = new vfs_dialog_tab({ "dev_hdd0", emu_settings::dev_hdd0Location, gui::fs_dev_hdd0_list, &g_cfg.vfs.dev_hdd0 },
+	vfs_dialog_tab* dev_hdd0_tab = new vfs_dialog_tab({ "dev_hdd0", emu_settings_type::dev_hdd0Location, gui::fs_dev_hdd0_list, &g_cfg.vfs.dev_hdd0 },
 		m_gui_settings, m_emu_settings, this);
 
-	vfs_dialog_tab* dev_hdd1_tab = new vfs_dialog_tab({ "dev_hdd1", emu_settings::dev_hdd1Location, gui::fs_dev_hdd1_list, &g_cfg.vfs.dev_hdd1 },
+	vfs_dialog_tab* dev_hdd1_tab = new vfs_dialog_tab({ "dev_hdd1", emu_settings_type::dev_hdd1Location, gui::fs_dev_hdd1_list, &g_cfg.vfs.dev_hdd1 },
 		m_gui_settings, m_emu_settings, this);
 
-	vfs_dialog_tab* dev_flash_tab = new vfs_dialog_tab({ "dev_flash", emu_settings::dev_flashLocation, gui::fs_dev_flash_list, &g_cfg.vfs.dev_flash },
+	vfs_dialog_tab* dev_flash_tab = new vfs_dialog_tab({ "dev_flash", emu_settings_type::dev_flashLocation, gui::fs_dev_flash_list, &g_cfg.vfs.dev_flash },
 		m_gui_settings, m_emu_settings, this);
 
-	vfs_dialog_tab* dev_usb000_tab = new vfs_dialog_tab({ "dev_usb000", emu_settings::dev_usb000Location, gui::fs_dev_usb000_list, &g_cfg.vfs.dev_usb000 },
+	vfs_dialog_tab* dev_usb000_tab = new vfs_dialog_tab({ "dev_usb000", emu_settings_type::dev_usb000Location, gui::fs_dev_usb000_list, &g_cfg.vfs.dev_usb000 },
 		m_gui_settings, m_emu_settings, this);
 
 	tabs->addTab(emulator_tab, "$(EmulatorDir)");

rpcs3/rpcs3qt/vfs_dialog_tab.h

@@ -5,6 +5,7 @@
 
 #include "gui_settings.h"
 #include "emu_settings.h"
+#include "emu_settings_type.h"
 
 #include <QListWidget>
 #include <QLabel>
@@ -12,7 +13,7 @@
 struct vfs_settings_info
 {
 	QString name; // name of tab
-	emu_settings::SettingsType settingLoc; // Where the setting is saved in emu_settings
+	emu_settings_type settingLoc; // Where the setting is saved in emu_settings
 	gui_save listLocation; // Where the list of dir options are saved
 	cfg::string* cfg_node; // Needed since emu_settings overrides settings file and doesn't touch g_cfg currently.
 };