franklinblanco/yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

settings: Add a registry of settings

Browse Source 
LoadString: Sanitize input

settings: Handle empty string, remove redundant category

settings: Rename Input to Controls, FS to DataStorage

settings: Fix Controls groups information

settings: Move use_docked_mode to System (again)

settings: Document

settings: Add type identification function

settings: Move registry into values

settings: Move global_reset_registry into values

settings: Separate AdvGraphics from Renderer

settings: More document

squash

settings: Use linkage object

uisettings: Move registry into settings

Probably wont build without

uisettings: Use settings linkage object

config: Load settings with a map

Uses the new all_settings vector to load settings.

qt-config: Rename settings category

qt config: Rename to read category

config: Read/write contols category with for_each

This is extremely limited due to the complexity of the Controls group,
but this handles the the settings that use the interface.

qt-config: Use new settings registry

qt-config: Read/write advgrphics

qt-config: Use settings linkage object

yuzu_cmd: Load setting off of vector

cmd-config: Finish settings rename

config: Read controls settings group with for_each

cmd/config: Move registry into values

cmd: Read adv graphics

cmd-config: Use settings linkage object
This commit is contained in:
lat9nq 2023-06-05 21:05:22 -04:00
parent e7543e8b84
commit 60773194a0
9 changed files with 688 additions and 858 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/common/settings.cpp
View File

@ -144,6 +144,56 @@ float Volume() {
return values.volume.GetValue() / static_cast<f32>(values.volume.GetDefault()); return values.volume.GetValue() / static_cast<f32>(values.volume.GetDefault());
} }
const char* TranslateCategory(Category category) {
switch (category) {
case Category::Audio:
return "Audio";
case Category::Core:
return "Core";
case Category::Cpu:
return "Cpu";
case Category::Renderer:
return "Renderer";
case Category::System:
return "System";
case Category::DataStorage:
return "Data Storage";
case Category::Debugging:
return "Debugging";
case Category::Miscellaneous:
return "Miscellaneous";
case Category::Network:
return "Network";
case Category::WebService:
return "WebService";
case Category::AddOns:
return "DisabledAddOns";
case Category::Controls:
return "Controls";
case Category::Ui:
return "UI";
case Category::UiLayout:
return "UiLayout";
case Category::UiGameList:
return "UiGameList";
case Category::Screenshots:
return "Screenshots";
case Category::Shortcuts:
return "Shortcuts";
case Category::Multiplayer:
return "Multiplayer";
case Category::Services:
return "Services";
case Category::Paths:
return "Paths";
case Category::MaxEnum:
break;
case Category::AdvancedGraphics:
return "Renderer";
}
return "Miscellaneous";
}
void UpdateRescalingInfo() { void UpdateRescalingInfo() {
const auto setup = values.resolution_setup.GetValue(); const auto setup = values.resolution_setup.GetValue();
auto& info = values.resolution_info; auto& info = values.resolution_info;
@ -212,7 +262,7 @@ void RestoreGlobalState(bool is_powered_on) {
return; return;
} }
for (const auto& reset : global_reset_registry) { for (const auto& reset : values.linkage.restore_functions) {
reset(); reset();
} }
} }

600
src/common/settings.h
View File

@ -9,7 +9,9 @@
#include <functional> #include <functional>
#include <map> #include <map>
#include <optional> #include <optional>
#include <stdexcept>
#include <string> #include <string>
#include <typeindex>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -104,6 +106,33 @@ enum class AstcRecompression : u32 {
Bc3 = 2, Bc3 = 2,
}; };
enum class Category : u32 {
Audio,
Core,
Cpu,
Renderer,
AdvancedGraphics,
System,
DataStorage,
Debugging,
Miscellaneous,
Network,
WebService,
AddOns,
Controls,
Ui,
UiLayout,
UiGameList,
Screenshots,
Shortcuts,
Multiplayer,
Services,
Paths,
MaxEnum,
};
const char* TranslateCategory(Settings::Category category);
struct ResolutionScalingInfo { struct ResolutionScalingInfo {
u32 up_scale{1}; u32 up_scale{1};
u32 down_shift{0}; u32 down_shift{0};
@ -127,15 +156,40 @@ struct ResolutionScalingInfo {
} }
}; };
static std::forward_list<std::function<void()>> global_reset_registry; class BasicSetting {
protected:
explicit BasicSetting() = default;
/** The Setting class is a simple resource manager. It defines a label and default value alongside public:
* the actual value of the setting for simpler and less-error prone use with frontend virtual ~BasicSetting() = default;
* configurations. Specifying a default value and label is required. A minimum and maximum range can
* be specified for sanitization. virtual Category Category() const = 0;
virtual constexpr bool Switchable() const = 0;
virtual std::string ToString() const = 0;
virtual void LoadString(const std::string& load) = 0;
virtual const std::string& GetLabel() const = 0;
virtual std::string DefaultToString() const = 0;
virtual bool Save() const = 0;
virtual std::type_index TypeId() const = 0;
virtual void SetGlobal(bool global) {}
virtual bool UsingGlobal() const {
return false;
}
};
class Linkage {
public:
std::map<Category, std::forward_list<BasicSetting*>> by_category;
std::vector<std::function<void()>> restore_functions;
};
/** The Setting class is a simple resource manager. It defines a label and default value
* alongside the actual value of the setting for simpler and less-error prone use with frontend
* configurations. Specifying a default value and label is required. A minimum and maximum range
* can be specified for sanitization.
*/ */
template <typename Type, bool ranged = false> template <typename Type, bool ranged = false, bool save = true>
class Setting { class Setting : public BasicSetting {
protected: protected:
Setting() = default; Setting() = default;
@ -151,27 +205,36 @@ public:
/** /**
* Sets a default value, label, and setting value. * Sets a default value, label, and setting value.
* *
* @param linkage Setting registry
* @param default_val Initial value of the setting, and default value of the setting * @param default_val Initial value of the setting, and default value of the setting
* @param name Label for the setting * @param name Label for the setting
* @param category_ Category of the setting AKA INI group
*/ */
explicit Setting(const Type& default_val, const std::string& name) explicit Setting(Linkage& linkage, const Type& default_val, const std::string& name,
enum Category category_)
requires(!ranged) requires(!ranged)
: value{default_val}, default_value{default_val}, label{name} {} : value{default_val}, default_value{default_val}, label{name}, category{category_} {
linkage.by_category[category].push_front(this);
}
virtual ~Setting() = default; virtual ~Setting() = default;
/** /**
* Sets a default value, minimum value, maximum value, and label. * Sets a default value, minimum value, maximum value, and label.
* *
* @param linkage Setting registry
* @param default_val Initial value of the setting, and default value of the setting * @param default_val Initial value of the setting, and default value of the setting
* @param min_val Sets the minimum allowed 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 max_val Sets the maximum allowed value of the setting
* @param name Label for the setting * @param name Label for the setting
* @param category_ Category of the setting AKA INI group
*/ */
explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val, explicit Setting(Linkage& linkage, const Type& default_val, const Type& min_val,
const std::string& name) const Type& max_val, const std::string& name, enum Category category_)
requires(ranged) requires(ranged)
: value{default_val}, : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},
default_value{default_val}, maximum{max_val}, minimum{min_val}, label{name} {} label{name}, category{category_} {
linkage.by_category[category].push_front(this);
}
/** /**
* Returns a reference to the setting's value. * Returns a reference to the setting's value.
@ -206,10 +269,61 @@ public:
* *
* @returns A reference to the label * @returns A reference to the label
*/ */
[[nodiscard]] const std::string& GetLabel() const { [[nodiscard]] const std::string& GetLabel() const override {
return label; return label;
} }
/**
* Returns the setting's category AKA INI group.
*
* @returns The setting's category
*/
[[nodiscard]] enum Category Category() const override {
return category;
}
/**
* Returns whether the current setting is Switchable.
*
* @returns If the setting is a SwitchableSetting
*/
[[nodiscard]] virtual constexpr bool Switchable() const override {
return false;
}
private:
std::string ToString(const Type& value_) const {
if constexpr (std::is_same<Type, std::string>()) {
return value_;
} else if constexpr (std::is_same<Type, std::optional<u32>>()) {
return value_.has_value() ? std::to_string(*value_) : "0";
} else if constexpr (std::is_same<Type, bool>()) {
return value_ ? "true" : "false";
} else {
return std::to_string(static_cast<u64>(value_));
}
}
public:
/**
* Converts the value of the setting to a std::string. Respects the global state if the setting
* has one.
*
* @returns The current setting as a std::string
*/
std::string ToString() const override {
return ToString(this->GetValue());
}
/**
* Returns the default value of the setting as a std::string.
*
* @returns The default value as a string.
*/
std::string DefaultToString() const override {
return ToString(default_value);
}
/** /**
* Assigns a value to the setting. * Assigns a value to the setting.
* *
@ -232,12 +346,58 @@ public:
return value; return value;
} }
/**
* Converts the given value to the Setting's type of value. Uses SetValue to enter the setting,
* thus respecting its constraints.
*
* @param input The desired value
*/
void LoadString(const std::string& input) override {
if (input.empty()) {
this->SetValue(this->GetDefault());
return;
}
try {
if constexpr (std::is_same<Type, std::string>()) {
this->SetValue(input);
} else if constexpr (std::is_same<Type, std::optional<u32>>()) {
this->SetValue(static_cast<u32>(std::stoll(input)));
} else if constexpr (std::is_same<Type, bool>()) {
this->SetValue(input == "true");
} else {
this->SetValue(static_cast<Type>(std::stoll(input)));
}
} catch (std::invalid_argument) {
this->SetValue(this->GetDefault());
}
}
/**
* Returns the save preference of the setting i.e. when saving or reading the setting from a
* frontend, whether this setting should be skipped.
*
* @returns The save preference
*/
virtual bool Save() const override {
return save;
}
/**
* Gives us another way to identify the setting without having to go through a string.
*
* @returns the type_index of the setting's type
*/
virtual std::type_index TypeId() const override {
return std::type_index(typeid(Type));
}
protected: protected:
Type value{}; ///< The setting Type value{}; ///< The setting
const Type default_value{}; ///< The default value const Type default_value{}; ///< The default value
const Type maximum{}; ///< Maximum allowed value of the setting const Type maximum{}; ///< Maximum allowed value of the setting
const Type minimum{}; ///< Minimum allowed value of the setting const Type minimum{}; ///< Minimum allowed value of the setting
const std::string label{}; ///< The setting's label const std::string label{}; ///< The setting's label
const enum Category category; ///< The setting's category AKA INI group
}; };
/** /**
@ -248,35 +408,40 @@ protected:
* *
* By default, the global setting is used. * By default, the global setting is used.
*/ */
template <typename Type, bool ranged = false> template <typename Type, bool ranged = false, bool save = true>
class SwitchableSetting : virtual public Setting<Type, ranged> { class SwitchableSetting : virtual public Setting<Type, ranged, save> {
public: public:
/** /**
* Sets a default value, label, and setting value. * Sets a default value, label, and setting value.
* *
* @param linkage Setting registry
* @param default_val Initial value of the setting, and default value of the setting * @param default_val Initial value of the setting, and default value of the setting
* @param name Label for the setting * @param name Label for the setting
* @param category_ Category of the setting AKA INI group
*/ */
explicit SwitchableSetting(const Type& default_val, const std::string& name) explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
Category category)
requires(!ranged) requires(!ranged)
: Setting<Type>{default_val, name} { : Setting<Type, false, save>{linkage, default_val, name, category} {
global_reset_registry.push_front([this]() { this->SetGlobal(true); }); linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
} }
virtual ~SwitchableSetting() = default; virtual ~SwitchableSetting() = default;
/** /**
* Sets a default value, minimum value, maximum value, and label. * Sets a default value, minimum value, maximum value, and label.
* *
* @param linkage Setting registry
* @param default_val Initial value of the setting, and default value of the setting * @param default_val Initial value of the setting, and default value of the setting
* @param min_val Sets the minimum allowed 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 max_val Sets the maximum allowed value of the setting
* @param name Label for the setting * @param name Label for the setting
* @param category_ Category of the setting AKA INI group
*/ */
explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val, explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
const std::string& name) const Type& max_val, const std::string& name, Category category)
requires(ranged) requires(ranged)
: Setting<Type, true>{default_val, min_val, max_val, name} { : Setting<Type, true, save>{linkage, default_val, min_val, max_val, name, category} {
global_reset_registry.push_front([this]() { this->SetGlobal(true); }); linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
} }
/** /**
@ -285,7 +450,7 @@ public:
* *
* @param to_global Whether to use the global or custom setting. * @param to_global Whether to use the global or custom setting.
*/ */
void SetGlobal(bool to_global) { void SetGlobal(bool to_global) override {
use_global = to_global; use_global = to_global;
} }
@ -294,7 +459,7 @@ public:
* *
* @returns The global state * @returns The global state
*/ */
[[nodiscard]] bool UsingGlobal() const { [[nodiscard]] bool UsingGlobal() const override {
return use_global; return use_global;
} }
@ -333,6 +498,10 @@ public:
} }
} }
[[nodiscard]] virtual constexpr bool Switchable() const override {
return true;
}
/** /**
* Assigns the current setting value depending on the global state. * Assigns the current setting value depending on the global state.
* *
@ -405,211 +574,290 @@ struct TouchFromButtonMap {
}; };
struct Values { struct Values {
Linkage linkage{};
// Audio // Audio
Setting<std::string> sink_id{"auto", "output_engine"}; Setting<std::string> sink_id{linkage, "auto", "output_engine", Category::Audio};
Setting<std::string> audio_output_device_id{"auto", "output_device"}; Setting<std::string> audio_output_device_id{linkage, "auto", "output_device", Category::Audio};
Setting<std::string> audio_input_device_id{"auto", "input_device"}; Setting<std::string> audio_input_device_id{linkage, "auto", "input_device", Category::Audio};
Setting<bool> audio_muted{false, "audio_muted"}; Setting<bool, false, false> audio_muted{linkage, false, "audio_muted", Category::Audio};
SwitchableSetting<u8, true> volume{100, 0, 200, "volume"}; SwitchableSetting<u8, true> volume{linkage, 100, 0, 200, "volume", Category::Audio};
Setting<bool> dump_audio_commands{false, "dump_audio_commands"}; Setting<bool, false, false> dump_audio_commands{linkage, false, "dump_audio_commands",
Category::Audio};
// Core // Core
SwitchableSetting<bool> use_multi_core{true, "use_multi_core"}; SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
SwitchableSetting<bool> use_unsafe_extended_memory_layout{false, SwitchableSetting<bool> use_unsafe_extended_memory_layout{
"use_unsafe_extended_memory_layout"}; linkage, false, "use_unsafe_extended_memory_layout", Category::Core};
// Cpu // Cpu
SwitchableSetting<CPUAccuracy, true> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto, SwitchableSetting<CPUAccuracy, true> cpu_accuracy{linkage, CPUAccuracy::Auto,
CPUAccuracy::Paranoid, "cpu_accuracy"}; CPUAccuracy::Auto, CPUAccuracy::Paranoid,
"cpu_accuracy", Category::Cpu};
// TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021 // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
Setting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"}; Setting<bool> cpu_accuracy_first_time{linkage, true, "cpu_accuracy_first_time", Category::Cpu};
Setting<bool> cpu_debug_mode{false, "cpu_debug_mode"}; Setting<bool> cpu_debug_mode{linkage, false, "cpu_debug_mode", Category::Cpu};
Setting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"}; Setting<bool> cpuopt_page_tables{linkage, true, "cpuopt_page_tables", Category::Cpu};
Setting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"}; Setting<bool> cpuopt_block_linking{linkage, true, "cpuopt_block_linking", Category::Cpu};
Setting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"}; Setting<bool> cpuopt_return_stack_buffer{linkage, true, "cpuopt_return_stack_buffer",
Setting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"}; Category::Cpu};
Setting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"}; Setting<bool> cpuopt_fast_dispatcher{linkage, true, "cpuopt_fast_dispatcher", Category::Cpu};
Setting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"}; Setting<bool> cpuopt_context_elimination{linkage, true, "cpuopt_context_elimination",
Setting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"}; Category::Cpu};
Setting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"}; Setting<bool> cpuopt_const_prop{linkage, true, "cpuopt_const_prop", Category::Cpu};
Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"}; Setting<bool> cpuopt_misc_ir{linkage, true, "cpuopt_misc_ir", Category::Cpu};
Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"}; Setting<bool> cpuopt_reduce_misalign_checks{linkage, true, "cpuopt_reduce_misalign_checks",
Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"}; Category::Cpu};
Setting<bool> cpuopt_ignore_memory_aborts{true, "cpuopt_ignore_memory_aborts"}; Setting<bool> cpuopt_fastmem{linkage, true, "cpuopt_fastmem", Category::Cpu};
Setting<bool> cpuopt_fastmem_exclusives{linkage, true, "cpuopt_fastmem_exclusives",
Category::Cpu};
Setting<bool> cpuopt_recompile_exclusives{linkage, true, "cpuopt_recompile_exclusives",
Category::Cpu};
Setting<bool> cpuopt_ignore_memory_aborts{linkage, true, "cpuopt_ignore_memory_aborts",
Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"}; SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"}; Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{ SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
true, "cpuopt_unsafe_ignore_standard_fpcr"}; linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"}; SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{
SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"}; linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{
linkage, true, "cpuopt_unsafe_fastmem_check", Category::Cpu};
SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{ SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
true, "cpuopt_unsafe_ignore_global_monitor"}; linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::Cpu};
// Renderer // Renderer
SwitchableSetting<RendererBackend, true> renderer_backend{ SwitchableSetting<RendererBackend, true> renderer_backend{
RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"}; linkage, RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
SwitchableSetting<bool> async_presentation{false, "async_presentation"}; "backend", Category::Renderer};
SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"}; SwitchableSetting<bool> async_presentation{linkage, false, "async_presentation",
Setting<bool> renderer_debug{false, "debug"}; Category::AdvancedGraphics};
Setting<bool> renderer_shader_feedback{false, "shader_feedback"}; SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"}; Category::AdvancedGraphics};
Setting<bool> disable_shader_loop_safety_checks{false, "disable_shader_loop_safety_checks"}; Setting<bool> renderer_debug{linkage, false, "debug", Category::Renderer};
SwitchableSetting<int> vulkan_device{0, "vulkan_device"}; Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback", Category::Renderer};
Setting<bool> enable_nsight_aftermath{linkage, false, "nsight_aftermath", Category::Renderer};
Setting<bool> disable_shader_loop_safety_checks{
linkage, false, "disable_shader_loop_safety_checks", Category::Renderer};
SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer};
ResolutionScalingInfo resolution_info{}; ResolutionScalingInfo resolution_info{};
SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"}; SwitchableSetting<ResolutionSetup> resolution_setup{linkage, ResolutionSetup::Res1X,
SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"}; "resolution_setup", Category::Renderer};
SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"}; SwitchableSetting<ScalingFilter> scaling_filter{linkage, ScalingFilter::Bilinear,
SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"}; "scaling_filter", Category::Renderer};
SwitchableSetting<int, true> fsr_sharpening_slider{
linkage, 25, 0, 200, "fsr_sharpening_slider", Category::Renderer};
SwitchableSetting<AntiAliasing> anti_aliasing{linkage, AntiAliasing::None, "anti_aliasing",
Category::Renderer};
// *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.
SwitchableSetting<FullscreenMode, true> fullscreen_mode{ SwitchableSetting<FullscreenMode, true> fullscreen_mode{linkage,
#ifdef _WIN32 #ifdef _WIN32
FullscreenMode::Borderless, FullscreenMode::Borderless,
#else #else
FullscreenMode::Exclusive, FullscreenMode::Exclusive,
#endif #endif
FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"}; FullscreenMode::Borderless,
SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"}; FullscreenMode::Exclusive,
SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"}; "fullscreen_mode",
SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"}; Category::Renderer};
SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"}; SwitchableSetting<int, true> aspect_ratio{linkage, 0, 0, 4, "aspect_ratio", Category::Renderer};
SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"}; SwitchableSetting<int, true> max_anisotropy{
SwitchableSetting<GPUAccuracy, true> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal, linkage, 0, 0, 5, "max_anisotropy", Category::AdvancedGraphics};
GPUAccuracy::Extreme, "gpu_accuracy"}; SwitchableSetting<bool, false, false> use_speed_limit{linkage, true, "use_speed_limit",
SwitchableSetting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"}; Category::Renderer};
SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"}; SwitchableSetting<u16, true> speed_limit{linkage, 100, 0,
SwitchableSetting<AstcDecodeMode, true> accelerate_astc{ 9999, "speed_limit", Category::Renderer};
AstcDecodeMode::CPU, AstcDecodeMode::CPU, AstcDecodeMode::CPUAsynchronous, SwitchableSetting<bool> use_disk_shader_cache{linkage, true, "use_disk_shader_cache",
"accelerate_astc"}; Category::Renderer};
Setting<VSyncMode, true> vsync_mode{VSyncMode::FIFO, VSyncMode::Immediate, SwitchableSetting<GPUAccuracy, true> gpu_accuracy{
VSyncMode::FIFORelaxed, "use_vsync"}; linkage, GPUAccuracy::High, GPUAccuracy::Normal, GPUAccuracy::Extreme,
SwitchableSetting<bool> use_reactive_flushing{true, "use_reactive_flushing"}; "gpu_accuracy", Category::AdvancedGraphics};
SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL, SwitchableSetting<bool> use_asynchronous_gpu_emulation{
ShaderBackend::SPIRV, "shader_backend"}; linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"}; SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::GPU,
SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"}; "nvdec_emulation", Category::Renderer};
SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true, SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
"use_vulkan_driver_pipeline_cache"}; AstcDecodeMode::CPU,
SwitchableSetting<bool> enable_compute_pipelines{false, "enable_compute_pipelines"}; AstcDecodeMode::CPU,
SwitchableSetting<AstcRecompression, true> astc_recompression{ AstcDecodeMode::CPUAsynchronous,
AstcRecompression::Uncompressed, AstcRecompression::Uncompressed, AstcRecompression::Bc3, "accelerate_astc",
"astc_recompression"}; Category::Renderer};
SwitchableSetting<bool> use_video_framerate{false, "use_video_framerate"}; Setting<VSyncMode, true> vsync_mode{
SwitchableSetting<bool> barrier_feedback_loops{true, "barrier_feedback_loops"}; linkage, VSyncMode::FIFO, VSyncMode::Immediate, VSyncMode::FIFORelaxed,
"use_vsync", Category::Renderer};
SwitchableSetting<bool> use_reactive_flushing{linkage, true, "use_reactive_flushing",
Category::Renderer};
SwitchableSetting<ShaderBackend, true> shader_backend{
linkage, ShaderBackend::GLSL, ShaderBackend::GLSL, ShaderBackend::SPIRV,
"shader_backend", Category::Renderer};
SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
Category::Renderer};
SwitchableSetting<bool> use_fast_gpu_time{linkage, true, "use_fast_gpu_time",
Category::AdvancedGraphics};
SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{
linkage, true, "use_vulkan_driver_pipeline_cache", Category::AdvancedGraphics};
SwitchableSetting<bool> enable_compute_pipelines{linkage, false, "enable_compute_pipelines",
Category::AdvancedGraphics};
SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
AstcRecompression::Uncompressed,
AstcRecompression::Uncompressed,
AstcRecompression::Bc3,
"astc_recompression",
Category::AdvancedGraphics};
SwitchableSetting<bool> use_video_framerate{linkage, false, "use_video_framerate",
Category::AdvancedGraphics};
SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
Category::AdvancedGraphics};
SwitchableSetting<u8> bg_red{0, "bg_red"}; SwitchableSetting<u8> bg_red{linkage, 0, "bg_red", Category::Renderer};
SwitchableSetting<u8> bg_green{0, "bg_green"}; SwitchableSetting<u8> bg_green{linkage, 0, "bg_green", Category::Renderer};
SwitchableSetting<u8> bg_blue{0, "bg_blue"}; SwitchableSetting<u8> bg_blue{linkage, 0, "bg_blue", Category::Renderer};
// System // System
SwitchableSetting<bool> rng_seed_enabled{false, "rng_seed_enabled"}; SwitchableSetting<bool> rng_seed_enabled{linkage, false, "rng_seed_enabled", Category::System};
SwitchableSetting<u32> rng_seed{0, "rng_seed"}; SwitchableSetting<u32> rng_seed{linkage, 0, "rng_seed", Category::System};
Setting<std::string> device_name{"Yuzu", "device_name"}; Setting<std::string> device_name{linkage, "Yuzu", "device_name", Category::System};
// Measured in seconds since epoch // Measured in seconds since epoch
SwitchableSetting<bool> custom_rtc_enabled{false, "custom_rtc_enabled"}; Setting<bool> custom_rtc_enabled{linkage, false, "custom_rtc_enabled", Category::System};
SwitchableSetting<s64> custom_rtc{0, "custom_rtc"}; Setting<s64> custom_rtc{linkage, 0, "custom_rtc", Category::System};
// 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;
Setting<s32> current_user{0, "current_user"}; Setting<s32> current_user{linkage, 0, "current_user", Category::System};
SwitchableSetting<s32, true> language_index{1, 0, 17, "language_index"}; SwitchableSetting<s32, true> language_index{linkage, 1, 0, 17, "language_index",
SwitchableSetting<s32, true> region_index{1, 0, 6, "region_index"}; Category::System};
SwitchableSetting<s32, true> time_zone_index{0, 0, 45, "time_zone_index"}; SwitchableSetting<s32, true> region_index{linkage, 1, 0, 6, "region_index", Category::System};
SwitchableSetting<s32, true> sound_index{1, 0, 2, "sound_index"}; SwitchableSetting<s32, true> time_zone_index{linkage, 0, 0, 45, "time_zone_index",
Category::System};
SwitchableSetting<s32, true> sound_index{linkage, 1, 0, 2, "sound_index", Category::System};
SwitchableSetting<bool> use_docked_mode{linkage, true, "use_docked_mode", Category::System};
// Controls // Controls
InputSetting<std::array<PlayerInput, 10>> players; InputSetting<std::array<PlayerInput, 10>> players;
SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"}; Setting<bool, false,
// Only read/write enable_raw_input on Windows platforms
#ifdef _WIN32
true
#else
false
#endif
>
enable_raw_input{linkage, false, "enable_raw_input", Category::Controls};
Setting<bool> controller_navigation{linkage, true, "controller_navigation", Category::Controls};
Setting<bool> enable_joycon_driver{linkage, true, "enable_joycon_driver", Category::Controls};
Setting<bool> enable_procon_driver{linkage, false, "enable_procon_driver", Category::Controls};
Setting<bool> enable_raw_input{false, "enable_raw_input"}; SwitchableSetting<bool> vibration_enabled{linkage, true, "vibration_enabled",
Setting<bool> controller_navigation{true, "controller_navigation"}; Category::Controls};
Setting<bool> enable_joycon_driver{true, "enable_joycon_driver"}; SwitchableSetting<bool> enable_accurate_vibrations{linkage, false, "enable_accurate_vibrations",
Setting<bool> enable_procon_driver{false, "enable_procon_driver"}; Category::Controls};
SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"}; SwitchableSetting<bool> motion_enabled{linkage, true, "motion_enabled", Category::Controls};
SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"}; Setting<std::string> udp_input_servers{linkage, "127.0.0.1:26760", "udp_input_servers",
Category::Controls};
Setting<bool> enable_udp_controller{linkage, false, "enable_udp_controller",
Category::Controls};
SwitchableSetting<bool> motion_enabled{true, "motion_enabled"}; Setting<bool> pause_tas_on_load{linkage, true, "pause_tas_on_load", Category::Controls};
Setting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"}; Setting<bool> tas_enable{linkage, false, "tas_enable", Category::Controls};
Setting<bool> enable_udp_controller{false, "enable_udp_controller"}; Setting<bool> tas_loop{linkage, false, "tas_loop", Category::Controls};
Setting<bool> pause_tas_on_load{true, "pause_tas_on_load"}; Setting<bool, false, false> mouse_panning{linkage, false, "mouse_panning", Category::Controls};
Setting<bool> tas_enable{false, "tas_enable"}; Setting<u8, true> mouse_panning_sensitivity{
Setting<bool> tas_loop{false, "tas_loop"}; linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
Setting<bool> mouse_enabled{linkage, false, "mouse_enabled", Category::Controls};
Setting<bool> mouse_panning{false, "mouse_panning"}; Setting<u8, true> mouse_panning_x_sensitivity{
Setting<u8, true> mouse_panning_x_sensitivity{50, 1, 100, "mouse_panning_x_sensitivity"}; linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
Setting<u8, true> mouse_panning_y_sensitivity{50, 1, 100, "mouse_panning_y_sensitivity"}; Setting<u8, true> mouse_panning_y_sensitivity{
Setting<u8, true> mouse_panning_deadzone_counterweight{20, 0, 100, linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
"mouse_panning_deadzone_counterweight"}; Setting<u8, true> mouse_panning_deadzone_counterweight{
Setting<u8, true> mouse_panning_decay_strength{18, 0, 100, "mouse_panning_decay_strength"}; linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
Setting<u8, true> mouse_panning_min_decay{6, 0, 100, "mouse_panning_min_decay"}; Setting<u8, true> mouse_panning_decay_strength{
linkage, 18, 0, 100, "mouse_panning_decay_strength", Category::Controls};
Setting<u8, true> mouse_panning_min_decay{
linkage, 6, 0, 100, "mouse_panning_min_decay", Category::Controls};
Setting<bool> mouse_enabled{false, "mouse_enabled"}; Setting<bool> emulate_analog_keyboard{linkage, false, "emulate_analog_keyboard",
Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"}; Category::Controls};
Setting<bool> keyboard_enabled{false, "keyboard_enabled"}; Setting<bool> keyboard_enabled{linkage, false, "keyboard_enabled", Category::Controls};
Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"}; Setting<bool> debug_pad_enabled{linkage, false, "debug_pad_enabled", Category::Controls};
ButtonsRaw debug_pad_buttons; ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs; AnalogsRaw debug_pad_analogs;
TouchscreenInput touchscreen; TouchscreenInput touchscreen;
Setting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", "touch_device"}; Setting<std::string> touch_device{linkage, "min_x:100,min_y:50,max_x:1800,max_y:850",
Setting<int> touch_from_button_map_index{0, "touch_from_button_map"}; "touch_device", Category::Controls};
Setting<int> touch_from_button_map_index{linkage, 0, "touch_from_button_map",
Category::Controls};
std::vector<TouchFromButtonMap> touch_from_button_maps; std::vector<TouchFromButtonMap> touch_from_button_maps;
Setting<bool> enable_ring_controller{true, "enable_ring_controller"}; Setting<bool> enable_ring_controller{linkage, true, "enable_ring_controller",
Category::Controls};
RingconRaw ringcon_analogs; RingconRaw ringcon_analogs;
Setting<bool> enable_ir_sensor{false, "enable_ir_sensor"}; Setting<bool> enable_ir_sensor{linkage, false, "enable_ir_sensor", Category::Controls};
Setting<std::string> ir_sensor_device{"auto", "ir_sensor_device"}; Setting<std::string> ir_sensor_device{linkage, "auto", "ir_sensor_device", Category::Controls};
Setting<bool> random_amiibo_id{false, "random_amiibo_id"}; Setting<bool> random_amiibo_id{linkage, false, "random_amiibo_id", Category::Controls};
// Data Storage // Data Storage
Setting<bool> use_virtual_sd{true, "use_virtual_sd"}; Setting<bool> use_virtual_sd{linkage, true, "use_virtual_sd", Category::DataStorage};
Setting<bool> gamecard_inserted{false, "gamecard_inserted"}; Setting<bool> gamecard_inserted{linkage, false, "gamecard_inserted", Category::DataStorage};
Setting<bool> gamecard_current_game{false, "gamecard_current_game"}; Setting<bool> gamecard_current_game{linkage, false, "gamecard_current_game",
Setting<std::string> gamecard_path{std::string(), "gamecard_path"}; Category::DataStorage};
Setting<std::string> gamecard_path{linkage, std::string(), "gamecard_path",
Category::DataStorage};
// Debugging // Debugging
bool record_frame_times; bool record_frame_times;
Setting<bool> use_gdbstub{false, "use_gdbstub"}; Setting<bool> use_gdbstub{linkage, false, "use_gdbstub", Category::Debugging};
Setting<u16> gdbstub_port{6543, "gdbstub_port"}; Setting<u16> gdbstub_port{linkage, 6543, "gdbstub_port", Category::Debugging};
Setting<std::string> program_args{std::string(), "program_args"}; Setting<std::string> program_args{linkage, std::string(), "program_args", Category::Debugging};
Setting<bool> dump_exefs{false, "dump_exefs"}; Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
Setting<bool> dump_nso{false, "dump_nso"}; Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
Setting<bool> dump_shaders{false, "dump_shaders"}; Setting<bool, false, false> dump_shaders{linkage, false, "dump_shaders", Category::Debugging};
Setting<bool> dump_macros{false, "dump_macros"}; Setting<bool, false, false> dump_macros{linkage, false, "dump_macros", Category::Debugging};
Setting<bool> enable_fs_access_log{false, "enable_fs_access_log"}; Setting<bool> enable_fs_access_log{linkage, false, "enable_fs_access_log", Category::Debugging};
Setting<bool> reporting_services{false, "reporting_services"}; Setting<bool, false, false> reporting_services{linkage, false, "reporting_services",
Setting<bool> quest_flag{false, "quest_flag"}; Category::Debugging};
Setting<bool> disable_macro_jit{false, "disable_macro_jit"}; Setting<bool> quest_flag{linkage, false, "quest_flag", Category::Debugging};
Setting<bool> disable_macro_hle{false, "disable_macro_hle"}; Setting<bool> disable_macro_jit{linkage, false, "disable_macro_jit", Category::Debugging};
Setting<bool> extended_logging{false, "extended_logging"}; Setting<bool> disable_macro_hle{linkage, false, "disable_macro_hle", Category::Debugging};
Setting<bool> use_debug_asserts{false, "use_debug_asserts"}; Setting<bool, false, false> extended_logging{linkage, false, "extended_logging",
Setting<bool> use_auto_stub{false, "use_auto_stub"}; Category::Debugging};
Setting<bool> enable_all_controllers{false, "enable_all_controllers"}; Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
Setting<bool> create_crash_dumps{false, "create_crash_dumps"}; Setting<bool, false, false> use_auto_stub{linkage, false, "use_auto_stub", Category::Debugging};
Setting<bool> perform_vulkan_check{true, "perform_vulkan_check"}; Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
Category::Debugging};
Setting<bool> create_crash_dumps{linkage, false, "create_crash_dumps", Category::Debugging};
Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};
// Miscellaneous // Miscellaneous
Setting<std::string> log_filter{"*:Info", "log_filter"}; Setting<std::string> log_filter{linkage, "*:Info", "log_filter", Category::Miscellaneous};
Setting<bool> use_dev_keys{false, "use_dev_keys"}; Setting<bool> use_dev_keys{linkage, false, "use_dev_keys", Category::Miscellaneous};
// Network // Network
Setting<std::string> network_interface{std::string(), "network_interface"}; Setting<std::string> network_interface{linkage, std::string(), "network_interface",
Category::Network};
// WebService // WebService
Setting<bool> enable_telemetry{true, "enable_telemetry"}; Setting<bool> enable_telemetry{linkage, true, "enable_telemetry", Category::WebService};
Setting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"}; Setting<std::string> web_api_url{linkage, "https://api.yuzu-emu.org", "web_api_url",
Setting<std::string> yuzu_username{std::string(), "yuzu_username"}; Category::WebService};
Setting<std::string> yuzu_token{std::string(), "yuzu_token"}; Setting<std::string> yuzu_username{linkage, std::string(), "yuzu_username",
Category::WebService};
Setting<std::string> yuzu_token{linkage, std::string(), "yuzu_token", Category::WebService};
// Add-Ons // Add-Ons
std::map<u64, std::vector<std::string>> disabled_addons; std::map<u64, std::vector<std::string>> disabled_addons;

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

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2014 Citra Emulator Project // SPDX-FileCopyrightText: 2014 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include <algorithm>
#include <array> #include <array>
#include <QKeySequence> #include <QKeySequence>
#include <QSettings> #include <QSettings>
@ -16,8 +17,11 @@
namespace FS = Common::FS; namespace FS = Common::FS;
Config::Config(const std::string& config_name, ConfigType config_type) : type(config_type) { Config::Config(const std::string& config_name, ConfigType config_type)
global = config_type == ConfigType::GlobalConfig; : type(config_type), global{config_type == ConfigType::GlobalConfig} {
settings_map = Settings::values.linkage.by_category;
settings_map.merge(UISettings::values.linkage.by_category);
Initialize(config_name); Initialize(config_name);
} }
@ -351,15 +355,9 @@ void Config::ReadPlayerValue(std::size_t player_index) {
player_motions = default_param; player_motions = default_param;
} }
} }
if (player_index == 0) {
ReadMousePanningValues();
}
} }
void Config::ReadDebugValues() { void Config::ReadDebugValues() {
ReadBasicSetting(Settings::values.debug_pad_enabled);
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) { for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]); const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i]; auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
@ -393,14 +391,6 @@ void Config::ReadDebugValues() {
} }
} }
void Config::ReadKeyboardValues() {
ReadBasicSetting(Settings::values.keyboard_enabled);
}
void Config::ReadMouseValues() {
ReadBasicSetting(Settings::values.mouse_enabled);
}
void Config::ReadTouchscreenValues() { void Config::ReadTouchscreenValues() {
Settings::values.touchscreen.enabled = Settings::values.touchscreen.enabled =
ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool(); ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool();
@ -414,9 +404,6 @@ void Config::ReadTouchscreenValues() {
} }
void Config::ReadHidbusValues() { void Config::ReadHidbusValues() {
Settings::values.enable_ring_controller =
ReadSetting(QStringLiteral("enable_ring_controller"), true).toBool();
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys( const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f); 0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
auto& ringcon_analogs = Settings::values.ringcon_analogs; auto& ringcon_analogs = Settings::values.ringcon_analogs;
@ -430,20 +417,10 @@ void Config::ReadHidbusValues() {
} }
} }
void Config::ReadIrCameraValues() {
ReadBasicSetting(Settings::values.enable_ir_sensor);
ReadBasicSetting(Settings::values.ir_sensor_device);
}
void Config::ReadAudioValues() { void Config::ReadAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio")); qt_config->beginGroup(QStringLiteral("Audio"));
if (global) { ReadCategory(Settings::Category::Audio);
ReadBasicSetting(Settings::values.sink_id);
ReadBasicSetting(Settings::values.audio_output_device_id);
ReadBasicSetting(Settings::values.audio_input_device_id);
}
ReadGlobalSetting(Settings::values.volume);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -451,11 +428,12 @@ void Config::ReadAudioValues() {
void Config::ReadControlValues() { void Config::ReadControlValues() {
qt_config->beginGroup(QStringLiteral("Controls")); qt_config->beginGroup(QStringLiteral("Controls"));
ReadCategory(Settings::Category::Controls);
Settings::values.players.SetGlobal(!IsCustomConfig()); Settings::values.players.SetGlobal(!IsCustomConfig());
for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) { for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
ReadPlayerValue(p); ReadPlayerValue(p);
} }
ReadGlobalSetting(Settings::values.use_docked_mode);
// Disable docked mode if handheld is selected // Disable docked mode if handheld is selected
const auto controller_type = Settings::values.players.GetValue()[0].controller_type; const auto controller_type = Settings::values.players.GetValue()[0].controller_type;
@ -464,50 +442,18 @@ void Config::ReadControlValues() {
Settings::values.use_docked_mode.SetValue(false); Settings::values.use_docked_mode.SetValue(false);
} }
ReadGlobalSetting(Settings::values.vibration_enabled);
ReadGlobalSetting(Settings::values.enable_accurate_vibrations);
ReadGlobalSetting(Settings::values.motion_enabled);
if (IsCustomConfig()) { if (IsCustomConfig()) {
qt_config->endGroup(); qt_config->endGroup();
return; return;
} }
ReadDebugValues(); ReadDebugValues();
ReadKeyboardValues();
ReadMouseValues();
ReadTouchscreenValues(); ReadTouchscreenValues();
ReadMousePanningValues();
ReadMotionTouchValues(); ReadMotionTouchValues();
ReadHidbusValues(); ReadHidbusValues();
ReadIrCameraValues();
#ifdef _WIN32
ReadBasicSetting(Settings::values.enable_raw_input);
#else
Settings::values.enable_raw_input = false;
#endif
ReadBasicSetting(Settings::values.emulate_analog_keyboard);
ReadBasicSetting(Settings::values.enable_joycon_driver);
ReadBasicSetting(Settings::values.enable_procon_driver);
ReadBasicSetting(Settings::values.random_amiibo_id);
ReadBasicSetting(Settings::values.tas_enable);
ReadBasicSetting(Settings::values.tas_loop);
ReadBasicSetting(Settings::values.pause_tas_on_load);
ReadBasicSetting(Settings::values.controller_navigation);
qt_config->endGroup(); qt_config->endGroup();
} }
void Config::ReadMousePanningValues() {
ReadBasicSetting(Settings::values.mouse_panning);
ReadBasicSetting(Settings::values.mouse_panning_x_sensitivity);
ReadBasicSetting(Settings::values.mouse_panning_y_sensitivity);
ReadBasicSetting(Settings::values.mouse_panning_deadzone_counterweight);
ReadBasicSetting(Settings::values.mouse_panning_decay_strength);
ReadBasicSetting(Settings::values.mouse_panning_min_decay);
}
void Config::ReadMotionTouchValues() { void Config::ReadMotionTouchValues() {
int num_touch_from_button_maps = int num_touch_from_button_maps =
qt_config->beginReadArray(QStringLiteral("touch_from_button_maps")); qt_config->beginReadArray(QStringLiteral("touch_from_button_maps"));
@ -541,19 +487,14 @@ void Config::ReadMotionTouchValues() {
} }
qt_config->endArray(); qt_config->endArray();
ReadBasicSetting(Settings::values.touch_device);
ReadBasicSetting(Settings::values.touch_from_button_map_index);
Settings::values.touch_from_button_map_index = std::clamp( Settings::values.touch_from_button_map_index = std::clamp(
Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1); Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
ReadBasicSetting(Settings::values.udp_input_servers);
ReadBasicSetting(Settings::values.enable_udp_controller);
} }
void Config::ReadCoreValues() { void Config::ReadCoreValues() {
qt_config->beginGroup(QStringLiteral("Core")); qt_config->beginGroup(QStringLiteral("Core"));
ReadGlobalSetting(Settings::values.use_multi_core); ReadCategory(Settings::Category::Core);
ReadGlobalSetting(Settings::values.use_unsafe_extended_memory_layout);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -561,7 +502,6 @@ void Config::ReadCoreValues() {
void Config::ReadDataStorageValues() { void Config::ReadDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage")); qt_config->beginGroup(QStringLiteral("Data Storage"));
ReadBasicSetting(Settings::values.use_virtual_sd);
FS::SetYuzuPath( FS::SetYuzuPath(
FS::YuzuPath::NANDDir, FS::YuzuPath::NANDDir,
qt_config qt_config
@ -597,9 +537,7 @@ void Config::ReadDataStorageValues() {
.toString() .toString()
.toStdString()); .toStdString());
ReadBasicSetting(Settings::values.gamecard_inserted); ReadCategory(Settings::Category::DataStorage);
ReadBasicSetting(Settings::values.gamecard_current_game);
ReadBasicSetting(Settings::values.gamecard_path);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -611,29 +549,16 @@ void Config::ReadDebuggingValues() {
Settings::values.record_frame_times = Settings::values.record_frame_times =
qt_config->value(QStringLiteral("record_frame_times"), false).toBool(); qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
ReadBasicSetting(Settings::values.use_gdbstub); ReadCategory(Settings::Category::Debugging);
ReadBasicSetting(Settings::values.gdbstub_port);
ReadBasicSetting(Settings::values.program_args);
ReadBasicSetting(Settings::values.dump_exefs);
ReadBasicSetting(Settings::values.dump_nso);
ReadBasicSetting(Settings::values.enable_fs_access_log);
ReadBasicSetting(Settings::values.reporting_services);
ReadBasicSetting(Settings::values.quest_flag);
ReadBasicSetting(Settings::values.disable_macro_jit);
ReadBasicSetting(Settings::values.disable_macro_hle);
ReadBasicSetting(Settings::values.extended_logging);
ReadBasicSetting(Settings::values.use_debug_asserts);
ReadBasicSetting(Settings::values.use_auto_stub);
ReadBasicSetting(Settings::values.enable_all_controllers);
ReadBasicSetting(Settings::values.create_crash_dumps);
ReadBasicSetting(Settings::values.perform_vulkan_check);
qt_config->endGroup(); qt_config->endGroup();
} }
void Config::ReadServiceValues() { void Config::ReadServiceValues() {
qt_config->beginGroup(QStringLiteral("Services")); qt_config->beginGroup(QStringLiteral("Services"));
ReadBasicSetting(Settings::values.network_interface);
ReadCategory(Settings::Category::Services);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -659,8 +584,7 @@ void Config::ReadDisabledAddOnValues() {
void Config::ReadMiscellaneousValues() { void Config::ReadMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous")); qt_config->beginGroup(QStringLiteral("Miscellaneous"));
ReadBasicSetting(Settings::values.log_filter); ReadCategory(Settings::Category::Miscellaneous);
ReadBasicSetting(Settings::values.use_dev_keys);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -710,35 +634,11 @@ void Config::ReadPathValues() {
void Config::ReadCpuValues() { void Config::ReadCpuValues() {
qt_config->beginGroup(QStringLiteral("Cpu")); qt_config->beginGroup(QStringLiteral("Cpu"));
ReadBasicSetting(Settings::values.cpu_accuracy_first_time); ReadCategory(Settings::Category::Cpu);
if (Settings::values.cpu_accuracy_first_time) { if (Settings::values.cpu_accuracy_first_time) {
Settings::values.cpu_accuracy.SetValue(Settings::values.cpu_accuracy.GetDefault()); Settings::values.cpu_accuracy.SetValue(Settings::values.cpu_accuracy.GetDefault());
Settings::values.cpu_accuracy_first_time.SetValue(false); Settings::values.cpu_accuracy_first_time.SetValue(false);
} else {
ReadGlobalSetting(Settings::values.cpu_accuracy);
}
ReadGlobalSetting(Settings::values.cpuopt_unsafe_unfuse_fma);
ReadGlobalSetting(Settings::values.cpuopt_unsafe_reduce_fp_error);
ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
ReadGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
ReadGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
if (global) {
ReadBasicSetting(Settings::values.cpu_debug_mode);
ReadBasicSetting(Settings::values.cpuopt_page_tables);
ReadBasicSetting(Settings::values.cpuopt_block_linking);
ReadBasicSetting(Settings::values.cpuopt_return_stack_buffer);
ReadBasicSetting(Settings::values.cpuopt_fast_dispatcher);
ReadBasicSetting(Settings::values.cpuopt_context_elimination);
ReadBasicSetting(Settings::values.cpuopt_const_prop);
ReadBasicSetting(Settings::values.cpuopt_misc_ir);
ReadBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
ReadBasicSetting(Settings::values.cpuopt_fastmem);
ReadBasicSetting(Settings::values.cpuopt_fastmem_exclusives);
ReadBasicSetting(Settings::values.cpuopt_recompile_exclusives);
ReadBasicSetting(Settings::values.cpuopt_ignore_memory_aborts);
} }
qt_config->endGroup(); qt_config->endGroup();
@ -747,45 +647,8 @@ void Config::ReadCpuValues() {
void Config::ReadRendererValues() { void Config::ReadRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer")); qt_config->beginGroup(QStringLiteral("Renderer"));
ReadGlobalSetting(Settings::values.renderer_backend); ReadCategory(Settings::Category::Renderer);
ReadGlobalSetting(Settings::values.async_presentation); ReadCategory(Settings::Category::AdvancedGraphics);
ReadGlobalSetting(Settings::values.renderer_force_max_clock);
ReadGlobalSetting(Settings::values.vulkan_device);
ReadGlobalSetting(Settings::values.fullscreen_mode);
ReadGlobalSetting(Settings::values.aspect_ratio);
ReadGlobalSetting(Settings::values.resolution_setup);
ReadGlobalSetting(Settings::values.scaling_filter);
ReadGlobalSetting(Settings::values.fsr_sharpening_slider);
ReadGlobalSetting(Settings::values.anti_aliasing);
ReadGlobalSetting(Settings::values.max_anisotropy);
ReadGlobalSetting(Settings::values.speed_limit);
ReadGlobalSetting(Settings::values.use_disk_shader_cache);
ReadGlobalSetting(Settings::values.gpu_accuracy);
ReadGlobalSetting(Settings::values.use_asynchronous_gpu_emulation);
ReadGlobalSetting(Settings::values.nvdec_emulation);
ReadGlobalSetting(Settings::values.accelerate_astc);
ReadGlobalSetting(Settings::values.astc_recompression);
ReadGlobalSetting(Settings::values.use_reactive_flushing);
ReadGlobalSetting(Settings::values.use_asynchronous_shaders);
ReadGlobalSetting(Settings::values.use_fast_gpu_time);
ReadGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
ReadGlobalSetting(Settings::values.enable_compute_pipelines);
ReadGlobalSetting(Settings::values.use_video_framerate);
ReadGlobalSetting(Settings::values.barrier_feedback_loops);
ReadGlobalSetting(Settings::values.bg_red);
ReadGlobalSetting(Settings::values.bg_green);
ReadGlobalSetting(Settings::values.bg_blue);
if (global) {
Settings::values.vsync_mode.SetValue(static_cast<Settings::VSyncMode>(
ReadSetting(QString::fromStdString(Settings::values.vsync_mode.GetLabel()),
static_cast<u32>(Settings::values.vsync_mode.GetDefault()))
.value<u32>()));
ReadBasicSetting(Settings::values.renderer_debug);
ReadBasicSetting(Settings::values.renderer_shader_feedback);
ReadBasicSetting(Settings::values.enable_nsight_aftermath);
ReadBasicSetting(Settings::values.disable_shader_loop_safety_checks);
}
qt_config->endGroup(); qt_config->endGroup();
} }
@ -832,41 +695,7 @@ void Config::ReadShortcutValues() {
void Config::ReadSystemValues() { void Config::ReadSystemValues() {
qt_config->beginGroup(QStringLiteral("System")); qt_config->beginGroup(QStringLiteral("System"));
ReadGlobalSetting(Settings::values.language_index); ReadCategory(Settings::Category::System);
ReadGlobalSetting(Settings::values.region_index);
ReadGlobalSetting(Settings::values.time_zone_index);
bool rng_seed_enabled;
ReadSettingGlobal(rng_seed_enabled, QStringLiteral("rng_seed_enabled"), false);
bool rng_seed_global =
global || qt_config->value(QStringLiteral("rng_seed/use_global"), true).toBool();
Settings::values.rng_seed.SetGlobal(rng_seed_global);
if (global || !rng_seed_global) {
if (rng_seed_enabled) {
Settings::values.rng_seed.SetValue(ReadSetting(QStringLiteral("rng_seed"), 0).toUInt());
} else {
Settings::values.rng_seed.SetValue(std::nullopt);
}
}
if (global) {
ReadBasicSetting(Settings::values.current_user);
Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
Service::Account::MAX_USERS - 1);
const auto custom_rtc_enabled =
ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
if (custom_rtc_enabled) {
Settings::values.custom_rtc = ReadSetting(QStringLiteral("custom_rtc"), 0).toLongLong();
} else {
Settings::values.custom_rtc = std::nullopt;
}
ReadBasicSetting(Settings::values.device_name);
}
ReadGlobalSetting(Settings::values.sound_index);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -879,8 +708,6 @@ void Config::ReadUIValues() {
QStringLiteral("theme"), QStringLiteral("theme"),
QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second)) QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second))
.toString(); .toString();
ReadBasicSetting(UISettings::values.enable_discord_presence);
ReadBasicSetting(UISettings::values.select_user_on_boot);
ReadUIGamelistValues(); ReadUIGamelistValues();
ReadUILayoutValues(); ReadUILayoutValues();
@ -889,20 +716,7 @@ void Config::ReadUIValues() {
ReadShortcutValues(); ReadShortcutValues();
ReadMultiplayerValues(); ReadMultiplayerValues();
ReadBasicSetting(UISettings::values.single_window_mode); ReadCategory(Settings::Category::Ui);
ReadBasicSetting(UISettings::values.fullscreen);
ReadBasicSetting(UISettings::values.display_titlebar);
ReadBasicSetting(UISettings::values.show_filter_bar);
ReadBasicSetting(UISettings::values.show_status_bar);
ReadBasicSetting(UISettings::values.confirm_before_closing);
ReadBasicSetting(UISettings::values.first_start);
ReadBasicSetting(UISettings::values.callout_flags);
ReadBasicSetting(UISettings::values.show_console);
ReadBasicSetting(UISettings::values.pause_when_in_background);
ReadBasicSetting(UISettings::values.mute_when_in_background);
ReadBasicSetting(UISettings::values.hide_mouse);
ReadBasicSetting(UISettings::values.controller_applet_disabled);
ReadBasicSetting(UISettings::values.disable_web_applet);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -910,16 +724,8 @@ void Config::ReadUIValues() {
void Config::ReadUIGamelistValues() { void Config::ReadUIGamelistValues() {
qt_config->beginGroup(QStringLiteral("UIGameList")); qt_config->beginGroup(QStringLiteral("UIGameList"));
ReadBasicSetting(UISettings::values.show_add_ons); ReadCategory(Settings::Category::UiGameList);
ReadBasicSetting(UISettings::values.show_compat);
ReadBasicSetting(UISettings::values.show_size);
ReadBasicSetting(UISettings::values.show_types);
ReadBasicSetting(UISettings::values.game_icon_size);
ReadBasicSetting(UISettings::values.folder_icon_size);
ReadBasicSetting(UISettings::values.row_1_text_id);
ReadBasicSetting(UISettings::values.row_2_text_id);
ReadBasicSetting(UISettings::values.cache_game_list);
ReadBasicSetting(UISettings::values.favorites_expanded);
const int favorites_size = qt_config->beginReadArray(QStringLiteral("favorites")); const int favorites_size = qt_config->beginReadArray(QStringLiteral("favorites"));
for (int i = 0; i < favorites_size; i++) { for (int i = 0; i < favorites_size; i++) {
qt_config->setArrayIndex(i); qt_config->setArrayIndex(i);
@ -942,7 +748,8 @@ void Config::ReadUILayoutValues() {
ReadSetting(QStringLiteral("gameListHeaderState")).toByteArray(); ReadSetting(QStringLiteral("gameListHeaderState")).toByteArray();
UISettings::values.microprofile_geometry = UISettings::values.microprofile_geometry =
ReadSetting(QStringLiteral("microProfileDialogGeometry")).toByteArray(); ReadSetting(QStringLiteral("microProfileDialogGeometry")).toByteArray();
ReadBasicSetting(UISettings::values.microprofile_visible);
ReadCategory(Settings::Category::UiLayout);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -950,10 +757,7 @@ void Config::ReadUILayoutValues() {
void Config::ReadWebServiceValues() { void Config::ReadWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService")); qt_config->beginGroup(QStringLiteral("WebService"));
ReadBasicSetting(Settings::values.enable_telemetry); ReadCategory(Settings::Category::WebService);
ReadBasicSetting(Settings::values.web_api_url);
ReadBasicSetting(Settings::values.yuzu_username);
ReadBasicSetting(Settings::values.yuzu_token);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -961,17 +765,7 @@ void Config::ReadWebServiceValues() {
void Config::ReadMultiplayerValues() { void Config::ReadMultiplayerValues() {
qt_config->beginGroup(QStringLiteral("Multiplayer")); qt_config->beginGroup(QStringLiteral("Multiplayer"));
ReadBasicSetting(UISettings::values.multiplayer_nickname); ReadCategory(Settings::Category::Multiplayer);
ReadBasicSetting(UISettings::values.multiplayer_ip);
ReadBasicSetting(UISettings::values.multiplayer_port);
ReadBasicSetting(UISettings::values.multiplayer_room_nickname);
ReadBasicSetting(UISettings::values.multiplayer_room_name);
ReadBasicSetting(UISettings::values.multiplayer_room_port);
ReadBasicSetting(UISettings::values.multiplayer_host_type);
ReadBasicSetting(UISettings::values.multiplayer_port);
ReadBasicSetting(UISettings::values.multiplayer_max_player);
ReadBasicSetting(UISettings::values.multiplayer_game_id);
ReadBasicSetting(UISettings::values.multiplayer_room_description);
// Read ban list back // Read ban list back
int size = qt_config->beginReadArray(QStringLiteral("username_ban_list")); int size = qt_config->beginReadArray(QStringLiteral("username_ban_list"));
@ -1075,14 +869,9 @@ void Config::SavePlayerValue(std::size_t player_index) {
QString::fromStdString(player.motions[i]), QString::fromStdString(player.motions[i]),
QString::fromStdString(default_param)); QString::fromStdString(default_param));
} }
if (player_index == 0) {
SaveMousePanningValues();
}
} }
void Config::SaveDebugValues() { void Config::SaveDebugValues() {
WriteBasicSetting(Settings::values.debug_pad_enabled);
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) { for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]); const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
WriteSetting(QStringLiteral("debug_pad_") + WriteSetting(QStringLiteral("debug_pad_") +
@ -1101,10 +890,6 @@ void Config::SaveDebugValues() {
} }
} }
void Config::SaveMouseValues() {
WriteBasicSetting(Settings::values.mouse_enabled);
}
void Config::SaveTouchscreenValues() { void Config::SaveTouchscreenValues() {
const auto& touchscreen = Settings::values.touchscreen; const auto& touchscreen = Settings::values.touchscreen;
@ -1115,21 +900,7 @@ void Config::SaveTouchscreenValues() {
WriteSetting(QStringLiteral("touchscreen_diameter_y"), touchscreen.diameter_y, 15); WriteSetting(QStringLiteral("touchscreen_diameter_y"), touchscreen.diameter_y, 15);
} }
void Config::SaveMousePanningValues() {
// Don't overwrite values.mouse_panning
WriteBasicSetting(Settings::values.mouse_panning_x_sensitivity);
WriteBasicSetting(Settings::values.mouse_panning_y_sensitivity);
WriteBasicSetting(Settings::values.mouse_panning_deadzone_counterweight);
WriteBasicSetting(Settings::values.mouse_panning_decay_strength);
WriteBasicSetting(Settings::values.mouse_panning_min_decay);
}
void Config::SaveMotionTouchValues() { void Config::SaveMotionTouchValues() {
WriteBasicSetting(Settings::values.touch_device);
WriteBasicSetting(Settings::values.touch_from_button_map_index);
WriteBasicSetting(Settings::values.udp_input_servers);
WriteBasicSetting(Settings::values.enable_udp_controller);
qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps")); qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) { for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
qt_config->setArrayIndex(static_cast<int>(p)); qt_config->setArrayIndex(static_cast<int>(p));
@ -1150,8 +921,6 @@ void Config::SaveMotionTouchValues() {
} }
void Config::SaveHidbusValues() { void Config::SaveHidbusValues() {
WriteBasicSetting(Settings::values.enable_ring_controller);
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys( const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f); 0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
WriteSetting(QStringLiteral("ring_controller"), WriteSetting(QStringLiteral("ring_controller"),
@ -1159,11 +928,6 @@ void Config::SaveHidbusValues() {
QString::fromStdString(default_param)); QString::fromStdString(default_param));
} }
void Config::SaveIrCameraValues() {
WriteBasicSetting(Settings::values.enable_ir_sensor);
WriteBasicSetting(Settings::values.ir_sensor_device);
}
void Config::SaveValues() { void Config::SaveValues() {
if (global) { if (global) {
SaveDataStorageValues(); SaveDataStorageValues();
@ -1180,18 +944,14 @@ void Config::SaveValues() {
SaveRendererValues(); SaveRendererValues();
SaveAudioValues(); SaveAudioValues();
SaveSystemValues(); SaveSystemValues();
qt_config->sync(); qt_config->sync();
} }
void Config::SaveAudioValues() { void Config::SaveAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio")); qt_config->beginGroup(QStringLiteral("Audio"));
if (global) { WriteCategory(Settings::Category::Audio);
WriteBasicSetting(Settings::values.sink_id);
WriteBasicSetting(Settings::values.audio_output_device_id);
WriteBasicSetting(Settings::values.audio_input_device_id);
}
WriteGlobalSetting(Settings::values.volume);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1199,6 +959,8 @@ void Config::SaveAudioValues() {
void Config::SaveControlValues() { void Config::SaveControlValues() {
qt_config->beginGroup(QStringLiteral("Controls")); qt_config->beginGroup(QStringLiteral("Controls"));
WriteCategory(Settings::Category::Controls);
Settings::values.players.SetGlobal(!IsCustomConfig()); Settings::values.players.SetGlobal(!IsCustomConfig());
for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) { for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
SavePlayerValue(p); SavePlayerValue(p);
@ -1208,28 +970,9 @@ void Config::SaveControlValues() {
return; return;
} }
SaveDebugValues(); SaveDebugValues();
SaveMouseValues();
SaveTouchscreenValues(); SaveTouchscreenValues();
SaveMousePanningValues();
SaveMotionTouchValues(); SaveMotionTouchValues();
SaveHidbusValues(); SaveHidbusValues();
SaveIrCameraValues();
WriteGlobalSetting(Settings::values.use_docked_mode);
WriteGlobalSetting(Settings::values.vibration_enabled);
WriteGlobalSetting(Settings::values.enable_accurate_vibrations);
WriteGlobalSetting(Settings::values.motion_enabled);
WriteBasicSetting(Settings::values.enable_raw_input);
WriteBasicSetting(Settings::values.enable_joycon_driver);
WriteBasicSetting(Settings::values.enable_procon_driver);
WriteBasicSetting(Settings::values.random_amiibo_id);
WriteBasicSetting(Settings::values.keyboard_enabled);
WriteBasicSetting(Settings::values.emulate_analog_keyboard);
WriteBasicSetting(Settings::values.controller_navigation);
WriteBasicSetting(Settings::values.tas_enable);
WriteBasicSetting(Settings::values.tas_loop);
WriteBasicSetting(Settings::values.pause_tas_on_load);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1237,8 +980,7 @@ void Config::SaveControlValues() {
void Config::SaveCoreValues() { void Config::SaveCoreValues() {
qt_config->beginGroup(QStringLiteral("Core")); qt_config->beginGroup(QStringLiteral("Core"));
WriteGlobalSetting(Settings::values.use_multi_core); WriteCategory(Settings::Category::Core);
WriteGlobalSetting(Settings::values.use_unsafe_extended_memory_layout);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1246,7 +988,6 @@ void Config::SaveCoreValues() {
void Config::SaveDataStorageValues() { void Config::SaveDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage")); qt_config->beginGroup(QStringLiteral("Data Storage"));
WriteBasicSetting(Settings::values.use_virtual_sd);
WriteSetting(QStringLiteral("nand_directory"), WriteSetting(QStringLiteral("nand_directory"),
QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)), QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)),
QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir))); QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
@ -1263,9 +1004,7 @@ void Config::SaveDataStorageValues() {
QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)), QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)),
QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir))); QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::TASDir)));
WriteBasicSetting(Settings::values.gamecard_inserted); WriteCategory(Settings::Category::DataStorage);
WriteBasicSetting(Settings::values.gamecard_current_game);
WriteBasicSetting(Settings::values.gamecard_path);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1275,19 +1014,8 @@ void Config::SaveDebuggingValues() {
// Intentionally not using the QT default setting as this is intended to be changed in the ini // Intentionally not using the QT default setting as this is intended to be changed in the ini
qt_config->setValue(QStringLiteral("record_frame_times"), Settings::values.record_frame_times); qt_config->setValue(QStringLiteral("record_frame_times"), Settings::values.record_frame_times);
WriteBasicSetting(Settings::values.use_gdbstub);
WriteBasicSetting(Settings::values.gdbstub_port); WriteCategory(Settings::Category::Debugging);
WriteBasicSetting(Settings::values.program_args);
WriteBasicSetting(Settings::values.dump_exefs);
WriteBasicSetting(Settings::values.dump_nso);
WriteBasicSetting(Settings::values.enable_fs_access_log);
WriteBasicSetting(Settings::values.quest_flag);
WriteBasicSetting(Settings::values.use_debug_asserts);
WriteBasicSetting(Settings::values.disable_macro_jit);
WriteBasicSetting(Settings::values.disable_macro_hle);
WriteBasicSetting(Settings::values.enable_all_controllers);
WriteBasicSetting(Settings::values.create_crash_dumps);
WriteBasicSetting(Settings::values.perform_vulkan_check);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1295,7 +1023,7 @@ void Config::SaveDebuggingValues() {
void Config::SaveNetworkValues() { void Config::SaveNetworkValues() {
qt_config->beginGroup(QStringLiteral("Services")); qt_config->beginGroup(QStringLiteral("Services"));
WriteBasicSetting(Settings::values.network_interface); WriteCategory(Settings::Category::Network);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1322,8 +1050,7 @@ void Config::SaveDisabledAddOnValues() {
void Config::SaveMiscellaneousValues() { void Config::SaveMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous")); qt_config->beginGroup(QStringLiteral("Miscellaneous"));
WriteBasicSetting(Settings::values.log_filter); WriteCategory(Settings::Category::Miscellaneous);
WriteBasicSetting(Settings::values.use_dev_keys);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1351,34 +1078,7 @@ void Config::SavePathValues() {
void Config::SaveCpuValues() { void Config::SaveCpuValues() {
qt_config->beginGroup(QStringLiteral("Cpu")); qt_config->beginGroup(QStringLiteral("Cpu"));
WriteBasicSetting(Settings::values.cpu_accuracy_first_time); WriteCategory(Settings::Category::Cpu);
WriteSetting(QStringLiteral("cpu_accuracy"),
static_cast<u32>(Settings::values.cpu_accuracy.GetValue(global)),
static_cast<u32>(Settings::values.cpu_accuracy.GetDefault()),
Settings::values.cpu_accuracy.UsingGlobal());
WriteGlobalSetting(Settings::values.cpuopt_unsafe_unfuse_fma);
WriteGlobalSetting(Settings::values.cpuopt_unsafe_reduce_fp_error);
WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
WriteGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
WriteGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
if (global) {
WriteBasicSetting(Settings::values.cpu_debug_mode);
WriteBasicSetting(Settings::values.cpuopt_page_tables);
WriteBasicSetting(Settings::values.cpuopt_block_linking);
WriteBasicSetting(Settings::values.cpuopt_return_stack_buffer);
WriteBasicSetting(Settings::values.cpuopt_fast_dispatcher);
WriteBasicSetting(Settings::values.cpuopt_context_elimination);
WriteBasicSetting(Settings::values.cpuopt_const_prop);
WriteBasicSetting(Settings::values.cpuopt_misc_ir);
WriteBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
WriteBasicSetting(Settings::values.cpuopt_fastmem);
WriteBasicSetting(Settings::values.cpuopt_fastmem_exclusives);
WriteBasicSetting(Settings::values.cpuopt_recompile_exclusives);
WriteBasicSetting(Settings::values.cpuopt_ignore_memory_aborts);
}
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1386,82 +1086,8 @@ void Config::SaveCpuValues() {
void Config::SaveRendererValues() { void Config::SaveRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer")); qt_config->beginGroup(QStringLiteral("Renderer"));
WriteSetting(QString::fromStdString(Settings::values.renderer_backend.GetLabel()), WriteCategory(Settings::Category::AdvancedGraphics);
static_cast<u32>(Settings::values.renderer_backend.GetValue(global)), WriteCategory(Settings::Category::Renderer);
static_cast<u32>(Settings::values.renderer_backend.GetDefault()),
Settings::values.renderer_backend.UsingGlobal());
WriteGlobalSetting(Settings::values.async_presentation);
WriteGlobalSetting(Settings::values.renderer_force_max_clock);
WriteGlobalSetting(Settings::values.vulkan_device);
WriteSetting(QString::fromStdString(Settings::values.fullscreen_mode.GetLabel()),
static_cast<u32>(Settings::values.fullscreen_mode.GetValue(global)),
static_cast<u32>(Settings::values.fullscreen_mode.GetDefault()),
Settings::values.fullscreen_mode.UsingGlobal());
WriteGlobalSetting(Settings::values.aspect_ratio);
WriteSetting(QString::fromStdString(Settings::values.resolution_setup.GetLabel()),
static_cast<u32>(Settings::values.resolution_setup.GetValue(global)),
static_cast<u32>(Settings::values.resolution_setup.GetDefault()),
Settings::values.resolution_setup.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.scaling_filter.GetLabel()),
static_cast<u32>(Settings::values.scaling_filter.GetValue(global)),
static_cast<u32>(Settings::values.scaling_filter.GetDefault()),
Settings::values.scaling_filter.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.fsr_sharpening_slider.GetLabel()),
static_cast<u32>(Settings::values.fsr_sharpening_slider.GetValue(global)),
static_cast<u32>(Settings::values.fsr_sharpening_slider.GetDefault()),
Settings::values.fsr_sharpening_slider.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.anti_aliasing.GetLabel()),
static_cast<u32>(Settings::values.anti_aliasing.GetValue(global)),
static_cast<u32>(Settings::values.anti_aliasing.GetDefault()),
Settings::values.anti_aliasing.UsingGlobal());
WriteGlobalSetting(Settings::values.max_anisotropy);
WriteGlobalSetting(Settings::values.speed_limit);
WriteGlobalSetting(Settings::values.use_disk_shader_cache);
WriteSetting(QString::fromStdString(Settings::values.gpu_accuracy.GetLabel()),
static_cast<u32>(Settings::values.gpu_accuracy.GetValue(global)),
static_cast<u32>(Settings::values.gpu_accuracy.GetDefault()),
Settings::values.gpu_accuracy.UsingGlobal());
WriteGlobalSetting(Settings::values.use_asynchronous_gpu_emulation);
WriteSetting(QString::fromStdString(Settings::values.nvdec_emulation.GetLabel()),
static_cast<u32>(Settings::values.nvdec_emulation.GetValue(global)),
static_cast<u32>(Settings::values.nvdec_emulation.GetDefault()),
Settings::values.nvdec_emulation.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.accelerate_astc.GetLabel()),
static_cast<u32>(Settings::values.accelerate_astc.GetValue(global)),
static_cast<u32>(Settings::values.accelerate_astc.GetDefault()),
Settings::values.accelerate_astc.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.astc_recompression.GetLabel()),
static_cast<u32>(Settings::values.astc_recompression.GetValue(global)),
static_cast<u32>(Settings::values.astc_recompression.GetDefault()),
Settings::values.astc_recompression.UsingGlobal());
WriteGlobalSetting(Settings::values.use_reactive_flushing);
WriteSetting(QString::fromStdString(Settings::values.accelerate_astc.GetLabel()),
static_cast<u32>(Settings::values.accelerate_astc.GetValue(global)),
static_cast<u32>(Settings::values.accelerate_astc.GetDefault()),
Settings::values.shader_backend.UsingGlobal());
WriteSetting(QString::fromStdString(Settings::values.shader_backend.GetLabel()),
static_cast<u32>(Settings::values.shader_backend.GetValue(global)),
static_cast<u32>(Settings::values.shader_backend.GetDefault()),
Settings::values.shader_backend.UsingGlobal());
WriteGlobalSetting(Settings::values.use_asynchronous_shaders);
WriteGlobalSetting(Settings::values.use_fast_gpu_time);
WriteGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
WriteGlobalSetting(Settings::values.enable_compute_pipelines);
WriteGlobalSetting(Settings::values.use_video_framerate);
WriteGlobalSetting(Settings::values.barrier_feedback_loops);
WriteGlobalSetting(Settings::values.bg_red);
WriteGlobalSetting(Settings::values.bg_green);
WriteGlobalSetting(Settings::values.bg_blue);
if (global) {
WriteSetting(QString::fromStdString(Settings::values.vsync_mode.GetLabel()),
static_cast<u32>(Settings::values.vsync_mode.GetValue()),
static_cast<u32>(Settings::values.vsync_mode.GetDefault()));
WriteBasicSetting(Settings::values.renderer_debug);
WriteBasicSetting(Settings::values.renderer_shader_feedback);
WriteBasicSetting(Settings::values.enable_nsight_aftermath);
WriteBasicSetting(Settings::values.disable_shader_loop_safety_checks);
}
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1469,9 +1095,9 @@ void Config::SaveRendererValues() {
void Config::SaveScreenshotValues() { void Config::SaveScreenshotValues() {
qt_config->beginGroup(QStringLiteral("Screenshots")); qt_config->beginGroup(QStringLiteral("Screenshots"));
WriteBasicSetting(UISettings::values.enable_screenshot_save_as);
WriteSetting(QStringLiteral("screenshot_path"), WriteSetting(QStringLiteral("screenshot_path"),
QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir))); QString::fromStdString(FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir)));
WriteCategory(Settings::Category::Screenshots);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1502,27 +1128,7 @@ void Config::SaveShortcutValues() {
void Config::SaveSystemValues() { void Config::SaveSystemValues() {
qt_config->beginGroup(QStringLiteral("System")); qt_config->beginGroup(QStringLiteral("System"));
WriteGlobalSetting(Settings::values.language_index); WriteCategory(Settings::Category::System);
WriteGlobalSetting(Settings::values.region_index);
WriteGlobalSetting(Settings::values.time_zone_index);
WriteSetting(QStringLiteral("rng_seed_enabled"),
Settings::values.rng_seed.GetValue(global).has_value(), false,
Settings::values.rng_seed.UsingGlobal());
WriteSetting(QStringLiteral("rng_seed"), Settings::values.rng_seed.GetValue(global).value_or(0),
0, Settings::values.rng_seed.UsingGlobal());
if (global) {
WriteBasicSetting(Settings::values.current_user);
WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
false);
WriteSetting(QStringLiteral("custom_rtc"),
QVariant::fromValue<long long>(Settings::values.custom_rtc.value_or(0)), 0);
WriteBasicSetting(Settings::values.device_name);
}
WriteGlobalSetting(Settings::values.sound_index);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1530,10 +1136,10 @@ void Config::SaveSystemValues() {
void Config::SaveUIValues() { void Config::SaveUIValues() {
qt_config->beginGroup(QStringLiteral("UI")); qt_config->beginGroup(QStringLiteral("UI"));
WriteCategory(Settings::Category::Ui);
WriteSetting(QStringLiteral("theme"), UISettings::values.theme, WriteSetting(QStringLiteral("theme"), UISettings::values.theme,
QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second)); QString::fromUtf8(UISettings::themes[static_cast<size_t>(default_theme)].second));
WriteBasicSetting(UISettings::values.enable_discord_presence);
WriteBasicSetting(UISettings::values.select_user_on_boot);
SaveUIGamelistValues(); SaveUIGamelistValues();
SaveUILayoutValues(); SaveUILayoutValues();
@ -1542,37 +1148,14 @@ void Config::SaveUIValues() {
SaveShortcutValues(); SaveShortcutValues();
SaveMultiplayerValues(); SaveMultiplayerValues();
WriteBasicSetting(UISettings::values.single_window_mode);
WriteBasicSetting(UISettings::values.fullscreen);
WriteBasicSetting(UISettings::values.display_titlebar);
WriteBasicSetting(UISettings::values.show_filter_bar);
WriteBasicSetting(UISettings::values.show_status_bar);
WriteBasicSetting(UISettings::values.confirm_before_closing);
WriteBasicSetting(UISettings::values.first_start);
WriteBasicSetting(UISettings::values.callout_flags);
WriteBasicSetting(UISettings::values.show_console);
WriteBasicSetting(UISettings::values.pause_when_in_background);
WriteBasicSetting(UISettings::values.mute_when_in_background);
WriteBasicSetting(UISettings::values.hide_mouse);
WriteBasicSetting(UISettings::values.controller_applet_disabled);
WriteBasicSetting(UISettings::values.disable_web_applet);
qt_config->endGroup(); qt_config->endGroup();
} }
void Config::SaveUIGamelistValues() { void Config::SaveUIGamelistValues() {
qt_config->beginGroup(QStringLiteral("UIGameList")); qt_config->beginGroup(QStringLiteral("UIGameList"));
WriteBasicSetting(UISettings::values.show_add_ons); WriteCategory(Settings::Category::UiGameList);
WriteBasicSetting(UISettings::values.show_compat);
WriteBasicSetting(UISettings::values.show_size);
WriteBasicSetting(UISettings::values.show_types);
WriteBasicSetting(UISettings::values.game_icon_size);
WriteBasicSetting(UISettings::values.folder_icon_size);
WriteBasicSetting(UISettings::values.row_1_text_id);
WriteBasicSetting(UISettings::values.row_2_text_id);
WriteBasicSetting(UISettings::values.cache_game_list);
WriteBasicSetting(UISettings::values.favorites_expanded);
qt_config->beginWriteArray(QStringLiteral("favorites")); qt_config->beginWriteArray(QStringLiteral("favorites"));
for (int i = 0; i < UISettings::values.favorited_ids.size(); i++) { for (int i = 0; i < UISettings::values.favorited_ids.size(); i++) {
qt_config->setArrayIndex(i); qt_config->setArrayIndex(i);
@ -1593,7 +1176,8 @@ void Config::SaveUILayoutValues() {
WriteSetting(QStringLiteral("gameListHeaderState"), UISettings::values.gamelist_header_state); WriteSetting(QStringLiteral("gameListHeaderState"), UISettings::values.gamelist_header_state);
WriteSetting(QStringLiteral("microProfileDialogGeometry"), WriteSetting(QStringLiteral("microProfileDialogGeometry"),
UISettings::values.microprofile_geometry); UISettings::values.microprofile_geometry);
WriteBasicSetting(UISettings::values.microprofile_visible);
WriteCategory(Settings::Category::UiLayout);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1601,10 +1185,7 @@ void Config::SaveUILayoutValues() {
void Config::SaveWebServiceValues() { void Config::SaveWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService")); qt_config->beginGroup(QStringLiteral("WebService"));
WriteBasicSetting(Settings::values.enable_telemetry); WriteCategory(Settings::Category::WebService);
WriteBasicSetting(Settings::values.web_api_url);
WriteBasicSetting(Settings::values.yuzu_username);
WriteBasicSetting(Settings::values.yuzu_token);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1612,17 +1193,7 @@ void Config::SaveWebServiceValues() {
void Config::SaveMultiplayerValues() { void Config::SaveMultiplayerValues() {
qt_config->beginGroup(QStringLiteral("Multiplayer")); qt_config->beginGroup(QStringLiteral("Multiplayer"));
WriteBasicSetting(UISettings::values.multiplayer_nickname); WriteCategory(Settings::Category::Multiplayer);
WriteBasicSetting(UISettings::values.multiplayer_ip);
WriteBasicSetting(UISettings::values.multiplayer_port);
WriteBasicSetting(UISettings::values.multiplayer_room_nickname);
WriteBasicSetting(UISettings::values.multiplayer_room_name);
WriteBasicSetting(UISettings::values.multiplayer_room_port);
WriteBasicSetting(UISettings::values.multiplayer_host_type);
WriteBasicSetting(UISettings::values.multiplayer_port);
WriteBasicSetting(UISettings::values.multiplayer_max_player);
WriteBasicSetting(UISettings::values.multiplayer_game_id);
WriteBasicSetting(UISettings::values.multiplayer_room_description);
// Write ban list // Write ban list
qt_config->beginWriteArray(QStringLiteral("username_ban_list")); qt_config->beginWriteArray(QStringLiteral("username_ban_list"));
@ -1731,3 +1302,58 @@ void Config::ClearControlPlayerValues() {
const std::string& Config::GetConfigFilePath() const { const std::string& Config::GetConfigFilePath() const {
return qt_config_loc; return qt_config_loc;
} }
void Config::ReadCategory(Settings::Category category) {
const auto& settings = settings_map[category];
std::for_each(settings.begin(), settings.end(),
[&](const auto& setting) { ReadSettingGeneric(setting); });
}
void Config::WriteCategory(Settings::Category category) {
const auto& settings = settings_map[category];
std::for_each(settings.begin(), settings.end(),
[&](const auto& setting) { WriteSettingGeneric(setting); });
}
void Config::ReadSettingGeneric(Settings::BasicSetting* const setting) {
if (!setting->Save()) {
return;
}
const QString name = QString::fromStdString(setting->GetLabel());
const auto default_value =
QVariant::fromValue<QString>(QString::fromStdString(setting->DefaultToString()));
if (setting->Switchable()) {
const bool use_global =
qt_config->value(name + QStringLiteral("/use_global"), true).value<bool>();
setting->SetGlobal(use_global);
if (global || !use_global) {
setting->LoadString(ReadSetting(name, default_value).value<QString>().toStdString());
}
} else if (global) {
setting->LoadString(ReadSetting(name, default_value).value<QString>().toStdString());
}
}
void Config::WriteSettingGeneric(Settings::BasicSetting* const setting) const {
if (!setting->Save()) {
return;
}
const QVariant value = QVariant::fromValue(QString::fromStdString(setting->ToString()));
const QVariant default_value =
QVariant::fromValue(QString::fromStdString(setting->DefaultToString()));
const QString label = QString::fromStdString(setting->GetLabel());
if (setting->Switchable()) {
if (!global) {
qt_config->setValue(label + QStringLiteral("/use_global"), setting->UsingGlobal());
}
if (global || !setting->UsingGlobal()) {
qt_config->setValue(label + QStringLiteral("/default"), value == default_value);
qt_config->setValue(label, value);
}
} else if (global) {
qt_config->setValue(label + QStringLiteral("/default"), value == default_value);
qt_config->setValue(label, value);
}
}

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

@ -74,7 +74,6 @@ private:
void ReadKeyboardValues(); void ReadKeyboardValues();
void ReadMouseValues(); void ReadMouseValues();
void ReadTouchscreenValues(); void ReadTouchscreenValues();
void ReadMousePanningValues();
void ReadMotionTouchValues(); void ReadMotionTouchValues();
void ReadHidbusValues(); void ReadHidbusValues();
void ReadIrCameraValues(); void ReadIrCameraValues();
@ -105,7 +104,6 @@ private:
void SaveDebugValues(); void SaveDebugValues();
void SaveMouseValues(); void SaveMouseValues();
void SaveTouchscreenValues(); void SaveTouchscreenValues();
void SaveMousePanningValues();
void SaveMotionTouchValues(); void SaveMotionTouchValues();
void SaveHidbusValues(); void SaveHidbusValues();
void SaveIrCameraValues(); void SaveIrCameraValues();
@ -201,10 +199,17 @@ private:
template <typename Type, bool ranged> template <typename Type, bool ranged>
void WriteBasicSetting(const Settings::Setting<Type, ranged>& setting); void WriteBasicSetting(const Settings::Setting<Type, ranged>& setting);
ConfigType type; void ReadCategory(Settings::Category category);
void WriteCategory(Settings::Category category);
void ReadSettingGeneric(Settings::BasicSetting* const setting);
void WriteSettingGeneric(Settings::BasicSetting* const setting) const;
std::map<Settings::Category, std::forward_list<Settings::BasicSetting*>> settings_map;
const ConfigType type;
std::unique_ptr<QSettings> qt_config; std::unique_ptr<QSettings> qt_config;
std::string qt_config_loc; std::string qt_config_loc;
bool global; const bool global;
}; };
// These metatype declarations cannot be in common/settings.h because core is devoid of QT // These metatype declarations cannot be in common/settings.h because core is devoid of QT

19
src/yuzu/configuration/configuration_shared.cpp
View File

@ -43,25 +43,6 @@ void ConfigurationShared::SetHighlight(QWidget* widget, bool highlighted) {
widget->show(); widget->show();
} }
void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox,
const Settings::SwitchableSetting<bool>& setting,
CheckState& tracker) {
if (setting.UsingGlobal()) {
tracker = CheckState::Global;
} else {
tracker = (setting.GetValue() == setting.GetValue(true)) ? CheckState::On : CheckState::Off;
}
SetHighlight(checkbox, tracker != CheckState::Global);
QObject::connect(checkbox, &QCheckBox::clicked, checkbox, [checkbox, setting, &tracker] {
tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
static_cast<int>(CheckState::Count));
if (tracker == CheckState::Global) {
checkbox->setChecked(setting.GetValue(true));
}
SetHighlight(checkbox, tracker != CheckState::Global);
});
}
void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, bool global, bool state, void ConfigurationShared::SetColoredTristate(QCheckBox* checkbox, bool global, bool state,
bool global_state, CheckState& tracker) { bool global_state, CheckState& tracker) {
if (global) { if (global) {

22
src/yuzu/configuration/configuration_shared.h
View File

@ -57,8 +57,26 @@ void SetPerGameSetting(QComboBox* combobox,
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::SwitchableSetting<bool>& setting, template <bool ranged, bool save>
CheckState& tracker); void SetColoredTristate(QCheckBox* checkbox,
const Settings::SwitchableSetting<bool, ranged, save>& setting,
CheckState& tracker) {
if (setting.UsingGlobal()) {
tracker = CheckState::Global;
} else {
tracker = (setting.GetValue() == setting.GetValue(true)) ? CheckState::On : CheckState::Off;
}
SetHighlight(checkbox, tracker != CheckState::Global);
QObject::connect(checkbox, &QCheckBox::clicked, checkbox, [checkbox, setting, &tracker] {
tracker = static_cast<CheckState>((static_cast<int>(tracker) + 1) %
static_cast<int>(CheckState::Count));
if (tracker == CheckState::Global) {
checkbox->setChecked(setting.GetValue(true));
}
SetHighlight(checkbox, tracker != CheckState::Global);
});
}
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);

86
src/yuzu/uisettings.h
View File

@ -14,6 +14,7 @@
#include "common/common_types.h" #include "common/common_types.h"
#include "common/settings.h" #include "common/settings.h"
using Settings::Category;
using Settings::Setting; using Settings::Setting;
namespace UISettings { namespace UISettings {
@ -58,6 +59,8 @@ struct GameDir {
}; };
struct Values { struct Values {
Settings::Linkage linkage{};
QByteArray geometry; QByteArray geometry;
QByteArray state; QByteArray state;
@ -66,33 +69,36 @@ struct Values {
QByteArray gamelist_header_state; QByteArray gamelist_header_state;
QByteArray microprofile_geometry; QByteArray microprofile_geometry;
Setting<bool> microprofile_visible{false, "microProfileDialogVisible"}; Setting<bool> microprofile_visible{linkage, false, "microProfileDialogVisible",
Category::UiLayout};
Setting<bool> single_window_mode{true, "singleWindowMode"}; Setting<bool> single_window_mode{linkage, true, "singleWindowMode", Category::Ui};
Setting<bool> fullscreen{false, "fullscreen"}; Setting<bool> fullscreen{linkage, false, "fullscreen", Category::Ui};
Setting<bool> display_titlebar{true, "displayTitleBars"}; Setting<bool> display_titlebar{linkage, true, "displayTitleBars", Category::Ui};
Setting<bool> show_filter_bar{true, "showFilterBar"}; Setting<bool> show_filter_bar{linkage, true, "showFilterBar", Category::Ui};
Setting<bool> show_status_bar{true, "showStatusBar"}; Setting<bool> show_status_bar{linkage, true, "showStatusBar", Category::Ui};
Setting<bool> confirm_before_closing{true, "confirmClose"}; Setting<bool> confirm_before_closing{linkage, true, "confirmClose", Category::Ui};
Setting<bool> first_start{true, "firstStart"}; Setting<bool> first_start{linkage, true, "firstStart", Category::Ui};
Setting<bool> pause_when_in_background{false, "pauseWhenInBackground"}; Setting<bool> pause_when_in_background{linkage, false, "pauseWhenInBackground", Category::Ui};
Setting<bool> mute_when_in_background{false, "muteWhenInBackground"}; Setting<bool> mute_when_in_background{linkage, false, "muteWhenInBackground", Category::Ui};
Setting<bool> hide_mouse{true, "hideInactiveMouse"}; Setting<bool> hide_mouse{linkage, true, "hideInactiveMouse", Category::Ui};
Setting<bool> controller_applet_disabled{false, "disableControllerApplet"}; Setting<bool> controller_applet_disabled{linkage, false, "disableControllerApplet",
Category::Ui};
// Set when Vulkan is known to crash the application // Set when Vulkan is known to crash the application
bool has_broken_vulkan = false; bool has_broken_vulkan = false;
Setting<bool> select_user_on_boot{false, "select_user_on_boot"}; Setting<bool> select_user_on_boot{linkage, false, "select_user_on_boot", Category::Ui};
Setting<bool> disable_web_applet{true, "disable_web_applet"}; Setting<bool> disable_web_applet{linkage, true, "disable_web_applet", Category::Ui};
// Discord RPC // Discord RPC
Setting<bool> enable_discord_presence{true, "enable_discord_presence"}; Setting<bool> enable_discord_presence{linkage, true, "enable_discord_presence", Category::Ui};
// logging // logging
Setting<bool> show_console{false, "showConsole"}; Setting<bool> show_console{linkage, false, "showConsole", Category::Ui};
Setting<bool> enable_screenshot_save_as{true, "enable_screenshot_save_as"}; Setting<bool> enable_screenshot_save_as{linkage, true, "enable_screenshot_save_as",
Category::Screenshots};
QString roms_path; QString roms_path;
QString symbols_path; QString symbols_path;
@ -107,38 +113,42 @@ struct Values {
// Shortcut name <Shortcut, context> // Shortcut name <Shortcut, context>
std::vector<Shortcut> shortcuts; std::vector<Shortcut> shortcuts;
Setting<u32> callout_flags{0, "calloutFlags"}; Setting<u32> callout_flags{linkage, 0, "calloutFlags", Category::Ui};
// multiplayer settings // multiplayer settings
Setting<std::string> multiplayer_nickname{{}, "nickname"}; Setting<std::string> multiplayer_nickname{linkage, {}, "nickname", Category::Multiplayer};
Setting<std::string> multiplayer_ip{{}, "ip"}; Setting<std::string> multiplayer_ip{linkage, {}, "ip", Category::Multiplayer};
Setting<u16, true> multiplayer_port{24872, 0, UINT16_MAX, "port"}; Setting<u16, true> multiplayer_port{linkage, 24872, 0,
Setting<std::string> multiplayer_room_nickname{{}, "room_nickname"}; UINT16_MAX, "port", Category::Multiplayer};
Setting<std::string> multiplayer_room_name{{}, "room_name"}; Setting<std::string> multiplayer_room_nickname{
Setting<u8, true> multiplayer_max_player{8, 0, 8, "max_player"}; linkage, {}, "room_nickname", Category::Multiplayer};
Setting<u16, true> multiplayer_room_port{24872, 0, UINT16_MAX, "room_port"}; Setting<std::string> multiplayer_room_name{linkage, {}, "room_name", Category::Multiplayer};
Setting<u8, true> multiplayer_host_type{0, 0, 1, "host_type"}; Setting<u8, true> multiplayer_max_player{linkage, 8, 0, 8, "max_player", Category::Multiplayer};
Setting<unsigned long long> multiplayer_game_id{{}, "game_id"}; Setting<u16, true> multiplayer_room_port{linkage, 24872, 0,
Setting<std::string> multiplayer_room_description{{}, "room_description"}; UINT16_MAX, "room_port", Category::Multiplayer};
Setting<u8, true> multiplayer_host_type{linkage, 0, 0, 1, "host_type", Category::Multiplayer};
Setting<unsigned long long> multiplayer_game_id{linkage, {}, "game_id", Category::Multiplayer};
Setting<std::string> multiplayer_room_description{
linkage, {}, "room_description", Category::Multiplayer};
std::pair<std::vector<std::string>, std::vector<std::string>> multiplayer_ban_list; std::pair<std::vector<std::string>, std::vector<std::string>> multiplayer_ban_list;
// Game List // Game List
Setting<bool> show_add_ons{true, "show_add_ons"}; Setting<bool> show_add_ons{linkage, true, "show_add_ons", Category::UiGameList};
Setting<u32> game_icon_size{64, "game_icon_size"}; Setting<u32> game_icon_size{linkage, 64, "game_icon_size", Category::UiGameList};
Setting<u32> folder_icon_size{48, "folder_icon_size"}; Setting<u32> folder_icon_size{linkage, 48, "folder_icon_size", Category::UiGameList};
Setting<u8> row_1_text_id{3, "row_1_text_id"}; Setting<u8> row_1_text_id{linkage, 3, "row_1_text_id", Category::UiGameList};
Setting<u8> row_2_text_id{2, "row_2_text_id"}; Setting<u8> row_2_text_id{linkage, 2, "row_2_text_id", Category::UiGameList};
std::atomic_bool is_game_list_reload_pending{false}; std::atomic_bool is_game_list_reload_pending{false};
Setting<bool> cache_game_list{true, "cache_game_list"}; Setting<bool> cache_game_list{linkage, true, "cache_game_list", Category::UiGameList};
Setting<bool> favorites_expanded{true, "favorites_expanded"}; Setting<bool> favorites_expanded{linkage, true, "favorites_expanded", Category::UiGameList};
QVector<u64> favorited_ids; QVector<u64> favorited_ids;
// Compatibility List // Compatibility List
Setting<bool> show_compat{false, "show_compat"}; Setting<bool> show_compat{linkage, false, "show_compat", Category::UiGameList};
// Size & File Types Column // Size & File Types Column
Setting<bool> show_size{true, "show_size"}; Setting<bool> show_size{linkage, true, "show_size", Category::UiGameList};
Setting<bool> show_types{true, "show_types"}; Setting<bool> show_types{linkage, true, "show_types", Category::UiGameList};
bool configuration_applied; bool configuration_applied;
bool reset_to_defaults; bool reset_to_defaults;

167
src/yuzu_cmd/config.cpp
View File

@ -98,8 +98,26 @@ void Config::ReadSetting(const std::string& group, Settings::Setting<Type, range
static_cast<long>(setting.GetDefault()))); static_cast<long>(setting.GetDefault())));
} }
void Config::ReadCategory(Settings::Category category) {
for (const auto setting : Settings::values.linkage.by_category[category]) {
const char* category_name = [&]() {
if (category == Settings::Category::Controls) {
// For compatibility with older configs
return "ControlsGeneral";
} else {
return Settings::TranslateCategory(category);
}
}();
std::string setting_value =
sdl2_config->Get(category_name, setting->GetLabel(), setting->DefaultToString());
setting->LoadString(setting_value);
}
}
void Config::ReadValues() { void Config::ReadValues() {
// Controls // Controls
ReadCategory(Settings::Category::Controls);
for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) { for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
auto& player = Settings::values.players.GetValue()[p]; auto& player = Settings::values.players.GetValue()[p];
@ -139,13 +157,6 @@ void Config::ReadValues() {
player.connected = sdl2_config->GetBoolean(group, "connected", false); player.connected = sdl2_config->GetBoolean(group, "connected", false);
} }
ReadSetting("ControlsGeneral", Settings::values.mouse_enabled);
ReadSetting("ControlsGeneral", Settings::values.touch_device);
ReadSetting("ControlsGeneral", Settings::values.keyboard_enabled);
ReadSetting("ControlsGeneral", Settings::values.debug_pad_enabled);
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) { for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]); std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
Settings::values.debug_pad_buttons[i] = sdl2_config->Get( Settings::values.debug_pad_buttons[i] = sdl2_config->Get(
@ -166,14 +177,6 @@ void Config::ReadValues() {
Settings::values.debug_pad_analogs[i] = default_param; Settings::values.debug_pad_analogs[i] = default_param;
} }
ReadSetting("ControlsGeneral", Settings::values.enable_raw_input);
ReadSetting("ControlsGeneral", Settings::values.enable_joycon_driver);
ReadSetting("ControlsGeneral", Settings::values.enable_procon_driver);
ReadSetting("ControlsGeneral", Settings::values.random_amiibo_id);
ReadSetting("ControlsGeneral", Settings::values.emulate_analog_keyboard);
ReadSetting("ControlsGeneral", Settings::values.vibration_enabled);
ReadSetting("ControlsGeneral", Settings::values.enable_accurate_vibrations);
ReadSetting("ControlsGeneral", Settings::values.motion_enabled);
Settings::values.touchscreen.enabled = Settings::values.touchscreen.enabled =
sdl2_config->GetBoolean("ControlsGeneral", "touch_enabled", true); sdl2_config->GetBoolean("ControlsGeneral", "touch_enabled", true);
Settings::values.touchscreen.rotation_angle = Settings::values.touchscreen.rotation_angle =
@ -217,10 +220,19 @@ void Config::ReadValues() {
Settings::values.touch_from_button_map_index = std::clamp( Settings::values.touch_from_button_map_index = std::clamp(
Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1); Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
ReadSetting("ControlsGeneral", Settings::values.udp_input_servers); ReadCategory(Settings::Category::Audio);
ReadCategory(Settings::Category::Core);
ReadCategory(Settings::Category::Cpu);
ReadCategory(Settings::Category::Renderer);
ReadCategory(Settings::Category::AdvancedGraphics);
ReadCategory(Settings::Category::System);
ReadCategory(Settings::Category::DataStorage);
ReadCategory(Settings::Category::Debugging);
ReadCategory(Settings::Category::Miscellaneous);
ReadCategory(Settings::Category::Network);
ReadCategory(Settings::Category::WebService);
// Data Storage // Data Storage
ReadSetting("Data Storage", Settings::values.use_virtual_sd);
FS::SetYuzuPath(FS::YuzuPath::NANDDir, FS::SetYuzuPath(FS::YuzuPath::NANDDir,
sdl2_config->Get("Data Storage", "nand_directory", sdl2_config->Get("Data Storage", "nand_directory",
FS::GetYuzuPathString(FS::YuzuPath::NANDDir))); FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
@ -233,122 +245,10 @@ void Config::ReadValues() {
FS::SetYuzuPath(FS::YuzuPath::DumpDir, FS::SetYuzuPath(FS::YuzuPath::DumpDir,
sdl2_config->Get("Data Storage", "dump_directory", sdl2_config->Get("Data Storage", "dump_directory",
FS::GetYuzuPathString(FS::YuzuPath::DumpDir))); FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
ReadSetting("Data Storage", Settings::values.gamecard_inserted);
ReadSetting("Data Storage", Settings::values.gamecard_current_game);
ReadSetting("Data Storage", Settings::values.gamecard_path);
// System
ReadSetting("System", Settings::values.use_docked_mode);
ReadSetting("System", Settings::values.current_user);
Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
Service::Account::MAX_USERS - 1);
const auto rng_seed_enabled = sdl2_config->GetBoolean("System", "rng_seed_enabled", false);
if (rng_seed_enabled) {
Settings::values.rng_seed.SetValue(sdl2_config->GetInteger("System", "rng_seed", 0));
} else {
Settings::values.rng_seed.SetValue(std::nullopt);
}
const auto custom_rtc_enabled = sdl2_config->GetBoolean("System", "custom_rtc_enabled", false);
if (custom_rtc_enabled) {
Settings::values.custom_rtc = sdl2_config->GetInteger("System", "custom_rtc", 0);
} else {
Settings::values.custom_rtc = std::nullopt;
}
ReadSetting("System", Settings::values.language_index);
ReadSetting("System", Settings::values.region_index);
ReadSetting("System", Settings::values.time_zone_index);
ReadSetting("System", Settings::values.sound_index);
// Core
ReadSetting("Core", Settings::values.use_multi_core);
ReadSetting("Core", Settings::values.use_unsafe_extended_memory_layout);
// Cpu
ReadSetting("Cpu", Settings::values.cpu_accuracy);
ReadSetting("Cpu", Settings::values.cpu_debug_mode);
ReadSetting("Cpu", Settings::values.cpuopt_page_tables);
ReadSetting("Cpu", Settings::values.cpuopt_block_linking);
ReadSetting("Cpu", Settings::values.cpuopt_return_stack_buffer);
ReadSetting("Cpu", Settings::values.cpuopt_fast_dispatcher);
ReadSetting("Cpu", Settings::values.cpuopt_context_elimination);
ReadSetting("Cpu", Settings::values.cpuopt_const_prop);
ReadSetting("Cpu", Settings::values.cpuopt_misc_ir);
ReadSetting("Cpu", Settings::values.cpuopt_reduce_misalign_checks);
ReadSetting("Cpu", Settings::values.cpuopt_fastmem);
ReadSetting("Cpu", Settings::values.cpuopt_fastmem_exclusives);
ReadSetting("Cpu", Settings::values.cpuopt_recompile_exclusives);
ReadSetting("Cpu", Settings::values.cpuopt_ignore_memory_aborts);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_unfuse_fma);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_reduce_fp_error);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_inaccurate_nan);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_fastmem_check);
ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_global_monitor);
// Renderer
ReadSetting("Renderer", Settings::values.renderer_backend);
ReadSetting("Renderer", Settings::values.async_presentation);
ReadSetting("Renderer", Settings::values.renderer_force_max_clock);
ReadSetting("Renderer", Settings::values.renderer_debug);
ReadSetting("Renderer", Settings::values.renderer_shader_feedback);
ReadSetting("Renderer", Settings::values.enable_nsight_aftermath);
ReadSetting("Renderer", Settings::values.disable_shader_loop_safety_checks);
ReadSetting("Renderer", Settings::values.vulkan_device);
ReadSetting("Renderer", Settings::values.resolution_setup);
ReadSetting("Renderer", Settings::values.scaling_filter);
ReadSetting("Renderer", Settings::values.fsr_sharpening_slider);
ReadSetting("Renderer", Settings::values.anti_aliasing);
ReadSetting("Renderer", Settings::values.fullscreen_mode);
ReadSetting("Renderer", Settings::values.aspect_ratio);
ReadSetting("Renderer", Settings::values.max_anisotropy);
ReadSetting("Renderer", Settings::values.use_speed_limit);
ReadSetting("Renderer", Settings::values.speed_limit);
ReadSetting("Renderer", Settings::values.use_disk_shader_cache);
ReadSetting("Renderer", Settings::values.gpu_accuracy);
ReadSetting("Renderer", Settings::values.use_asynchronous_gpu_emulation);
ReadSetting("Renderer", Settings::values.vsync_mode);
ReadSetting("Renderer", Settings::values.shader_backend);
ReadSetting("Renderer", Settings::values.use_reactive_flushing);
ReadSetting("Renderer", Settings::values.use_asynchronous_shaders);
ReadSetting("Renderer", Settings::values.nvdec_emulation);
ReadSetting("Renderer", Settings::values.accelerate_astc);
ReadSetting("Renderer", Settings::values.astc_recompression);
ReadSetting("Renderer", Settings::values.use_vulkan_driver_pipeline_cache);
ReadSetting("Renderer", Settings::values.bg_red);
ReadSetting("Renderer", Settings::values.bg_green);
ReadSetting("Renderer", Settings::values.bg_blue);
// Audio
ReadSetting("Audio", Settings::values.sink_id);
ReadSetting("Audio", Settings::values.audio_output_device_id);
ReadSetting("Audio", Settings::values.volume);
// Miscellaneous
// log_filter has a different default here than from common
Settings::values.log_filter =
sdl2_config->Get("Miscellaneous", Settings::values.log_filter.GetLabel(), "*:Trace");
ReadSetting("Miscellaneous", Settings::values.use_dev_keys);
// Debugging // Debugging
Settings::values.record_frame_times = Settings::values.record_frame_times =
sdl2_config->GetBoolean("Debugging", "record_frame_times", false); sdl2_config->GetBoolean("Debugging", "record_frame_times", false);
ReadSetting("Debugging", Settings::values.dump_exefs);
ReadSetting("Debugging", Settings::values.dump_nso);
ReadSetting("Debugging", Settings::values.enable_fs_access_log);
ReadSetting("Debugging", Settings::values.reporting_services);
ReadSetting("Debugging", Settings::values.quest_flag);
ReadSetting("Debugging", Settings::values.use_debug_asserts);
ReadSetting("Debugging", Settings::values.use_auto_stub);
ReadSetting("Debugging", Settings::values.disable_macro_jit);
ReadSetting("Debugging", Settings::values.disable_macro_hle);
ReadSetting("Debugging", Settings::values.use_gdbstub);
ReadSetting("Debugging", Settings::values.gdbstub_port);
const auto title_list = sdl2_config->Get("AddOns", "title_ids", ""); const auto title_list = sdl2_config->Get("AddOns", "title_ids", "");
std::stringstream ss(title_list); std::stringstream ss(title_list);
@ -366,15 +266,6 @@ void Config::ReadValues() {
Settings::values.disabled_addons.insert_or_assign(title_id, out); Settings::values.disabled_addons.insert_or_assign(title_id, out);
} }
// Web Service
ReadSetting("WebService", Settings::values.enable_telemetry);
ReadSetting("WebService", Settings::values.web_api_url);
ReadSetting("WebService", Settings::values.yuzu_username);
ReadSetting("WebService", Settings::values.yuzu_token);
// Network
ReadSetting("Network", Settings::values.network_interface);
} }
void Config::Reload() { void Config::Reload() {

1
src/yuzu_cmd/config.h
View File

@ -34,4 +34,5 @@ private:
*/ */
template <typename Type, bool ranged> template <typename Type, bool ranged>
void ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting); void ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting);
void ReadCategory(Settings::Category category);
}; };