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

configuration: change config interfaces to use config-specific pointers

Browse Source 
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
This commit is contained in:
lat9nq
2020-06-18 14:24:58 -04:00
parent 4342f759a3
commit e66c9a79b5
21 changed files with 418 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/core/settings.cpp
View File

@@ -66,6 +66,7 @@ const std::array<const char*, NumMouseButtons> mapping = {{
Values global_values;
Values game_values;
Values *values = &global_values;
Values *config_values = &global_values;
void CopyValues(Values& dst, const Values& src) {
dst.udp_input_address = src.udp_input_address;
@@ -115,6 +116,16 @@ void SwapValues(ValuesSwapTarget target) {
}
}
void SwapConfigValues(ValuesSwapTarget target) {
if (target == ValuesSwapTarget::ToGlobal) {
config_values = &global_values;
}
else {
CopyValues(game_values, global_values);
config_values = &game_values;
}
}
std::string GetTimeZoneString() {
static constexpr std::array<const char*, 46> timezones{{
"auto", "default", "CET", "CST6CDT", "Cuba", "EET", "Egypt", "Eire",

4
src/core/settings.h
View File

@@ -497,16 +497,18 @@ struct Values {
extern Values global_values;
extern Values game_values;
extern Values *values;
extern Values *config_values;
float Volume();
void CopyValues(Values& dst, const Values& src);
enum class ValuesSwapTarget {
ToGlobal,
ToGame,
};
void CopyValues(Values& dst, const Values& src);
void SwapValues(ValuesSwapTarget target);
void SwapConfigValues(ValuesSwapTarget target);
bool IsGPULevelExtreme();
bool IsGPULevelHigh();

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

@@ -234,8 +234,8 @@ const std::array<UISettings::Shortcut, 16> Config::default_hotkeys{{
// clang-format on
void Config::ReadPlayerValues() {
for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
auto& player = Settings::values->players[p];
for (std::size_t p = 0; p < Settings::config_values->players.size(); ++p) {
auto& player = Settings::config_values->players[p];
player.connected =
ReadSetting(QStringLiteral("player_%1_connected").arg(p), false).toBool();
@@ -299,19 +299,19 @@ void Config::ReadPlayerValues() {
}
std::stable_partition(
Settings::values->players.begin(),
Settings::values->players.begin() +
Settings::config_values->players.begin(),
Settings::config_values->players.begin() +
Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
[](const auto& player) { return player.connected; });
}
void Config::ReadDebugValues() {
Settings::values->debug_pad_enabled =
Settings::config_values->debug_pad_enabled =
ReadSetting(QStringLiteral("debug_pad_enabled"), false).toBool();
for (int i = 0; i < Settings::NativeButton::NumButtons; ++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::config_values->debug_pad_buttons[i];
debug_pad_buttons = qt_config
->value(QStringLiteral("debug_pad_") +
@@ -328,7 +328,7 @@ void Config::ReadDebugValues() {
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
auto& debug_pad_analogs = Settings::values->debug_pad_analogs[i];
auto& debug_pad_analogs = Settings::config_values->debug_pad_analogs[i];
debug_pad_analogs = qt_config
->value(QStringLiteral("debug_pad_") +
@@ -343,26 +343,29 @@ void Config::ReadDebugValues() {
}
void Config::ReadKeyboardValues() {
Settings::values->keyboard_enabled =
Settings::config_values->keyboard_enabled =
ReadSetting(QStringLiteral("keyboard_enabled"), false).toBool();
std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
Settings::values->keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
Settings::config_values->keyboard_keys.begin(),
InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::values->keyboard_keys.begin() +
Settings::config_values->keyboard_keys.begin() +
Settings::NativeKeyboard::LeftControlKey,
InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::values->keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
Settings::config_values->keyboard_mods.begin(),
InputCommon::GenerateKeyboardParam);
}
void Config::ReadMouseValues() {
Settings::values->mouse_enabled = ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
Settings::config_values->mouse_enabled =
ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
auto& mouse_buttons = Settings::values->mouse_buttons[i];
auto& mouse_buttons = Settings::config_values->mouse_buttons[i];
mouse_buttons = qt_config
->value(QStringLiteral("mouse_") +
@@ -377,25 +380,26 @@ void Config::ReadMouseValues() {
}
void Config::ReadTouchscreenValues() {
Settings::values->touchscreen.enabled =
Settings::config_values->touchscreen.enabled =
ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool();
Settings::values->touchscreen.device =
Settings::config_values->touchscreen.device =
ReadSetting(QStringLiteral("touchscreen_device"), QStringLiteral("engine:emu_window"))
.toString()
.toStdString();
Settings::values->touchscreen.finger =
Settings::config_values->touchscreen.finger =
ReadSetting(QStringLiteral("touchscreen_finger"), 0).toUInt();
Settings::values->touchscreen.rotation_angle =
Settings::config_values->touchscreen.rotation_angle =
ReadSetting(QStringLiteral("touchscreen_angle"), 0).toUInt();
Settings::values->touchscreen.diameter_x =
Settings::config_values->touchscreen.diameter_x =
ReadSetting(QStringLiteral("touchscreen_diameter_x"), 15).toUInt();
Settings::values->touchscreen.diameter_y =
Settings::config_values->touchscreen.diameter_y =
ReadSetting(QStringLiteral("touchscreen_diameter_y"), 15).toUInt();
}
void Config::ApplyDefaultProfileIfInputInvalid() {
if (!std::any_of(Settings::values->players.begin(), Settings::values->players.end(),
if (!std::any_of(Settings::config_values->players.begin(),
Settings::config_values->players.end(),
[](const Settings::PlayerInput& in) { return in.connected; })) {
ApplyInputProfileConfiguration(UISettings::values.profile_index);
}
@@ -404,16 +408,17 @@ void Config::ApplyDefaultProfileIfInputInvalid() {
void Config::ReadAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
Settings::values->sink_id = ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
.toString()
.toStdString();
Settings::values->enable_audio_stretching =
Settings::config_values->sink_id =
ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
.toString()
.toStdString();
Settings::config_values->enable_audio_stretching =
ReadSetting(QStringLiteral("enable_audio_stretching"), true).toBool();
Settings::values->audio_device_id =
Settings::config_values->audio_device_id =
ReadSetting(QStringLiteral("output_device"), QStringLiteral("auto"))
.toString()
.toStdString();
Settings::values->volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
Settings::config_values->volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
qt_config->endGroup();
}
@@ -427,20 +432,20 @@ void Config::ReadControlValues() {
ReadMouseValues();
ReadTouchscreenValues();
Settings::values->motion_device =
Settings::config_values->motion_device =
ReadSetting(QStringLiteral("motion_device"),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
.toString()
.toStdString();
Settings::values->udp_input_address =
Settings::config_values->udp_input_address =
ReadSetting(QStringLiteral("udp_input_address"),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
.toString()
.toStdString();
Settings::values->udp_input_port = static_cast<u16>(
Settings::config_values->udp_input_port = static_cast<u16>(
ReadSetting(QStringLiteral("udp_input_port"), InputCommon::CemuhookUDP::DEFAULT_PORT)
.toInt());
Settings::values->udp_pad_index =
Settings::config_values->udp_pad_index =
static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
qt_config->endGroup();
@@ -449,7 +454,8 @@ void Config::ReadControlValues() {
void Config::ReadCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
Settings::values->use_multi_core = ReadSetting(QStringLiteral("use_multi_core"), false).toBool();
Settings::config_values->use_multi_core =
ReadSetting(QStringLiteral("use_multi_core"), false).toBool();
qt_config->endGroup();
}
@@ -457,7 +463,8 @@ void Config::ReadCoreValues() {
void Config::ReadDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
Settings::values->use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
Settings::config_values->use_virtual_sd =
ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
FileUtil::GetUserPath(
FileUtil::UserPath::NANDDir,
qt_config
@@ -493,25 +500,25 @@ void Config::ReadDataStorageValues() {
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)))
.toString()
.toStdString());
Settings::values->gamecard_inserted =
Settings::config_values->gamecard_inserted =
ReadSetting(QStringLiteral("gamecard_inserted"), false).toBool();
Settings::values->gamecard_current_game =
Settings::config_values->gamecard_current_game =
ReadSetting(QStringLiteral("gamecard_current_game"), false).toBool();
Settings::values->gamecard_path =
Settings::config_values->gamecard_path =
ReadSetting(QStringLiteral("gamecard_path"), QStringLiteral("")).toString().toStdString();
Settings::values->nand_total_size = static_cast<Settings::NANDTotalSize>(
Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
ReadSetting(QStringLiteral("nand_total_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDTotalSize::S29_1GB)))
.toULongLong());
Settings::values->nand_user_size = static_cast<Settings::NANDUserSize>(
Settings::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
ReadSetting(QStringLiteral("nand_user_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDUserSize::S26GB)))
.toULongLong());
Settings::values->nand_system_size = static_cast<Settings::NANDSystemSize>(
Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
ReadSetting(QStringLiteral("nand_system_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDSystemSize::S2_5GB)))
.toULongLong());
Settings::values->sdmc_size = static_cast<Settings::SDMCSize>(
Settings::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
ReadSetting(QStringLiteral("sdmc_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)))
.toULongLong());
@@ -523,20 +530,22 @@ void Config::ReadDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
// Intentionally not using the QT default setting as this is intended to be changed in the ini
Settings::values->record_frame_times =
Settings::config_values->record_frame_times =
qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
Settings::values->use_gdbstub = ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
Settings::values->gdbstub_port = ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
Settings::values->program_args =
Settings::config_values->use_gdbstub =
ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
Settings::config_values->gdbstub_port =
ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
Settings::config_values->program_args =
ReadSetting(QStringLiteral("program_args"), QStringLiteral("")).toString().toStdString();
Settings::values->dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
Settings::values->dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
Settings::values->reporting_services =
Settings::config_values->dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
Settings::config_values->dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
Settings::config_values->reporting_services =
ReadSetting(QStringLiteral("reporting_services"), false).toBool();
Settings::values->quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
Settings::values->disable_cpu_opt =
Settings::config_values->quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
Settings::config_values->disable_cpu_opt =
ReadSetting(QStringLiteral("disable_cpu_opt"), false).toBool();
Settings::values->disable_macro_jit =
Settings::config_values->disable_macro_jit =
ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
qt_config->endGroup();
@@ -544,11 +553,11 @@ void Config::ReadDebuggingValues() {
void Config::ReadServiceValues() {
qt_config->beginGroup(QStringLiteral("Services"));
Settings::values->bcat_backend =
Settings::config_values->bcat_backend =
ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("null"))
.toString()
.toStdString();
Settings::values->bcat_boxcat_local =
Settings::config_values->bcat_boxcat_local =
ReadSetting(QStringLiteral("bcat_boxcat_local"), false).toBool();
qt_config->endGroup();
}
@@ -576,12 +585,13 @@ void Config::ReadDisabledAddOnValues() {
void Config::ReadMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
Settings::values->log_filter =
Settings::config_values->log_filter =
ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
.toString()
.toStdString();
Settings::values->use_dev_keys = ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
Settings::values->use_global_values =
Settings::config_values->use_dev_keys =
ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
Settings::config_values->use_global_values =
ReadSetting(QStringLiteral("use_global_values"), true).toBool();
qt_config->endGroup();
@@ -632,32 +642,35 @@ void Config::ReadPathValues() {
void Config::ReadRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
Settings::values->renderer_backend =
Settings::config_values->renderer_backend =
static_cast<Settings::RendererBackend>(ReadSetting(QStringLiteral("backend"), 0).toInt());
Settings::values->renderer_debug = ReadSetting(QStringLiteral("debug"), false).toBool();
Settings::values->vulkan_device = ReadSetting(QStringLiteral("vulkan_device"), 0).toInt();
Settings::values->aspect_ratio = ReadSetting(QStringLiteral("aspect_ratio"), 0).toInt();
Settings::values->max_anisotropy = ReadSetting(QStringLiteral("max_anisotropy"), 0).toInt();
Settings::values->use_frame_limit =
Settings::config_values->renderer_debug = ReadSetting(QStringLiteral("debug"), false).toBool();
Settings::config_values->vulkan_device =
ReadSetting(QStringLiteral("vulkan_device"), 0).toInt();
Settings::config_values->aspect_ratio =
ReadSetting(QStringLiteral("aspect_ratio"), 0).toInt();
Settings::config_values->max_anisotropy =
ReadSetting(QStringLiteral("max_anisotropy"), 0).toInt();
Settings::config_values->use_frame_limit =
ReadSetting(QStringLiteral("use_frame_limit"), true).toBool();
Settings::values->frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
Settings::values->use_disk_shader_cache =
Settings::config_values->frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
Settings::config_values->use_disk_shader_cache =
ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
const int gpu_accuracy_level = ReadSetting(QStringLiteral("gpu_accuracy"), 0).toInt();
Settings::values->gpu_accuracy = static_cast<Settings::GPUAccuracy>(gpu_accuracy_level);
Settings::values->use_asynchronous_gpu_emulation =
Settings::config_values->gpu_accuracy = static_cast<Settings::GPUAccuracy>(gpu_accuracy_level);
Settings::config_values->use_asynchronous_gpu_emulation =
ReadSetting(QStringLiteral("use_asynchronous_gpu_emulation"), false).toBool();
Settings::values->use_vsync = ReadSetting(QStringLiteral("use_vsync"), true).toBool();
Settings::values->use_assembly_shaders =
Settings::config_values->use_vsync = ReadSetting(QStringLiteral("use_vsync"), true).toBool();
Settings::config_values->use_assembly_shaders =
ReadSetting(QStringLiteral("use_assembly_shaders"), false).toBool();
Settings::values->use_fast_gpu_time =
Settings::config_values->use_fast_gpu_time =
ReadSetting(QStringLiteral("use_fast_gpu_time"), true).toBool();
Settings::values->force_30fps_mode =
Settings::config_values->force_30fps_mode =
ReadSetting(QStringLiteral("force_30fps_mode"), false).toBool();
Settings::values->bg_red = ReadSetting(QStringLiteral("bg_red"), 0.0).toFloat();
Settings::values->bg_green = ReadSetting(QStringLiteral("bg_green"), 0.0).toFloat();
Settings::values->bg_blue = ReadSetting(QStringLiteral("bg_blue"), 0.0).toFloat();
Settings::config_values->bg_red = ReadSetting(QStringLiteral("bg_red"), 0.0).toFloat();
Settings::config_values->bg_green = ReadSetting(QStringLiteral("bg_green"), 0.0).toFloat();
Settings::config_values->bg_blue = ReadSetting(QStringLiteral("bg_blue"), 0.0).toFloat();
qt_config->endGroup();
}
@@ -686,35 +699,39 @@ void Config::ReadShortcutValues() {
void Config::ReadSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
Settings::values->use_docked_mode =
Settings::config_values->use_docked_mode =
ReadSetting(QStringLiteral("use_docked_mode"), false).toBool();
Settings::values->current_user = std::clamp<int>(
Settings::config_values->current_user = std::clamp<int>(
ReadSetting(QStringLiteral("current_user"), 0).toInt(), 0, Service::Account::MAX_USERS - 1);
Settings::values->language_index = ReadSetting(QStringLiteral("language_index"), 1).toInt();
Settings::config_values->language_index =
ReadSetting(QStringLiteral("language_index"), 1).toInt();
Settings::values->region_index = ReadSetting(QStringLiteral("region_index"), 1).toInt();
Settings::config_values->region_index =
ReadSetting(QStringLiteral("region_index"), 1).toInt();
Settings::values->time_zone_index = ReadSetting(QStringLiteral("time_zone_index"), 0).toInt();
Settings::config_values->time_zone_index =
ReadSetting(QStringLiteral("time_zone_index"), 0).toInt();
const auto rng_seed_enabled = ReadSetting(QStringLiteral("rng_seed_enabled"), false).toBool();
if (rng_seed_enabled) {
Settings::values->rng_seed = ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
Settings::config_values->rng_seed =
ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
} else {
Settings::values->rng_seed = std::nullopt;
Settings::config_values->rng_seed = std::nullopt;
}
const auto custom_rtc_enabled =
ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
if (custom_rtc_enabled) {
Settings::values->custom_rtc =
Settings::config_values->custom_rtc =
std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
} else {
Settings::values->custom_rtc = std::nullopt;
Settings::config_values->custom_rtc = std::nullopt;
}
Settings::values->sound_index = ReadSetting(QStringLiteral("sound_index"), 1).toInt();
Settings::config_values->sound_index = ReadSetting(QStringLiteral("sound_index"), 1).toInt();
qt_config->endGroup();
}
@@ -793,15 +810,15 @@ void Config::ReadUILayoutValues() {
void Config::ReadWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
Settings::values->enable_telemetry =
Settings::config_values->enable_telemetry =
ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
Settings::values->web_api_url =
Settings::config_values->web_api_url =
ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.yuzu-emu.org"))
.toString()
.toStdString();
Settings::values->yuzu_username =
Settings::config_values->yuzu_username =
ReadSetting(QStringLiteral("yuzu_username")).toString().toStdString();
Settings::values->yuzu_token =
Settings::config_values->yuzu_token =
ReadSetting(QStringLiteral("yuzu_token")).toString().toStdString();
qt_config->endGroup();
@@ -814,8 +831,8 @@ void Config::ReadValues() {
ReadWebServiceValues();
ReadDisabledAddOnValues();
ReadUIValues();
ReadControlValues();
}
ReadControlValues();
ReadCoreValues();
ReadRendererValues();
ReadAudioValues();
@@ -825,8 +842,8 @@ void Config::ReadValues() {
}
void Config::SavePlayerValues() {
for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
const auto& player = Settings::values->players[p];
for (std::size_t p = 0; p < Settings::config_values->players.size(); ++p) {
const auto& player = Settings::config_values->players[p];
WriteSetting(QStringLiteral("player_%1_connected").arg(p), player.connected, false);
WriteSetting(QStringLiteral("player_%1_type").arg(p), static_cast<u8>(player.type),
@@ -862,12 +879,13 @@ void Config::SavePlayerValues() {
}
void Config::SaveDebugValues() {
WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::values->debug_pad_enabled, false);
WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::config_values->debug_pad_enabled,
false);
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
WriteSetting(QStringLiteral("debug_pad_") +
QString::fromStdString(Settings::NativeButton::mapping[i]),
QString::fromStdString(Settings::values->debug_pad_buttons[i]),
QString::fromStdString(Settings::config_values->debug_pad_buttons[i]),
QString::fromStdString(default_param));
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
@@ -876,26 +894,26 @@ void Config::SaveDebugValues() {
default_analogs[i][3], default_analogs[i][4], 0.5f);
WriteSetting(QStringLiteral("debug_pad_") +
QString::fromStdString(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(Settings::values->debug_pad_analogs[i]),
QString::fromStdString(Settings::config_values->debug_pad_analogs[i]),
QString::fromStdString(default_param));
}
}
void Config::SaveMouseValues() {
WriteSetting(QStringLiteral("mouse_enabled"), Settings::values->mouse_enabled, false);
WriteSetting(QStringLiteral("mouse_enabled"), Settings::config_values->mouse_enabled, false);
for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
WriteSetting(QStringLiteral("mouse_") +
QString::fromStdString(Settings::NativeMouseButton::mapping[i]),
QString::fromStdString(Settings::values->mouse_buttons[i]),
QString::fromStdString(Settings::config_values->mouse_buttons[i]),
QString::fromStdString(default_param));
}
}
void Config::SaveTouchscreenValues() {
const auto& touchscreen = Settings::values->touchscreen;
const auto& touchscreen = Settings::config_values->touchscreen;
WriteSetting(QStringLiteral("touchscreen_enabled"), touchscreen.enabled, true);
WriteSetting(QStringLiteral("touchscreen_device"), QString::fromStdString(touchscreen.device),
@@ -914,8 +932,8 @@ void Config::SaveValues() {
SaveWebServiceValues();
SaveDisabledAddOnValues();
SaveUIValues();
SaveControlValues();
}
SaveControlValues();
SaveCoreValues();
SaveRendererValues();
SaveAudioValues();
@@ -927,13 +945,15 @@ void Config::SaveValues() {
void Config::SaveAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
WriteSetting(QStringLiteral("output_engine"), QString::fromStdString(Settings::values->sink_id),
WriteSetting(QStringLiteral("output_engine"),
QString::fromStdString(Settings::config_values->sink_id),
QStringLiteral("auto"));
WriteSetting(QStringLiteral("enable_audio_stretching"),
Settings::values->enable_audio_stretching, true);
Settings::config_values->enable_audio_stretching, true);
WriteSetting(QStringLiteral("output_device"),
QString::fromStdString(Settings::values->audio_device_id), QStringLiteral("auto"));
WriteSetting(QStringLiteral("volume"), Settings::values->volume, 1.0f);
QString::fromStdString(Settings::config_values->audio_device_id),
QStringLiteral("auto"));
WriteSetting(QStringLiteral("volume"), Settings::config_values->volume, 1.0f);
qt_config->endGroup();
}
@@ -947,15 +967,16 @@ void Config::SaveControlValues() {
SaveTouchscreenValues();
WriteSetting(QStringLiteral("motion_device"),
QString::fromStdString(Settings::values->motion_device),
QString::fromStdString(Settings::config_values->motion_device),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values->keyboard_enabled, false);
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::config_values->keyboard_enabled,
false);
WriteSetting(QStringLiteral("udp_input_address"),
QString::fromStdString(Settings::values->udp_input_address),
QString::fromStdString(Settings::config_values->udp_input_address),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
WriteSetting(QStringLiteral("udp_input_port"), Settings::values->udp_input_port,
WriteSetting(QStringLiteral("udp_input_port"), Settings::config_values->udp_input_port,
InputCommon::CemuhookUDP::DEFAULT_PORT);
WriteSetting(QStringLiteral("udp_pad_index"), Settings::values->udp_pad_index, 0);
WriteSetting(QStringLiteral("udp_pad_index"), Settings::config_values->udp_pad_index, 0);
qt_config->endGroup();
}
@@ -963,7 +984,7 @@ void Config::SaveControlValues() {
void Config::SaveCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
WriteSetting(QStringLiteral("use_multi_core"), Settings::values->use_multi_core, false);
WriteSetting(QStringLiteral("use_multi_core"), Settings::config_values->use_multi_core, false);
qt_config->endGroup();
}
@@ -971,7 +992,7 @@ void Config::SaveCoreValues() {
void Config::SaveDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values->use_virtual_sd, true);
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::config_values->use_virtual_sd, true);
WriteSetting(QStringLiteral("nand_directory"),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
@@ -987,22 +1008,27 @@ void Config::SaveDataStorageValues() {
WriteSetting(QStringLiteral("cache_directory"),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)));
WriteSetting(QStringLiteral("gamecard_inserted"), Settings::values->gamecard_inserted, false);
WriteSetting(QStringLiteral("gamecard_current_game"), Settings::values->gamecard_current_game,
WriteSetting(QStringLiteral("gamecard_inserted"), Settings::config_values->gamecard_inserted,
false);
WriteSetting(QStringLiteral("gamecard_current_game"),
Settings::config_values->gamecard_current_game, false);
WriteSetting(QStringLiteral("gamecard_path"),
QString::fromStdString(Settings::values->gamecard_path), QStringLiteral(""));
QString::fromStdString(Settings::config_values->gamecard_path),
QStringLiteral(""));
WriteSetting(QStringLiteral("nand_total_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_total_size)),
QVariant::fromValue<u64>(static_cast<u64>(
Settings::config_values->nand_total_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDTotalSize::S29_1GB)));
WriteSetting(QStringLiteral("nand_user_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_user_size)),
QVariant::fromValue<u64>(static_cast<u64>(
Settings::config_values->nand_user_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDUserSize::S26GB)));
WriteSetting(QStringLiteral("nand_system_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::values->nand_system_size)),
QVariant::fromValue<u64>(
static_cast<u64>(Settings::config_values->nand_system_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDSystemSize::S2_5GB)));
WriteSetting(QStringLiteral("sdmc_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::values->sdmc_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::config_values->sdmc_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)));
qt_config->endGroup();
}
@@ -1011,16 +1037,19 @@ void Config::SaveDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
// 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);
WriteSetting(QStringLiteral("use_gdbstub"), Settings::values->use_gdbstub, false);
WriteSetting(QStringLiteral("gdbstub_port"), Settings::values->gdbstub_port, 24689);
qt_config->setValue(QStringLiteral("record_frame_times"),
Settings::config_values->record_frame_times);
WriteSetting(QStringLiteral("use_gdbstub"), Settings::config_values->use_gdbstub, false);
WriteSetting(QStringLiteral("gdbstub_port"), Settings::config_values->gdbstub_port, 24689);
WriteSetting(QStringLiteral("program_args"),
QString::fromStdString(Settings::values->program_args), QStringLiteral(""));
WriteSetting(QStringLiteral("dump_exefs"), Settings::values->dump_exefs, false);
WriteSetting(QStringLiteral("dump_nso"), Settings::values->dump_nso, false);
WriteSetting(QStringLiteral("quest_flag"), Settings::values->quest_flag, false);
WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::values->disable_cpu_opt, false);
WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values->disable_macro_jit, false);
QString::fromStdString(Settings::config_values->program_args), QStringLiteral(""));
WriteSetting(QStringLiteral("dump_exefs"), Settings::config_values->dump_exefs, false);
WriteSetting(QStringLiteral("dump_nso"), Settings::config_values->dump_nso, false);
WriteSetting(QStringLiteral("quest_flag"), Settings::config_values->quest_flag, false);
WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::config_values->disable_cpu_opt,
false);
WriteSetting(QStringLiteral("disable_macro_jit"), Settings::config_values->disable_macro_jit,
false);
qt_config->endGroup();
}
@@ -1028,8 +1057,10 @@ void Config::SaveDebuggingValues() {
void Config::SaveServiceValues() {
qt_config->beginGroup(QStringLiteral("Services"));
WriteSetting(QStringLiteral("bcat_backend"),
QString::fromStdString(Settings::values->bcat_backend), QStringLiteral("null"));
WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::values->bcat_boxcat_local, false);
QString::fromStdString(Settings::config_values->bcat_backend),
QStringLiteral("null"));
WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::config_values->bcat_boxcat_local,
false);
qt_config->endGroup();
}
@@ -1056,10 +1087,12 @@ void Config::SaveDisabledAddOnValues() {
void Config::SaveMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values->log_filter),
WriteSetting(QStringLiteral("log_filter"),
QString::fromStdString(Settings::config_values->log_filter),
QStringLiteral("*:Info"));
WriteSetting(QStringLiteral("use_dev_keys"), Settings::values->use_dev_keys, false);
WriteSetting(QStringLiteral("use_global_values"), Settings::values->use_global_values, true);
WriteSetting(QStringLiteral("use_dev_keys"), Settings::config_values->use_dev_keys, false);
WriteSetting(QStringLiteral("use_global_values"), Settings::config_values->use_global_values,
true);
qt_config->endGroup();
}
@@ -1087,29 +1120,35 @@ void Config::SavePathValues() {
void Config::SaveRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
WriteSetting(QStringLiteral("backend"), static_cast<int>(Settings::values->renderer_backend), 0);
WriteSetting(QStringLiteral("debug"), Settings::values->renderer_debug, false);
WriteSetting(QStringLiteral("vulkan_device"), Settings::values->vulkan_device, 0);
WriteSetting(QStringLiteral("aspect_ratio"), Settings::values->aspect_ratio, 0);
WriteSetting(QStringLiteral("max_anisotropy"), Settings::values->max_anisotropy, 0);
WriteSetting(QStringLiteral("use_frame_limit"), Settings::values->use_frame_limit, true);
WriteSetting(QStringLiteral("frame_limit"), Settings::values->frame_limit, 100);
WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values->use_disk_shader_cache,
true);
WriteSetting(QStringLiteral("gpu_accuracy"), static_cast<int>(Settings::values->gpu_accuracy),
0);
WriteSetting(QStringLiteral("backend"),
static_cast<int>(Settings::config_values->renderer_backend), 0);
WriteSetting(QStringLiteral("debug"), Settings::config_values->renderer_debug, false);
WriteSetting(QStringLiteral("vulkan_device"), Settings::config_values->vulkan_device, 0);
WriteSetting(QStringLiteral("aspect_ratio"), Settings::config_values->aspect_ratio, 0);
WriteSetting(QStringLiteral("max_anisotropy"), Settings::config_values->max_anisotropy, 0);
WriteSetting(QStringLiteral("use_frame_limit"), Settings::config_values->use_frame_limit, true);
WriteSetting(QStringLiteral("frame_limit"), Settings::config_values->frame_limit, 100);
WriteSetting(QStringLiteral("use_disk_shader_cache"),
Settings::config_values->use_disk_shader_cache, true);
WriteSetting(QStringLiteral("gpu_accuracy"),
static_cast<int>(Settings::config_values->gpu_accuracy), 0);
WriteSetting(QStringLiteral("use_asynchronous_gpu_emulation"),
Settings::values->use_asynchronous_gpu_emulation, false);
WriteSetting(QStringLiteral("use_vsync"), Settings::values->use_vsync, true);
WriteSetting(QStringLiteral("use_assembly_shaders"), Settings::values->use_assembly_shaders,
false);
WriteSetting(QStringLiteral("use_fast_gpu_time"), Settings::values->use_fast_gpu_time, true);
WriteSetting(QStringLiteral("force_30fps_mode"), Settings::values->force_30fps_mode, false);
Settings::config_values->use_asynchronous_gpu_emulation, false);
WriteSetting(QStringLiteral("use_vsync"), Settings::config_values->use_vsync, true);
WriteSetting(QStringLiteral("use_assembly_shaders"),
Settings::config_values->use_assembly_shaders, false);
WriteSetting(QStringLiteral("use_fast_gpu_time"),
Settings::config_values->use_fast_gpu_time, true);
WriteSetting(QStringLiteral("force_30fps_mode"),
Settings::config_values->force_30fps_mode, false);
// Cast to double because Qt's written float values are not human-readable
WriteSetting(QStringLiteral("bg_red"), static_cast<double>(Settings::values->bg_red), 0.0);
WriteSetting(QStringLiteral("bg_green"), static_cast<double>(Settings::values->bg_green), 0.0);
WriteSetting(QStringLiteral("bg_blue"), static_cast<double>(Settings::values->bg_blue), 0.0);
WriteSetting(QStringLiteral("bg_red"),
static_cast<double>(Settings::config_values->bg_red), 0.0);
WriteSetting(QStringLiteral("bg_green"),
static_cast<double>(Settings::config_values->bg_green), 0.0);
WriteSetting(QStringLiteral("bg_blue"),
static_cast<double>(Settings::config_values->bg_blue), 0.0);
qt_config->endGroup();
}
@@ -1137,23 +1176,25 @@ void Config::SaveShortcutValues() {
void Config::SaveSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
WriteSetting(QStringLiteral("use_docked_mode"), Settings::values->use_docked_mode, false);
WriteSetting(QStringLiteral("current_user"), Settings::values->current_user, 0);
WriteSetting(QStringLiteral("language_index"), Settings::values->language_index, 1);
WriteSetting(QStringLiteral("region_index"), Settings::values->region_index, 1);
WriteSetting(QStringLiteral("time_zone_index"), Settings::values->time_zone_index, 0);
WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::values->rng_seed.has_value(), false);
WriteSetting(QStringLiteral("rng_seed"), Settings::values->rng_seed.value_or(0), 0);
WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values->custom_rtc.has_value(),
WriteSetting(QStringLiteral("use_docked_mode"), Settings::config_values->use_docked_mode,
false);
WriteSetting(QStringLiteral("current_user"), Settings::config_values->current_user, 0);
WriteSetting(QStringLiteral("language_index"), Settings::config_values->language_index, 1);
WriteSetting(QStringLiteral("region_index"), Settings::config_values->region_index, 1);
WriteSetting(QStringLiteral("time_zone_index"), Settings::config_values->time_zone_index, 0);
WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::config_values->rng_seed.has_value(),
false);
WriteSetting(QStringLiteral("rng_seed"), Settings::config_values->rng_seed.value_or(0), 0);
WriteSetting(QStringLiteral("custom_rtc_enabled"),
Settings::config_values->custom_rtc.has_value(), false);
WriteSetting(QStringLiteral("custom_rtc"),
QVariant::fromValue<long long>(
Settings::values->custom_rtc.value_or(std::chrono::seconds{}).count()),
Settings::config_values->custom_rtc.value_or(std::chrono::seconds{}).count()),
0);
WriteSetting(QStringLiteral("sound_index"), Settings::values->sound_index, 1);
WriteSetting(QStringLiteral("sound_index"), Settings::config_values->sound_index, 1);
qt_config->endGroup();
}
@@ -1220,13 +1261,15 @@ void Config::SaveUILayoutValues() {
void Config::SaveWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
WriteSetting(QStringLiteral("enable_telemetry"), Settings::values->enable_telemetry, true);
WriteSetting(QStringLiteral("enable_telemetry"),
Settings::config_values->enable_telemetry, true);
WriteSetting(QStringLiteral("web_api_url"),
QString::fromStdString(Settings::values->web_api_url),
QString::fromStdString(Settings::config_values->web_api_url),
QStringLiteral("https://api.yuzu-emu.org"));
WriteSetting(QStringLiteral("yuzu_username"),
QString::fromStdString(Settings::values->yuzu_username));
WriteSetting(QStringLiteral("yuzu_token"), QString::fromStdString(Settings::values->yuzu_token));
QString::fromStdString(Settings::config_values->yuzu_username));
WriteSetting(QStringLiteral("yuzu_token"),
QString::fromStdString(Settings::config_values->yuzu_token));
qt_config->endGroup();
}

16
src/yuzu/configuration/configure_audio.cpp
View File

@@ -41,8 +41,8 @@ void ConfigureAudio::SetConfiguration() {
SetAudioDeviceFromDeviceID();
ui->toggle_audio_stretching->setChecked(Settings::values->enable_audio_stretching);
ui->volume_slider->setValue(Settings::values->volume * ui->volume_slider->maximum());
ui->toggle_audio_stretching->setChecked(Settings::config_values->enable_audio_stretching);
ui->volume_slider->setValue(Settings::config_values->volume * ui->volume_slider->maximum());
SetVolumeIndicatorText(ui->volume_slider->sliderPosition());
}
@@ -50,7 +50,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
[[maybe_unused]] const QSignalBlocker blocker(ui->output_sink_combo_box);
int new_sink_index = 0;
const QString sink_id = QString::fromStdString(Settings::values->sink_id);
const QString sink_id = QString::fromStdString(Settings::config_values->sink_id);
for (int index = 0; index < ui->output_sink_combo_box->count(); index++) {
if (ui->output_sink_combo_box->itemText(index) == sink_id) {
new_sink_index = index;
@@ -64,7 +64,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
void ConfigureAudio::SetAudioDeviceFromDeviceID() {
int new_device_index = -1;
const QString device_id = QString::fromStdString(Settings::values->audio_device_id);
const QString device_id = QString::fromStdString(Settings::config_values->audio_device_id);
for (int index = 0; index < ui->audio_device_combo_box->count(); index++) {
if (ui->audio_device_combo_box->itemText(index) == device_id) {
new_device_index = index;
@@ -80,14 +80,14 @@ void ConfigureAudio::SetVolumeIndicatorText(int percentage) {
}
void ConfigureAudio::ApplyConfiguration() {
Settings::values->sink_id =
Settings::config_values->sink_id =
ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
.toStdString();
Settings::values->enable_audio_stretching = ui->toggle_audio_stretching->isChecked();
Settings::values->audio_device_id =
Settings::config_values->enable_audio_stretching = ui->toggle_audio_stretching->isChecked();
Settings::config_values->audio_device_id =
ui->audio_device_combo_box->itemText(ui->audio_device_combo_box->currentIndex())
.toStdString();
Settings::values->volume =
Settings::config_values->volume =
static_cast<float>(ui->volume_slider->sliderPosition()) / ui->volume_slider->maximum();
}

40
src/yuzu/configuration/configure_debug.cpp
View File

@@ -27,36 +27,36 @@ ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::Co
ConfigureDebug::~ConfigureDebug() = default;
void ConfigureDebug::SetConfiguration() {
ui->toggle_gdbstub->setChecked(Settings::values->use_gdbstub);
ui->gdbport_spinbox->setEnabled(Settings::values->use_gdbstub);
ui->gdbport_spinbox->setValue(Settings::values->gdbstub_port);
ui->toggle_gdbstub->setChecked(Settings::config_values->use_gdbstub);
ui->gdbport_spinbox->setEnabled(Settings::config_values->use_gdbstub);
ui->gdbport_spinbox->setValue(Settings::config_values->gdbstub_port);
ui->toggle_console->setEnabled(!Core::System::GetInstance().IsPoweredOn());
ui->toggle_console->setChecked(UISettings::values.show_console);
ui->log_filter_edit->setText(QString::fromStdString(Settings::values->log_filter));
ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values->program_args));
ui->reporting_services->setChecked(Settings::values->reporting_services);
ui->quest_flag->setChecked(Settings::values->quest_flag);
ui->disable_cpu_opt->setChecked(Settings::values->disable_cpu_opt);
ui->log_filter_edit->setText(QString::fromStdString(Settings::config_values->log_filter));
ui->homebrew_args_edit->setText(QString::fromStdString(Settings::config_values->program_args));
ui->reporting_services->setChecked(Settings::config_values->reporting_services);
ui->quest_flag->setChecked(Settings::config_values->quest_flag);
ui->disable_cpu_opt->setChecked(Settings::config_values->disable_cpu_opt);
ui->enable_graphics_debugging->setEnabled(!Core::System::GetInstance().IsPoweredOn());
ui->enable_graphics_debugging->setChecked(Settings::values->renderer_debug);
ui->enable_graphics_debugging->setChecked(Settings::config_values->renderer_debug);
ui->disable_macro_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
ui->disable_macro_jit->setChecked(Settings::values->disable_macro_jit);
ui->disable_macro_jit->setChecked(Settings::config_values->disable_macro_jit);
}
void ConfigureDebug::ApplyConfiguration() {
Settings::values->use_gdbstub = ui->toggle_gdbstub->isChecked();
Settings::values->gdbstub_port = ui->gdbport_spinbox->value();
Settings::config_values->use_gdbstub = ui->toggle_gdbstub->isChecked();
Settings::config_values->gdbstub_port = ui->gdbport_spinbox->value();
UISettings::values.show_console = ui->toggle_console->isChecked();
Settings::values->log_filter = ui->log_filter_edit->text().toStdString();
Settings::values->program_args = ui->homebrew_args_edit->text().toStdString();
Settings::values->reporting_services = ui->reporting_services->isChecked();
Settings::values->quest_flag = ui->quest_flag->isChecked();
Settings::values->disable_cpu_opt = ui->disable_cpu_opt->isChecked();
Settings::values->renderer_debug = ui->enable_graphics_debugging->isChecked();
Settings::values->disable_macro_jit = ui->disable_macro_jit->isChecked();
Settings::config_values->log_filter = ui->log_filter_edit->text().toStdString();
Settings::config_values->program_args = ui->homebrew_args_edit->text().toStdString();
Settings::config_values->reporting_services = ui->reporting_services->isChecked();
Settings::config_values->quest_flag = ui->quest_flag->isChecked();
Settings::config_values->disable_cpu_opt = ui->disable_cpu_opt->isChecked();
Settings::config_values->renderer_debug = ui->enable_graphics_debugging->isChecked();
Settings::config_values->disable_macro_jit = ui->disable_macro_jit->isChecked();
Debugger::ToggleConsole();
Log::Filter filter;
filter.ParseFilterString(Settings::values->log_filter);
filter.ParseFilterString(Settings::config_values->log_filter);
Log::SetGlobalFilter(filter);
}

6
src/yuzu/configuration/configure_dialog.cpp
View File

@@ -14,6 +14,8 @@
ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
: QDialog(parent), ui(new Ui::ConfigureDialog), registry(registry) {
SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
ui->setupUi(this);
ui->hotkeysTab->Populate(registry);
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
@@ -28,7 +30,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry)
ui->selectorList->setCurrentRow(0);
}
ConfigureDialog::~ConfigureDialog() = default;
ConfigureDialog::~ConfigureDialog() {
Settings::CopyValues(Settings::game_values, Settings::global_values);
}
void ConfigureDialog::SetConfiguration() {}

36
src/yuzu/configuration/configure_filesystem.cpp
View File

@@ -58,7 +58,7 @@ void ConfigureFilesystem::setConfiguration() {
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
ui->sdmc_directory_edit->setText(
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
ui->gamecard_path_edit->setText(QString::fromStdString(Settings::values->gamecard_path));
ui->gamecard_path_edit->setText(QString::fromStdString(Settings::config_values->gamecard_path));
ui->dump_path_edit->setText(
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::DumpDir)));
ui->load_path_edit->setText(
@@ -66,17 +66,17 @@ void ConfigureFilesystem::setConfiguration() {
ui->cache_directory_edit->setText(
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)));
ui->gamecard_inserted->setChecked(Settings::values->gamecard_inserted);
ui->gamecard_current_game->setChecked(Settings::values->gamecard_current_game);
ui->dump_exefs->setChecked(Settings::values->dump_exefs);
ui->dump_nso->setChecked(Settings::values->dump_nso);
ui->gamecard_inserted->setChecked(Settings::config_values->gamecard_inserted);
ui->gamecard_current_game->setChecked(Settings::config_values->gamecard_current_game);
ui->dump_exefs->setChecked(Settings::config_values->dump_exefs);
ui->dump_nso->setChecked(Settings::config_values->dump_nso);
ui->cache_game_list->setChecked(UISettings::values.cache_game_list);
SetComboBoxFromData(ui->nand_size, Settings::values->nand_total_size);
SetComboBoxFromData(ui->usrnand_size, Settings::values->nand_user_size);
SetComboBoxFromData(ui->sysnand_size, Settings::values->nand_system_size);
SetComboBoxFromData(ui->sdmc_size, Settings::values->sdmc_size);
SetComboBoxFromData(ui->nand_size, Settings::config_values->nand_total_size);
SetComboBoxFromData(ui->usrnand_size, Settings::config_values->nand_user_size);
SetComboBoxFromData(ui->sysnand_size, Settings::config_values->nand_system_size);
SetComboBoxFromData(ui->sdmc_size, Settings::config_values->sdmc_size);
UpdateEnabledControls();
}
@@ -90,22 +90,22 @@ void ConfigureFilesystem::applyConfiguration() {
FileUtil::GetUserPath(FileUtil::UserPath::LoadDir, ui->load_path_edit->text().toStdString());
FileUtil::GetUserPath(FileUtil::UserPath::CacheDir,
ui->cache_directory_edit->text().toStdString());
Settings::values->gamecard_path = ui->gamecard_path_edit->text().toStdString();
Settings::config_values->gamecard_path = ui->gamecard_path_edit->text().toStdString();
Settings::values->gamecard_inserted = ui->gamecard_inserted->isChecked();
Settings::values->gamecard_current_game = ui->gamecard_current_game->isChecked();
Settings::values->dump_exefs = ui->dump_exefs->isChecked();
Settings::values->dump_nso = ui->dump_nso->isChecked();
Settings::config_values->gamecard_inserted = ui->gamecard_inserted->isChecked();
Settings::config_values->gamecard_current_game = ui->gamecard_current_game->isChecked();
Settings::config_values->dump_exefs = ui->dump_exefs->isChecked();
Settings::config_values->dump_nso = ui->dump_nso->isChecked();
UISettings::values.cache_game_list = ui->cache_game_list->isChecked();
Settings::values->nand_total_size = static_cast<Settings::NANDTotalSize>(
Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
ui->nand_size->itemData(ui->nand_size->currentIndex()).toULongLong());
Settings::values->nand_system_size = static_cast<Settings::NANDSystemSize>(
Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
ui->nand_size->itemData(ui->sysnand_size->currentIndex()).toULongLong());
Settings::values->nand_user_size = static_cast<Settings::NANDUserSize>(
Settings::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
ui->nand_size->itemData(ui->usrnand_size->currentIndex()).toULongLong());
Settings::values->sdmc_size = static_cast<Settings::SDMCSize>(
Settings::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
ui->nand_size->itemData(ui->sdmc_size->currentIndex()).toULongLong());
}

21
src/yuzu/configuration/configure_general.cpp
View File

@@ -12,7 +12,6 @@
ConfigureGeneral::ConfigureGeneral(QWidget* parent)
: QWidget(parent), ui(new Ui::ConfigureGeneral) {
ui->setupUi(this);
SetConfiguration();
@@ -28,33 +27,33 @@ void ConfigureGeneral::SetConfiguration() {
ui->use_multi_core->setEnabled(runtime_lock);
ui->use_multi_core->setChecked(Settings::values.use_multi_core);
if (Settings::values == &Settings::global_values) {
if (Settings::config_values == &Settings::global_values) {
ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);
ui->toggle_hide_mouse->setChecked(UISettings::values.hide_mouse);
}
ui->toggle_check_exit->setVisible(Settings::values == &Settings::global_values);
ui->toggle_user_on_boot->setVisible(Settings::values == &Settings::global_values);
ui->toggle_background_pause->setVisible(Settings::values == &Settings::global_values);
ui->toggle_hide_mouse->setVisible(Settings::values == &Settings::global_values);
ui->toggle_check_exit->setVisible(Settings::config_values == &Settings::global_values);
ui->toggle_user_on_boot->setVisible(Settings::config_values == &Settings::global_values);
ui->toggle_background_pause->setVisible(Settings::config_values == &Settings::global_values);
ui->toggle_hide_mouse->setVisible(Settings::config_values == &Settings::global_values);
ui->toggle_frame_limit->setChecked(Settings::values->use_frame_limit);
ui->toggle_frame_limit->setChecked(Settings::config_values->use_frame_limit);
ui->frame_limit->setEnabled(ui->toggle_frame_limit->isChecked());
ui->frame_limit->setValue(Settings::values->frame_limit);
ui->frame_limit->setValue(Settings::config_values->frame_limit);
}
void ConfigureGeneral::ApplyConfiguration() {
if (Settings::values == &Settings::global_values) {
if (Settings::config_values == &Settings::global_values) {
UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();
UISettings::values.hide_mouse = ui->toggle_hide_mouse->isChecked();
}
Settings::values->use_frame_limit = ui->toggle_frame_limit->isChecked();
Settings::values->frame_limit = ui->frame_limit->value();
Settings::values->use_multi_core = ui->use_multi_core->isChecked();
Settings::config_values->use_frame_limit = ui->toggle_frame_limit->isChecked();
Settings::config_values->frame_limit = ui->frame_limit->value();
}
void ConfigureGeneral::changeEvent(QEvent* event) {

32
src/yuzu/configuration/configure_graphics.cpp
View File

@@ -21,7 +21,7 @@
ConfigureGraphics::ConfigureGraphics(QWidget* parent)
: QWidget(parent), ui(new Ui::ConfigureGraphics) {
vulkan_device = Settings::values->vulkan_device;
vulkan_device = Settings::config_values->vulkan_device;
RetrieveVulkanDevices();
ui->setupUi(this);
@@ -57,27 +57,29 @@ void ConfigureGraphics::SetConfiguration() {
const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
ui->api->setEnabled(runtime_lock);
ui->api->setCurrentIndex(static_cast<int>(Settings::values->renderer_backend));
ui->aspect_ratio_combobox->setCurrentIndex(Settings::values->aspect_ratio);
ui->api->setCurrentIndex(static_cast<int>(Settings::config_values->renderer_backend));
ui->aspect_ratio_combobox->setCurrentIndex(Settings::config_values->aspect_ratio);
ui->use_disk_shader_cache->setEnabled(runtime_lock);
ui->use_disk_shader_cache->setChecked(Settings::values->use_disk_shader_cache);
ui->use_disk_shader_cache->setChecked(Settings::config_values->use_disk_shader_cache);
ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
ui->use_asynchronous_gpu_emulation->setChecked(Settings::values->use_asynchronous_gpu_emulation);
UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values->bg_red, Settings::values->bg_green,
Settings::values->bg_blue));
ui->use_asynchronous_gpu_emulation->setChecked(
Settings::config_values->use_asynchronous_gpu_emulation);
UpdateBackgroundColorButton(QColor::fromRgbF(Settings::config_values->bg_red,
Settings::config_values->bg_green,
Settings::config_values->bg_blue));
UpdateDeviceComboBox();
}
void ConfigureGraphics::ApplyConfiguration() {
Settings::values->renderer_backend = GetCurrentGraphicsBackend();
Settings::values->vulkan_device = vulkan_device;
Settings::values->aspect_ratio = ui->aspect_ratio_combobox->currentIndex();
Settings::values->use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
Settings::values->use_asynchronous_gpu_emulation =
Settings::config_values->renderer_backend = GetCurrentGraphicsBackend();
Settings::config_values->vulkan_device = vulkan_device;
Settings::config_values->aspect_ratio = ui->aspect_ratio_combobox->currentIndex();
Settings::config_values->use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
Settings::config_values->use_asynchronous_gpu_emulation =
ui->use_asynchronous_gpu_emulation->isChecked();
Settings::values->bg_red = static_cast<float>(bg_color.redF());
Settings::values->bg_green = static_cast<float>(bg_color.greenF());
Settings::values->bg_blue = static_cast<float>(bg_color.blueF());
Settings::config_values->bg_red = static_cast<float>(bg_color.redF());
Settings::config_values->bg_green = static_cast<float>(bg_color.greenF());
Settings::config_values->bg_blue = static_cast<float>(bg_color.blueF());
}
void ConfigureGraphics::changeEvent(QEvent* event) {

24
src/yuzu/configuration/configure_graphics_advanced.cpp
View File

@@ -19,26 +19,26 @@ ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
void ConfigureGraphicsAdvanced::SetConfiguration() {
const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
ui->gpu_accuracy->setCurrentIndex(static_cast<int>(Settings::values->gpu_accuracy));
ui->gpu_accuracy->setCurrentIndex(static_cast<int>(Settings::config_values->gpu_accuracy));
ui->use_vsync->setEnabled(runtime_lock);
ui->use_vsync->setChecked(Settings::values->use_vsync);
ui->use_vsync->setChecked(Settings::config_values->use_vsync);
ui->use_assembly_shaders->setEnabled(runtime_lock);
ui->use_assembly_shaders->setChecked(Settings::values->use_assembly_shaders);
ui->use_fast_gpu_time->setChecked(Settings::values->use_fast_gpu_time);
ui->use_assembly_shaders->setChecked(Settings::config_values->use_assembly_shaders);
ui->use_fast_gpu_time->setChecked(Settings::config_values->use_fast_gpu_time);
ui->force_30fps_mode->setEnabled(runtime_lock);
ui->force_30fps_mode->setChecked(Settings::values->force_30fps_mode);
ui->force_30fps_mode->setChecked(Settings::config_values->force_30fps_mode);
ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
ui->anisotropic_filtering_combobox->setCurrentIndex(Settings::values->max_anisotropy);
ui->anisotropic_filtering_combobox->setCurrentIndex(Settings::config_values->max_anisotropy);
}
void ConfigureGraphicsAdvanced::ApplyConfiguration() {
auto gpu_accuracy = static_cast<Settings::GPUAccuracy>(ui->gpu_accuracy->currentIndex());
Settings::values->gpu_accuracy = gpu_accuracy;
Settings::values->use_vsync = ui->use_vsync->isChecked();
Settings::values->use_assembly_shaders = ui->use_assembly_shaders->isChecked();
Settings::values->use_fast_gpu_time = ui->use_fast_gpu_time->isChecked();
Settings::values->force_30fps_mode = ui->force_30fps_mode->isChecked();
Settings::values->max_anisotropy = ui->anisotropic_filtering_combobox->currentIndex();
Settings::config_values->gpu_accuracy = gpu_accuracy;
Settings::config_values->use_vsync = ui->use_vsync->isChecked();
Settings::config_values->use_assembly_shaders = ui->use_assembly_shaders->isChecked();
Settings::config_values->use_fast_gpu_time = ui->use_fast_gpu_time->isChecked();
Settings::config_values->force_30fps_mode = ui->force_30fps_mode->isChecked();
Settings::config_values->max_anisotropy = ui->anisotropic_filtering_combobox->currentIndex();
}
void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {

38
src/yuzu/configuration/configure_input.cpp
View File

@@ -119,26 +119,26 @@ void ConfigureInput::ApplyConfiguration() {
for (std::size_t i = 0; i < players_controller.size(); ++i) {
const auto controller_type_index = players_controller[i]->currentIndex();
Settings::values->players[i].connected = controller_type_index != 0;
Settings::config_values->players[i].connected = controller_type_index != 0;
if (controller_type_index > 0) {
Settings::values->players[i].type =
Settings::config_values->players[i].type =
static_cast<Settings::ControllerType>(controller_type_index - 1);
} else {
Settings::values->players[i].type = Settings::ControllerType::DualJoycon;
Settings::config_values->players[i].type = Settings::ControllerType::DualJoycon;
}
}
const bool pre_docked_mode = Settings::values->use_docked_mode;
Settings::values->use_docked_mode = ui->use_docked_mode->isChecked();
OnDockedModeChanged(pre_docked_mode, Settings::values->use_docked_mode);
const bool pre_docked_mode = Settings::config_values->use_docked_mode;
Settings::config_values->use_docked_mode = ui->use_docked_mode->isChecked();
OnDockedModeChanged(pre_docked_mode, Settings::config_values->use_docked_mode);
Settings::values
->players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
.connected = ui->handheld_connected->isChecked();
Settings::values->debug_pad_enabled = ui->debug_enabled->isChecked();
Settings::values->mouse_enabled = ui->mouse_enabled->isChecked();
Settings::values->keyboard_enabled = ui->keyboard_enabled->isChecked();
Settings::values->touchscreen.enabled = ui->touchscreen_enabled->isChecked();
Settings::config_values->debug_pad_enabled = ui->debug_enabled->isChecked();
Settings::config_values->mouse_enabled = ui->mouse_enabled->isChecked();
Settings::config_values->keyboard_enabled = ui->keyboard_enabled->isChecked();
Settings::config_values->touchscreen.enabled = ui->touchscreen_enabled->isChecked();
}
void ConfigureInput::changeEvent(QEvent* event) {
@@ -194,31 +194,31 @@ void ConfigureInput::UpdateUIEnabled() {
void ConfigureInput::LoadConfiguration() {
std::stable_partition(
Settings::values->players.begin(),
Settings::values->players.begin() +
Settings::config_values->players.begin(),
Settings::config_values->players.begin() +
Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
[](const auto& player) { return player.connected; });
LoadPlayerControllerIndices();
ui->use_docked_mode->setChecked(Settings::values->use_docked_mode);
ui->use_docked_mode->setChecked(Settings::config_values->use_docked_mode);
ui->handheld_connected->setChecked(
Settings::values
->players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
.connected);
ui->debug_enabled->setChecked(Settings::values->debug_pad_enabled);
ui->mouse_enabled->setChecked(Settings::values->mouse_enabled);
ui->keyboard_enabled->setChecked(Settings::values->keyboard_enabled);
ui->touchscreen_enabled->setChecked(Settings::values->touchscreen.enabled);
ui->debug_enabled->setChecked(Settings::config_values->debug_pad_enabled);
ui->mouse_enabled->setChecked(Settings::config_values->mouse_enabled);
ui->keyboard_enabled->setChecked(Settings::config_values->keyboard_enabled);
ui->touchscreen_enabled->setChecked(Settings::config_values->touchscreen.enabled);
UpdateUIEnabled();
}
void ConfigureInput::LoadPlayerControllerIndices() {
for (std::size_t i = 0; i < players_controller.size(); ++i) {
const auto connected = Settings::values->players[i].connected;
const auto connected = Settings::config_values->players[i].connected;
players_controller[i]->setCurrentIndex(
connected ? static_cast<u8>(Settings::values->players[i].type) + 1 : 0);
connected ? static_cast<u8>(Settings::config_values->players[i].type) + 1 : 0);
}
}

38
src/yuzu/configuration/configure_input_player.cpp
View File

@@ -205,7 +205,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
ui->buttonScreenshot, ui->labelScreenshot,
};
auto layout = Settings::values->players[player_index].type;
auto layout = Settings::config_values->players[player_index].type;
if (debug)
layout = Settings::ControllerType::DualJoycon;
@@ -432,9 +432,9 @@ ConfigureInputPlayer::~ConfigureInputPlayer() = default;
void ConfigureInputPlayer::ApplyConfiguration() {
auto& buttons =
debug ? Settings::values->debug_pad_buttons : Settings::values->players[player_index].buttons;
debug ? Settings::config_values->debug_pad_buttons : Settings::config_values->players[player_index].buttons;
auto& analogs =
debug ? Settings::values->debug_pad_analogs : Settings::values->players[player_index].analogs;
debug ? Settings::config_values->debug_pad_analogs : Settings::config_values->players[player_index].analogs;
std::transform(buttons_param.begin(), buttons_param.end(), buttons.begin(),
[](const Common::ParamPackage& param) { return param.Serialize(); });
@@ -448,10 +448,10 @@ void ConfigureInputPlayer::ApplyConfiguration() {
std::transform(controller_colors.begin(), controller_colors.end(), colors.begin(),
[](QColor color) { return color.rgb(); });
Settings::values->players[player_index].body_color_left = colors[0];
Settings::values->players[player_index].button_color_left = colors[1];
Settings::values->players[player_index].body_color_right = colors[2];
Settings::values->players[player_index].button_color_right = colors[3];
Settings::config_values->players[player_index].body_color_left = colors[0];
Settings::config_values->players[player_index].button_color_left = colors[1];
Settings::config_values->players[player_index].body_color_right = colors[2];
Settings::config_values->players[player_index].button_color_right = colors[3];
}
void ConfigureInputPlayer::changeEvent(QEvent* event) {
@@ -478,18 +478,18 @@ void ConfigureInputPlayer::OnControllerButtonClick(int i) {
void ConfigureInputPlayer::LoadConfiguration() {
if (debug) {
std::transform(Settings::values->debug_pad_buttons.begin(),
Settings::values->debug_pad_buttons.end(), buttons_param.begin(),
std::transform(Settings::config_values->debug_pad_buttons.begin(),
Settings::config_values->debug_pad_buttons.end(), buttons_param.begin(),
[](const std::string& str) { return Common::ParamPackage(str); });
std::transform(Settings::values->debug_pad_analogs.begin(),
Settings::values->debug_pad_analogs.end(), analogs_param.begin(),
std::transform(Settings::config_values->debug_pad_analogs.begin(),
Settings::config_values->debug_pad_analogs.end(), analogs_param.begin(),
[](const std::string& str) { return Common::ParamPackage(str); });
} else {
std::transform(Settings::values->players[player_index].buttons.begin(),
Settings::values->players[player_index].buttons.end(), buttons_param.begin(),
std::transform(Settings::config_values->players[player_index].buttons.begin(),
Settings::config_values->players[player_index].buttons.end(), buttons_param.begin(),
[](const std::string& str) { return Common::ParamPackage(str); });
std::transform(Settings::values->players[player_index].analogs.begin(),
Settings::values->players[player_index].analogs.end(), analogs_param.begin(),
std::transform(Settings::config_values->players[player_index].analogs.begin(),
Settings::config_values->players[player_index].analogs.end(), analogs_param.begin(),
[](const std::string& str) { return Common::ParamPackage(str); });
}
@@ -499,10 +499,10 @@ void ConfigureInputPlayer::LoadConfiguration() {
return;
std::array<u32, 4> colors = {
Settings::values->players[player_index].body_color_left,
Settings::values->players[player_index].button_color_left,
Settings::values->players[player_index].body_color_right,
Settings::values->players[player_index].button_color_right,
Settings::config_values->players[player_index].body_color_left,
Settings::config_values->players[player_index].button_color_left,
Settings::config_values->players[player_index].body_color_right,
Settings::config_values->players[player_index].button_color_right,
};
std::transform(colors.begin(), colors.end(), controller_colors.begin(),

36
src/yuzu/configuration/configure_input_simple.cpp
View File

@@ -39,33 +39,33 @@ constexpr std::size_t PLAYER_0_INDEX = 0;
constexpr std::size_t HANDHELD_INDEX = 8;
void HandheldOnProfileSelect() {
Settings::values->players[HANDHELD_INDEX].connected = true;
Settings::values->players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
Settings::config_values->players[HANDHELD_INDEX].connected = true;
Settings::config_values->players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
for (std::size_t player = 0; player < HANDHELD_INDEX; ++player) {
Settings::values->players[player].connected = false;
Settings::config_values->players[player].connected = false;
}
Settings::values->use_docked_mode = false;
Settings::values->keyboard_enabled = false;
Settings::values->mouse_enabled = false;
Settings::values->debug_pad_enabled = false;
Settings::values->touchscreen.enabled = true;
Settings::config_values->use_docked_mode = false;
Settings::config_values->keyboard_enabled = false;
Settings::config_values->mouse_enabled = false;
Settings::config_values->debug_pad_enabled = false;
Settings::config_values->touchscreen.enabled = true;
}
void DualJoyconsDockedOnProfileSelect() {
Settings::values->players[PLAYER_0_INDEX].connected = true;
Settings::values->players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
Settings::config_values->players[PLAYER_0_INDEX].connected = true;
Settings::config_values->players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
for (std::size_t player = 1; player <= HANDHELD_INDEX; ++player) {
Settings::values->players[player].connected = false;
Settings::config_values->players[player].connected = false;
}
Settings::values->use_docked_mode = true;
Settings::values->keyboard_enabled = false;
Settings::values->mouse_enabled = false;
Settings::values->debug_pad_enabled = false;
Settings::values->touchscreen.enabled = true;
Settings::config_values->use_docked_mode = true;
Settings::config_values->keyboard_enabled = false;
Settings::config_values->mouse_enabled = false;
Settings::config_values->debug_pad_enabled = false;
Settings::config_values->touchscreen.enabled = true;
}
// Name, OnProfileSelect (called when selected in drop down), OnConfigure (called when configure
@@ -142,9 +142,9 @@ void ConfigureInputSimple::LoadConfiguration() {
}
void ConfigureInputSimple::OnSelectProfile(int index) {
const auto old_docked = Settings::values->use_docked_mode;
const auto old_docked = Settings::config_values->use_docked_mode;
ApplyInputProfileConfiguration(index);
OnDockedModeChanged(old_docked, Settings::values->use_docked_mode);
OnDockedModeChanged(old_docked, Settings::config_values->use_docked_mode);
}
void ConfigureInputSimple::OnConfigure() {

5
src/yuzu/configuration/configure_mouse_advanced.cpp
View File

@@ -129,12 +129,13 @@ ConfigureMouseAdvanced::~ConfigureMouseAdvanced() = default;
void ConfigureMouseAdvanced::ApplyConfiguration() {
std::transform(buttons_param.begin(), buttons_param.end(),
Settings::values->mouse_buttons.begin(),
Settings::config_values->mouse_buttons.begin(),
[](const Common::ParamPackage& param) { return param.Serialize(); });
}
void ConfigureMouseAdvanced::LoadConfiguration() {
std::transform(Settings::values->mouse_buttons.begin(), Settings::values->mouse_buttons.end(),
std::transform(Settings::config_values->mouse_buttons.begin(),
Settings::config_values->mouse_buttons.end(),
buttons_param.begin(),
[](const std::string& str) { return Common::ParamPackage(str); });
UpdateButtonLabels();

15
src/yuzu/configuration/configure_per_game.cpp
View File

@@ -29,8 +29,7 @@
ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id)
: QDialog(parent), ui(std::make_unique<Ui::ConfigurePerGame>()), title_id(title_id) {
Settings::SwapValues(Settings::ValuesSwapTarget::ToGame);
Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGame);
game_config = std::make_unique<Config>(fmt::format("{:016X}", title_id) + ".ini", false);
ui->setupUi(this);
@@ -48,11 +47,11 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id)
}
ConfigurePerGame::~ConfigurePerGame() {
Settings::SwapValues(Settings::ValuesSwapTarget::ToGlobal);
Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
};
void ConfigurePerGame::ApplyConfiguration() {
Settings::values->use_global_values = ui->check_global->isChecked();
Settings::config_values->use_global_values = ui->check_global->isChecked();
ui->addonsTab->ApplyConfiguration();
ui->generalTab->ApplyConfiguration();
@@ -60,10 +59,10 @@ void ConfigurePerGame::ApplyConfiguration() {
ui->graphicsTab->ApplyConfiguration();
ui->graphicsAdvancedTab->ApplyConfiguration();
ui->audioTab->ApplyConfiguration();
ui->inputTab->ApplyConfiguration();
//ui->inputTab->ApplyConfiguration();
game_config->Save();
Settings::SwapValues(Settings::ValuesSwapTarget::ToGlobal);
Settings::SwapConfigValues(Settings::ValuesSwapTarget::ToGlobal);
Settings::Apply();
Settings::LogSettings();
@@ -91,7 +90,7 @@ void ConfigurePerGame::LoadConfiguration() {
return;
}
ui->check_global->setChecked(Settings::values->use_global_values);
ui->check_global->setChecked(Settings::config_values->use_global_values);
ui->addonsTab->LoadFromFile(file);
@@ -157,5 +156,5 @@ void ConfigurePerGame::UpdateVisibleTabs() {
ui->graphicsTab->setEnabled(visible);
ui->graphicsAdvancedTab->setEnabled(visible);
ui->audioTab->setEnabled(visible);
ui->inputTab->setEnabled(visible);
//ui->inputTab->setEnabled(visible);
}

11
src/yuzu/configuration/configure_per_game.ui
View File

@@ -260,11 +260,6 @@
<string>Audio</string>
</attribute>
</widget>
<widget class="ConfigureInputSimple" name="inputTab">
<attribute name="title">
<string>Input</string>
</attribute>
</widget>
</widget>
</item>
</layout>
@@ -326,12 +321,6 @@
<header>configuration/configure_per_game_addons.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>ConfigureInputSimple</class>
<extends>QWidget</extends>
<header>configuration/configure_input_simple.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections>

8
src/yuzu/configuration/configure_profile_manager.cpp
View File

@@ -165,7 +165,7 @@ void ConfigureProfileManager::PopulateUserList() {
void ConfigureProfileManager::UpdateCurrentUser() {
ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
const auto& current_user = profile_manager->GetUser(Settings::values->current_user);
const auto& current_user = profile_manager->GetUser(Settings::config_values->current_user);
ASSERT(current_user);
const auto username = GetAccountUsername(*profile_manager, *current_user);
@@ -184,7 +184,7 @@ void ConfigureProfileManager::ApplyConfiguration() {
}
void ConfigureProfileManager::SelectUser(const QModelIndex& index) {
Settings::values->current_user =
Settings::config_values->current_user =
std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager->GetUserCount() - 1));
UpdateCurrentUser();
@@ -247,8 +247,8 @@ void ConfigureProfileManager::DeleteUser() {
if (confirm == QMessageBox::No)
return;
if (Settings::values->current_user == tree_view->currentIndex().row())
Settings::values->current_user = 0;
if (Settings::config_values->current_user == tree_view->currentIndex().row())
Settings::config_values->current_user = 0;
UpdateCurrentUser();
if (!profile_manager->RemoveUser(*uuid))

4
src/yuzu/configuration/configure_service.cpp
View File

@@ -54,7 +54,7 @@ ConfigureService::ConfigureService(QWidget* parent)
ConfigureService::~ConfigureService() = default;
void ConfigureService::ApplyConfiguration() {
Settings::values->bcat_backend = ui->bcat_source->currentText().toLower().toStdString();
Settings::config_values->bcat_backend = ui->bcat_source->currentText().toLower().toStdString();
}
void ConfigureService::RetranslateUi() {
@@ -63,7 +63,7 @@ void ConfigureService::RetranslateUi() {
void ConfigureService::SetConfiguration() {
const int index =
ui->bcat_source->findData(QString::fromStdString(Settings::values->bcat_backend));
ui->bcat_source->findData(QString::fromStdString(Settings::config_values->bcat_backend));
ui->bcat_source->setCurrentIndex(index == -1 ? 0 : index);
}

37
src/yuzu/configuration/configure_system.cpp
View File

@@ -58,23 +58,24 @@ void ConfigureSystem::SetConfiguration() {
ui->label_console_id->setVisible(Settings::values == &Settings::global_values);
ui->button_regenerate_console_id->setVisible(Settings::values == &Settings::global_values);
ui->combo_language->setCurrentIndex(Settings::values->language_index);
ui->combo_region->setCurrentIndex(Settings::values->region_index);
ui->combo_time_zone->setCurrentIndex(Settings::values->time_zone_index);
ui->combo_sound->setCurrentIndex(Settings::values->sound_index);
ui->combo_language->setCurrentIndex(Settings::config_values->language_index);
ui->combo_region->setCurrentIndex(Settings::config_values->region_index);
ui->combo_time_zone->setCurrentIndex(Settings::config_values->time_zone_index);
ui->combo_sound->setCurrentIndex(Settings::config_values->sound_index);
ui->rng_seed_checkbox->setChecked(Settings::values->rng_seed.has_value());
ui->rng_seed_edit->setEnabled(Settings::values->rng_seed.has_value());
ui->rng_seed_checkbox->setChecked(Settings::config_values->rng_seed.has_value());
ui->rng_seed_edit->setEnabled(Settings::config_values->rng_seed.has_value());
const auto rng_seed = QStringLiteral("%1")
.arg(Settings::values->rng_seed.value_or(0), 8, 16, QLatin1Char{'0'})
.arg(Settings::config_values->rng_seed.value_or(0), 8, 16,
QLatin1Char{'0'})
.toUpper();
ui->rng_seed_edit->setText(rng_seed);
ui->custom_rtc_checkbox->setChecked(Settings::values->custom_rtc.has_value());
ui->custom_rtc_edit->setEnabled(Settings::values->custom_rtc.has_value());
ui->custom_rtc_checkbox->setChecked(Settings::config_values->custom_rtc.has_value());
ui->custom_rtc_edit->setEnabled(Settings::config_values->custom_rtc.has_value());
const auto rtc_time = Settings::values->custom_rtc.value_or(
const auto rtc_time = Settings::config_values->custom_rtc.value_or(
std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
}
@@ -86,22 +87,22 @@ void ConfigureSystem::ApplyConfiguration() {
return;
}
Settings::values->language_index = ui->combo_language->currentIndex();
Settings::values->region_index = ui->combo_region->currentIndex();
Settings::values->time_zone_index = ui->combo_time_zone->currentIndex();
Settings::values->sound_index = ui->combo_sound->currentIndex();
Settings::config_values->language_index = ui->combo_language->currentIndex();
Settings::config_values->region_index = ui->combo_region->currentIndex();
Settings::config_values->time_zone_index = ui->combo_time_zone->currentIndex();
Settings::config_values->sound_index = ui->combo_sound->currentIndex();
if (ui->rng_seed_checkbox->isChecked()) {
Settings::values->rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);
Settings::config_values->rng_seed = ui->rng_seed_edit->text().toULongLong(nullptr, 16);
} else {
Settings::values->rng_seed = std::nullopt;
Settings::config_values->rng_seed = std::nullopt;
}
if (ui->custom_rtc_checkbox->isChecked()) {
Settings::values->custom_rtc =
Settings::config_values->custom_rtc =
std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
} else {
Settings::values->custom_rtc = std::nullopt;
Settings::config_values->custom_rtc = std::nullopt;
}
Settings::Apply();

16
src/yuzu/configuration/configure_touchscreen_advanced.cpp
View File

@@ -33,17 +33,17 @@ void ConfigureTouchscreenAdvanced::RetranslateUI() {
}
void ConfigureTouchscreenAdvanced::ApplyConfiguration() {
Settings::values->touchscreen.finger = ui->finger_box->value();
Settings::values->touchscreen.diameter_x = ui->diameter_x_box->value();
Settings::values->touchscreen.diameter_y = ui->diameter_y_box->value();
Settings::values->touchscreen.rotation_angle = ui->angle_box->value();
Settings::config_values->touchscreen.finger = ui->finger_box->value();
Settings::config_values->touchscreen.diameter_x = ui->diameter_x_box->value();
Settings::config_values->touchscreen.diameter_y = ui->diameter_y_box->value();
Settings::config_values->touchscreen.rotation_angle = ui->angle_box->value();
}
void ConfigureTouchscreenAdvanced::LoadConfiguration() {
ui->finger_box->setValue(Settings::values->touchscreen.finger);
ui->diameter_x_box->setValue(Settings::values->touchscreen.diameter_x);
ui->diameter_y_box->setValue(Settings::values->touchscreen.diameter_y);
ui->angle_box->setValue(Settings::values->touchscreen.rotation_angle);
ui->finger_box->setValue(Settings::config_values->touchscreen.finger);
ui->diameter_x_box->setValue(Settings::config_values->touchscreen.diameter_x);
ui->diameter_y_box->setValue(Settings::config_values->touchscreen.diameter_y);
ui->angle_box->setValue(Settings::config_values->touchscreen.rotation_angle);
}
void ConfigureTouchscreenAdvanced::RestoreDefaults() {

16
src/yuzu/configuration/configure_web.cpp
View File

@@ -88,15 +88,16 @@ void ConfigureWeb::SetConfiguration() {
ui->web_signup_link->setOpenExternalLinks(true);
ui->web_token_info_link->setOpenExternalLinks(true);
if (Settings::values->yuzu_username.empty()) {
if (Settings::config_values->yuzu_username.empty()) {
ui->username->setText(tr("Unspecified"));
} else {
ui->username->setText(QString::fromStdString(Settings::values->yuzu_username));
ui->username->setText(QString::fromStdString(Settings::config_values->yuzu_username));
}
ui->toggle_telemetry->setChecked(Settings::values->enable_telemetry);
ui->toggle_telemetry->setChecked(Settings::config_values->enable_telemetry);
ui->edit_token->setText(QString::fromStdString(
GenerateDisplayToken(Settings::values->yuzu_username, Settings::values->yuzu_token)));
GenerateDisplayToken(Settings::config_values->yuzu_username,
Settings::config_values->yuzu_token)));
// Connect after setting the values, to avoid calling OnLoginChanged now
connect(ui->edit_token, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
@@ -107,12 +108,13 @@ void ConfigureWeb::SetConfiguration() {
}
void ConfigureWeb::ApplyConfiguration() {
Settings::values->enable_telemetry = ui->toggle_telemetry->isChecked();
Settings::config_values->enable_telemetry = ui->toggle_telemetry->isChecked();
UISettings::values.enable_discord_presence = ui->toggle_discordrpc->isChecked();
if (user_verified) {
Settings::values->yuzu_username =
Settings::config_values->yuzu_username =
UsernameFromDisplayToken(ui->edit_token->text().toStdString());
Settings::values->yuzu_token = TokenFromDisplayToken(ui->edit_token->text().toStdString());
Settings::config_values->yuzu_token =
TokenFromDisplayToken(ui->edit_token->text().toStdString());
} else {
QMessageBox::warning(
this, tr("Token not verified"),