stuff/suyu
stuff/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-25 12:56:27 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

settings: Consolidate RangedSetting's with regular ones

Browse source 
The latest git version of GCC has issues with my diamond inheritance
shenanigans. Since that's now two compilers that don't like it I thought
it'd be best to just axe all of it and just have the two templates like
before.

This rolls the features of BasicRangedSetting into BasicSetting, and
likewise RangedSetting into Setting. It also renames them from
BasicSetting and Setting to Setting and SwitchableSetting respectively.
Now longer name corresponds to more complex thing.
This commit is contained in:
lat9nq 2022-06-30 12:32:03 -04:00
parent 01bc0c84f0
commit ca36722a54
8 changed files with 230 additions and 318 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

452
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);
}; };