diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index a642b96dc8..68847c3ddd 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -523,6 +523,11 @@ true true + + true + true + true + true true @@ -798,6 +803,11 @@ true true + + true + true + true + true true @@ -1093,6 +1103,11 @@ true true + + true + true + true + true true @@ -1368,6 +1383,11 @@ true true + + true + true + true + true true @@ -1475,6 +1495,7 @@ + @@ -2223,6 +2244,25 @@ .\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp "$(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" + + + Moc%27ing %(Identity)... + .\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp + "$(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" + Moc%27ing %(Identity)... + .\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp + "$(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" + Moc%27ing %(Identity)... + .\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp + "$(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" + Moc%27ing %(Identity)... + .\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp + "$(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" + $(QTDIR)\bin\moc.exe;%(FullPath) + $(QTDIR)\bin\moc.exe;%(FullPath) + $(QTDIR)\bin\moc.exe;%(FullPath) + $(QTDIR)\bin\moc.exe;%(FullPath) + $(QTDIR)\bin\moc.exe;%(FullPath) diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters index ea40bbaad4..002272307a 100644 --- a/rpcs3/rpcs3.vcxproj.filters +++ b/rpcs3/rpcs3.vcxproj.filters @@ -1024,6 +1024,21 @@ Generated Files\Debug - LLVM + + Gui\settings + + + Generated Files\Release - LLVM + + + Generated Files\Debug + + + Generated Files\Release + + + Generated Files\Debug - LLVM + @@ -1113,6 +1128,9 @@ rpcs3 + + Gui\settings + @@ -1322,6 +1340,9 @@ Gui\settings + + Gui\settings + diff --git a/rpcs3/rpcs3qt/CMakeLists.txt b/rpcs3/rpcs3qt/CMakeLists.txt index 43d32b28b0..02bfbeac0f 100644 --- a/rpcs3/rpcs3qt/CMakeLists.txt +++ b/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 diff --git a/rpcs3/rpcs3qt/emu_settings.cpp b/rpcs3/rpcs3qt/emu_settings.cpp index 0933672799..a727d98224 100644 --- a/rpcs3/rpcs3qt/emu_settings.cpp +++ b/rpcs3/rpcs3qt/emu_settings.cpp @@ -1,21 +1,12 @@ #include "emu_settings.h" -#include -#include -#include -#include - #include "Utilities/Config.h" -#include "Utilities/Thread.h" #include #include #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 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 &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(video_renderer::null)), - GetLocalizedSetting("Vulkan", emu_settings::Renderer, static_cast(video_renderer::vulkan)), - GetLocalizedSetting("OpenGl", emu_settings::Renderer, static_cast(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& 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(index)) { case enter_button_assign::circle: return tr("Enter with circle", "Enter button assignment"); diff --git a/rpcs3/rpcs3qt/emu_settings.h b/rpcs3/rpcs3qt/emu_settings.h index b25e8eb6c7..c008648fb0 100644 --- a/rpcs3/rpcs3qt/emu_settings.h +++ b/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 #include @@ -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 renderers; - - Render_Creator(const QString& name_null, const QString& name_vulkan, const QString& name_openGL); - }; - - std::set m_broken_types; // list of broken settings + std::set 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 GetLoadedLibraries(); void SaveSelectedLibraries(const std::vector& 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 m_settings_location = + const QMap 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. diff --git a/rpcs3/rpcs3qt/emu_settings_type.h b/rpcs3/rpcs3qt/emu_settings_type.h new file mode 100644 index 0000000000..a5accfdfeb --- /dev/null +++ b/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, +}; diff --git a/rpcs3/rpcs3qt/render_creator.cpp b/rpcs3/rpcs3qt/render_creator.cpp new file mode 100644 index 0000000000..9566b45280 --- /dev/null +++ b/rpcs3/rpcs3qt/render_creator.cpp @@ -0,0 +1,112 @@ +#include "render_creator.h" + +#include + +#include "Utilities/Config.h" +#include "Utilities/Thread.h" + +#if defined(_WIN32) || defined(HAVE_VULKAN) +#include "Emu/RSX/VK/VKHelpers.h" +#endif + +#include +#include +#include +#include + +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 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& 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(i) >= renderers.size() || !renderers[i]) + { + cfg_log.error("render_creator::update_names could not update renderer %d", i); + return; + } + + renderers[i]->name = names[i]; + } +} diff --git a/rpcs3/rpcs3qt/render_creator.h b/rpcs3/rpcs3qt/render_creator.h new file mode 100644 index 0000000000..0f5d5e06af --- /dev/null +++ b/rpcs3/rpcs3qt/render_creator.h @@ -0,0 +1,44 @@ +#pragma once + +#include "emu_settings_type.h" + +#include +#include +#include + +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 renderers; + + render_creator(QObject *parent); + + void update_names(const QStringList& names); +}; diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp index ab5ae77a5a..005284efbe 100644 --- a/rpcs3/rpcs3qt/settings_dialog.cpp +++ b/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, 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, std ppu_bg->addButton(ui->ppu_fast, static_cast(ppu_decoder_type::fast)); ppu_bg->addButton(ui->ppu_llvm, static_cast(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, std spu_bg->addButton(ui->spu_asmjit, static_cast(spu_decoder_type::asmjit)); spu_bg->addButton(ui->spu_llvm, static_cast(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, 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(video_renderer::vulkan)), + m_emu_settings->GetLocalizedSetting("OpenGl", emu_settings_type::Renderer, static_cast(video_renderer::opengl)), + m_emu_settings->GetLocalizedSetting("Null", emu_settings_type::Renderer, static_cast(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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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::of(&QComboBox::currentIndexChanged), [this](int index) @@ -899,7 +915,7 @@ settings_dialog::settings_dialog(std::shared_ptr 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, 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(u8"%0 µs"), "Driver wake up delay")); + EnhanceSlider(emu_settings_type::DriverWakeUpDelay, ui->wakeupDelay, ui->wakeupText, tr(reinterpret_cast(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, std lib_mode_bg->addButton(ui->lib_lv2b, static_cast(lib_loading_type::liblv2both)); lib_mode_bg->addButton(ui->lib_lv2l, static_cast(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& vec) @@ -1129,41 +1145,41 @@ settings_dialog::settings_dialog(std::shared_ptr 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, 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, 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, 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, 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, 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, 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, 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, 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); diff --git a/rpcs3/rpcs3qt/settings_dialog.h b/rpcs3/rpcs3qt/settings_dialog.h index 564540e90c..5e9be518f8 100644 --- a/rpcs3/rpcs3qt/settings_dialog.h +++ b/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); diff --git a/rpcs3/rpcs3qt/vfs_dialog.cpp b/rpcs3/rpcs3qt/vfs_dialog.cpp index 19bfec779d..6f4430f65c 100644 --- a/rpcs3/rpcs3qt/vfs_dialog.cpp +++ b/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 #include @@ -22,19 +23,19 @@ vfs_dialog::vfs_dialog(std::shared_ptr 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)"); diff --git a/rpcs3/rpcs3qt/vfs_dialog_tab.h b/rpcs3/rpcs3qt/vfs_dialog_tab.h index 183e001a52..be5be38b84 100644 --- a/rpcs3/rpcs3qt/vfs_dialog_tab.h +++ b/rpcs3/rpcs3qt/vfs_dialog_tab.h @@ -5,6 +5,7 @@ #include "gui_settings.h" #include "emu_settings.h" +#include "emu_settings_type.h" #include #include @@ -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. };