pineapple-src/src/common/settings.h

452 lines
15 KiB
C
Raw Normal View History

2021-04-15 02:05:28 +00:00
// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <array>
#include <atomic>
#include <chrono>
#include <map>
#include <optional>
#include <string>
2021-07-03 09:00:06 +00:00
#include <utility>
2021-04-15 02:05:28 +00:00
#include <vector>
#include "common/common_types.h"
#include "common/settings_input.h"
2021-07-03 09:00:06 +00:00
#include "input_common/udp/client.h"
2021-04-15 02:05:28 +00:00
namespace Settings {
enum class RendererBackend : u32 {
OpenGL = 0,
Vulkan = 1,
};
enum class GPUAccuracy : u32 {
Normal = 0,
High = 1,
Extreme = 2,
};
enum class CPUAccuracy : u32 {
Accurate = 0,
Unsafe = 1,
DebugMode = 2,
};
2021-07-03 09:00:06 +00:00
/** The BasicSetting 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. Setting a default value and label is required, though subclasses may deviate from
* this requirement.
*/
template <typename Type>
class BasicSetting {
protected:
BasicSetting() = 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 BasicSetting(const Type& global_val) : global{global_val} {}
public:
/**
* Sets a default value, label, and setting value.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param name Label for the setting
*/
explicit BasicSetting(const Type& default_val, const std::string& name)
: default_value{default_val}, global{default_val}, label{name} {}
~BasicSetting() = default;
/**
* Returns a reference to the setting's value.
*
* @returns A reference to the setting
*/
[[nodiscard]] const Type& GetValue() const {
return global;
}
/**
* Sets the setting to the given value.
*
* @param value The desired value
*/
void SetValue(const Type& value) {
Type temp{value};
std::swap(global, 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 value The desired setting value
*
* @returns A reference to the setting
*/
const Type& operator=(const Type& value) {
Type temp{value};
std::swap(global, temp);
return global;
}
/**
* Returns a reference to the setting.
*
* @returns A reference to the setting
*/
explicit operator const Type&() const {
return global;
}
protected:
const Type default_value{}; ///< The default value
Type global{}; ///< The setting
const std::string label{}; ///< The setting's label
};
/**
* The Setting class is a slightly more complex version of the BasicSetting class. This adds a
* custom setting to switch to when a guest application specifically requires it. The effect is that
* other components of the emulator can access the setting's intended value without any need for the
* component to ask whether the custom or global setting is needed at the moment.
*
* By default, the global setting is used.
*
* Like the BasicSetting, this requires setting a default value and label to use.
*/
2021-04-15 02:05:28 +00:00
template <typename Type>
2021-07-03 09:00:06 +00:00
class Setting final : public BasicSetting<Type> {
2021-04-15 02:05:28 +00:00
public:
2021-07-03 09:00:06 +00:00
/**
* Sets a default value, label, and setting value.
*
* @param default_val Intial value of the setting, and default value of the setting
* @param name Label for the setting
*/
explicit Setting(const Type& default_val, const std::string& name)
: BasicSetting<Type>(default_val, name) {}
2021-04-15 02:05:28 +00:00
~Setting() = default;
2021-07-03 09:00:06 +00:00
/**
* Tells this setting to represent either the global or custom setting when other member
* functions are used. Setting to_global to true means using the global setting, to false
* false for the custom setting.
*
* @param to_global Whether to use the global or custom setting.
*/
2021-04-15 02:05:28 +00:00
void SetGlobal(bool to_global) {
use_global = to_global;
}
2021-07-03 09:00:06 +00:00
/**
* Returns whether this setting is using the global setting or not.
*
* @returns The global state
*/
[[nodiscard]] bool UsingGlobal() const {
2021-04-15 02:05:28 +00:00
return use_global;
}
2021-07-03 09:00:06 +00:00
/**
* 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]] const Type& GetValue(bool need_global = false) const {
2021-04-15 02:05:28 +00:00
if (use_global || need_global) {
2021-07-03 09:00:06 +00:00
return this->global;
2021-04-15 02:05:28 +00:00
}
2021-07-03 09:00:06 +00:00
return custom;
2021-04-15 02:05:28 +00:00
}
2021-07-03 09:00:06 +00:00
/**
* Sets the current setting value depending on the global state.
*
* @param value The new value
*/
2021-04-15 02:05:28 +00:00
void SetValue(const Type& value) {
2021-07-03 09:00:06 +00:00
Type temp{value};
2021-04-15 02:05:28 +00:00
if (use_global) {
2021-07-03 09:00:06 +00:00
std::swap(this->global, temp);
2021-04-15 02:05:28 +00:00
} else {
2021-07-03 09:00:06 +00:00
std::swap(custom, temp);
}
}
/**
* Assigns the current setting value depending on the global state.
*
* @param value The new value
*
* @returns A reference to the current setting value
*/
const Type& operator=(const Type& value) {
Type temp{value};
if (use_global) {
std::swap(this->global, temp);
return this->global;
}
std::swap(custom, temp);
return custom;
}
/**
* Returns the current setting value depending on the global state.
*
* @returns A reference to the current setting value
*/
explicit operator const Type&() const {
if (use_global) {
return this->global;
2021-04-15 02:05:28 +00:00
}
2021-07-03 09:00:06 +00:00
return custom;
2021-04-15 02:05:28 +00:00
}
private:
2021-07-03 09:00:06 +00:00
bool use_global{true}; ///< The setting's global state
Type custom{}; ///< The custom value of the setting
2021-04-15 02:05:28 +00:00
};
/**
2021-07-03 09:00:06 +00:00
* The InputSetting class allows for getting a reference to either the global or custom members.
2021-04-15 02:05:28 +00:00
* This is required as we cannot easily modify the values of user-defined types within containers
* using the SetValue() member function found in the Setting class. The primary purpose of this
2021-07-03 09:00:06 +00:00
* class is to store an array of 10 PlayerInput structs for both the global and custom setting and
* allows for easily accessing and modifying both settings.
2021-04-15 02:05:28 +00:00
*/
template <typename Type>
class InputSetting final {
public:
InputSetting() = default;
2021-07-03 09:00:06 +00:00
explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
2021-04-15 02:05:28 +00:00
~InputSetting() = default;
void SetGlobal(bool to_global) {
use_global = to_global;
}
2021-07-03 09:00:06 +00:00
[[nodiscard]] bool UsingGlobal() const {
2021-04-15 02:05:28 +00:00
return use_global;
}
2021-07-03 09:00:06 +00:00
[[nodiscard]] Type& GetValue(bool need_global = false) {
2021-04-15 02:05:28 +00:00
if (use_global || need_global) {
return global;
}
2021-07-03 09:00:06 +00:00
return custom;
2021-04-15 02:05:28 +00:00
}
private:
2021-07-03 09:00:06 +00:00
bool use_global{true}; ///< The setting's global state
Type global{}; ///< The setting
Type custom{}; ///< The custom setting value
2021-04-15 02:05:28 +00:00
};
struct TouchFromButtonMap {
std::string name;
std::vector<std::string> buttons;
};
struct Values {
// Audio
2021-07-03 09:00:06 +00:00
BasicSetting<std::string> audio_device_id{"auto", "output_device"};
BasicSetting<std::string> sink_id{"auto", "output_engine"};
BasicSetting<bool> audio_muted{false, "audio_muted"};
Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
Setting<float> volume{1.0f, "volume"};
2021-04-15 02:05:28 +00:00
// Core
2021-07-03 09:00:06 +00:00
Setting<bool> use_multi_core{true, "use_multi_core"};
2021-04-15 02:05:28 +00:00
// Cpu
2021-07-03 09:00:06 +00:00
Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Accurate, "cpu_accuracy"};
BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
2021-04-15 02:05:28 +00:00
// Renderer
2021-07-03 09:00:06 +00:00
Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
BasicSetting<bool> renderer_debug{false, "debug"};
Setting<int> vulkan_device{0, "vulkan_device"};
Setting<u16> resolution_factor{1, "resolution_factor"};
// *nix platforms may have issues with the borderless windowed fullscreen mode.
// Default to exclusive fullscreen on these platforms for now.
Setting<int> fullscreen_mode{
#ifdef _WIN32
0,
#else
1,
#endif
"fullscreen_mode"};
Setting<int> aspect_ratio{0, "aspect_ratio"};
Setting<int> max_anisotropy{0, "max_anisotropy"};
Setting<bool> use_frame_limit{true, "use_frame_limit"};
Setting<u16> frame_limit{100, "frame_limit"};
Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
Setting<bool> accelerate_astc{true, "accelerate_astc"};
Setting<bool> use_vsync{true, "use_vsync"};
Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
Setting<bool> use_assembly_shaders{false, "use_assembly_shaders"};
Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
Setting<bool> use_caches_gc{false, "use_caches_gc"};
Setting<float> bg_red{0.0f, "bg_red"};
Setting<float> bg_green{0.0f, "bg_green"};
Setting<float> bg_blue{0.0f, "bg_blue"};
2021-04-15 02:05:28 +00:00
// System
2021-07-03 09:00:06 +00:00
Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
2021-04-15 02:05:28 +00:00
// Measured in seconds since epoch
2021-05-17 00:21:13 +00:00
std::optional<std::chrono::seconds> custom_rtc;
2021-04-15 02:05:28 +00:00
// Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
std::chrono::seconds custom_rtc_differential;
2021-07-03 09:00:06 +00:00
BasicSetting<s32> current_user{0, "current_user"};
Setting<s32> language_index{1, "language_index"};
Setting<s32> region_index{1, "region_index"};
Setting<s32> time_zone_index{0, "time_zone_index"};
Setting<s32> sound_index{1, "sound_index"};
2021-04-15 02:05:28 +00:00
// Controls
InputSetting<std::array<PlayerInput, 10>> players;
2021-07-03 09:00:06 +00:00
Setting<bool> use_docked_mode{true, "use_docked_mode"};
2021-04-15 02:05:28 +00:00
2021-07-03 09:00:06 +00:00
Setting<bool> vibration_enabled{true, "vibration_enabled"};
Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
2021-04-15 02:05:28 +00:00
2021-07-03 09:00:06 +00:00
Setting<bool> motion_enabled{true, "motion_enabled"};
BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
"motion_device"};
BasicSetting<std::string> udp_input_servers{InputCommon::CemuhookUDP::DEFAULT_SRV,
"udp_input_servers"};
2021-04-15 02:05:28 +00:00
2021-07-03 09:00:06 +00:00
BasicSetting<bool> mouse_panning{false, "mouse_panning"};
BasicSetting<float> mouse_panning_sensitivity{1.0f, "mouse_panning_sensitivity"};
BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
2021-04-15 02:05:28 +00:00
std::string mouse_device;
MouseButtonsRaw mouse_buttons;
2021-07-03 09:00:06 +00:00
BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
2021-04-15 02:05:28 +00:00
KeyboardKeysRaw keyboard_keys;
KeyboardModsRaw keyboard_mods;
2021-07-03 09:00:06 +00:00
BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
2021-04-15 02:05:28 +00:00
ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs;
TouchscreenInput touchscreen;
2021-07-03 09:00:06 +00:00
BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
"touch_device"};
BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
2021-04-15 02:05:28 +00:00
std::vector<TouchFromButtonMap> touch_from_button_maps;
std::atomic_bool is_device_reload_pending{true};
// Data Storage
2021-07-03 09:00:06 +00:00
BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};
2021-04-15 02:05:28 +00:00
// Debugging
bool record_frame_times;
2021-07-03 09:00:06 +00:00
BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
BasicSetting<u16> gdbstub_port{0, "gdbstub_port"};
BasicSetting<std::string> program_args{std::string(), "program_args"};
BasicSetting<bool> dump_exefs{false, "dump_exefs"};
BasicSetting<bool> dump_nso{false, "dump_nso"};
BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
BasicSetting<bool> reporting_services{false, "reporting_services"};
BasicSetting<bool> quest_flag{false, "quest_flag"};
BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
BasicSetting<bool> extended_logging{false, "extended_logging"};
BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
2021-04-15 02:05:28 +00:00
// Miscellaneous
2021-07-03 09:00:06 +00:00
BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
2021-04-15 02:05:28 +00:00
// Services
2021-07-03 09:00:06 +00:00
BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
2021-04-15 02:05:28 +00:00
// WebService
2021-07-03 09:00:06 +00:00
BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};
2021-04-15 02:05:28 +00:00
// Add-Ons
std::map<u64, std::vector<std::string>> disabled_addons;
};
extern Values values;
bool IsConfiguringGlobal();
void SetConfiguringGlobal(bool is_global);
bool IsGPULevelExtreme();
bool IsGPULevelHigh();
2021-06-07 01:57:28 +00:00
bool IsFastmemEnabled();
2021-04-15 02:05:28 +00:00
float Volume();
std::string GetTimeZoneString();
void LogSettings();
// Restore the global state of all applicable settings in the Values struct
void RestoreGlobalState(bool is_powered_on);
} // namespace Settings