Mirrors/yuzu-fork
1
0
Fork 0
mirror of https://github.com/yuzu-mirror/yuzu.git synced 2024-11-20 07:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #8522 from lat9nq/consolidate-settings

Browse source 
settings: Consolidate RangedSetting's with regular ones
This commit is contained in:
Morph 2022-07-07 01:22:01 -04:00 committed by GitHub
commit ec4cba9de8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 230 additions and 318 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

444
src/common/settings.h
View file

@ -101,15 +101,15 @@ struct ResolutionScalingInfo {
} }
}; };
/** The BasicSetting class is a simple resource manager. It defines a label and default value /** The Setting class is a simple resource manager. It defines a label and default value alongside
* alongside the actual value of the setting for simpler and less-error prone use with frontend * the actual value of the setting for simpler and less-error prone use with frontend
* configurations. Setting a default value and label is required, though subclasses may deviate from * configurations. Specifying a default value and label is required. A minimum and maximum range can
* this requirement. * be specified for sanitization.
*/ */
template <typename Type> template <typename Type>
class BasicSetting { class Setting {
protected: protected:
BasicSetting() = default; Setting() = default;
/** /**
* Only sets the setting to the given initializer, leaving the other members to their default * Only sets the setting to the given initializer, leaving the other members to their default
@ -117,7 +117,7 @@ protected:
* *
* @param global_val Initial value of the setting * @param global_val Initial value of the setting
*/ */
explicit BasicSetting(const Type& global_val) : global{global_val} {} explicit Setting(const Type& val) : value{val} {}
public: public:
/** /**
@ -126,9 +126,22 @@ public:
* @param default_val Intial value of the setting, and default value of the setting * @param default_val Intial value of the setting, and default value of the setting
* @param name Label for the setting * @param name Label for the setting
*/ */
explicit BasicSetting(const Type& default_val, const std::string& name) explicit Setting(const Type& default_val, const std::string& name)
: default_value{default_val}, global{default_val}, label{name} {} : value{default_val}, default_value{default_val}, ranged{false}, label{name} {}
virtual ~BasicSetting() = default; virtual ~Setting() = default;
/**
* Sets a default value, minimum value, maximum value, and label.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param min_val Sets the minimum allowed value of the setting
* @param max_val Sets the maximum allowed value of the setting
* @param name Label for the setting
*/
explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val,
const std::string& name)
: value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},
ranged{true}, label{name} {}
/** /**
* Returns a reference to the setting's value. * Returns a reference to the setting's value.
@ -136,17 +149,17 @@ public:
* @returns A reference to the setting * @returns A reference to the setting
*/ */
[[nodiscard]] virtual const Type& GetValue() const { [[nodiscard]] virtual const Type& GetValue() const {
return global; return value;
} }
/** /**
* Sets the setting to the given value. * Sets the setting to the given value.
* *
* @param value The desired value * @param val The desired value
*/ */
virtual void SetValue(const Type& value) { virtual void SetValue(const Type& val) {
Type temp{value}; Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
std::swap(global, temp); std::swap(value, temp);
} }
/** /**
@ -170,14 +183,14 @@ public:
/** /**
* Assigns a value to the setting. * Assigns a value to the setting.
* *
* @param value The desired setting value * @param val The desired setting value
* *
* @returns A reference to the setting * @returns A reference to the setting
*/ */
virtual const Type& operator=(const Type& value) { virtual const Type& operator=(const Type& val) {
Type temp{value}; Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
std::swap(global, temp); std::swap(value, temp);
return global; return value;
} }
/** /**
@ -186,23 +199,39 @@ public:
* @returns A reference to the setting * @returns A reference to the setting
*/ */
explicit virtual operator const Type&() const { explicit virtual operator const Type&() const {
return global; return value;
} }
protected: protected:
Type value{}; ///< The setting
const Type default_value{}; ///< The default value const Type default_value{}; ///< The default value
Type global{}; ///< The setting const Type maximum{}; ///< Maximum allowed value of the setting
const Type minimum{}; ///< Minimum allowed value of the setting
const bool ranged; ///< The setting has sanitization ranges
const std::string label{}; ///< The setting's label const std::string label{}; ///< The setting's label
}; };
/** /**
* BasicRangedSetting class is intended for use with quantifiable settings that need a more * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
* restrictive range than implicitly defined by its type. Implements a minimum and maximum that is * custom setting to switch to when a guest application specifically requires it. The effect is that
* simply used to sanitize SetValue and the assignment overload. * other components of the emulator can access the setting's intended value without any need for the
* component to ask whether the custom or global setting is needed at the moment.
*
* By default, the global setting is used.
*/ */
template <typename Type> template <typename Type>
class BasicRangedSetting : virtual public BasicSetting<Type> { class SwitchableSetting : virtual public Setting<Type> {
public: public:
/**
* Sets a default value, label, and setting value.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param name Label for the setting
*/
explicit SwitchableSetting(const Type& default_val, const std::string& name)
: Setting<Type>{default_val, name} {}
virtual ~SwitchableSetting() = default;
/** /**
* Sets a default value, minimum value, maximum value, and label. * Sets a default value, minimum value, maximum value, and label.
* *
@ -211,57 +240,9 @@ public:
* @param max_val Sets the maximum allowed value of the setting * @param max_val Sets the maximum allowed value of the setting
* @param name Label for the setting * @param name Label for the setting
*/ */
explicit BasicRangedSetting(const Type& default_val, const Type& min_val, const Type& max_val, explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
const std::string& name) const std::string& name)
: BasicSetting<Type>{default_val, name}, minimum{min_val}, maximum{max_val} {} : Setting<Type>{default_val, min_val, max_val, name} {}
virtual ~BasicRangedSetting() = default;
/**
* Like BasicSetting's SetValue, except value is clamped to the range of the setting.
*
* @param value The desired value
*/
void SetValue(const Type& value) override {
this->global = std::clamp(value, minimum, maximum);
}
/**
* Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
*
* @param value The desired value
* @returns A reference to the setting's value
*/
const Type& operator=(const Type& value) override {
this->global = std::clamp(value, minimum, maximum);
return this->global;
}
const Type minimum; ///< Minimum allowed value of the setting
const Type maximum; ///< Maximum allowed value of the setting
};
/**
* The Setting class is a slightly more complex version of the BasicSetting class. This adds a
* custom setting to switch to when a guest application specifically requires it. The effect is that
* other components of the emulator can access the setting's intended value without any need for the
* component to ask whether the custom or global setting is needed at the moment.
*
* By default, the global setting is used.
*
* Like the BasicSetting, this requires setting a default value and label to use.
*/
template <typename Type>
class Setting : virtual public BasicSetting<Type> {
public:
/**
* Sets a default value, label, and setting value.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param name Label for the setting
*/
explicit Setting(const Type& default_val, const std::string& name)
: BasicSetting<Type>(default_val, name) {}
virtual ~Setting() = default;
/** /**
* Tells this setting to represent either the global or custom setting when other member * Tells this setting to represent either the global or custom setting when other member
@ -292,13 +273,13 @@ public:
*/ */
[[nodiscard]] virtual const Type& GetValue() const override { [[nodiscard]] virtual const Type& GetValue() const override {
if (use_global) { if (use_global) {
return this->global; return this->value;
} }
return custom; return custom;
} }
[[nodiscard]] virtual const Type& GetValue(bool need_global) const { [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
if (use_global || need_global) { if (use_global || need_global) {
return this->global; return this->value;
} }
return custom; return custom;
} }
@ -306,12 +287,12 @@ public:
/** /**
* Sets the current setting value depending on the global state. * Sets the current setting value depending on the global state.
* *
* @param value The new value * @param val The new value
*/ */
void SetValue(const Type& value) override { void SetValue(const Type& val) override {
Type temp{value}; Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
if (use_global) { if (use_global) {
std::swap(this->global, temp); std::swap(this->value, temp);
} else { } else {
std::swap(custom, temp); std::swap(custom, temp);
} }
@ -320,15 +301,15 @@ public:
/** /**
* Assigns the current setting value depending on the global state. * Assigns the current setting value depending on the global state.
* *
* @param value The new value * @param val The new value
* *
* @returns A reference to the current setting value * @returns A reference to the current setting value
*/ */
const Type& operator=(const Type& value) override { const Type& operator=(const Type& val) override {
Type temp{value}; Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
if (use_global) { if (use_global) {
std::swap(this->global, temp); std::swap(this->value, temp);
return this->global; return this->value;
} }
std::swap(custom, temp); std::swap(custom, temp);
return custom; return custom;
@ -341,7 +322,7 @@ public:
*/ */
virtual explicit operator const Type&() const override { virtual explicit operator const Type&() const override {
if (use_global) { if (use_global) {
return this->global; return this->value;
} }
return custom; return custom;
} }
@ -351,75 +332,6 @@ protected:
Type custom{}; ///< The custom value of the setting Type custom{}; ///< The custom value of the setting
}; };
/**
* RangedSetting is a Setting that implements a maximum and minimum value for its setting. Intended
* for use with quantifiable settings.
*/
template <typename Type>
class RangedSetting final : public BasicRangedSetting<Type>, public Setting<Type> {
public:
/**
* Sets a default value, minimum value, maximum value, and label.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param min_val Sets the minimum allowed value of the setting
* @param max_val Sets the maximum allowed value of the setting
* @param name Label for the setting
*/
explicit RangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
const std::string& name)
: BasicSetting<Type>{default_val, name},
BasicRangedSetting<Type>{default_val, min_val, max_val, name}, Setting<Type>{default_val,
name} {}
virtual ~RangedSetting() = default;
// The following are needed to avoid a MSVC bug
// (source: https://stackoverflow.com/questions/469508)
[[nodiscard]] const Type& GetValue() const override {
return Setting<Type>::GetValue();
}
[[nodiscard]] const Type& GetValue(bool need_global) const override {
return Setting<Type>::GetValue(need_global);
}
explicit operator const Type&() const override {
if (this->use_global) {
return this->global;
}
return this->custom;
}
/**
* Like BasicSetting's SetValue, except value is clamped to the range of the setting. Sets the
* appropriate value depending on the global state.
*
* @param value The desired value
*/
void SetValue(const Type& value) override {
const Type temp = std::clamp(value, this->minimum, this->maximum);
if (this->use_global) {
this->global = temp;
}
this->custom = temp;
}
/**
* Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
* Uses the appropriate value depending on the global state.
*
* @param value The desired value
* @returns A reference to the setting's value
*/
const Type& operator=(const Type& value) override {
const Type temp = std::clamp(value, this->minimum, this->maximum);
if (this->use_global) {
this->global = temp;
return this->global;
}
this->custom = temp;
return this->custom;
}
};
/** /**
* The InputSetting class allows for getting a reference to either the global or custom members. * The InputSetting class allows for getting a reference to either the global or custom members.
* This is required as we cannot easily modify the values of user-defined types within containers * This is required as we cannot easily modify the values of user-defined types within containers
@ -431,7 +343,7 @@ template <typename Type>
class InputSetting final { class InputSetting final {
public: public:
InputSetting() = default; InputSetting() = default;
explicit InputSetting(Type val) : BasicSetting<Type>(val) {} explicit InputSetting(Type val) : Setting<Type>(val) {}
~InputSetting() = default; ~InputSetting() = default;
void SetGlobal(bool to_global) { void SetGlobal(bool to_global) {
use_global = to_global; use_global = to_global;
@ -459,175 +371,175 @@ struct TouchFromButtonMap {
struct Values { struct Values {
// Audio // Audio
BasicSetting<std::string> audio_device_id{"auto", "output_device"}; Setting<std::string> audio_device_id{"auto", "output_device"};
BasicSetting<std::string> sink_id{"auto", "output_engine"}; Setting<std::string> sink_id{"auto", "output_engine"};
BasicSetting<bool> audio_muted{false, "audio_muted"}; Setting<bool> audio_muted{false, "audio_muted"};
RangedSetting<u8> volume{100, 0, 100, "volume"}; SwitchableSetting<u8> volume{100, 0, 100, "volume"};
// Core // Core
Setting<bool> use_multi_core{true, "use_multi_core"}; SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
Setting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"}; SwitchableSetting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
// Cpu // Cpu
RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto, SwitchableSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
CPUAccuracy::Paranoid, "cpu_accuracy"}; CPUAccuracy::Paranoid, "cpu_accuracy"};
// TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021 // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"}; Setting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"}; Setting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"}; Setting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"}; Setting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"}; Setting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"}; Setting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"}; Setting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"}; Setting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"}; Setting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"}; Setting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"}; Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
BasicSetting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"}; Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
BasicSetting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"}; Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"}; SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"}; SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"}; SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"}; true, "cpuopt_unsafe_ignore_standard_fpcr"};
Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"}; SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
Setting<bool> cpuopt_unsafe_ignore_global_monitor{true, "cpuopt_unsafe_ignore_global_monitor"}; SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
true, "cpuopt_unsafe_ignore_global_monitor"};
// Renderer // Renderer
RangedSetting<RendererBackend> renderer_backend{ SwitchableSetting<RendererBackend> renderer_backend{
RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"}; RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
BasicSetting<bool> renderer_debug{false, "debug"}; Setting<bool> renderer_debug{false, "debug"};
BasicSetting<bool> renderer_shader_feedback{false, "shader_feedback"}; Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"}; Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
BasicSetting<bool> disable_shader_loop_safety_checks{false, Setting<bool> disable_shader_loop_safety_checks{false, "disable_shader_loop_safety_checks"};
"disable_shader_loop_safety_checks"}; SwitchableSetting<int> vulkan_device{0, "vulkan_device"};
Setting<int> vulkan_device{0, "vulkan_device"};
ResolutionScalingInfo resolution_info{}; ResolutionScalingInfo resolution_info{};
Setting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"}; SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
Setting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"}; SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
Setting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"}; SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
// *nix platforms may have issues with the borderless windowed fullscreen mode. // *nix platforms may have issues with the borderless windowed fullscreen mode.
// Default to exclusive fullscreen on these platforms for now. // Default to exclusive fullscreen on these platforms for now.
RangedSetting<FullscreenMode> fullscreen_mode{ SwitchableSetting<FullscreenMode> fullscreen_mode{
#ifdef _WIN32 #ifdef _WIN32
FullscreenMode::Borderless, FullscreenMode::Borderless,
#else #else
FullscreenMode::Exclusive, FullscreenMode::Exclusive,
#endif #endif
FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"}; FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"}; SwitchableSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
RangedSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"}; SwitchableSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
Setting<bool> use_speed_limit{true, "use_speed_limit"}; SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"}; SwitchableSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"}; SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal, SwitchableSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
GPUAccuracy::Extreme, "gpu_accuracy"}; GPUAccuracy::Extreme, "gpu_accuracy"};
Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"}; SwitchableSetting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"}; SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
Setting<bool> accelerate_astc{true, "accelerate_astc"}; SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
Setting<bool> use_vsync{true, "use_vsync"}; SwitchableSetting<bool> use_vsync{true, "use_vsync"};
RangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"}; SwitchableSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"}; Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL, SwitchableSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
ShaderBackend::SPIRV, "shader_backend"}; ShaderBackend::SPIRV, "shader_backend"};
Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"}; SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"}; SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
Setting<u8> bg_red{0, "bg_red"}; SwitchableSetting<u8> bg_red{0, "bg_red"};
Setting<u8> bg_green{0, "bg_green"}; SwitchableSetting<u8> bg_green{0, "bg_green"};
Setting<u8> bg_blue{0, "bg_blue"}; SwitchableSetting<u8> bg_blue{0, "bg_blue"};
// System // System
Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"}; SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
// Measured in seconds since epoch // Measured in seconds since epoch
std::optional<s64> custom_rtc; std::optional<s64> custom_rtc;
// Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc` // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
s64 custom_rtc_differential; s64 custom_rtc_differential;
BasicSetting<s32> current_user{0, "current_user"}; Setting<s32> current_user{0, "current_user"};
RangedSetting<s32> language_index{1, 0, 17, "language_index"}; SwitchableSetting<s32> language_index{1, 0, 17, "language_index"};
RangedSetting<s32> region_index{1, 0, 6, "region_index"}; SwitchableSetting<s32> region_index{1, 0, 6, "region_index"};
RangedSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"}; SwitchableSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
RangedSetting<s32> sound_index{1, 0, 2, "sound_index"}; SwitchableSetting<s32> sound_index{1, 0, 2, "sound_index"};
// Controls // Controls
InputSetting<std::array<PlayerInput, 10>> players; InputSetting<std::array<PlayerInput, 10>> players;
Setting<bool> use_docked_mode{true, "use_docked_mode"}; SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"};
BasicSetting<bool> enable_raw_input{false, "enable_raw_input"}; Setting<bool> enable_raw_input{false, "enable_raw_input"};
BasicSetting<bool> controller_navigation{true, "controller_navigation"}; Setting<bool> controller_navigation{true, "controller_navigation"};
Setting<bool> vibration_enabled{true, "vibration_enabled"}; SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"}; SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
Setting<bool> motion_enabled{true, "motion_enabled"}; SwitchableSetting<bool> motion_enabled{true, "motion_enabled"};
BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"}; Setting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
BasicSetting<bool> enable_udp_controller{false, "enable_udp_controller"}; Setting<bool> enable_udp_controller{false, "enable_udp_controller"};
BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"}; Setting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
BasicSetting<bool> tas_enable{false, "tas_enable"}; Setting<bool> tas_enable{false, "tas_enable"};
BasicSetting<bool> tas_loop{false, "tas_loop"}; Setting<bool> tas_loop{false, "tas_loop"};
BasicSetting<bool> mouse_panning{false, "mouse_panning"}; Setting<bool> mouse_panning{false, "mouse_panning"};
BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"}; Setting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
BasicSetting<bool> mouse_enabled{false, "mouse_enabled"}; Setting<bool> mouse_enabled{false, "mouse_enabled"};
BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"}; Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"}; Setting<bool> keyboard_enabled{false, "keyboard_enabled"};
BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"}; Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
ButtonsRaw debug_pad_buttons; ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs; AnalogsRaw debug_pad_analogs;
TouchscreenInput touchscreen; TouchscreenInput touchscreen;
BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", Setting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", "touch_device"};
"touch_device"}; Setting<int> touch_from_button_map_index{0, "touch_from_button_map"};
BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
std::vector<TouchFromButtonMap> touch_from_button_maps; std::vector<TouchFromButtonMap> touch_from_button_maps;
BasicSetting<bool> enable_ring_controller{true, "enable_ring_controller"}; Setting<bool> enable_ring_controller{true, "enable_ring_controller"};
RingconRaw ringcon_analogs; RingconRaw ringcon_analogs;
// Data Storage // Data Storage
BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"}; Setting<bool> use_virtual_sd{true, "use_virtual_sd"};
BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"}; Setting<bool> gamecard_inserted{false, "gamecard_inserted"};
BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"}; Setting<bool> gamecard_current_game{false, "gamecard_current_game"};
BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"}; Setting<std::string> gamecard_path{std::string(), "gamecard_path"};
// Debugging // Debugging
bool record_frame_times; bool record_frame_times;
BasicSetting<bool> use_gdbstub{false, "use_gdbstub"}; Setting<bool> use_gdbstub{false, "use_gdbstub"};
BasicSetting<u16> gdbstub_port{6543, "gdbstub_port"}; Setting<u16> gdbstub_port{6543, "gdbstub_port"};
BasicSetting<std::string> program_args{std::string(), "program_args"}; Setting<std::string> program_args{std::string(), "program_args"};
BasicSetting<bool> dump_exefs{false, "dump_exefs"}; Setting<bool> dump_exefs{false, "dump_exefs"};
BasicSetting<bool> dump_nso{false, "dump_nso"}; Setting<bool> dump_nso{false, "dump_nso"};
BasicSetting<bool> dump_shaders{false, "dump_shaders"}; Setting<bool> dump_shaders{false, "dump_shaders"};
BasicSetting<bool> dump_macros{false, "dump_macros"}; Setting<bool> dump_macros{false, "dump_macros"};
BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"}; Setting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
BasicSetting<bool> reporting_services{false, "reporting_services"}; Setting<bool> reporting_services{false, "reporting_services"};
BasicSetting<bool> quest_flag{false, "quest_flag"}; Setting<bool> quest_flag{false, "quest_flag"};
BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"}; Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
BasicSetting<bool> extended_logging{false, "extended_logging"}; Setting<bool> extended_logging{false, "extended_logging"};
BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"}; Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
BasicSetting<bool> use_auto_stub{false, "use_auto_stub"}; Setting<bool> use_auto_stub{false, "use_auto_stub"};
BasicSetting<bool> enable_all_controllers{false, "enable_all_controllers"}; Setting<bool> enable_all_controllers{false, "enable_all_controllers"};
// Miscellaneous // Miscellaneous
BasicSetting<std::string> log_filter{"*:Info", "log_filter"}; Setting<std::string> log_filter{"*:Info", "log_filter"};
BasicSetting<bool> use_dev_keys{false, "use_dev_keys"}; Setting<bool> use_dev_keys{false, "use_dev_keys"};
// Network // Network
BasicSetting<std::string> network_interface{std::string(), "network_interface"}; Setting<std::string> network_interface{std::string(), "network_interface"};
// WebService // WebService
BasicSetting<bool> enable_telemetry{true, "enable_telemetry"}; Setting<bool> enable_telemetry{true, "enable_telemetry"};
BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"}; Setting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"}; Setting<std::string> yuzu_username{std::string(), "yuzu_username"};
BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"}; Setting<std::string> yuzu_token{std::string(), "yuzu_token"};
// Add-Ons // Add-Ons
std::map<u64, std::vector<std::string>> disabled_addons; std::map<u64, std::vector<std::string>> disabled_addons;

12
src/yuzu/configuration/config.cpp
View file

@ -133,7 +133,7 @@ void Config::Initialize(const std::string& config_name) {
// Explicit std::string definition: Qt can't implicitly convert a std::string to a QVariant, nor // Explicit std::string definition: Qt can't implicitly convert a std::string to a QVariant, nor
// can it implicitly convert a QVariant back to a {std::,Q}string // can it implicitly convert a QVariant back to a {std::,Q}string
template <> template <>
void Config::ReadBasicSetting(Settings::BasicSetting<std::string>& setting) { void Config::ReadBasicSetting(Settings::Setting<std::string>& setting) {
const QString name = QString::fromStdString(setting.GetLabel()); const QString name = QString::fromStdString(setting.GetLabel());
const auto default_value = QString::fromStdString(setting.GetDefault()); const auto default_value = QString::fromStdString(setting.GetDefault());
if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) { if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
@ -144,7 +144,7 @@ void Config::ReadBasicSetting(Settings::BasicSetting<std::string>& setting) {
} }
template <typename Type> template <typename Type>
void Config::ReadBasicSetting(Settings::BasicSetting<Type>& setting) { void Config::ReadBasicSetting(Settings::Setting<Type>& setting) {
const QString name = QString::fromStdString(setting.GetLabel()); const QString name = QString::fromStdString(setting.GetLabel());
const Type default_value = setting.GetDefault(); const Type default_value = setting.GetDefault();
if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) { if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
@ -157,7 +157,7 @@ void Config::ReadBasicSetting(Settings::BasicSetting<Type>& setting) {
// Explicit std::string definition: Qt can't implicitly convert a std::string to a QVariant // Explicit std::string definition: Qt can't implicitly convert a std::string to a QVariant
template <> template <>
void Config::WriteBasicSetting(const Settings::BasicSetting<std::string>& setting) { void Config::WriteBasicSetting(const Settings::Setting<std::string>& setting) {
const QString name = QString::fromStdString(setting.GetLabel()); const QString name = QString::fromStdString(setting.GetLabel());
const std::string& value = setting.GetValue(); const std::string& value = setting.GetValue();
qt_config->setValue(name + QStringLiteral("/default"), value == setting.GetDefault()); qt_config->setValue(name + QStringLiteral("/default"), value == setting.GetDefault());
@ -165,7 +165,7 @@ void Config::WriteBasicSetting(const Settings::BasicSetting<std::string>& settin
} }
template <typename Type> template <typename Type>
void Config::WriteBasicSetting(const Settings::BasicSetting<Type>& setting) { void Config::WriteBasicSetting(const Settings::Setting<Type>& setting) {
const QString name = QString::fromStdString(setting.GetLabel()); const QString name = QString::fromStdString(setting.GetLabel());
const Type value = setting.GetValue(); const Type value = setting.GetValue();
qt_config->setValue(name + QStringLiteral("/default"), value == setting.GetDefault()); qt_config->setValue(name + QStringLiteral("/default"), value == setting.GetDefault());
@ -173,7 +173,7 @@ void Config::WriteBasicSetting(const Settings::BasicSetting<Type>& setting) {
} }
template <typename Type> template <typename Type>
void Config::WriteGlobalSetting(const Settings::Setting<Type>& setting) { void Config::WriteGlobalSetting(const Settings::SwitchableSetting<Type>& setting) {
const QString name = QString::fromStdString(setting.GetLabel()); const QString name = QString::fromStdString(setting.GetLabel());
const Type& value = setting.GetValue(global); const Type& value = setting.GetValue(global);
if (!global) { if (!global) {
@ -1422,7 +1422,7 @@ QVariant Config::ReadSetting(const QString& name, const QVariant& default_value)
} }
template <typename Type> template <typename Type>
void Config::ReadGlobalSetting(Settings::Setting<Type>& setting) { void Config::ReadGlobalSetting(Settings::SwitchableSetting<Type>& setting) {
QString name = QString::fromStdString(setting.GetLabel()); QString name = QString::fromStdString(setting.GetLabel());
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);

8
src/yuzu/configuration/config.h
View file

@ -160,7 +160,7 @@ private:
* @param The setting * @param The setting
*/ */
template <typename Type> template <typename Type>
void ReadGlobalSetting(Settings::Setting<Type>& setting); void ReadGlobalSetting(Settings::SwitchableSetting<Type>& setting);
/** /**
* Sets a value to the qt_config using the setting's label and default value. If the config is a * Sets a value to the qt_config using the setting's label and default value. If the config is a
@ -169,7 +169,7 @@ private:
* @param The setting * @param The setting
*/ */
template <typename Type> template <typename Type>
void WriteGlobalSetting(const Settings::Setting<Type>& setting); void WriteGlobalSetting(const Settings::SwitchableSetting<Type>& setting);
/** /**
* Reads a value from the qt_config using the setting's label and default value and applies the * Reads a value from the qt_config using the setting's label and default value and applies the
@ -178,14 +178,14 @@ private:
* @param The setting * @param The setting
*/ */
template <typename Type> template <typename Type>
void ReadBasicSetting(Settings::BasicSetting<Type>& setting); void ReadBasicSetting(Settings::Setting<Type>& setting);
/** Sets a value from the setting in the qt_config using the setting's label and default value. /** Sets a value from the setting in the qt_config using the setting's label and default value.
* *
* @param The setting * @param The setting
*/ */
template <typename Type> template <typename Type>
void WriteBasicSetting(const Settings::BasicSetting<Type>& setting); void WriteBasicSetting(const Settings::Setting<Type>& setting);
ConfigType type; ConfigType type;
std::unique_ptr<QSettings> qt_config; std::unique_ptr<QSettings> qt_config;

6
src/yuzu/configuration/configuration_shared.cpp
View file

@ -9,7 +9,7 @@
#include "yuzu/configuration/configuration_shared.h" #include "yuzu/configuration/configuration_shared.h"
#include "yuzu/configuration/configure_per_game.h" #include "yuzu/configuration/configure_per_game.h"
void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<bool>* setting, void ConfigurationShared::ApplyPerGameSetting(Settings::SwitchableSetting<bool>* setting,
const QCheckBox* checkbox, const QCheckBox* checkbox,
const CheckState& tracker) { const CheckState& tracker) {
if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) { if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
@ -25,7 +25,7 @@ void ConfigurationShared::ApplyPerGameSetting(Settings::Setting<bool>* setting,
} }
void ConfigurationShared::SetPerGameSetting(QCheckBox* checkbox, void ConfigurationShared::SetPerGameSetting(QCheckBox* checkbox,
const Settings::Setting<bool>* setting) { const Settings::SwitchableSetting<bool>* setting) {
if (setting->UsingGlobal()) { if (setting->UsingGlobal()) {
checkbox->setCheckState(Qt::PartiallyChecked); checkbox->setCheckState(Qt::PartiallyChecked);
} else { } else {
@ -45,7 +45,7 @@ void ConfigurationShared::SetHighlight(QWidget* widget, bool highlighted) {
} }
void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox,
const Settings::Setting<bool>& setting, const Settings::SwitchableSetting<bool>& setting,
CheckState& tracker) { CheckState& tracker) {
if (setting.UsingGlobal()) { if (setting.UsingGlobal()) {
tracker = CheckState::Global; tracker = CheckState::Global;

10
src/yuzu/configuration/configuration_shared.h
View file

@ -25,10 +25,10 @@ enum class CheckState {
// Global-aware apply and set functions // Global-aware apply and set functions
// ApplyPerGameSetting, given a Settings::Setting and a Qt UI element, properly applies a Setting // ApplyPerGameSetting, given a Settings::Setting and a Qt UI element, properly applies a Setting
void ApplyPerGameSetting(Settings::Setting<bool>* setting, const QCheckBox* checkbox, void ApplyPerGameSetting(Settings::SwitchableSetting<bool>* setting, const QCheckBox* checkbox,
const CheckState& tracker); const CheckState& tracker);
template <typename Type> template <typename Type>
void ApplyPerGameSetting(Settings::Setting<Type>* setting, const QComboBox* combobox) { void ApplyPerGameSetting(Settings::SwitchableSetting<Type>* setting, const QComboBox* combobox) {
if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) { if (Settings::IsConfiguringGlobal() && setting->UsingGlobal()) {
setting->SetValue(static_cast<Type>(combobox->currentIndex())); setting->SetValue(static_cast<Type>(combobox->currentIndex()));
} else if (!Settings::IsConfiguringGlobal()) { } else if (!Settings::IsConfiguringGlobal()) {
@ -43,10 +43,10 @@ void ApplyPerGameSetting(Settings::Setting<Type>* setting, const QComboBox* comb
} }
// Sets a Qt UI element given a Settings::Setting // Sets a Qt UI element given a Settings::Setting
void SetPerGameSetting(QCheckBox* checkbox, const Settings::Setting<bool>* setting); void SetPerGameSetting(QCheckBox* checkbox, const Settings::SwitchableSetting<bool>* setting);
template <typename Type> template <typename Type>
void SetPerGameSetting(QComboBox* combobox, const Settings::Setting<Type>* setting) { void SetPerGameSetting(QComboBox* combobox, const Settings::SwitchableSetting<Type>* setting) {
combobox->setCurrentIndex(setting->UsingGlobal() ? ConfigurationShared::USE_GLOBAL_INDEX combobox->setCurrentIndex(setting->UsingGlobal() ? ConfigurationShared::USE_GLOBAL_INDEX
: static_cast<int>(setting->GetValue()) + : static_cast<int>(setting->GetValue()) +
ConfigurationShared::USE_GLOBAL_OFFSET); ConfigurationShared::USE_GLOBAL_OFFSET);
@ -56,7 +56,7 @@ void SetPerGameSetting(QComboBox* combobox, const Settings::Setting<Type>* setti
void SetHighlight(QWidget* widget, bool highlighted); void SetHighlight(QWidget* widget, bool highlighted);
// Sets up a QCheckBox like a tristate one, given a Setting // Sets up a QCheckBox like a tristate one, given a Setting
void SetColoredTristate(QCheckBox* checkbox, const Settings::Setting<bool>& setting, void SetColoredTristate(QCheckBox* checkbox, const Settings::SwitchableSetting<bool>& setting,
CheckState& tracker); CheckState& tracker);
void SetColoredTristate(QCheckBox* checkbox, bool global, bool state, bool global_state, void SetColoredTristate(QCheckBox* checkbox, bool global, bool state, bool global_state,
CheckState& tracker); CheckState& tracker);

50
src/yuzu/uisettings.h
View file

@ -64,28 +64,28 @@ struct Values {
QByteArray gamelist_header_state; QByteArray gamelist_header_state;
QByteArray microprofile_geometry; QByteArray microprofile_geometry;
Settings::BasicSetting<bool> microprofile_visible{false, "microProfileDialogVisible"}; Settings::Setting<bool> microprofile_visible{false, "microProfileDialogVisible"};
Settings::BasicSetting<bool> single_window_mode{true, "singleWindowMode"}; Settings::Setting<bool> single_window_mode{true, "singleWindowMode"};
Settings::BasicSetting<bool> fullscreen{false, "fullscreen"}; Settings::Setting<bool> fullscreen{false, "fullscreen"};
Settings::BasicSetting<bool> display_titlebar{true, "displayTitleBars"}; Settings::Setting<bool> display_titlebar{true, "displayTitleBars"};
Settings::BasicSetting<bool> show_filter_bar{true, "showFilterBar"}; Settings::Setting<bool> show_filter_bar{true, "showFilterBar"};
Settings::BasicSetting<bool> show_status_bar{true, "showStatusBar"}; Settings::Setting<bool> show_status_bar{true, "showStatusBar"};
Settings::BasicSetting<bool> confirm_before_closing{true, "confirmClose"}; Settings::Setting<bool> confirm_before_closing{true, "confirmClose"};
Settings::BasicSetting<bool> first_start{true, "firstStart"}; Settings::Setting<bool> first_start{true, "firstStart"};
Settings::BasicSetting<bool> pause_when_in_background{false, "pauseWhenInBackground"}; Settings::Setting<bool> pause_when_in_background{false, "pauseWhenInBackground"};
Settings::BasicSetting<bool> mute_when_in_background{false, "muteWhenInBackground"}; Settings::Setting<bool> mute_when_in_background{false, "muteWhenInBackground"};
Settings::BasicSetting<bool> hide_mouse{true, "hideInactiveMouse"}; Settings::Setting<bool> hide_mouse{true, "hideInactiveMouse"};
// Set when Vulkan is known to crash the application // Set when Vulkan is known to crash the application
Settings::BasicSetting<bool> has_broken_vulkan{false, "has_broken_vulkan"}; Settings::Setting<bool> has_broken_vulkan{false, "has_broken_vulkan"};
Settings::BasicSetting<bool> select_user_on_boot{false, "select_user_on_boot"}; Settings::Setting<bool> select_user_on_boot{false, "select_user_on_boot"};
// Discord RPC // Discord RPC
Settings::BasicSetting<bool> enable_discord_presence{true, "enable_discord_presence"}; Settings::Setting<bool> enable_discord_presence{true, "enable_discord_presence"};
Settings::BasicSetting<bool> enable_screenshot_save_as{true, "enable_screenshot_save_as"}; Settings::Setting<bool> enable_screenshot_save_as{true, "enable_screenshot_save_as"};
QString roms_path; QString roms_path;
QString symbols_path; QString symbols_path;
@ -100,25 +100,25 @@ struct Values {
// Shortcut name <Shortcut, context> // Shortcut name <Shortcut, context>
std::vector<Shortcut> shortcuts; std::vector<Shortcut> shortcuts;
Settings::BasicSetting<uint32_t> callout_flags{0, "calloutFlags"}; Settings::Setting<uint32_t> callout_flags{0, "calloutFlags"};
// logging // logging
Settings::BasicSetting<bool> show_console{false, "showConsole"}; Settings::Setting<bool> show_console{false, "showConsole"};
// Game List // Game List
Settings::BasicSetting<bool> show_add_ons{true, "show_add_ons"}; Settings::Setting<bool> show_add_ons{true, "show_add_ons"};
Settings::BasicSetting<uint32_t> game_icon_size{64, "game_icon_size"}; Settings::Setting<uint32_t> game_icon_size{64, "game_icon_size"};
Settings::BasicSetting<uint32_t> folder_icon_size{48, "folder_icon_size"}; Settings::Setting<uint32_t> folder_icon_size{48, "folder_icon_size"};
Settings::BasicSetting<uint8_t> row_1_text_id{3, "row_1_text_id"}; Settings::Setting<uint8_t> row_1_text_id{3, "row_1_text_id"};
Settings::BasicSetting<uint8_t> row_2_text_id{2, "row_2_text_id"}; Settings::Setting<uint8_t> row_2_text_id{2, "row_2_text_id"};
std::atomic_bool is_game_list_reload_pending{false}; std::atomic_bool is_game_list_reload_pending{false};
Settings::BasicSetting<bool> cache_game_list{true, "cache_game_list"}; Settings::Setting<bool> cache_game_list{true, "cache_game_list"};
Settings::BasicSetting<bool> favorites_expanded{true, "favorites_expanded"}; Settings::Setting<bool> favorites_expanded{true, "favorites_expanded"};
QVector<u64> favorited_ids; QVector<u64> favorited_ids;
bool configuration_applied; bool configuration_applied;
bool reset_to_defaults; bool reset_to_defaults;
Settings::BasicSetting<bool> disable_web_applet{true, "disable_web_applet"}; Settings::Setting<bool> disable_web_applet{true, "disable_web_applet"};
}; };
extern Values values; extern Values values;

6
src/yuzu_cmd/config.cpp
View file

@ -90,17 +90,17 @@ static const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs>
}}; }};
template <> template <>
void Config::ReadSetting(const std::string& group, Settings::BasicSetting<std::string>& setting) { void Config::ReadSetting(const std::string& group, Settings::Setting<std::string>& setting) {
setting = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault()); setting = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault());
} }
template <> template <>
void Config::ReadSetting(const std::string& group, Settings::BasicSetting<bool>& setting) { void Config::ReadSetting(const std::string& group, Settings::Setting<bool>& setting) {
setting = sdl2_config->GetBoolean(group, setting.GetLabel(), setting.GetDefault()); setting = sdl2_config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
} }
template <typename Type> template <typename Type>
void Config::ReadSetting(const std::string& group, Settings::BasicSetting<Type>& setting) { void Config::ReadSetting(const std::string& group, Settings::Setting<Type>& setting) {
setting = static_cast<Type>(sdl2_config->GetInteger(group, setting.GetLabel(), setting = static_cast<Type>(sdl2_config->GetInteger(group, setting.GetLabel(),
static_cast<long>(setting.GetDefault()))); static_cast<long>(setting.GetDefault())));
} }

4
src/yuzu_cmd/config.h
View file

@ -28,11 +28,11 @@ public:
private: private:
/** /**
* Applies a value read from the sdl2_config to a BasicSetting. * Applies a value read from the sdl2_config to a Setting.
* *
* @param group The name of the INI group * @param group The name of the INI group
* @param setting The yuzu setting to modify * @param setting The yuzu setting to modify
*/ */
template <typename Type> template <typename Type>
void ReadSetting(const std::string& group, Settings::BasicSetting<Type>& setting); void ReadSetting(const std::string& group, Settings::Setting<Type>& setting);
}; };