VERY experimental Nintendo Switch 2 emulator
C++
(ui,)settings: Use explicit instantiation
lat9nq5a2b7f951d53
diff --git a/src/audio_core/sink/sink_details.h b/src/audio_core/sink/sink_details.hindex 44403db718..c8498842b9 100644--- a/src/audio_core/sink/sink_details.h+++ b/src/audio_core/sink/sink_details.h@@ -3,13 +3,12 @@#pragma once+#include <memory>#include <string>#include <string_view>#include <vector>+#include "common/settings_enums.h"-namespace Settings {-enum class AudioEngine : u32;-}namespace AudioCore {class AudioManager;diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txtindex 5902dd6171..3c8368bb2b 100644--- a/src/common/CMakeLists.txt+++ b/src/common/CMakeLists.txt@@ -110,9 +110,11 @@ add_library(common STATICscratch_buffer.hsettings.cppsettings.h+ settings_common.hsettings_enums.hsettings_input.cppsettings_input.h+ settings_setting.hsocket_types.hspin_lock.cppspin_lock.hdiff --git a/src/common/settings.cpp b/src/common/settings.cppindex 84e90f8937..10cdea8442 100644--- a/src/common/settings.cpp+++ b/src/common/settings.cpp@@ -7,10 +7,17 @@#include <exception>#include <stdexcept>#endif+#include <compare>+#include <cstddef>+#include <filesystem>+#include <forward_list>#include <functional>#include <string_view>+#include <type_traits>+#include <fmt/core.h>#include "common/assert.h"+#include "common/fs/fs_util.h"#include "common/fs/path_util.h"#include "common/logging/log.h"#include "common/settings.h"@@ -18,6 +25,43 @@namespace Settings {+#define SETTING(TYPE, RANGED) template class Setting<TYPE, RANGED>+#define SWITCHABLE(TYPE, RANGED) template class SwitchableSetting<TYPE, RANGED>++SETTING(AudioEngine, false);+SETTING(bool, false);+SETTING(int, 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+Values values;static bool configuring_global = true;@@ -238,6 +282,14 @@ void UpdateRescalingInfo() {info.active = info.up_scale != 1 || info.down_shift != 0;}+std::string BasicSetting::ToStringGlobal() const {+ return {};+}++bool BasicSetting::UsingGlobal() const {+ return true;+}+void RestoreGlobalState(bool is_powered_on) {// If a game is running, DO NOT restore the global settings stateif (is_powered_on) {diff --git a/src/common/settings.h b/src/common/settings.hindex ec06861207..e03233eaf8 100644--- a/src/common/settings.h+++ b/src/common/settings.h@@ -5,54 +5,21 @@#include <algorithm>#include <array>-#include <forward_list>-#include <functional>#include <map>-#include <optional>+#include <memory>#include <stdexcept>#include <string>-#include <typeindex>-#include <typeinfo>#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 Category : u32 {- Audio,- Core,- Cpu,- CpuDebug,- CpuUnsafe,- Renderer,- RendererAdvanced,- RendererDebug,- System,- SystemAudio,- DataStorage,- Debugging,- DebuggingGraphics,- Miscellaneous,- Network,- WebService,- AddOns,- Controls,- Ui,- UiGeneral,- UiLayout,- UiGameList,- Screenshots,- Shortcuts,- Multiplayer,- Services,- Paths,- MaxEnum,-};-const char* TranslateCategory(Settings::Category category);struct ResolutionScalingInfo {@@ -78,441 +45,45 @@ struct ResolutionScalingInfo {}};-class BasicSetting {-protected:- explicit BasicSetting() = default;--public:- virtual ~BasicSetting() = default;-- virtual Category Category() const = 0;- virtual constexpr bool Switchable() const = 0;- virtual std::string ToString() const = 0;- virtual std::string ToStringGlobal() const {- return {};- }- virtual void LoadString(const std::string& load) = 0;- virtual std::string Canonicalize() const = 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 constexpr bool IsEnum() const = 0;- virtual bool RuntimeModfiable() const = 0;- virtual void SetGlobal(bool global) {}- virtual constexpr u32 Id() const = 0;- virtual std::string MinVal() const = 0;- virtual std::string MaxVal() const = 0;- virtual bool UsingGlobal() const {- return true;- }-};--class Linkage {-public:- explicit Linkage(u32 initial_count = 0);- ~Linkage();- std::map<Category, std::forward_list<BasicSetting*>> by_category{};- std::vector<std::function<void()>> restore_functions{};- u32 count;-};--/** 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 : public BasicSetting {-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 linkage Setting registry- * @param default_val Initial value of the setting, and default value of the setting- * @param name Label for the setting- * @param category_ Category of the setting AKA INI group- */- explicit Setting(Linkage& linkage, const Type& default_val, const std::string& name,- enum Category category_, bool save_ = true, bool runtime_modifiable_ = false)- requires(!ranged)- : value{default_val}, default_value{default_val}, label{name}, category{category_},- id{linkage.count}, save{save_}, runtime_modifiable{runtime_modifiable_} {- linkage.by_category[category].push_front(this);- linkage.count++;- }- virtual ~Setting() = default;-- /**- * 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 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- * @param category_ Category of the setting AKA INI group- */- explicit Setting(Linkage& linkage, const Type& default_val, const Type& min_val,- const Type& max_val, const std::string& name, enum Category category_,- bool save_ = true, bool runtime_modifiable_ = false)- requires(ranged)- : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},- label{name}, category{category_}, id{linkage.count}, save{save_},- runtime_modifiable{runtime_modifiable_} {- linkage.by_category[category].push_front(this);- linkage.count++;- }-- /**- * 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 override {- return label;- }-- /**- * Returns the setting's category AKA INI group.- *- * @returns The setting's category- */- [[nodiscard]] enum Category Category() const override {- return category;- }-- [[nodiscard]] bool RuntimeModfiable() const override {- return runtime_modifiable;- }-- [[nodiscard]] constexpr bool IsEnum() const override {- return std::is_enum<Type>::value;- }-- /**- * Returns whether the current setting is Switchable.- *- * @returns If the setting is a SwitchableSetting- */- [[nodiscard]] virtual constexpr bool Switchable() const override {- return false;- }--protected:- 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_) : "none";- } else if constexpr (std::is_same<Type, bool>()) {- return value_ ? "true" : "false";- } else if (std::is_same<Type, AudioEngine>()) {- return CanonicalizeEnum(value_);- } 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.- *- * @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;- }-- /**- * 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::stoul(input)));- } else if constexpr (std::is_same<Type, bool>()) {- this->SetValue(input == "true");- } else if constexpr (std::is_same<Type, AudioEngine>()) {- this->SetValue(ToEnum<Type>(input));- } else {- this->SetValue(static_cast<Type>(std::stoll(input)));- }- } catch (std::invalid_argument) {- this->SetValue(this->GetDefault());- }- }-- [[nodiscard]] std::string constexpr Canonicalize() const override {- if constexpr (std::is_enum<Type>::value) {- return CanonicalizeEnum(this->GetValue());- }- return ToString(this->GetValue());- }-- /**- * 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));- }-- virtual constexpr u32 Id() const override {- return id;- }-- virtual std::string MinVal() const override {- return this->ToString(minimum);- }- virtual std::string MaxVal() const override {- return this->ToString(maximum);- }--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- const enum Category category; ///< The setting's category AKA INI group- const u32 id;- bool save;- bool runtime_modifiable;-};--/**- * 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 linkage Setting registry- * @param default_val Initial value of the setting, and default value of the setting- * @param name Label for the setting- * @param category_ Category of the setting AKA INI group- */- explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,- Category category, bool save = true, bool runtime_modifiable = false)- requires(!ranged)- : Setting<Type, false>{linkage, default_val, name, category, save, runtime_modifiable} {- linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });- }- virtual ~SwitchableSetting() = default;-- /**- * 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 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- * @param category_ Category of the setting AKA INI group- */- explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,- const Type& max_val, const std::string& name, Category category,- bool save = true, bool runtime_modifiable = false)- requires(ranged)- : Setting<Type, true>{linkage, default_val, min_val, max_val,- name, category, save, runtime_modifiable} {- linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });- }-- /**- * 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) override {- use_global = to_global;- }-- /**- * Returns whether this setting is using the global setting or not.- *- * @returns The global state- */- [[nodiscard]] bool UsingGlobal() const override {- 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);- }- }-- [[nodiscard]] virtual constexpr bool Switchable() const override {- return true;- }-- [[nodiscard]] virtual std::string ToStringGlobal() const override {- return this->ToString(this->value);- }-- /**- * 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-};+// 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/*** The InputSetting class allows for getting a reference to either the global or custom members.diff --git a/src/common/settings_common.h b/src/common/settings_common.hnew file mode 100644index 0000000000..93fddeba65--- /dev/null+++ b/src/common/settings_common.h@@ -0,0 +1,78 @@+#pragma once++#include <forward_list>+#include <functional>+#include <map>+#include <string>+#include <typeindex>+#include "common/common_types.h"++namespace Settings {++enum class Category : u32 {+ Audio,+ Core,+ Cpu,+ CpuDebug,+ CpuUnsafe,+ Renderer,+ RendererAdvanced,+ RendererDebug,+ System,+ SystemAudio,+ DataStorage,+ Debugging,+ DebuggingGraphics,+ Miscellaneous,+ Network,+ WebService,+ AddOns,+ Controls,+ Ui,+ UiGeneral,+ UiLayout,+ UiGameList,+ Screenshots,+ Shortcuts,+ Multiplayer,+ Services,+ Paths,+ MaxEnum,+};++class BasicSetting {+protected:+ explicit BasicSetting() = default;++public:+ virtual ~BasicSetting() = default;++ virtual Category Category() const = 0;+ virtual constexpr bool Switchable() const = 0;+ virtual std::string ToString() const = 0;+ virtual std::string ToStringGlobal() const;+ virtual void LoadString(const std::string& load) = 0;+ virtual std::string Canonicalize() const = 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 constexpr bool IsEnum() const = 0;+ virtual bool RuntimeModfiable() const = 0;+ virtual void SetGlobal(bool global) {}+ virtual constexpr u32 Id() const = 0;+ virtual std::string MinVal() const = 0;+ virtual std::string MaxVal() const = 0;+ virtual bool UsingGlobal() const;+};++class Linkage {+public:+ explicit Linkage(u32 initial_count = 0);+ ~Linkage();+ std::map<Category, std::forward_list<BasicSetting*>> by_category{};+ std::vector<std::function<void()>> restore_functions{};+ u32 count;+};++} // namespace Settingsdiff --git a/src/common/settings_setting.h b/src/common/settings_setting.hnew file mode 100644index 0000000000..f226e38d4f--- /dev/null+++ b/src/common/settings_setting.h@@ -0,0 +1,413 @@+#pragma once++#include <map>+#include <optional>+#include <string>+#include <typeindex>+#include <typeinfo>+#include "common/common_types.h"+#include "common/settings_common.h"+#include "common/settings_enums.h"++namespace Settings {++/** 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 : public BasicSetting {+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},+ default_value{}, maximum{}, minimum{}, label{}, category{Category::Miscellaneous}, id{} {}++public:+ /**+ * 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 name Label for the setting+ * @param category_ Category of the setting AKA INI group+ */+ explicit Setting(Linkage& linkage, const Type& default_val, const std::string& name,+ enum Category category_, bool save_ = true, bool runtime_modifiable_ = false)+ requires(!ranged)+ : value{default_val}, default_value{default_val}, label{name}, category{category_},+ id{linkage.count}, save{save_}, runtime_modifiable{runtime_modifiable_} {+ linkage.by_category[category].push_front(this);+ linkage.count++;+ }+ virtual ~Setting() = default;++ /**+ * 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 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+ * @param category_ Category of the setting AKA INI group+ */+ explicit Setting(Linkage& linkage, const Type& default_val, const Type& min_val,+ const Type& max_val, const std::string& name, enum Category category_,+ bool save_ = true, bool runtime_modifiable_ = false)+ requires(ranged)+ : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},+ label{name}, category{category_}, id{linkage.count}, save{save_},+ runtime_modifiable{runtime_modifiable_} {+ linkage.by_category[category].push_front(this);+ linkage.count++;+ }++ /**+ * 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 override {+ return label;+ }++ /**+ * Returns the setting's category AKA INI group.+ *+ * @returns The setting's category+ */+ [[nodiscard]] enum Category Category() const override {+ return category;+ }++ [[nodiscard]] bool RuntimeModfiable() const override {+ return runtime_modifiable;+ }++ [[nodiscard]] constexpr bool IsEnum() const override {+ return std::is_enum<Type>::value;+ }++ /**+ * Returns whether the current setting is Switchable.+ *+ * @returns If the setting is a SwitchableSetting+ */+ [[nodiscard]] virtual constexpr bool Switchable() const override {+ return false;+ }++protected:+ 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_) : "none";+ } else if constexpr (std::is_same<Type, bool>()) {+ return value_ ? "true" : "false";+ } else if (std::is_same<Type, AudioEngine>()) {+ return CanonicalizeEnum(value_);+ } 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.+ *+ * @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;+ }++ /**+ * 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::stoul(input)));+ } else if constexpr (std::is_same<Type, bool>()) {+ this->SetValue(input == "true");+ } else if constexpr (std::is_same<Type, AudioEngine>()) {+ this->SetValue(ToEnum<Type>(input));+ } else {+ this->SetValue(static_cast<Type>(std::stoll(input)));+ }+ } catch (std::invalid_argument) {+ this->SetValue(this->GetDefault());+ }+ }++ [[nodiscard]] std::string constexpr Canonicalize() const override {+ if constexpr (std::is_enum<Type>::value) {+ return CanonicalizeEnum(this->GetValue());+ }+ return ToString(this->GetValue());+ }++ /**+ * 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));+ }++ virtual constexpr u32 Id() const override {+ return id;+ }++ virtual std::string MinVal() const override {+ return this->ToString(minimum);+ }+ virtual std::string MaxVal() const override {+ return this->ToString(maximum);+ }++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+ const enum Category category; ///< The setting's category AKA INI group+ const u32 id;+ bool save;+ bool runtime_modifiable;+};++/**+ * 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 linkage Setting registry+ * @param default_val Initial value of the setting, and default value of the setting+ * @param name Label for the setting+ * @param category_ Category of the setting AKA INI group+ */+ explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,+ Category category, bool save = true, bool runtime_modifiable = false)+ requires(!ranged)+ : Setting<Type, false>{linkage, default_val, name, category, save, runtime_modifiable} {+ linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });+ }+ virtual ~SwitchableSetting() = default;++ /**+ * 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 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+ * @param category_ Category of the setting AKA INI group+ */+ explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,+ const Type& max_val, const std::string& name, Category category,+ bool save = true, bool runtime_modifiable = false)+ requires(ranged)+ : Setting<Type, true>{linkage, default_val, min_val, max_val,+ name, category, save, runtime_modifiable} {+ linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });+ }++ /**+ * 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) override {+ use_global = to_global;+ }++ /**+ * Returns whether this setting is using the global setting or not.+ *+ * @returns The global state+ */+ [[nodiscard]] bool UsingGlobal() const override {+ 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);+ }+ }++ [[nodiscard]] virtual constexpr bool Switchable() const override {+ return true;+ }++ [[nodiscard]] virtual std::string ToStringGlobal() const override {+ return this->ToString(this->value);+ }++ /**+ * 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+};++} // namespace Settingsdiff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cppindex 051756452e..ba18479761 100644--- a/src/yuzu/configuration/config.cpp+++ b/src/yuzu/configuration/config.cpp@@ -102,9 +102,9 @@ const std::map<Settings::RendererBackend, QString> Config::renderer_backend_text};const std::map<Settings::ShaderBackend, QString> Config::shader_backend_texts_map = {- {Settings::ShaderBackend::GLSL, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},- {Settings::ShaderBackend::GLASM, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},- {Settings::ShaderBackend::SPIRV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},+ {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},+ {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},+ {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},};// This shouldn't have anything except static initializers (no functions). Sodiff --git a/src/yuzu/configuration/shared_widget.cpp b/src/yuzu/configuration/shared_widget.cppindex efb3b329c5..6142c3cb92 100644--- a/src/yuzu/configuration/shared_widget.cpp+++ b/src/yuzu/configuration/shared_widget.cpp@@ -21,7 +21,10 @@#include <QStyle>#include <QValidator>#include <QWidget>+#include <fmt/core.h>+#include "common/assert.h"#include "common/common_types.h"+#include "common/logging/log.h"#include "common/settings.h"#include "yuzu/configuration/configuration_shared.h"#include "yuzu/configuration/shared_translation.h"diff --git a/src/yuzu/uisettings.cpp b/src/yuzu/uisettings.cppindex 2c1b547fba..2a02a27bc6 100644--- a/src/yuzu/uisettings.cpp+++ b/src/yuzu/uisettings.cpp@@ -3,6 +3,16 @@#include "yuzu/uisettings.h"+namespace Settings {+template class Setting<bool>;+template class Setting<std::string>;+template class Setting<u16, true>;+template class Setting<u32>;+template class Setting<u8, true>;+template class Setting<u8>;+template class Setting<unsigned long long>;+} // namespace Settings+namespace UISettings {const Themes themes{{diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.hindex a734513ea4..2152b0b3bf 100644--- a/src/yuzu/uisettings.h+++ b/src/yuzu/uisettings.h@@ -17,6 +17,16 @@using Settings::Category;using Settings::Setting;+namespace Settings {+extern template class Setting<bool>;+extern template class Setting<std::string>;+extern template class Setting<u16, true>;+extern template class Setting<u32>;+extern template class Setting<u8, true>;+extern template class Setting<u8>;+extern template class Setting<unsigned long long>;+} // namespace Settings+namespace UISettings {bool IsDarkTheme();