yuzu-emu
/
yuzu-mainline
Archived
1
0
Fork 0
Code

configuration: Defer to common/settings for per-game settings defaults 

Avoids double-setting defaults, and avoids potential accidents when
inconsistently setting the default on new settings.
This commit is contained in:
lat9nq 2021-06-26 02:45:14 -04:00
parent 20e51402b0
commit 35b17fa5e0
2 changed files with 101 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
src/yuzu/configuration/config.cpp
View File

@ -491,8 +491,8 @@ void Config::ReadAudioValues() {
.toStdString(); .toStdString();
} }
ReadSettingGlobal(Settings::values.enable_audio_stretching, ReadSettingGlobal(Settings::values.enable_audio_stretching,
QStringLiteral("enable_audio_stretching"), true); QStringLiteral("enable_audio_stretching"));
ReadSettingGlobal(Settings::values.volume, QStringLiteral("volume"), 1); ReadSettingGlobal(Settings::values.volume, QStringLiteral("volume"));
qt_config->endGroup(); qt_config->endGroup();
} }
@ -515,7 +515,7 @@ void Config::ReadControlValues() {
Settings::values.mouse_panning_sensitivity = Settings::values.mouse_panning_sensitivity =
ReadSetting(QStringLiteral("mouse_panning_sensitivity"), 1).toFloat(); ReadSetting(QStringLiteral("mouse_panning_sensitivity"), 1).toFloat();
ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"), true); ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"));
// Disable docked mode if handheld is selected // Disable docked mode if handheld is selected
const auto controller_type = Settings::values.players.GetValue()[0].controller_type; const auto controller_type = Settings::values.players.GetValue()[0].controller_type;
@ -523,11 +523,10 @@ void Config::ReadControlValues() {
Settings::values.use_docked_mode.SetValue(false); Settings::values.use_docked_mode.SetValue(false);
} }
ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"), ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"));
true);
ReadSettingGlobal(Settings::values.enable_accurate_vibrations, ReadSettingGlobal(Settings::values.enable_accurate_vibrations,
QStringLiteral("enable_accurate_vibrations"), false); QStringLiteral("enable_accurate_vibrations"));
ReadSettingGlobal(Settings::values.motion_enabled, QStringLiteral("motion_enabled"), true); ReadSettingGlobal(Settings::values.motion_enabled, QStringLiteral("motion_enabled"));
qt_config->endGroup(); qt_config->endGroup();
} }
@ -591,7 +590,7 @@ void Config::ReadMotionTouchValues() {
void Config::ReadCoreValues() { void Config::ReadCoreValues() {
qt_config->beginGroup(QStringLiteral("Core")); qt_config->beginGroup(QStringLiteral("Core"));
ReadSettingGlobal(Settings::values.use_multi_core, QStringLiteral("use_multi_core"), true); ReadSettingGlobal(Settings::values.use_multi_core, QStringLiteral("use_multi_core"));
qt_config->endGroup(); qt_config->endGroup();
} }
@ -751,18 +750,18 @@ void Config::ReadPathValues() {
void Config::ReadCpuValues() { void Config::ReadCpuValues() {
qt_config->beginGroup(QStringLiteral("Cpu")); qt_config->beginGroup(QStringLiteral("Cpu"));
ReadSettingGlobal(Settings::values.cpu_accuracy, QStringLiteral("cpu_accuracy"), 0); ReadSettingGlobal(Settings::values.cpu_accuracy, QStringLiteral("cpu_accuracy"));
ReadSettingGlobal(Settings::values.cpuopt_unsafe_unfuse_fma, ReadSettingGlobal(Settings::values.cpuopt_unsafe_unfuse_fma,
QStringLiteral("cpuopt_unsafe_unfuse_fma"), true); QStringLiteral("cpuopt_unsafe_unfuse_fma"));
ReadSettingGlobal(Settings::values.cpuopt_unsafe_reduce_fp_error, ReadSettingGlobal(Settings::values.cpuopt_unsafe_reduce_fp_error,
QStringLiteral("cpuopt_unsafe_reduce_fp_error"), true); QStringLiteral("cpuopt_unsafe_reduce_fp_error"));
ReadSettingGlobal(Settings::values.cpuopt_unsafe_ignore_standard_fpcr, ReadSettingGlobal(Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"), true); QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"));
ReadSettingGlobal(Settings::values.cpuopt_unsafe_inaccurate_nan, ReadSettingGlobal(Settings::values.cpuopt_unsafe_inaccurate_nan,
QStringLiteral("cpuopt_unsafe_inaccurate_nan"), true); QStringLiteral("cpuopt_unsafe_inaccurate_nan"));
ReadSettingGlobal(Settings::values.cpuopt_unsafe_fastmem_check, ReadSettingGlobal(Settings::values.cpuopt_unsafe_fastmem_check,
QStringLiteral("cpuopt_unsafe_fastmem_check"), true); QStringLiteral("cpuopt_unsafe_fastmem_check"));
if (global) { if (global) {
Settings::values.cpuopt_page_tables = Settings::values.cpuopt_page_tables =
@ -791,41 +790,32 @@ void Config::ReadCpuValues() {
void Config::ReadRendererValues() { void Config::ReadRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer")); qt_config->beginGroup(QStringLiteral("Renderer"));
ReadSettingGlobal(Settings::values.renderer_backend, QStringLiteral("backend"), 0); ReadSettingGlobal(Settings::values.renderer_backend, QStringLiteral("backend"));
ReadSettingGlobal(Settings::values.renderer_debug, QStringLiteral("debug"), false); ReadSettingGlobal(Settings::values.renderer_debug, QStringLiteral("debug"), false);
ReadSettingGlobal(Settings::values.vulkan_device, QStringLiteral("vulkan_device"), 0); ReadSettingGlobal(Settings::values.vulkan_device, QStringLiteral("vulkan_device"));
#ifdef _WIN32 ReadSettingGlobal(Settings::values.fullscreen_mode, QStringLiteral("fullscreen_mode"));
ReadSettingGlobal(Settings::values.fullscreen_mode, QStringLiteral("fullscreen_mode"), 0); ReadSettingGlobal(Settings::values.aspect_ratio, QStringLiteral("aspect_ratio"));
#else ReadSettingGlobal(Settings::values.max_anisotropy, QStringLiteral("max_anisotropy"));
// *nix platforms may have issues with the borderless windowed fullscreen mode. ReadSettingGlobal(Settings::values.use_frame_limit, QStringLiteral("use_frame_limit"));
// Default to exclusive fullscreen on these platforms for now. ReadSettingGlobal(Settings::values.frame_limit, QStringLiteral("frame_limit"));
ReadSettingGlobal(Settings::values.fullscreen_mode, QStringLiteral("fullscreen_mode"), 1);
#endif
ReadSettingGlobal(Settings::values.aspect_ratio, QStringLiteral("aspect_ratio"), 0);
ReadSettingGlobal(Settings::values.max_anisotropy, QStringLiteral("max_anisotropy"), 0);
ReadSettingGlobal(Settings::values.use_frame_limit, QStringLiteral("use_frame_limit"), true);
ReadSettingGlobal(Settings::values.frame_limit, QStringLiteral("frame_limit"), 100);
ReadSettingGlobal(Settings::values.use_disk_shader_cache, ReadSettingGlobal(Settings::values.use_disk_shader_cache,
QStringLiteral("use_disk_shader_cache"), true); QStringLiteral("use_disk_shader_cache"));
ReadSettingGlobal(Settings::values.gpu_accuracy, QStringLiteral("gpu_accuracy"), 1); ReadSettingGlobal(Settings::values.gpu_accuracy, QStringLiteral("gpu_accuracy"));
ReadSettingGlobal(Settings::values.use_asynchronous_gpu_emulation, ReadSettingGlobal(Settings::values.use_asynchronous_gpu_emulation,
QStringLiteral("use_asynchronous_gpu_emulation"), true); QStringLiteral("use_asynchronous_gpu_emulation"));
ReadSettingGlobal(Settings::values.use_nvdec_emulation, QStringLiteral("use_nvdec_emulation"), ReadSettingGlobal(Settings::values.use_nvdec_emulation, QStringLiteral("use_nvdec_emulation"));
true); ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"));
ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"), true); ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"));
ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"), true); ReadSettingGlobal(Settings::values.disable_fps_limit, QStringLiteral("disable_fps_limit"));
ReadSettingGlobal(Settings::values.disable_fps_limit, QStringLiteral("disable_fps_limit"), ReadSettingGlobal(Settings::values.use_assembly_shaders,
false); QStringLiteral("use_assembly_shaders"));
ReadSettingGlobal(Settings::values.use_assembly_shaders, QStringLiteral("use_assembly_shaders"),
false);
ReadSettingGlobal(Settings::values.use_asynchronous_shaders, ReadSettingGlobal(Settings::values.use_asynchronous_shaders,
QStringLiteral("use_asynchronous_shaders"), false); QStringLiteral("use_asynchronous_shaders"));
ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"), ReadSettingGlobal(Settings::values.use_fast_gpu_time, QStringLiteral("use_fast_gpu_time"));
true); ReadSettingGlobal(Settings::values.use_caches_gc, QStringLiteral("use_caches_gc"));
ReadSettingGlobal(Settings::values.use_caches_gc, QStringLiteral("use_caches_gc"), false); ReadSettingGlobal(Settings::values.bg_red, QStringLiteral("bg_red"));
ReadSettingGlobal(Settings::values.bg_red, QStringLiteral("bg_red"), 0.0); ReadSettingGlobal(Settings::values.bg_green, QStringLiteral("bg_green"));
ReadSettingGlobal(Settings::values.bg_green, QStringLiteral("bg_green"), 0.0); ReadSettingGlobal(Settings::values.bg_blue, QStringLiteral("bg_blue"));
ReadSettingGlobal(Settings::values.bg_blue, QStringLiteral("bg_blue"), 0.0);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -874,11 +864,11 @@ void Config::ReadSystemValues() {
Settings::values.current_user = Settings::values.current_user =
std::clamp<int>(Settings::values.current_user, 0, Service::Account::MAX_USERS - 1); std::clamp<int>(Settings::values.current_user, 0, Service::Account::MAX_USERS - 1);
ReadSettingGlobal(Settings::values.language_index, QStringLiteral("language_index"), 1); ReadSettingGlobal(Settings::values.language_index, QStringLiteral("language_index"));
ReadSettingGlobal(Settings::values.region_index, QStringLiteral("region_index"), 1); ReadSettingGlobal(Settings::values.region_index, QStringLiteral("region_index"));
ReadSettingGlobal(Settings::values.time_zone_index, QStringLiteral("time_zone_index"), 0); ReadSettingGlobal(Settings::values.time_zone_index, QStringLiteral("time_zone_index"));
bool rng_seed_enabled; bool rng_seed_enabled;
ReadSettingGlobal(rng_seed_enabled, QStringLiteral("rng_seed_enabled"), false); ReadSettingGlobal(rng_seed_enabled, QStringLiteral("rng_seed_enabled"), false);
@ -904,7 +894,7 @@ void Config::ReadSystemValues() {
} }
} }
ReadSettingGlobal(Settings::values.sound_index, QStringLiteral("sound_index"), 1); ReadSettingGlobal(Settings::values.sound_index, QStringLiteral("sound_index"));
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1188,8 +1178,8 @@ void Config::SaveAudioValues() {
QStringLiteral("auto")); QStringLiteral("auto"));
} }
WriteSettingGlobal(QStringLiteral("enable_audio_stretching"), WriteSettingGlobal(QStringLiteral("enable_audio_stretching"),
Settings::values.enable_audio_stretching, true); Settings::values.enable_audio_stretching);
WriteSettingGlobal(QStringLiteral("volume"), Settings::values.volume, 1.0f); WriteSettingGlobal(QStringLiteral("volume"), Settings::values.volume);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1205,12 +1195,11 @@ void Config::SaveControlValues() {
SaveTouchscreenValues(); SaveTouchscreenValues();
SaveMotionTouchValues(); SaveMotionTouchValues();
WriteSettingGlobal(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, true); WriteSettingGlobal(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode);
WriteSettingGlobal(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled, WriteSettingGlobal(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled);
true);
WriteSettingGlobal(QStringLiteral("enable_accurate_vibrations"), WriteSettingGlobal(QStringLiteral("enable_accurate_vibrations"),
Settings::values.enable_accurate_vibrations, false); Settings::values.enable_accurate_vibrations);
WriteSettingGlobal(QStringLiteral("motion_enabled"), Settings::values.motion_enabled, true); WriteSettingGlobal(QStringLiteral("motion_enabled"), Settings::values.motion_enabled);
WriteSetting(QStringLiteral("motion_device"), WriteSetting(QStringLiteral("motion_device"),
QString::fromStdString(Settings::values.motion_device), QString::fromStdString(Settings::values.motion_device),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01")); QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
@ -1228,7 +1217,7 @@ void Config::SaveControlValues() {
void Config::SaveCoreValues() { void Config::SaveCoreValues() {
qt_config->beginGroup(QStringLiteral("Core")); qt_config->beginGroup(QStringLiteral("Core"));
WriteSettingGlobal(QStringLiteral("use_multi_core"), Settings::values.use_multi_core, true); WriteSettingGlobal(QStringLiteral("use_multi_core"), Settings::values.use_multi_core);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1339,18 +1328,18 @@ void Config::SaveCpuValues() {
WriteSettingGlobal(QStringLiteral("cpu_accuracy"), WriteSettingGlobal(QStringLiteral("cpu_accuracy"),
static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)), static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)),
Settings::values.cpu_accuracy.UsingGlobal(), Settings::values.cpu_accuracy.UsingGlobal(),
static_cast<u32>(Settings::CPUAccuracy::Accurate)); static_cast<u32>(Settings::values.cpu_accuracy.GetDefault()));
WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_unfuse_fma"), WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_unfuse_fma"),
Settings::values.cpuopt_unsafe_unfuse_fma, true); Settings::values.cpuopt_unsafe_unfuse_fma);
WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_reduce_fp_error"), WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_reduce_fp_error"),
Settings::values.cpuopt_unsafe_reduce_fp_error, true); Settings::values.cpuopt_unsafe_reduce_fp_error);
WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"), WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"),
Settings::values.cpuopt_unsafe_ignore_standard_fpcr, true); Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_inaccurate_nan"), WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_inaccurate_nan"),
Settings::values.cpuopt_unsafe_inaccurate_nan, true); Settings::values.cpuopt_unsafe_inaccurate_nan);
WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_fastmem_check"), WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_fastmem_check"),
Settings::values.cpuopt_unsafe_fastmem_check, true); Settings::values.cpuopt_unsafe_fastmem_check);
if (global) { if (global) {
WriteSetting(QStringLiteral("cpuopt_page_tables"), Settings::values.cpuopt_page_tables, WriteSetting(QStringLiteral("cpuopt_page_tables"), Settings::values.cpuopt_page_tables,
@ -1377,45 +1366,37 @@ void Config::SaveRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer")); qt_config->beginGroup(QStringLiteral("Renderer"));
WriteSettingGlobal(QStringLiteral("backend"), WriteSettingGlobal(QStringLiteral("backend"),
static_cast<int>(Settings::values.renderer_backend.GetValue(global)), static_cast<u32>(Settings::values.renderer_backend.GetValue(global)),
Settings::values.renderer_backend.UsingGlobal(), 0); Settings::values.renderer_backend.UsingGlobal(),
WriteSetting(QStringLiteral("debug"), Settings::values.renderer_debug, false); static_cast<u32>(Settings::values.renderer_backend.GetDefault()));
WriteSettingGlobal(QStringLiteral("vulkan_device"), Settings::values.vulkan_device, 0); WriteSetting(QStringLiteral("debug"), Settings::values.renderer_debug);
#ifdef _WIN32 WriteSettingGlobal(QStringLiteral("vulkan_device"), Settings::values.vulkan_device);
WriteSettingGlobal(QStringLiteral("fullscreen_mode"), Settings::values.fullscreen_mode, 0); WriteSettingGlobal(QStringLiteral("fullscreen_mode"), Settings::values.fullscreen_mode);
#else WriteSettingGlobal(QStringLiteral("aspect_ratio"), Settings::values.aspect_ratio);
// *nix platforms may have issues with the borderless windowed fullscreen mode. WriteSettingGlobal(QStringLiteral("max_anisotropy"), Settings::values.max_anisotropy);
// Default to exclusive fullscreen on these platforms for now. WriteSettingGlobal(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit);
WriteSettingGlobal(QStringLiteral("fullscreen_mode"), Settings::values.fullscreen_mode, 1); WriteSettingGlobal(QStringLiteral("frame_limit"), Settings::values.frame_limit);
#endif
WriteSettingGlobal(QStringLiteral("aspect_ratio"), Settings::values.aspect_ratio, 0);
WriteSettingGlobal(QStringLiteral("max_anisotropy"), Settings::values.max_anisotropy, 0);
WriteSettingGlobal(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit, true);
WriteSettingGlobal(QStringLiteral("frame_limit"), Settings::values.frame_limit, 100);
WriteSettingGlobal(QStringLiteral("use_disk_shader_cache"), WriteSettingGlobal(QStringLiteral("use_disk_shader_cache"),
Settings::values.use_disk_shader_cache, true); Settings::values.use_disk_shader_cache);
WriteSettingGlobal(QStringLiteral("gpu_accuracy"), WriteSettingGlobal(QStringLiteral("gpu_accuracy"),
static_cast<int>(Settings::values.gpu_accuracy.GetValue(global)), static_cast<u32>(Settings::values.gpu_accuracy.GetValue(global)),
Settings::values.gpu_accuracy.UsingGlobal(), 1); Settings::values.gpu_accuracy.UsingGlobal(),
static_cast<u32>(Settings::values.gpu_accuracy.GetDefault()));
WriteSettingGlobal(QStringLiteral("use_asynchronous_gpu_emulation"), WriteSettingGlobal(QStringLiteral("use_asynchronous_gpu_emulation"),
Settings::values.use_asynchronous_gpu_emulation, true); Settings::values.use_asynchronous_gpu_emulation);
WriteSettingGlobal(QStringLiteral("use_nvdec_emulation"), Settings::values.use_nvdec_emulation, WriteSettingGlobal(QStringLiteral("use_nvdec_emulation"), Settings::values.use_nvdec_emulation);
true); WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc);
WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc, true); WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync);
WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync, true); WriteSettingGlobal(QStringLiteral("disable_fps_limit"), Settings::values.disable_fps_limit);
WriteSettingGlobal(QStringLiteral("disable_fps_limit"), Settings::values.disable_fps_limit,
false);
WriteSettingGlobal(QStringLiteral("use_assembly_shaders"), WriteSettingGlobal(QStringLiteral("use_assembly_shaders"),
Settings::values.use_assembly_shaders, false); Settings::values.use_assembly_shaders);
WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"), WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"),
Settings::values.use_asynchronous_shaders, false); Settings::values.use_asynchronous_shaders);
WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time, WriteSettingGlobal(QStringLiteral("use_fast_gpu_time"), Settings::values.use_fast_gpu_time);
true); WriteSettingGlobal(QStringLiteral("use_caches_gc"), Settings::values.use_caches_gc);
WriteSettingGlobal(QStringLiteral("use_caches_gc"), Settings::values.use_caches_gc, false); WriteSettingGlobal(QStringLiteral("bg_red"), Settings::values.bg_red);
// Cast to double because Qt's written float values are not human-readable WriteSettingGlobal(QStringLiteral("bg_green"), Settings::values.bg_green);
WriteSettingGlobal(QStringLiteral("bg_red"), Settings::values.bg_red, 0.0); WriteSettingGlobal(QStringLiteral("bg_blue"), Settings::values.bg_blue);
WriteSettingGlobal(QStringLiteral("bg_green"), Settings::values.bg_green, 0.0);
WriteSettingGlobal(QStringLiteral("bg_blue"), Settings::values.bg_blue, 0.0);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1454,10 +1435,10 @@ void Config::SaveShortcutValues() {
void Config::SaveSystemValues() { void Config::SaveSystemValues() {
qt_config->beginGroup(QStringLiteral("System")); qt_config->beginGroup(QStringLiteral("System"));
WriteSetting(QStringLiteral("current_user"), Settings::values.current_user, 0); WriteSetting(QStringLiteral("current_user"), Settings::values.current_user);
WriteSettingGlobal(QStringLiteral("language_index"), Settings::values.language_index, 1); WriteSettingGlobal(QStringLiteral("language_index"), Settings::values.language_index);
WriteSettingGlobal(QStringLiteral("region_index"), Settings::values.region_index, 1); WriteSettingGlobal(QStringLiteral("region_index"), Settings::values.region_index);
WriteSettingGlobal(QStringLiteral("time_zone_index"), Settings::values.time_zone_index, 0); WriteSettingGlobal(QStringLiteral("time_zone_index"), Settings::values.time_zone_index);
WriteSettingGlobal(QStringLiteral("rng_seed_enabled"), WriteSettingGlobal(QStringLiteral("rng_seed_enabled"),
Settings::values.rng_seed.GetValue(global).has_value(), Settings::values.rng_seed.GetValue(global).has_value(),
@ -1475,7 +1456,7 @@ void Config::SaveSystemValues() {
0); 0);
} }
WriteSettingGlobal(QStringLiteral("sound_index"), Settings::values.sound_index, 1); WriteSettingGlobal(QStringLiteral("sound_index"), Settings::values.sound_index);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1574,22 +1555,25 @@ QVariant Config::ReadSetting(const QString& name, const QVariant& default_value)
return result; return result;
} }
QVariant Config::ReadSetting(const QString& name, Settings::CPUAccuracy default_value) const {
return ReadSetting(name, static_cast<u32>(default_value));
}
QVariant Config::ReadSetting(const QString& name, Settings::GPUAccuracy default_value) const {
return ReadSetting(name, static_cast<u32>(default_value));
}
QVariant Config::ReadSetting(const QString& name, Settings::RendererBackend default_value) const {
return ReadSetting(name, static_cast<u32>(default_value));
}
template <typename Type> template <typename Type>
void Config::ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name) { void Config::ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name) {
const bool use_global = qt_config->value(name + QStringLiteral("/use_global"), true).toBool(); const bool use_global = qt_config->value(name + QStringLiteral("/use_global"), true).toBool();
setting.SetGlobal(use_global); setting.SetGlobal(use_global);
const Type& default_value = setting.GetDefault();
if (global || !use_global) { if (global || !use_global) {
setting.SetValue(ReadSetting(name).value<Type>()); setting.SetValue(static_cast<QVariant>(ReadSetting(name, default_value)).value<Type>());
}
}
template <typename Type>
void Config::ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name,
const QVariant& default_value) {
const bool use_global = qt_config->value(name + QStringLiteral("/use_global"), true).toBool();
setting.SetGlobal(use_global);
if (global || !use_global) {
setting.SetValue(ReadSetting(name, default_value).value<Type>());
} }
} }
@ -1617,20 +1601,9 @@ void Config::WriteSettingGlobal(const QString& name, const Settings::Setting<Typ
if (!global) { if (!global) {
qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal()); qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal());
} }
if (global || !setting.UsingGlobal()) {
qt_config->setValue(name, setting.GetValue(global));
}
}
template <typename Type>
void Config::WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting,
const QVariant& default_value) {
if (!global) {
qt_config->setValue(name + QStringLiteral("/use_global"), setting.UsingGlobal());
}
if (global || !setting.UsingGlobal()) { if (global || !setting.UsingGlobal()) {
qt_config->setValue(name + QStringLiteral("/default"), qt_config->setValue(name + QStringLiteral("/default"),
setting.GetValue(global) == default_value.value<Type>()); setting.GetValue(global) == setting.GetDefault());
qt_config->setValue(name, setting.GetValue(global)); qt_config->setValue(name, setting.GetValue(global));
} }
} }

6
src/yuzu/configuration/config.h
View File

@ -104,14 +104,14 @@ private:
QVariant ReadSetting(const QString& name) const; QVariant ReadSetting(const QString& name) const;
QVariant ReadSetting(const QString& name, const QVariant& default_value) const; QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
QVariant ReadSetting(const QString& name, Settings::CPUAccuracy default_value) const;
QVariant ReadSetting(const QString& name, Settings::GPUAccuracy default_value) const;
QVariant ReadSetting(const QString& name, Settings::RendererBackend default_value) const;
// Templated ReadSettingGlobal functions will also look for the use_global setting and set // Templated ReadSettingGlobal functions will also look for the use_global setting and set
// both the value and the global state properly // both the value and the global state properly
template <typename Type> template <typename Type>
void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name); void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name);
template <typename Type> template <typename Type>
void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name,
const QVariant& default_value);
template <typename Type>
void ReadSettingGlobal(Type& setting, const QString& name, const QVariant& default_value) const; void ReadSettingGlobal(Type& setting, const QString& name, const QVariant& default_value) const;
// Templated WriteSettingGlobal functions will also write the global state if needed and will // Templated WriteSettingGlobal functions will also write the global state if needed and will
// skip writing the actual setting if it defers to the global value // skip writing the actual setting if it defers to the global value