summaryrefslogtreecommitdiffstats
path: root/src/common/settings.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/settings.h')
-rw-r--r--src/common/settings.h877
1 files changed, 403 insertions, 474 deletions
diff --git a/src/common/settings.h b/src/common/settings.h
index 59e96e74f..98ab0ec2e 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -6,95 +6,21 @@
#include <algorithm>
#include <array>
#include <map>
-#include <optional>
+#include <memory>
+#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include "common/common_types.h"
+#include "common/settings_common.h"
+#include "common/settings_enums.h"
#include "common/settings_input.h"
+#include "common/settings_setting.h"
namespace Settings {
-enum class VSyncMode : u32 {
- Immediate = 0,
- Mailbox = 1,
- FIFO = 2,
- FIFORelaxed = 3,
-};
-
-enum class RendererBackend : u32 {
- OpenGL = 0,
- Vulkan = 1,
- Null = 2,
-};
-
-enum class ShaderBackend : u32 {
- GLSL = 0,
- GLASM = 1,
- SPIRV = 2,
-};
-
-enum class GPUAccuracy : u32 {
- Normal = 0,
- High = 1,
- Extreme = 2,
-};
-
-enum class CPUAccuracy : u32 {
- Auto = 0,
- Accurate = 1,
- Unsafe = 2,
- Paranoid = 3,
-};
-
-enum class FullscreenMode : u32 {
- Borderless = 0,
- Exclusive = 1,
-};
-
-enum class NvdecEmulation : u32 {
- Off = 0,
- CPU = 1,
- GPU = 2,
-};
-
-enum class ResolutionSetup : u32 {
- Res1_2X = 0,
- Res3_4X = 1,
- Res1X = 2,
- Res3_2X = 3,
- Res2X = 4,
- Res3X = 5,
- Res4X = 6,
- Res5X = 7,
- Res6X = 8,
- Res7X = 9,
- Res8X = 10,
-};
-
-enum class ScalingFilter : u32 {
- NearestNeighbor = 0,
- Bilinear = 1,
- Bicubic = 2,
- Gaussian = 3,
- ScaleForce = 4,
- Fsr = 5,
- LastFilter = Fsr,
-};
-
-enum class AntiAliasing : u32 {
- None = 0,
- Fxaa = 1,
- Smaa = 2,
- LastAA = Smaa,
-};
-
-enum class AstcRecompression : u32 {
- Uncompressed = 0,
- Bc1 = 1,
- Bc3 = 2,
-};
+const char* TranslateCategory(Settings::Category category);
struct ResolutionScalingInfo {
u32 up_scale{1};
@@ -119,239 +45,47 @@ struct ResolutionScalingInfo {
}
};
-/** 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>
-class Setting {
-protected:
- Setting() = default;
-
- /**
- * Only sets the setting to the given initializer, leaving the other members to their default
- * initializers.
- *
- * @param global_val Initial value of the setting
- */
- explicit Setting(const Type& val) : value{val} {}
-
-public:
- /**
- * Sets a default value, label, and setting value.
- *
- * @param default_val Initial value of the setting, and default value of the setting
- * @param name Label for the setting
- */
- explicit Setting(const Type& default_val, const std::string& name)
- requires(!ranged)
- : value{default_val}, default_value{default_val}, label{name} {}
- virtual ~Setting() = default;
-
- /**
- * Sets a default value, minimum value, maximum value, and label.
- *
- * @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 max_val Sets the maximum allowed value of the setting
- * @param name Label for the setting
- */
- explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val,
- const std::string& name)
- requires(ranged)
- : value{default_val},
- default_value{default_val}, maximum{max_val}, minimum{min_val}, label{name} {}
-
- /**
- * Returns a reference to the setting's value.
- *
- * @returns A reference to the setting
- */
- [[nodiscard]] virtual const Type& GetValue() const {
- return value;
- }
-
- /**
- * Sets the setting to the given value.
- *
- * @param val The desired value
- */
- virtual void SetValue(const Type& val) {
- Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
- std::swap(value, temp);
- }
-
- /**
- * Returns the value that this setting was created with.
- *
- * @returns A reference to the default value
- */
- [[nodiscard]] const Type& GetDefault() const {
- return default_value;
- }
-
- /**
- * Returns the label this setting was created with.
- *
- * @returns A reference to the label
- */
- [[nodiscard]] const std::string& GetLabel() const {
- return label;
- }
-
- /**
- * Assigns a value to the setting.
- *
- * @param val The desired setting value
- *
- * @returns A reference to the setting
- */
- virtual const Type& operator=(const Type& val) {
- Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
- std::swap(value, temp);
- return value;
- }
-
- /**
- * Returns a reference to the setting.
- *
- * @returns A reference to the setting
- */
- explicit virtual operator const Type&() const {
- return value;
- }
-
-protected:
- Type value{}; ///< The setting
- const Type default_value{}; ///< The default value
- const Type maximum{}; ///< Maximum allowed value of the setting
- const Type minimum{}; ///< Minimum allowed value of the setting
- const std::string label{}; ///< The setting's label
-};
-
-/**
- * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
- * custom setting to switch to when a guest application specifically requires it. The effect is that
- * other components of the emulator can access the setting's intended value without any need for the
- * component to ask whether the custom or global setting is needed at the moment.
- *
- * By default, the global setting is used.
- */
-template <typename Type, bool ranged = false>
-class SwitchableSetting : virtual public Setting<Type, ranged> {
-public:
- /**
- * Sets a default value, label, and setting value.
- *
- * @param default_val Initial value of the setting, and default value of the setting
- * @param name Label for the setting
- */
- explicit SwitchableSetting(const Type& default_val, const std::string& name)
- requires(!ranged)
- : Setting<Type>{default_val, name} {}
- virtual ~SwitchableSetting() = default;
-
- /**
- * Sets a default value, minimum value, maximum value, and label.
- *
- * @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 max_val Sets the maximum allowed value of the setting
- * @param name Label for the setting
- */
- explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
- const std::string& name)
- requires(ranged)
- : Setting<Type, true>{default_val, min_val, max_val, name} {}
-
- /**
- * Tells this setting to represent either the global or custom setting when other member
- * functions are used.
- *
- * @param to_global Whether to use the global or custom setting.
- */
- void SetGlobal(bool to_global) {
- use_global = to_global;
- }
-
- /**
- * Returns whether this setting is using the global setting or not.
- *
- * @returns The global state
- */
- [[nodiscard]] bool UsingGlobal() const {
- return use_global;
- }
-
- /**
- * Returns either the global or custom setting depending on the values of this setting's global
- * state or if the global value was specifically requested.
- *
- * @param need_global Request global value regardless of setting's state; defaults to false
- *
- * @returns The required value of the setting
- */
- [[nodiscard]] virtual const Type& GetValue() const override {
- if (use_global) {
- return this->value;
- }
- return custom;
- }
- [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
- if (use_global || need_global) {
- return this->value;
- }
- return custom;
- }
-
- /**
- * Sets the current setting value depending on the global state.
- *
- * @param val The new value
- */
- void SetValue(const Type& val) override {
- Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
- if (use_global) {
- std::swap(this->value, temp);
- } else {
- std::swap(custom, temp);
- }
- }
-
- /**
- * Assigns the current setting value depending on the global state.
- *
- * @param val The new value
- *
- * @returns A reference to the current setting value
- */
- const Type& operator=(const Type& val) override {
- Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
- if (use_global) {
- std::swap(this->value, temp);
- return this->value;
- }
- std::swap(custom, temp);
- return custom;
- }
-
- /**
- * Returns the current setting value depending on the global state.
- *
- * @returns A reference to the current setting value
- */
- virtual explicit operator const Type&() const override {
- if (use_global) {
- return this->value;
- }
- return custom;
- }
-
-protected:
- bool use_global{true}; ///< The setting's global state
- Type custom{}; ///< The custom value of the setting
-};
+#ifndef CANNOT_EXPLICITLY_INSTANTIATE
+// Instantiate the classes elsewhere (settings.cpp) to reduce compiler/linker work
+#define SETTING(TYPE, RANGED) extern template class Setting<TYPE, RANGED>
+#define SWITCHABLE(TYPE, RANGED) extern template class SwitchableSetting<TYPE, RANGED>
+
+SETTING(AudioEngine, false);
+SETTING(bool, false);
+SETTING(int, false);
+SETTING(s32, false);
+SETTING(std::string, false);
+SETTING(std::string, false);
+SETTING(u16, false);
+SWITCHABLE(AnisotropyMode, true);
+SWITCHABLE(AntiAliasing, false);
+SWITCHABLE(AspectRatio, true);
+SWITCHABLE(AstcDecodeMode, true);
+SWITCHABLE(AstcRecompression, true);
+SWITCHABLE(AudioMode, true);
+SWITCHABLE(CpuAccuracy, true);
+SWITCHABLE(FullscreenMode, true);
+SWITCHABLE(GpuAccuracy, true);
+SWITCHABLE(Language, true);
+SWITCHABLE(NvdecEmulation, false);
+SWITCHABLE(Region, true);
+SWITCHABLE(RendererBackend, true);
+SWITCHABLE(ScalingFilter, false);
+SWITCHABLE(ShaderBackend, true);
+SWITCHABLE(TimeZone, true);
+SETTING(VSyncMode, true);
+SWITCHABLE(bool, false);
+SWITCHABLE(int, false);
+SWITCHABLE(int, true);
+SWITCHABLE(s64, false);
+SWITCHABLE(u16, true);
+SWITCHABLE(u32, false);
+SWITCHABLE(u8, false);
+SWITCHABLE(u8, true);
+
+#undef SETTING
+#undef SWITCHABLE
+#endif
/**
* The InputSetting class allows for getting a reference to either the global or custom members.
@@ -391,208 +125,399 @@ struct TouchFromButtonMap {
};
struct Values {
+ Linkage linkage{};
+
// Audio
- Setting<std::string> sink_id{"auto", "output_engine"};
- Setting<std::string> audio_output_device_id{"auto", "output_device"};
- Setting<std::string> audio_input_device_id{"auto", "input_device"};
- Setting<bool> audio_muted{false, "audio_muted"};
- SwitchableSetting<u8, true> volume{100, 0, 200, "volume"};
- Setting<bool> dump_audio_commands{false, "dump_audio_commands"};
+ Setting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine", Category::Audio,
+ Specialization::RuntimeList};
+ Setting<std::string> audio_output_device_id{linkage, "auto", "output_device", Category::Audio,
+ Specialization::RuntimeList};
+ Setting<std::string> audio_input_device_id{linkage, "auto", "input_device", Category::Audio,
+ Specialization::RuntimeList};
+ SwitchableSetting<AudioMode, true> sound_index{
+ linkage, AudioMode::Stereo, AudioMode::Mono, AudioMode::Surround,
+ "sound_index", Category::SystemAudio, Specialization::Default, true,
+ true};
+ SwitchableSetting<u8, true> volume{linkage,
+ 100,
+ 0,
+ 200,
+ "volume",
+ Category::Audio,
+ Specialization::Scalar | Specialization::Percentage,
+ true,
+ true};
+ Setting<bool, false> audio_muted{
+ linkage, false, "audio_muted", Category::Audio, Specialization::Default, false, true};
+ Setting<bool, false> dump_audio_commands{
+ linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
// Core
- SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
- SwitchableSetting<bool> use_unsafe_extended_memory_layout{false,
- "use_unsafe_extended_memory_layout"};
+ SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
+ SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
+ MemoryLayout::Memory_4Gb,
+ MemoryLayout::Memory_4Gb,
+ MemoryLayout::Memory_8Gb,
+ "memory_layout_mode",
+ Category::Core};
+ SwitchableSetting<bool> use_speed_limit{
+ linkage, true, "use_speed_limit", Category::Core, Specialization::Paired, false, true};
+ SwitchableSetting<u16, true> speed_limit{linkage,
+ 100,
+ 0,
+ 9999,
+ "speed_limit",
+ Category::Core,
+ Specialization::Countable | Specialization::Percentage,
+ true,
+ true,
+ &use_speed_limit};
// Cpu
- SwitchableSetting<CPUAccuracy, true> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
- CPUAccuracy::Paranoid, "cpu_accuracy"};
- // 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_debug_mode{false, "cpu_debug_mode"};
-
- Setting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
- Setting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
- Setting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
- Setting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
- Setting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
- Setting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
- Setting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
- Setting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
- Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
- Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
- Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
- Setting<bool> cpuopt_ignore_memory_aborts{true, "cpuopt_ignore_memory_aborts"};
-
- SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
- SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
+ SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
+ CpuAccuracy::Auto, CpuAccuracy::Paranoid,
+ "cpu_accuracy", Category::Cpu};
+ Setting<bool> cpu_debug_mode{linkage, false, "cpu_debug_mode", Category::CpuDebug};
+
+ Setting<bool> cpuopt_page_tables{linkage, true, "cpuopt_page_tables", Category::CpuDebug};
+ Setting<bool> cpuopt_block_linking{linkage, true, "cpuopt_block_linking", Category::CpuDebug};
+ Setting<bool> cpuopt_return_stack_buffer{linkage, true, "cpuopt_return_stack_buffer",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_fast_dispatcher{linkage, true, "cpuopt_fast_dispatcher",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_context_elimination{linkage, true, "cpuopt_context_elimination",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_const_prop{linkage, true, "cpuopt_const_prop", Category::CpuDebug};
+ Setting<bool> cpuopt_misc_ir{linkage, true, "cpuopt_misc_ir", Category::CpuDebug};
+ Setting<bool> cpuopt_reduce_misalign_checks{linkage, true, "cpuopt_reduce_misalign_checks",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_fastmem{linkage, true, "cpuopt_fastmem", Category::CpuDebug};
+ Setting<bool> cpuopt_fastmem_exclusives{linkage, true, "cpuopt_fastmem_exclusives",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_recompile_exclusives{linkage, true, "cpuopt_recompile_exclusives",
+ Category::CpuDebug};
+ Setting<bool> cpuopt_ignore_memory_aborts{linkage, true, "cpuopt_ignore_memory_aborts",
+ Category::CpuDebug};
+
+ SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
+ Category::CpuUnsafe};
+ SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
+ linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
- true, "cpuopt_unsafe_ignore_standard_fpcr"};
- SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
- SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
+ linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::CpuUnsafe};
+ SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{
+ linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::CpuUnsafe};
+ SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{
+ linkage, true, "cpuopt_unsafe_fastmem_check", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
- true, "cpuopt_unsafe_ignore_global_monitor"};
+ linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::CpuUnsafe};
// Renderer
SwitchableSetting<RendererBackend, true> renderer_backend{
- RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
- SwitchableSetting<bool> async_presentation{false, "async_presentation"};
- SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
- Setting<bool> renderer_debug{false, "debug"};
- Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
- Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
- Setting<bool> disable_shader_loop_safety_checks{false, "disable_shader_loop_safety_checks"};
- SwitchableSetting<int> vulkan_device{0, "vulkan_device"};
-
- ResolutionScalingInfo resolution_info{};
- SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
- SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
- SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"};
- SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
+ linkage, RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
+ "backend", Category::Renderer};
+ SwitchableSetting<ShaderBackend, true> shader_backend{
+ linkage, ShaderBackend::Glsl, ShaderBackend::Glsl, ShaderBackend::SpirV,
+ "shader_backend", Category::Renderer, Specialization::RuntimeList};
+ SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer,
+ Specialization::RuntimeList};
+
+ SwitchableSetting<bool> use_disk_shader_cache{linkage, true, "use_disk_shader_cache",
+ Category::Renderer};
+ SwitchableSetting<bool> use_asynchronous_gpu_emulation{
+ linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
+ SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
+ AstcDecodeMode::Gpu,
+ AstcDecodeMode::Cpu,
+ AstcDecodeMode::CpuAsynchronous,
+ "accelerate_astc",
+ Category::Renderer};
+ Setting<VSyncMode, true> vsync_mode{
+ linkage, VSyncMode::Fifo, VSyncMode::Immediate, VSyncMode::FifoRelaxed,
+ "use_vsync", Category::Renderer, Specialization::RuntimeList, true,
+ true};
+ SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
+ "nvdec_emulation", Category::Renderer};
// *nix platforms may have issues with the borderless windowed fullscreen mode.
// Default to exclusive fullscreen on these platforms for now.
- SwitchableSetting<FullscreenMode, true> fullscreen_mode{
+ SwitchableSetting<FullscreenMode, true> fullscreen_mode{linkage,
#ifdef _WIN32
- FullscreenMode::Borderless,
+ FullscreenMode::Borderless,
#else
- FullscreenMode::Exclusive,
+ FullscreenMode::Exclusive,
#endif
- FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
- SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"};
- SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
- SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
- SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};
- SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
- SwitchableSetting<GPUAccuracy, true> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
- GPUAccuracy::Extreme, "gpu_accuracy"};
- SwitchableSetting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
- SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
- SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
- SwitchableSetting<bool> async_astc{false, "async_astc"};
- Setting<VSyncMode, true> vsync_mode{VSyncMode::FIFO, VSyncMode::Immediate,
- VSyncMode::FIFORelaxed, "use_vsync"};
- SwitchableSetting<bool> use_reactive_flushing{true, "use_reactive_flushing"};
- SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL,
- ShaderBackend::SPIRV, "shader_backend"};
- SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
- SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
- SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
- "use_vulkan_driver_pipeline_cache"};
- SwitchableSetting<bool> enable_compute_pipelines{false, "enable_compute_pipelines"};
- SwitchableSetting<AstcRecompression, true> astc_recompression{
- AstcRecompression::Uncompressed, AstcRecompression::Uncompressed, AstcRecompression::Bc3,
- "astc_recompression"};
- SwitchableSetting<bool> use_video_framerate{false, "use_video_framerate"};
- SwitchableSetting<bool> barrier_feedback_loops{true, "barrier_feedback_loops"};
-
- SwitchableSetting<u8> bg_red{0, "bg_red"};
- SwitchableSetting<u8> bg_green{0, "bg_green"};
- SwitchableSetting<u8> bg_blue{0, "bg_blue"};
+ FullscreenMode::Borderless,
+ FullscreenMode::Exclusive,
+ "fullscreen_mode",
+ Category::Renderer,
+ Specialization::Default,
+ true,
+ true};
+ SwitchableSetting<AspectRatio, true> aspect_ratio{linkage,
+ AspectRatio::R16_9,
+ AspectRatio::R16_9,
+ AspectRatio::Stretch,
+ "aspect_ratio",
+ Category::Renderer,
+ Specialization::Default,
+ true,
+ true};
+
+ ResolutionScalingInfo resolution_info{};
+ SwitchableSetting<ResolutionSetup> resolution_setup{linkage, ResolutionSetup::Res1X,
+ "resolution_setup", Category::Renderer};
+ SwitchableSetting<ScalingFilter> scaling_filter{linkage,
+ ScalingFilter::Bilinear,
+ "scaling_filter",
+ Category::Renderer,
+ Specialization::Default,
+ true,
+ true};
+ SwitchableSetting<AntiAliasing> anti_aliasing{linkage,
+ AntiAliasing::None,
+ "anti_aliasing",
+ Category::Renderer,
+ Specialization::Default,
+ true,
+ true};
+ SwitchableSetting<int, true> fsr_sharpening_slider{linkage,
+ 25,
+ 0,
+ 200,
+ "fsr_sharpening_slider",
+ Category::Renderer,
+ Specialization::Scalar |
+ Specialization::Percentage,
+ true,
+ true};
+
+ SwitchableSetting<u8, false> bg_red{
+ linkage, 0, "bg_red", Category::Renderer, Specialization::Default, true, true};
+ SwitchableSetting<u8, false> bg_green{
+ linkage, 0, "bg_green", Category::Renderer, Specialization::Default, true, true};
+ SwitchableSetting<u8, false> bg_blue{
+ linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
+
+ SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
+ GpuAccuracy::High,
+ GpuAccuracy::Normal,
+ GpuAccuracy::Extreme,
+ "gpu_accuracy",
+ Category::RendererAdvanced,
+ Specialization::Default,
+ true,
+ true};
+ GpuAccuracy current_gpu_accuracy{GpuAccuracy::High};
+ SwitchableSetting<AnisotropyMode, true> max_anisotropy{
+ linkage, AnisotropyMode::Automatic, AnisotropyMode::Automatic, AnisotropyMode::X16,
+ "max_anisotropy", Category::RendererAdvanced};
+ SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
+ AstcRecompression::Uncompressed,
+ AstcRecompression::Uncompressed,
+ AstcRecompression::Bc3,
+ "astc_recompression",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> async_presentation{linkage, false, "async_presentation",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> use_reactive_flushing{linkage, true, "use_reactive_flushing",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> use_fast_gpu_time{
+ linkage, true, "use_fast_gpu_time", Category::RendererAdvanced, Specialization::Default,
+ true, true};
+ SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{linkage,
+ true,
+ "use_vulkan_driver_pipeline_cache",
+ Category::RendererAdvanced,
+ Specialization::Default,
+ true,
+ true};
+ SwitchableSetting<bool> enable_compute_pipelines{linkage, false, "enable_compute_pipelines",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> use_video_framerate{linkage, false, "use_video_framerate",
+ Category::RendererAdvanced};
+ SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
+ Category::RendererAdvanced};
+
+ Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
+ Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
+ Category::RendererDebug};
+ Setting<bool> enable_nsight_aftermath{linkage, false, "nsight_aftermath",
+ Category::RendererDebug};
+ Setting<bool> disable_shader_loop_safety_checks{
+ linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
+ Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
+ Category::RendererDebug};
+ // TODO: remove this once AMDVLK supports VK_EXT_depth_bias_control
+ bool renderer_amdvlk_depth_bias_workaround{};
// System
- SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
- Setting<std::string> device_name{"Yuzu", "device_name"};
+ SwitchableSetting<Language, true> language_index{linkage,
+ Language::EnglishAmerican,
+ Language::Japanese,
+ Language::PortugueseBrazilian,
+ "language_index",
+ Category::System};
+ SwitchableSetting<Region, true> region_index{linkage, Region::Usa, Region::Japan,
+ Region::Taiwan, "region_index", Category::System};
+ SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto,
+ TimeZone::Auto, TimeZone::Zulu,
+ "time_zone_index", Category::System};
// Measured in seconds since epoch
- std::optional<s64> custom_rtc;
+ SwitchableSetting<bool> custom_rtc_enabled{
+ linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
+ SwitchableSetting<s64> custom_rtc{
+ linkage, 0, "custom_rtc", Category::System, Specialization::Time,
+ true, true, &custom_rtc_enabled};
// Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
s64 custom_rtc_differential;
-
- Setting<s32> current_user{0, "current_user"};
- SwitchableSetting<s32, true> language_index{1, 0, 17, "language_index"};
- SwitchableSetting<s32, true> region_index{1, 0, 6, "region_index"};
- SwitchableSetting<s32, true> time_zone_index{0, 0, 45, "time_zone_index"};
- SwitchableSetting<s32, true> sound_index{1, 0, 2, "sound_index"};
+ SwitchableSetting<bool> rng_seed_enabled{
+ linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
+ SwitchableSetting<u32> rng_seed{
+ linkage, 0, "rng_seed", Category::System, Specialization::Hex,
+ true, true, &rng_seed_enabled};
+ Setting<std::string> device_name{
+ linkage, "yuzu", "device_name", Category::System, Specialization::Default, true, true};
+
+ Setting<s32> current_user{linkage, 0, "current_user", Category::System};
+
+ SwitchableSetting<ConsoleMode> use_docked_mode{linkage,
+ ConsoleMode::Docked,
+ "use_docked_mode",
+ Category::System,
+ Specialization::Radio,
+ true,
+ true};
// Controls
InputSetting<std::array<PlayerInput, 10>> players;
- SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"};
-
- Setting<bool> enable_raw_input{false, "enable_raw_input"};
- Setting<bool> controller_navigation{true, "controller_navigation"};
- Setting<bool> enable_joycon_driver{true, "enable_joycon_driver"};
- Setting<bool> enable_procon_driver{false, "enable_procon_driver"};
-
- SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
- SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
-
- SwitchableSetting<bool> motion_enabled{true, "motion_enabled"};
- Setting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
- Setting<bool> enable_udp_controller{false, "enable_udp_controller"};
-
- Setting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
- Setting<bool> tas_enable{false, "tas_enable"};
- Setting<bool> tas_loop{false, "tas_loop"};
-
- Setting<bool> mouse_panning{false, "mouse_panning"};
- Setting<u8, true> mouse_panning_x_sensitivity{50, 1, 100, "mouse_panning_x_sensitivity"};
- Setting<u8, true> mouse_panning_y_sensitivity{50, 1, 100, "mouse_panning_y_sensitivity"};
- Setting<u8, true> mouse_panning_deadzone_counterweight{20, 0, 100,
- "mouse_panning_deadzone_counterweight"};
- Setting<u8, true> mouse_panning_decay_strength{18, 0, 100, "mouse_panning_decay_strength"};
- Setting<u8, true> mouse_panning_min_decay{6, 0, 100, "mouse_panning_min_decay"};
-
- Setting<bool> mouse_enabled{false, "mouse_enabled"};
- Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
- Setting<bool> keyboard_enabled{false, "keyboard_enabled"};
-
- Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
+ Setting<bool> enable_raw_input{
+ linkage, false, "enable_raw_input", Category::Controls, Specialization::Default,
+// Only read/write enable_raw_input on Windows platforms
+#ifdef _WIN32
+ true
+#else
+ false
+#endif
+ };
+ 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};
+
+ SwitchableSetting<bool> vibration_enabled{linkage, true, "vibration_enabled",
+ Category::Controls};
+ SwitchableSetting<bool> enable_accurate_vibrations{linkage, false, "enable_accurate_vibrations",
+ Category::Controls};
+
+ SwitchableSetting<bool> motion_enabled{linkage, true, "motion_enabled", Category::Controls};
+ 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};
+
+ Setting<bool> pause_tas_on_load{linkage, true, "pause_tas_on_load", Category::Controls};
+ Setting<bool> tas_enable{linkage, false, "tas_enable", Category::Controls};
+ Setting<bool> tas_loop{linkage, false, "tas_loop", Category::Controls};
+
+ Setting<bool> mouse_panning{
+ linkage, false, "mouse_panning", Category::Controls, Specialization::Default, false};
+ Setting<u8, true> mouse_panning_sensitivity{
+ linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
+ Setting<bool> mouse_enabled{linkage, false, "mouse_enabled", Category::Controls};
+
+ Setting<u8, true> mouse_panning_x_sensitivity{
+ linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
+ Setting<u8, true> mouse_panning_y_sensitivity{
+ linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
+ Setting<u8, true> mouse_panning_deadzone_counterweight{
+ linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
+ 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> emulate_analog_keyboard{linkage, false, "emulate_analog_keyboard",
+ Category::Controls};
+ Setting<bool> keyboard_enabled{linkage, false, "keyboard_enabled", Category::Controls};
+
+ Setting<bool> debug_pad_enabled{linkage, false, "debug_pad_enabled", Category::Controls};
ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs;
TouchscreenInput touchscreen;
- Setting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", "touch_device"};
- Setting<int> touch_from_button_map_index{0, "touch_from_button_map"};
+ Setting<std::string> touch_device{linkage, "min_x:100,min_y:50,max_x:1800,max_y:850",
+ "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;
- Setting<bool> enable_ring_controller{true, "enable_ring_controller"};
+ Setting<bool> enable_ring_controller{linkage, true, "enable_ring_controller",
+ Category::Controls};
RingconRaw ringcon_analogs;
- Setting<bool> enable_ir_sensor{false, "enable_ir_sensor"};
- Setting<std::string> ir_sensor_device{"auto", "ir_sensor_device"};
+ Setting<bool> enable_ir_sensor{linkage, false, "enable_ir_sensor", Category::Controls};
+ 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
- Setting<bool> use_virtual_sd{true, "use_virtual_sd"};
- Setting<bool> gamecard_inserted{false, "gamecard_inserted"};
- Setting<bool> gamecard_current_game{false, "gamecard_current_game"};
- Setting<std::string> gamecard_path{std::string(), "gamecard_path"};
+ Setting<bool> use_virtual_sd{linkage, true, "use_virtual_sd", Category::DataStorage};
+ Setting<bool> gamecard_inserted{linkage, false, "gamecard_inserted", Category::DataStorage};
+ Setting<bool> gamecard_current_game{linkage, false, "gamecard_current_game",
+ Category::DataStorage};
+ Setting<std::string> gamecard_path{linkage, std::string(), "gamecard_path",
+ Category::DataStorage};
// Debugging
bool record_frame_times;
- Setting<bool> use_gdbstub{false, "use_gdbstub"};
- Setting<u16> gdbstub_port{6543, "gdbstub_port"};
- Setting<std::string> program_args{std::string(), "program_args"};
- Setting<bool> dump_exefs{false, "dump_exefs"};
- Setting<bool> dump_nso{false, "dump_nso"};
- Setting<bool> dump_shaders{false, "dump_shaders"};
- Setting<bool> dump_macros{false, "dump_macros"};
- Setting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
- Setting<bool> reporting_services{false, "reporting_services"};
- Setting<bool> quest_flag{false, "quest_flag"};
- Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
- Setting<bool> disable_macro_hle{false, "disable_macro_hle"};
- Setting<bool> extended_logging{false, "extended_logging"};
- Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
- Setting<bool> use_auto_stub{false, "use_auto_stub"};
- Setting<bool> enable_all_controllers{false, "enable_all_controllers"};
- Setting<bool> create_crash_dumps{false, "create_crash_dumps"};
- Setting<bool> perform_vulkan_check{true, "perform_vulkan_check"};
+ Setting<bool> use_gdbstub{linkage, false, "use_gdbstub", Category::Debugging};
+ Setting<u16> gdbstub_port{linkage, 6543, "gdbstub_port", Category::Debugging};
+ Setting<std::string> program_args{linkage, std::string(), "program_args", Category::Debugging};
+ Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
+ Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
+ Setting<bool> dump_shaders{
+ linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
+ false};
+ Setting<bool> dump_macros{
+ linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
+ Setting<bool> enable_fs_access_log{linkage, false, "enable_fs_access_log", Category::Debugging};
+ Setting<bool> reporting_services{
+ linkage, false, "reporting_services", Category::Debugging, Specialization::Default, false};
+ Setting<bool> quest_flag{linkage, false, "quest_flag", Category::Debugging};
+ Setting<bool> disable_macro_jit{linkage, false, "disable_macro_jit",
+ Category::DebuggingGraphics};
+ Setting<bool> disable_macro_hle{linkage, false, "disable_macro_hle",
+ Category::DebuggingGraphics};
+ Setting<bool> extended_logging{
+ linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
+ Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
+ Setting<bool> use_auto_stub{
+ linkage, false, "use_auto_stub", Category::Debugging, Specialization::Default, false};
+ 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
- Setting<std::string> log_filter{"*:Info", "log_filter"};
- Setting<bool> use_dev_keys{false, "use_dev_keys"};
+ Setting<std::string> log_filter{linkage, "*:Info", "log_filter", Category::Miscellaneous};
+ Setting<bool> use_dev_keys{linkage, false, "use_dev_keys", Category::Miscellaneous};
// Network
- Setting<std::string> network_interface{std::string(), "network_interface"};
+ Setting<std::string> network_interface{linkage, std::string(), "network_interface",
+ Category::Network};
// WebService
- Setting<bool> enable_telemetry{true, "enable_telemetry"};
- Setting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
- Setting<std::string> yuzu_username{std::string(), "yuzu_username"};
- Setting<std::string> yuzu_token{std::string(), "yuzu_token"};
+ Setting<bool> enable_telemetry{linkage, true, "enable_telemetry", Category::WebService};
+ Setting<std::string> web_api_url{linkage, "https://api.yuzu-emu.org", "web_api_url",
+ Category::WebService};
+ 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
std::map<u64, std::vector<std::string>> disabled_addons;
@@ -600,23 +525,27 @@ struct Values {
extern Values values;
-bool IsConfiguringGlobal();
-void SetConfiguringGlobal(bool is_global);
-
+void UpdateGPUAccuracy();
bool IsGPULevelExtreme();
bool IsGPULevelHigh();
bool IsFastmemEnabled();
+bool IsDockedMode();
+
float Volume();
-std::string GetTimeZoneString();
+std::string GetTimeZoneString(TimeZone time_zone);
void LogSettings();
+void TranslateResolutionInfo(ResolutionSetup setup, ResolutionScalingInfo& info);
void UpdateRescalingInfo();
// Restore the global state of all applicable settings in the Values struct
void RestoreGlobalState(bool is_powered_on);
+bool IsConfiguringGlobal();
+void SetConfiguringGlobal(bool is_global);
+
} // namespace Settings