2014-09-13 02:06:13 +02:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
2014-12-17 06:38:14 +01:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-09-13 02:06:13 +02:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
2018-12-29 14:39:30 +01:00
|
|
|
#include <algorithm>
|
2018-05-22 21:30:36 +02:00
|
|
|
#include <array>
|
2018-08-09 21:10:11 +02:00
|
|
|
#include <unordered_map>
|
2018-05-22 21:30:36 +02:00
|
|
|
#include <QKeySequence>
|
2016-09-20 17:21:23 +02:00
|
|
|
#include <QSettings>
|
2016-12-22 05:49:36 +01:00
|
|
|
#include "citra_qt/configuration/config.h"
|
2019-08-15 06:38:54 +02:00
|
|
|
#include "citra_qt/uisettings.h"
|
2015-09-11 06:23:00 +02:00
|
|
|
#include "common/file_util.h"
|
2019-11-01 19:33:06 +01:00
|
|
|
#include "core/frontend/mic.h"
|
2018-08-09 21:10:11 +02:00
|
|
|
#include "core/hle/service/service.h"
|
2017-01-21 10:53:03 +01:00
|
|
|
#include "input_common/main.h"
|
2018-01-18 16:43:17 +01:00
|
|
|
#include "input_common/udp/client.h"
|
2018-01-19 14:42:21 +01:00
|
|
|
#include "network/network.h"
|
2014-09-13 02:06:13 +02:00
|
|
|
|
|
|
|
|
Config::Config() {
|
|
|
|
|
// TODO: Don't hardcode the path; let the frontend decide where to put the config files.
|
2018-07-21 21:52:42 +02:00
|
|
|
qt_config_loc = FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) + "qt-config.ini";
|
2014-09-13 02:06:13 +02:00
|
|
|
FileUtil::CreateFullPath(qt_config_loc);
|
2018-10-24 03:49:50 +02:00
|
|
|
qt_config =
|
|
|
|
|
std::make_unique<QSettings>(QString::fromStdString(qt_config_loc), QSettings::IniFormat);
|
2014-09-13 02:06:13 +02:00
|
|
|
Reload();
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-24 03:49:50 +02:00
|
|
|
Config::~Config() {
|
|
|
|
|
Save();
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-21 10:53:03 +01:00
|
|
|
const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
|
2018-12-29 00:13:37 +01:00
|
|
|
Qt::Key_A, Qt::Key_S, Qt::Key_Z, Qt::Key_X, Qt::Key_T, Qt::Key_G,
|
|
|
|
|
Qt::Key_F, Qt::Key_H, Qt::Key_Q, Qt::Key_W, Qt::Key_M, Qt::Key_N,
|
|
|
|
|
Qt::Key_O, Qt::Key_P, Qt::Key_1, Qt::Key_2, Qt::Key_B,
|
2015-06-20 05:34:45 +02:00
|
|
|
};
|
|
|
|
|
|
2017-01-21 12:04:00 +01:00
|
|
|
const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> Config::default_analogs{{
|
|
|
|
|
{
|
2018-03-09 18:54:43 +01:00
|
|
|
Qt::Key_Up,
|
|
|
|
|
Qt::Key_Down,
|
|
|
|
|
Qt::Key_Left,
|
|
|
|
|
Qt::Key_Right,
|
|
|
|
|
Qt::Key_D,
|
2017-01-21 12:04:00 +01:00
|
|
|
},
|
|
|
|
|
{
|
2018-03-09 18:54:43 +01:00
|
|
|
Qt::Key_I,
|
|
|
|
|
Qt::Key_K,
|
|
|
|
|
Qt::Key_J,
|
|
|
|
|
Qt::Key_L,
|
|
|
|
|
Qt::Key_D,
|
2017-01-21 12:04:00 +01:00
|
|
|
},
|
|
|
|
|
}};
|
|
|
|
|
|
2018-12-30 11:09:16 +01:00
|
|
|
// This shouldn't have anything except static initializers (no functions). So
|
2019-07-25 23:34:05 +02:00
|
|
|
// QKeySequence(...).toString() is NOT ALLOWED HERE.
|
2018-12-30 11:09:16 +01:00
|
|
|
// This must be in alphabetical order according to action name as it must have the same order as
|
|
|
|
|
// UISetting::values.shortcuts, which is alphabetically ordered.
|
2019-07-25 23:34:05 +02:00
|
|
|
// clang-format off
|
2020-04-06 23:47:52 +02:00
|
|
|
const std::array<UISettings::Shortcut, 23> default_hotkeys{
|
2019-07-25 23:34:05 +02:00
|
|
|
{{QStringLiteral("Advance Frame"), QStringLiteral("Main Window"), {QStringLiteral("\\"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Capture Screenshot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Decrease Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("-"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Exit Citra"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Exit Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("Esc"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("F11"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Increase Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("+"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Load Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F2"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Load File"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), Qt::WindowShortcut}},
|
2020-08-23 21:16:38 +02:00
|
|
|
{QStringLiteral("Load from Newest Slot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+V"), Qt::WindowShortcut}},
|
2019-07-25 23:34:05 +02:00
|
|
|
{QStringLiteral("Remove Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F3"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
|
2020-01-08 22:33:37 +01:00
|
|
|
{QStringLiteral("Rotate Screens Upright"), QStringLiteral("Main Window"), {QStringLiteral("F8"), Qt::WindowShortcut}},
|
2020-08-23 21:16:38 +02:00
|
|
|
{QStringLiteral("Save to Oldest Slot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+C"), Qt::WindowShortcut}},
|
2019-07-25 23:34:05 +02:00
|
|
|
{QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Swap Screens"), QStringLiteral("Main Window"), {QStringLiteral("F9"), Qt::WindowShortcut}},
|
2020-08-23 21:16:38 +02:00
|
|
|
{QStringLiteral("Toggle Alternate Speed"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
|
2019-07-25 23:34:05 +02:00
|
|
|
{QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Toggle Frame Advancing"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+A"), Qt::ApplicationShortcut}},
|
|
|
|
|
{QStringLiteral("Toggle Screen Layout"), QStringLiteral("Main Window"), {QStringLiteral("F10"), Qt::WindowShortcut}},
|
2019-08-18 01:43:40 +02:00
|
|
|
{QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
|
|
|
|
|
{QStringLiteral("Toggle Texture Dumping"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+D"), Qt::ApplicationShortcut}}}};
|
2019-07-25 23:34:05 +02:00
|
|
|
// clang-format on
|
2018-12-30 11:09:16 +01:00
|
|
|
|
2014-11-15 20:56:18 +01:00
|
|
|
void Config::ReadValues() {
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadControlValues();
|
|
|
|
|
ReadCoreValues();
|
|
|
|
|
ReadRendererValues();
|
|
|
|
|
ReadLayoutValues();
|
|
|
|
|
ReadAudioValues();
|
|
|
|
|
ReadCameraValues();
|
|
|
|
|
ReadDataStorageValues();
|
|
|
|
|
ReadSystemValues();
|
|
|
|
|
ReadMiscellaneousValues();
|
|
|
|
|
ReadDebuggingValues();
|
|
|
|
|
ReadWebServiceValues();
|
2020-01-29 07:57:16 +01:00
|
|
|
ReadVideoDumpingValues();
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadUIValues();
|
2019-11-11 01:26:03 +01:00
|
|
|
ReadUtilityValues();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadAudioValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Audio"));
|
|
|
|
|
|
|
|
|
|
Settings::values.enable_dsp_lle = ReadSetting(QStringLiteral("enable_dsp_lle"), false).toBool();
|
|
|
|
|
Settings::values.enable_dsp_lle_multithread =
|
|
|
|
|
ReadSetting(QStringLiteral("enable_dsp_lle_multithread"), false).toBool();
|
|
|
|
|
Settings::values.sink_id = ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.enable_audio_stretching =
|
|
|
|
|
ReadSetting(QStringLiteral("enable_audio_stretching"), true).toBool();
|
|
|
|
|
Settings::values.audio_device_id =
|
|
|
|
|
ReadSetting(QStringLiteral("output_device"), QStringLiteral("auto"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
|
|
|
|
|
Settings::values.mic_input_type = static_cast<Settings::MicInputType>(
|
|
|
|
|
ReadSetting(QStringLiteral("mic_input_type"), 0).toInt());
|
|
|
|
|
Settings::values.mic_input_device =
|
2020-02-11 13:12:09 +01:00
|
|
|
ReadSetting(QStringLiteral("mic_input_device"),
|
|
|
|
|
QString::fromUtf8(Frontend::Mic::default_device_name))
|
2019-11-07 17:33:41 +01:00
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadCameraValues() {
|
|
|
|
|
using namespace Service::CAM;
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Camera"));
|
|
|
|
|
|
|
|
|
|
Settings::values.camera_name[OuterRightCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_right_name"), QStringLiteral("blank"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.camera_config[OuterRightCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_right_config"), QString{})
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.camera_flip[OuterRightCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_right_flip"), 0).toInt();
|
|
|
|
|
Settings::values.camera_name[InnerCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_inner_name"), QStringLiteral("blank"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.camera_config[InnerCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_inner_config"), QString{}).toString().toStdString();
|
|
|
|
|
Settings::values.camera_flip[InnerCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_inner_flip"), 0).toInt();
|
|
|
|
|
Settings::values.camera_name[OuterLeftCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_left_name"), QStringLiteral("blank"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.camera_config[OuterLeftCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_left_config"), QString{}).toString().toStdString();
|
|
|
|
|
Settings::values.camera_flip[OuterLeftCamera] =
|
|
|
|
|
ReadSetting(QStringLiteral("camera_outer_left_flip"), 0).toInt();
|
2018-12-29 01:24:56 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadControlValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Controls"));
|
|
|
|
|
|
2020-04-01 20:07:16 +02:00
|
|
|
int num_touch_from_button_maps =
|
|
|
|
|
qt_config->beginReadArray(QStringLiteral("touch_from_button_maps"));
|
|
|
|
|
|
|
|
|
|
if (num_touch_from_button_maps > 0) {
|
2020-05-11 16:05:05 +02:00
|
|
|
const auto append_touch_from_button_map = [this] {
|
2020-04-01 20:07:16 +02:00
|
|
|
Settings::TouchFromButtonMap map;
|
|
|
|
|
map.name = ReadSetting(QStringLiteral("name"), QStringLiteral("default"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2020-05-11 16:05:05 +02:00
|
|
|
const int num_touch_maps = qt_config->beginReadArray(QStringLiteral("entries"));
|
2020-04-01 20:07:16 +02:00
|
|
|
map.buttons.reserve(num_touch_maps);
|
|
|
|
|
for (int i = 0; i < num_touch_maps; i++) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
std::string touch_mapping =
|
|
|
|
|
ReadSetting(QStringLiteral("bind")).toString().toStdString();
|
|
|
|
|
map.buttons.emplace_back(std::move(touch_mapping));
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray(); // entries
|
|
|
|
|
Settings::values.touch_from_button_maps.emplace_back(std::move(map));
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < num_touch_from_button_maps; ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
append_touch_from_button_map();
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
Settings::values.touch_from_button_maps.emplace_back(
|
|
|
|
|
Settings::TouchFromButtonMap{"default", {}});
|
|
|
|
|
num_touch_from_button_maps = 1;
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.current_input_profile_index =
|
|
|
|
|
ReadSetting(QStringLiteral("profile"), 0).toInt();
|
2018-12-29 01:24:56 +01:00
|
|
|
|
2020-04-01 20:07:16 +02:00
|
|
|
const auto append_profile = [this, num_touch_from_button_maps] {
|
2018-12-29 01:24:56 +01:00
|
|
|
Settings::InputProfile profile;
|
2019-11-07 17:33:41 +01:00
|
|
|
profile.name =
|
|
|
|
|
ReadSetting(QStringLiteral("name"), QStringLiteral("default")).toString().toStdString();
|
2018-12-29 01:24:56 +01:00
|
|
|
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
|
|
|
|
|
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
|
2019-11-07 17:33:41 +01:00
|
|
|
profile.buttons[i] = ReadSetting(QString::fromUtf8(Settings::NativeButton::mapping[i]),
|
2018-12-29 01:24:56 +01:00
|
|
|
QString::fromStdString(default_param))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2018-12-29 14:14:37 +01:00
|
|
|
if (profile.buttons[i].empty())
|
2018-12-29 01:24:56 +01:00
|
|
|
profile.buttons[i] = default_param;
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
|
|
|
|
|
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);
|
2019-11-07 17:33:41 +01:00
|
|
|
profile.analogs[i] = ReadSetting(QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
|
2018-12-29 01:24:56 +01:00
|
|
|
QString::fromStdString(default_param))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
if (profile.analogs[i].empty())
|
|
|
|
|
profile.analogs[i] = default_param;
|
|
|
|
|
}
|
|
|
|
|
profile.motion_device =
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("motion_device"),
|
|
|
|
|
QStringLiteral(
|
|
|
|
|
"engine:motion_emu,update_period:100,sensitivity:0.01,tilt_clamp:90.0"))
|
2017-01-21 10:53:03 +01:00
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2018-12-29 01:24:56 +01:00
|
|
|
profile.touch_device =
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("touch_device"), QStringLiteral("engine:emu_window"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2020-04-01 20:07:16 +02:00
|
|
|
profile.use_touch_from_button =
|
|
|
|
|
ReadSetting(QStringLiteral("use_touch_from_button"), false).toBool();
|
|
|
|
|
profile.touch_from_button_map_index =
|
|
|
|
|
ReadSetting(QStringLiteral("touch_from_button_map"), 0).toInt();
|
|
|
|
|
profile.touch_from_button_map_index =
|
|
|
|
|
std::clamp(profile.touch_from_button_map_index, 0, num_touch_from_button_maps - 1);
|
2018-12-29 01:24:56 +01:00
|
|
|
profile.udp_input_address =
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("udp_input_address"),
|
|
|
|
|
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
|
2017-01-21 12:04:00 +01:00
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2018-12-29 01:24:56 +01:00
|
|
|
profile.udp_input_port = static_cast<u16>(
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("udp_input_port"), InputCommon::CemuhookUDP::DEFAULT_PORT)
|
|
|
|
|
.toInt());
|
|
|
|
|
profile.udp_pad_index =
|
|
|
|
|
static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
|
2018-12-29 03:15:18 +01:00
|
|
|
Settings::values.input_profiles.emplace_back(std::move(profile));
|
2018-12-29 01:24:56 +01:00
|
|
|
};
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
int num_input_profiles = qt_config->beginReadArray(QStringLiteral("profiles"));
|
2018-12-29 01:24:56 +01:00
|
|
|
|
2018-12-29 03:13:57 +01:00
|
|
|
for (int i = 0; i < num_input_profiles; ++i) {
|
2018-12-29 01:24:56 +01:00
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
append_profile();
|
2017-01-21 12:04:00 +01:00
|
|
|
}
|
|
|
|
|
|
2018-12-29 01:24:56 +01:00
|
|
|
qt_config->endArray();
|
2018-01-18 16:43:17 +01:00
|
|
|
|
2018-12-29 03:13:57 +01:00
|
|
|
// create a input profile if no input profiles exist, with the default or old settings
|
|
|
|
|
if (num_input_profiles == 0) {
|
2018-12-29 01:24:56 +01:00
|
|
|
append_profile();
|
2018-12-29 22:23:33 +01:00
|
|
|
num_input_profiles = 1;
|
2018-12-29 01:24:56 +01:00
|
|
|
}
|
|
|
|
|
|
2018-12-29 14:39:30 +01:00
|
|
|
// ensure that the current input profile index is valid.
|
|
|
|
|
Settings::values.current_input_profile_index =
|
|
|
|
|
std::clamp(Settings::values.current_input_profile_index, 0, num_input_profiles - 1);
|
|
|
|
|
|
2018-12-29 05:31:55 +01:00
|
|
|
Settings::LoadProfile(Settings::values.current_input_profile_index);
|
2018-01-18 16:43:17 +01:00
|
|
|
|
2014-09-13 02:06:13 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2014-11-15 20:56:18 +01:00
|
|
|
|
2019-04-03 02:57:13 +02:00
|
|
|
void Config::ReadUtilityValues() {
|
2019-11-20 22:34:39 +01:00
|
|
|
qt_config->beginGroup(QStringLiteral("Utility"));
|
2019-08-06 14:43:24 +02:00
|
|
|
|
2019-11-20 22:34:39 +01:00
|
|
|
Settings::values.dump_textures = ReadSetting(QStringLiteral("dump_textures"), false).toBool();
|
|
|
|
|
Settings::values.custom_textures =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_textures"), false).toBool();
|
|
|
|
|
Settings::values.preload_textures =
|
|
|
|
|
ReadSetting(QStringLiteral("preload_textures"), false).toBool();
|
2019-08-06 14:43:24 +02:00
|
|
|
|
2019-04-03 02:57:13 +02:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadCoreValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Core"));
|
2014-11-15 20:56:18 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.use_cpu_jit = ReadSetting(QStringLiteral("use_cpu_jit"), true).toBool();
|
2019-12-16 06:04:33 +01:00
|
|
|
Settings::values.cpu_clock_percentage =
|
|
|
|
|
ReadSetting(QStringLiteral("cpu_clock_percentage"), 100).toInt();
|
2015-05-03 21:34:48 +02:00
|
|
|
|
2016-04-27 14:53:23 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2016-04-27 14:53:23 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadDataStorageValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Data Storage"));
|
2016-12-21 19:05:56 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
|
2021-04-13 22:32:36 +02:00
|
|
|
std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
|
2021-04-17 15:29:12 +02:00
|
|
|
Settings::values.nand_dir =
|
2021-04-13 22:32:36 +02:00
|
|
|
ReadSetting(QStringLiteral("nand_directory"), QString::fromStdString(nand_dir))
|
2021-04-17 15:29:12 +02:00
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2021-04-10 20:48:28 +02:00
|
|
|
std::string sdmc_dir = FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir);
|
2021-04-17 15:29:12 +02:00
|
|
|
Settings::values.sdmc_dir =
|
|
|
|
|
ReadSetting(QStringLiteral("sdmc_directory"), QString::fromStdString(sdmc_dir))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2014-11-15 20:56:18 +01:00
|
|
|
|
2015-02-01 00:11:51 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2015-02-01 00:11:51 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadDebuggingValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Debugging"));
|
2015-09-02 14:56:38 +02:00
|
|
|
|
2019-08-15 05:03:11 +02:00
|
|
|
// Intentionally not using the QT default setting as this is intended to be changed in the ini
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::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();
|
2018-08-09 21:10:11 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->beginGroup(QStringLiteral("LLE"));
|
2018-08-09 21:10:11 +02:00
|
|
|
for (const auto& service_module : Service::service_module_map) {
|
|
|
|
|
bool use_lle = ReadSetting(QString::fromStdString(service_module.name), false).toBool();
|
|
|
|
|
Settings::values.lle_modules.emplace(service_module.name, use_lle);
|
|
|
|
|
}
|
|
|
|
|
qt_config->endGroup();
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2017-06-28 04:46:52 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2017-06-28 04:46:52 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadLayoutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Layout"));
|
|
|
|
|
|
|
|
|
|
Settings::values.render_3d = static_cast<Settings::StereoRenderOption>(
|
|
|
|
|
ReadSetting(QStringLiteral("render_3d"), 0).toInt());
|
|
|
|
|
Settings::values.factor_3d = ReadSetting(QStringLiteral("factor_3d"), 0).toInt();
|
|
|
|
|
Settings::values.pp_shader_name =
|
|
|
|
|
ReadSetting(QStringLiteral("pp_shader_name"),
|
|
|
|
|
(Settings::values.render_3d == Settings::StereoRenderOption::Anaglyph)
|
|
|
|
|
? QStringLiteral("dubois (builtin)")
|
|
|
|
|
: QStringLiteral("none (builtin)"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.filter_mode = ReadSetting(QStringLiteral("filter_mode"), true).toBool();
|
|
|
|
|
Settings::values.layout_option =
|
|
|
|
|
static_cast<Settings::LayoutOption>(ReadSetting(QStringLiteral("layout_option")).toInt());
|
|
|
|
|
Settings::values.swap_screen = ReadSetting(QStringLiteral("swap_screen"), false).toBool();
|
2019-10-26 01:21:10 +02:00
|
|
|
Settings::values.upright_screen = ReadSetting(QStringLiteral("upright_screen"), false).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.custom_layout = ReadSetting(QStringLiteral("custom_layout"), false).toBool();
|
|
|
|
|
Settings::values.custom_top_left = ReadSetting(QStringLiteral("custom_top_left"), 0).toInt();
|
|
|
|
|
Settings::values.custom_top_top = ReadSetting(QStringLiteral("custom_top_top"), 0).toInt();
|
|
|
|
|
Settings::values.custom_top_right =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_top_right"), 400).toInt();
|
|
|
|
|
Settings::values.custom_top_bottom =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_top_bottom"), 240).toInt();
|
|
|
|
|
Settings::values.custom_bottom_left =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_bottom_left"), 40).toInt();
|
|
|
|
|
Settings::values.custom_bottom_top =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_bottom_top"), 240).toInt();
|
|
|
|
|
Settings::values.custom_bottom_right =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_bottom_right"), 360).toInt();
|
|
|
|
|
Settings::values.custom_bottom_bottom =
|
|
|
|
|
ReadSetting(QStringLiteral("custom_bottom_bottom"), 480).toInt();
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2017-08-19 07:05:49 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadMiscellaneousValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
|
|
|
|
|
|
|
|
|
|
Settings::values.log_filter =
|
|
|
|
|
ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
2017-08-19 07:05:49 +02:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadMultiplayerValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Multiplayer"));
|
|
|
|
|
|
|
|
|
|
UISettings::values.nickname = ReadSetting(QStringLiteral("nickname"), QString{}).toString();
|
|
|
|
|
UISettings::values.ip = ReadSetting(QStringLiteral("ip"), QString{}).toString();
|
|
|
|
|
UISettings::values.port =
|
|
|
|
|
ReadSetting(QStringLiteral("port"), Network::DefaultRoomPort).toString();
|
|
|
|
|
UISettings::values.room_nickname =
|
|
|
|
|
ReadSetting(QStringLiteral("room_nickname"), QString{}).toString();
|
|
|
|
|
UISettings::values.room_name = ReadSetting(QStringLiteral("room_name"), QString{}).toString();
|
|
|
|
|
UISettings::values.room_port =
|
|
|
|
|
ReadSetting(QStringLiteral("room_port"), QStringLiteral("24872")).toString();
|
|
|
|
|
bool ok;
|
|
|
|
|
UISettings::values.host_type = ReadSetting(QStringLiteral("host_type"), 0).toUInt(&ok);
|
|
|
|
|
if (!ok) {
|
|
|
|
|
UISettings::values.host_type = 0;
|
2018-09-23 05:22:44 +02:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.max_player = ReadSetting(QStringLiteral("max_player"), 8).toUInt();
|
|
|
|
|
UISettings::values.game_id = ReadSetting(QStringLiteral("game_id"), 0).toULongLong();
|
|
|
|
|
UISettings::values.room_description =
|
|
|
|
|
ReadSetting(QStringLiteral("room_description"), QString{}).toString();
|
|
|
|
|
// Read ban list back
|
|
|
|
|
int size = qt_config->beginReadArray(QStringLiteral("username_ban_list"));
|
|
|
|
|
UISettings::values.ban_list.first.resize(size);
|
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
UISettings::values.ban_list.first[i] =
|
|
|
|
|
ReadSetting(QStringLiteral("username")).toString().toStdString();
|
2018-09-23 05:22:44 +02:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->endArray();
|
|
|
|
|
size = qt_config->beginReadArray(QStringLiteral("ip_ban_list"));
|
|
|
|
|
UISettings::values.ban_list.second.resize(size);
|
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
UISettings::values.ban_list.second[i] =
|
|
|
|
|
ReadSetting(QStringLiteral("ip")).toString().toStdString();
|
2018-09-23 05:22:44 +02:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->endArray();
|
2018-09-23 05:22:44 +02:00
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2018-09-23 05:22:44 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadPathValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Paths"));
|
|
|
|
|
|
|
|
|
|
UISettings::values.roms_path = ReadSetting(QStringLiteral("romsPath")).toString();
|
|
|
|
|
UISettings::values.symbols_path = ReadSetting(QStringLiteral("symbolsPath")).toString();
|
|
|
|
|
UISettings::values.movie_record_path =
|
|
|
|
|
ReadSetting(QStringLiteral("movieRecordPath")).toString();
|
|
|
|
|
UISettings::values.movie_playback_path =
|
|
|
|
|
ReadSetting(QStringLiteral("moviePlaybackPath")).toString();
|
|
|
|
|
UISettings::values.screenshot_path = ReadSetting(QStringLiteral("screenshotPath")).toString();
|
|
|
|
|
UISettings::values.video_dumping_path =
|
|
|
|
|
ReadSetting(QStringLiteral("videoDumpingPath")).toString();
|
|
|
|
|
UISettings::values.game_dir_deprecated =
|
|
|
|
|
ReadSetting(QStringLiteral("gameListRootDir"), QStringLiteral(".")).toString();
|
2018-04-20 02:56:24 +02:00
|
|
|
UISettings::values.game_dir_deprecated_deepscan =
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("gameListDeepScan"), false).toBool();
|
|
|
|
|
int size = qt_config->beginReadArray(QStringLiteral("gamedirs"));
|
2018-04-20 02:56:24 +02:00
|
|
|
for (int i = 0; i < size; ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
UISettings::GameDir game_dir;
|
2019-11-07 17:33:41 +01:00
|
|
|
game_dir.path = ReadSetting(QStringLiteral("path")).toString();
|
|
|
|
|
game_dir.deep_scan = ReadSetting(QStringLiteral("deep_scan"), false).toBool();
|
|
|
|
|
game_dir.expanded = ReadSetting(QStringLiteral("expanded"), true).toBool();
|
2018-04-20 02:56:24 +02:00
|
|
|
UISettings::values.game_dirs.append(game_dir);
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
2018-12-29 01:24:56 +01:00
|
|
|
// create NAND and SD card directories if empty, these are not removable through the UI,
|
|
|
|
|
// also carries over old game list settings if present
|
2018-04-20 02:56:24 +02:00
|
|
|
if (UISettings::values.game_dirs.isEmpty()) {
|
|
|
|
|
UISettings::GameDir game_dir;
|
2019-11-07 17:33:41 +01:00
|
|
|
game_dir.path = QStringLiteral("INSTALLED");
|
2018-04-20 02:56:24 +02:00
|
|
|
game_dir.expanded = true;
|
|
|
|
|
UISettings::values.game_dirs.append(game_dir);
|
2019-11-07 17:33:41 +01:00
|
|
|
game_dir.path = QStringLiteral("SYSTEM");
|
2018-04-20 02:56:24 +02:00
|
|
|
UISettings::values.game_dirs.append(game_dir);
|
2019-11-07 17:33:41 +01:00
|
|
|
if (UISettings::values.game_dir_deprecated != QStringLiteral(".")) {
|
2018-04-20 02:56:24 +02:00
|
|
|
game_dir.path = UISettings::values.game_dir_deprecated;
|
|
|
|
|
game_dir.deep_scan = UISettings::values.game_dir_deprecated_deepscan;
|
|
|
|
|
UISettings::values.game_dirs.append(game_dir);
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.recent_files = ReadSetting(QStringLiteral("recentFiles")).toStringList();
|
|
|
|
|
UISettings::values.language = ReadSetting(QStringLiteral("language"), QString{}).toString();
|
|
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadRendererValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Renderer"));
|
|
|
|
|
|
|
|
|
|
Settings::values.use_hw_renderer =
|
|
|
|
|
ReadSetting(QStringLiteral("use_hw_renderer"), true).toBool();
|
2020-04-18 13:37:58 +02:00
|
|
|
Settings::values.use_hw_shader = ReadSetting(QStringLiteral("use_hw_shader"), true).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
#ifdef __APPLE__
|
2020-05-04 12:14:40 +02:00
|
|
|
// Hardware shader is broken on macos with Intel GPUs thanks to poor drivers.
|
2019-11-07 17:33:41 +01:00
|
|
|
// We still want to provide this option for test/development purposes, but disable it by
|
|
|
|
|
// default.
|
2020-05-04 12:14:40 +02:00
|
|
|
Settings::values.separable_shader =
|
|
|
|
|
ReadSetting(QStringLiteral("separable_shader"), false).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
#endif
|
|
|
|
|
Settings::values.shaders_accurate_mul =
|
2020-11-06 19:07:59 +01:00
|
|
|
ReadSetting(QStringLiteral("shaders_accurate_mul"), true).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.use_shader_jit = ReadSetting(QStringLiteral("use_shader_jit"), true).toBool();
|
2020-11-06 19:07:59 +01:00
|
|
|
Settings::values.use_disk_shader_cache =
|
|
|
|
|
ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
|
2019-12-15 23:42:05 +01:00
|
|
|
Settings::values.use_vsync_new = ReadSetting(QStringLiteral("use_vsync_new"), true).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.resolution_factor =
|
|
|
|
|
static_cast<u16>(ReadSetting(QStringLiteral("resolution_factor"), 1).toInt());
|
|
|
|
|
Settings::values.frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
|
2020-06-20 20:52:14 +02:00
|
|
|
Settings::values.use_frame_limit_alternate =
|
|
|
|
|
ReadSetting(QStringLiteral("use_frame_limit_alternate"), false).toBool();
|
|
|
|
|
Settings::values.frame_limit_alternate =
|
|
|
|
|
ReadSetting(QStringLiteral("frame_limit_alternate"), 200).toInt();
|
2019-11-07 17:33:41 +01:00
|
|
|
|
|
|
|
|
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();
|
|
|
|
|
|
2020-03-16 15:42:05 +01:00
|
|
|
Settings::values.texture_filter_name =
|
|
|
|
|
ReadSetting(QStringLiteral("texture_filter_name"), QStringLiteral("none"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadShortcutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Shortcuts"));
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2018-12-30 11:09:16 +01:00
|
|
|
for (auto [name, group, shortcut] : default_hotkeys) {
|
|
|
|
|
auto [keyseq, context] = shortcut;
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->beginGroup(group);
|
2018-12-30 11:09:16 +01:00
|
|
|
qt_config->beginGroup(name);
|
2018-05-22 21:30:36 +02:00
|
|
|
UISettings::values.shortcuts.push_back(
|
2018-12-30 11:09:16 +01:00
|
|
|
{name,
|
|
|
|
|
group,
|
2019-11-07 17:33:41 +01:00
|
|
|
{ReadSetting(QStringLiteral("KeySeq"), keyseq).toString(),
|
|
|
|
|
ReadSetting(QStringLiteral("Context"), context).toInt()}});
|
2018-05-22 21:30:36 +02:00
|
|
|
qt_config->endGroup();
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadSystemValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("System"));
|
|
|
|
|
|
2020-02-28 02:56:24 +01:00
|
|
|
Settings::values.is_new_3ds = ReadSetting(QStringLiteral("is_new_3ds"), true).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
Settings::values.region_value =
|
|
|
|
|
ReadSetting(QStringLiteral("region_value"), Settings::REGION_VALUE_AUTO_SELECT).toInt();
|
|
|
|
|
Settings::values.init_clock = static_cast<Settings::InitClock>(
|
|
|
|
|
ReadSetting(QStringLiteral("init_clock"), static_cast<u32>(Settings::InitClock::SystemTime))
|
|
|
|
|
.toInt());
|
|
|
|
|
Settings::values.init_time =
|
|
|
|
|
ReadSetting(QStringLiteral("init_time"), 946681277ULL).toULongLong();
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-29 07:57:16 +01:00
|
|
|
// Options for variable bit rate live streaming taken from here:
|
|
|
|
|
// https://developers.google.com/media/vp9/live-encoding
|
|
|
|
|
const QString DEFAULT_VIDEO_ENCODER_OPTIONS =
|
|
|
|
|
QStringLiteral("quality:realtime,speed:6,tile-columns:4,frame-parallel:1,threads:8,row-mt:1");
|
|
|
|
|
const QString DEFAULT_AUDIO_ENCODER_OPTIONS = QString{};
|
|
|
|
|
|
|
|
|
|
void Config::ReadVideoDumpingValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("VideoDumping"));
|
|
|
|
|
|
|
|
|
|
Settings::values.output_format =
|
|
|
|
|
ReadSetting(QStringLiteral("output_format"), QStringLiteral("webm"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.format_options =
|
|
|
|
|
ReadSetting(QStringLiteral("format_options")).toString().toStdString();
|
|
|
|
|
|
|
|
|
|
Settings::values.video_encoder =
|
|
|
|
|
ReadSetting(QStringLiteral("video_encoder"), QStringLiteral("libvpx-vp9"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
|
|
|
|
|
Settings::values.video_encoder_options =
|
|
|
|
|
ReadSetting(QStringLiteral("video_encoder_options"), DEFAULT_VIDEO_ENCODER_OPTIONS)
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
|
|
|
|
|
Settings::values.video_bitrate =
|
|
|
|
|
ReadSetting(QStringLiteral("video_bitrate"), 2500000).toULongLong();
|
|
|
|
|
|
|
|
|
|
Settings::values.audio_encoder =
|
|
|
|
|
ReadSetting(QStringLiteral("audio_encoder"), QStringLiteral("libvorbis"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.audio_encoder_options =
|
|
|
|
|
ReadSetting(QStringLiteral("audio_encoder_options"), DEFAULT_AUDIO_ENCODER_OPTIONS)
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.audio_bitrate =
|
|
|
|
|
ReadSetting(QStringLiteral("audio_bitrate"), 64000).toULongLong();
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::ReadUIValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("UI"));
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.theme =
|
|
|
|
|
ReadSetting(QStringLiteral("theme"), QString::fromUtf8(UISettings::themes[0].second))
|
|
|
|
|
.toString();
|
|
|
|
|
UISettings::values.enable_discord_presence =
|
|
|
|
|
ReadSetting(QStringLiteral("enable_discord_presence"), true).toBool();
|
|
|
|
|
UISettings::values.screenshot_resolution_factor =
|
|
|
|
|
static_cast<u16>(ReadSetting(QStringLiteral("screenshot_resolution_factor"), 0).toUInt());
|
|
|
|
|
|
|
|
|
|
ReadUpdaterValues();
|
|
|
|
|
ReadUILayoutValues();
|
|
|
|
|
ReadUIGameListValues();
|
|
|
|
|
ReadPathValues();
|
|
|
|
|
ReadShortcutValues();
|
|
|
|
|
ReadMultiplayerValues();
|
|
|
|
|
|
|
|
|
|
UISettings::values.single_window_mode =
|
|
|
|
|
ReadSetting(QStringLiteral("singleWindowMode"), true).toBool();
|
|
|
|
|
UISettings::values.fullscreen = ReadSetting(QStringLiteral("fullscreen"), false).toBool();
|
|
|
|
|
UISettings::values.display_titlebar =
|
|
|
|
|
ReadSetting(QStringLiteral("displayTitleBars"), true).toBool();
|
|
|
|
|
UISettings::values.show_filter_bar =
|
|
|
|
|
ReadSetting(QStringLiteral("showFilterBar"), true).toBool();
|
|
|
|
|
UISettings::values.show_status_bar =
|
|
|
|
|
ReadSetting(QStringLiteral("showStatusBar"), true).toBool();
|
|
|
|
|
UISettings::values.confirm_before_closing =
|
|
|
|
|
ReadSetting(QStringLiteral("confirmClose"), true).toBool();
|
|
|
|
|
UISettings::values.first_start = ReadSetting(QStringLiteral("firstStart"), true).toBool();
|
|
|
|
|
UISettings::values.callout_flags = ReadSetting(QStringLiteral("calloutFlags"), 0).toUInt();
|
|
|
|
|
UISettings::values.show_console = ReadSetting(QStringLiteral("showConsole"), false).toBool();
|
2019-09-14 23:14:23 +02:00
|
|
|
UISettings::values.pause_when_in_background =
|
2019-11-07 17:33:41 +01:00
|
|
|
ReadSetting(QStringLiteral("pauseWhenInBackground"), false).toBool();
|
2020-04-07 16:58:51 +02:00
|
|
|
UISettings::values.hide_mouse =
|
|
|
|
|
ReadSetting(QStringLiteral("hideInactiveMouse"), false).toBool();
|
2019-11-07 17:33:41 +01:00
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadUIGameListValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("GameList"));
|
|
|
|
|
|
|
|
|
|
auto icon_size = UISettings::GameListIconSize{
|
|
|
|
|
ReadSetting(QStringLiteral("iconSize"),
|
|
|
|
|
static_cast<int>(UISettings::GameListIconSize::LargeIcon))
|
|
|
|
|
.toInt()};
|
|
|
|
|
if (icon_size < UISettings::GameListIconSize::NoIcon ||
|
|
|
|
|
icon_size > UISettings::GameListIconSize::LargeIcon) {
|
|
|
|
|
icon_size = UISettings::GameListIconSize::LargeIcon;
|
2018-04-18 07:06:02 +02:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.game_list_icon_size = icon_size;
|
|
|
|
|
|
|
|
|
|
UISettings::GameListText row_1 = UISettings::GameListText{
|
|
|
|
|
ReadSetting(QStringLiteral("row1"), static_cast<int>(UISettings::GameListText::TitleName))
|
|
|
|
|
.toInt()};
|
|
|
|
|
if (row_1 <= UISettings::GameListText::NoText || row_1 >= UISettings::GameListText::ListEnd) {
|
|
|
|
|
row_1 = UISettings::GameListText::TitleName;
|
2018-11-24 09:22:49 +01:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.game_list_row_1 = row_1;
|
|
|
|
|
|
|
|
|
|
UISettings::GameListText row_2 = UISettings::GameListText{
|
|
|
|
|
ReadSetting(QStringLiteral("row2"), static_cast<int>(UISettings::GameListText::FileName))
|
|
|
|
|
.toInt()};
|
|
|
|
|
if (row_2 < UISettings::GameListText::NoText || row_2 >= UISettings::GameListText::ListEnd) {
|
|
|
|
|
row_2 = UISettings::GameListText::FileName;
|
2018-11-24 09:22:49 +01:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
UISettings::values.game_list_row_2 = row_2;
|
|
|
|
|
|
|
|
|
|
UISettings::values.game_list_hide_no_icon =
|
|
|
|
|
ReadSetting(QStringLiteral("hideNoIcon"), false).toBool();
|
|
|
|
|
UISettings::values.game_list_single_line_mode =
|
|
|
|
|
ReadSetting(QStringLiteral("singleLineMode"), false).toBool();
|
|
|
|
|
|
2018-01-19 14:42:21 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadUILayoutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("UILayout"));
|
|
|
|
|
|
|
|
|
|
UISettings::values.geometry = ReadSetting(QStringLiteral("geometry")).toByteArray();
|
|
|
|
|
UISettings::values.state = ReadSetting(QStringLiteral("state")).toByteArray();
|
|
|
|
|
UISettings::values.renderwindow_geometry =
|
|
|
|
|
ReadSetting(QStringLiteral("geometryRenderWindow")).toByteArray();
|
|
|
|
|
UISettings::values.gamelist_header_state =
|
|
|
|
|
ReadSetting(QStringLiteral("gameListHeaderState")).toByteArray();
|
|
|
|
|
UISettings::values.microprofile_geometry =
|
|
|
|
|
ReadSetting(QStringLiteral("microProfileDialogGeometry")).toByteArray();
|
|
|
|
|
UISettings::values.microprofile_visible =
|
|
|
|
|
ReadSetting(QStringLiteral("microProfileDialogVisible"), false).toBool();
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadUpdaterValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Updater"));
|
|
|
|
|
|
|
|
|
|
UISettings::values.check_for_update_on_start =
|
|
|
|
|
ReadSetting(QStringLiteral("check_for_update_on_start"), true).toBool();
|
|
|
|
|
UISettings::values.update_on_close =
|
|
|
|
|
ReadSetting(QStringLiteral("update_on_close"), false).toBool();
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::ReadWebServiceValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("WebService"));
|
|
|
|
|
|
|
|
|
|
Settings::values.enable_telemetry =
|
|
|
|
|
ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
|
|
|
|
|
Settings::values.web_api_url =
|
|
|
|
|
ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.citra-emu.org"))
|
|
|
|
|
.toString()
|
|
|
|
|
.toStdString();
|
|
|
|
|
Settings::values.citra_username =
|
|
|
|
|
ReadSetting(QStringLiteral("citra_username")).toString().toStdString();
|
|
|
|
|
Settings::values.citra_token =
|
|
|
|
|
ReadSetting(QStringLiteral("citra_token")).toString().toStdString();
|
2018-01-19 14:42:21 +01:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2014-09-13 02:06:13 +02:00
|
|
|
}
|
|
|
|
|
|
2014-11-15 20:56:18 +01:00
|
|
|
void Config::SaveValues() {
|
2019-11-07 17:33:41 +01:00
|
|
|
SaveControlValues();
|
|
|
|
|
SaveCoreValues();
|
|
|
|
|
SaveRendererValues();
|
|
|
|
|
SaveLayoutValues();
|
|
|
|
|
SaveAudioValues();
|
|
|
|
|
SaveCameraValues();
|
|
|
|
|
SaveDataStorageValues();
|
|
|
|
|
SaveSystemValues();
|
|
|
|
|
SaveMiscellaneousValues();
|
|
|
|
|
SaveDebuggingValues();
|
|
|
|
|
SaveWebServiceValues();
|
2020-01-29 07:57:16 +01:00
|
|
|
SaveVideoDumpingValues();
|
2019-11-07 17:33:41 +01:00
|
|
|
SaveUIValues();
|
2019-11-11 01:26:03 +01:00
|
|
|
SaveUtilityValues();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveAudioValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Audio"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("enable_dsp_lle"), Settings::values.enable_dsp_lle, false);
|
|
|
|
|
WriteSetting(QStringLiteral("enable_dsp_lle_multithread"),
|
|
|
|
|
Settings::values.enable_dsp_lle_multithread, false);
|
|
|
|
|
WriteSetting(QStringLiteral("output_engine"), QString::fromStdString(Settings::values.sink_id),
|
|
|
|
|
QStringLiteral("auto"));
|
|
|
|
|
WriteSetting(QStringLiteral("enable_audio_stretching"),
|
|
|
|
|
Settings::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);
|
|
|
|
|
WriteSetting(QStringLiteral("mic_input_device"),
|
|
|
|
|
QString::fromStdString(Settings::values.mic_input_device),
|
2020-02-11 13:12:09 +01:00
|
|
|
QString::fromUtf8(Frontend::Mic::default_device_name));
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("mic_input_type"),
|
|
|
|
|
static_cast<int>(Settings::values.mic_input_type), 0);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveCameraValues() {
|
|
|
|
|
using namespace Service::CAM;
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Camera"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_right_name"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_name[OuterRightCamera]),
|
|
|
|
|
QStringLiteral("blank"));
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_right_config"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_config[OuterRightCamera]),
|
|
|
|
|
QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_right_flip"),
|
|
|
|
|
Settings::values.camera_flip[OuterRightCamera], 0);
|
|
|
|
|
WriteSetting(QStringLiteral("camera_inner_name"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_name[InnerCamera]),
|
|
|
|
|
QStringLiteral("blank"));
|
|
|
|
|
WriteSetting(QStringLiteral("camera_inner_config"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_config[InnerCamera]), QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("camera_inner_flip"), Settings::values.camera_flip[InnerCamera], 0);
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_left_name"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_name[OuterLeftCamera]),
|
|
|
|
|
QStringLiteral("blank"));
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_left_config"),
|
|
|
|
|
QString::fromStdString(Settings::values.camera_config[OuterLeftCamera]),
|
|
|
|
|
QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("camera_outer_left_flip"),
|
|
|
|
|
Settings::values.camera_flip[OuterLeftCamera], 0);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveControlValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Controls"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("profile"), Settings::values.current_input_profile_index, 0);
|
|
|
|
|
qt_config->beginWriteArray(QStringLiteral("profiles"));
|
2018-12-29 03:14:44 +01:00
|
|
|
for (std::size_t p = 0; p < Settings::values.input_profiles.size(); ++p) {
|
2018-12-29 03:13:57 +01:00
|
|
|
qt_config->setArrayIndex(static_cast<int>(p));
|
2018-12-29 03:14:44 +01:00
|
|
|
const auto& profile = Settings::values.input_profiles[p];
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("name"), QString::fromStdString(profile.name),
|
|
|
|
|
QStringLiteral("default"));
|
2018-12-29 01:24:56 +01:00
|
|
|
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
|
|
|
|
|
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
|
|
|
|
|
WriteSetting(QString::fromStdString(Settings::NativeButton::mapping[i]),
|
|
|
|
|
QString::fromStdString(profile.buttons[i]),
|
|
|
|
|
QString::fromStdString(default_param));
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
|
|
|
|
|
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);
|
|
|
|
|
WriteSetting(QString::fromStdString(Settings::NativeAnalog::mapping[i]),
|
|
|
|
|
QString::fromStdString(profile.analogs[i]),
|
|
|
|
|
QString::fromStdString(default_param));
|
|
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(
|
|
|
|
|
QStringLiteral("motion_device"), QString::fromStdString(profile.motion_device),
|
|
|
|
|
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01,tilt_clamp:90.0"));
|
|
|
|
|
WriteSetting(QStringLiteral("touch_device"), QString::fromStdString(profile.touch_device),
|
|
|
|
|
QStringLiteral("engine:emu_window"));
|
2020-04-01 20:07:16 +02:00
|
|
|
WriteSetting(QStringLiteral("use_touch_from_button"), profile.use_touch_from_button, false);
|
|
|
|
|
WriteSetting(QStringLiteral("touch_from_button_map"), profile.touch_from_button_map_index,
|
|
|
|
|
0);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("udp_input_address"),
|
|
|
|
|
QString::fromStdString(profile.udp_input_address),
|
|
|
|
|
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
|
|
|
|
|
WriteSetting(QStringLiteral("udp_input_port"), profile.udp_input_port,
|
2018-12-29 01:24:56 +01:00
|
|
|
InputCommon::CemuhookUDP::DEFAULT_PORT);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("udp_pad_index"), profile.udp_pad_index, 0);
|
2015-06-20 05:34:45 +02:00
|
|
|
}
|
2018-12-29 01:24:56 +01:00
|
|
|
qt_config->endArray();
|
2014-10-25 21:54:44 +02:00
|
|
|
|
2020-04-01 20:07:16 +02:00
|
|
|
qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
|
|
|
|
|
for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
|
|
|
|
|
qt_config->setArrayIndex(static_cast<int>(p));
|
|
|
|
|
const auto& map = Settings::values.touch_from_button_maps[p];
|
|
|
|
|
WriteSetting(QStringLiteral("name"), QString::fromStdString(map.name),
|
|
|
|
|
QStringLiteral("default"));
|
|
|
|
|
qt_config->beginWriteArray(QStringLiteral("entries"));
|
|
|
|
|
for (std::size_t q = 0; q < map.buttons.size(); ++q) {
|
|
|
|
|
qt_config->setArrayIndex(static_cast<int>(q));
|
|
|
|
|
WriteSetting(QStringLiteral("bind"), QString::fromStdString(map.buttons[q]));
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
|
|
|
|
|
2014-10-25 21:54:44 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2014-10-10 04:43:40 +02:00
|
|
|
|
2019-04-03 02:57:13 +02:00
|
|
|
void Config::SaveUtilityValues() {
|
2019-11-20 22:34:39 +01:00
|
|
|
qt_config->beginGroup(QStringLiteral("Utility"));
|
2019-04-03 02:57:13 +02:00
|
|
|
|
2019-11-20 22:34:39 +01:00
|
|
|
WriteSetting(QStringLiteral("dump_textures"), Settings::values.dump_textures, false);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_textures"), Settings::values.custom_textures, false);
|
|
|
|
|
WriteSetting(QStringLiteral("preload_textures"), Settings::values.preload_textures, false);
|
2019-04-03 02:57:13 +02:00
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::SaveCoreValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Core"));
|
2015-05-03 21:34:48 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("use_cpu_jit"), Settings::values.use_cpu_jit, true);
|
2019-12-16 06:04:33 +01:00
|
|
|
WriteSetting(QStringLiteral("cpu_clock_percentage"), Settings::values.cpu_clock_percentage,
|
|
|
|
|
100);
|
2015-04-04 00:35:51 +02:00
|
|
|
|
2016-04-27 14:53:23 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
2016-04-27 14:53:23 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::SaveDataStorageValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Data Storage"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values.use_virtual_sd, true);
|
2021-04-08 00:20:52 +02:00
|
|
|
WriteSetting(QStringLiteral("nand_directory"),
|
2021-04-17 15:16:48 +02:00
|
|
|
QString::fromStdString(Settings::values.nand_dir),
|
2021-04-17 15:29:12 +02:00
|
|
|
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
|
2021-04-08 00:20:52 +02:00
|
|
|
WriteSetting(QStringLiteral("sdmc_directory"),
|
2021-04-17 15:16:48 +02:00
|
|
|
QString::fromStdString(Settings::values.sdmc_dir),
|
2021-04-17 15:29:12 +02:00
|
|
|
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
|
2015-02-01 00:11:51 +01:00
|
|
|
|
2014-10-27 22:18:28 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveDebuggingValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Debugging"));
|
2015-09-02 14:56:38 +02:00
|
|
|
|
2019-08-15 05:03:11 +02:00
|
|
|
// Intentionally not using the QT default setting as this is intended to be changed in the ini
|
2019-11-07 17:33:41 +01:00
|
|
|
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);
|
2018-08-09 21:10:11 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->beginGroup(QStringLiteral("LLE"));
|
2018-08-09 21:10:11 +02:00
|
|
|
for (const auto& service_module : Settings::values.lle_modules) {
|
|
|
|
|
WriteSetting(QString::fromStdString(service_module.first), service_module.second, false);
|
|
|
|
|
}
|
|
|
|
|
qt_config->endGroup();
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2017-06-28 04:46:52 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveLayoutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Layout"));
|
2017-06-28 04:46:52 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("render_3d"), static_cast<int>(Settings::values.render_3d), 0);
|
|
|
|
|
WriteSetting(QStringLiteral("factor_3d"), Settings::values.factor_3d.load(), 0);
|
|
|
|
|
WriteSetting(QStringLiteral("pp_shader_name"),
|
|
|
|
|
QString::fromStdString(Settings::values.pp_shader_name),
|
|
|
|
|
(Settings::values.render_3d == Settings::StereoRenderOption::Anaglyph)
|
|
|
|
|
? QStringLiteral("dubois (builtin)")
|
|
|
|
|
: QStringLiteral("none (builtin)"));
|
|
|
|
|
WriteSetting(QStringLiteral("filter_mode"), Settings::values.filter_mode, true);
|
|
|
|
|
WriteSetting(QStringLiteral("layout_option"), static_cast<int>(Settings::values.layout_option));
|
|
|
|
|
WriteSetting(QStringLiteral("swap_screen"), Settings::values.swap_screen, false);
|
2019-10-26 01:21:10 +02:00
|
|
|
WriteSetting(QStringLiteral("upright_screen"), Settings::values.upright_screen, false);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("custom_layout"), Settings::values.custom_layout, false);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_top_left"), Settings::values.custom_top_left, 0);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_top_top"), Settings::values.custom_top_top, 0);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_top_right"), Settings::values.custom_top_right, 400);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_top_bottom"), Settings::values.custom_top_bottom, 240);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_bottom_left"), Settings::values.custom_bottom_left, 40);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_bottom_top"), Settings::values.custom_bottom_top, 240);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_bottom_right"), Settings::values.custom_bottom_right, 360);
|
|
|
|
|
WriteSetting(QStringLiteral("custom_bottom_bottom"), Settings::values.custom_bottom_bottom,
|
|
|
|
|
480);
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2017-08-19 07:05:49 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveMiscellaneousValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values.log_filter),
|
|
|
|
|
QStringLiteral("*:Info"));
|
2017-08-19 07:05:49 +02:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveMultiplayerValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Multiplayer"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("nickname"), UISettings::values.nickname, QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("ip"), UISettings::values.ip, QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("port"), UISettings::values.port, Network::DefaultRoomPort);
|
|
|
|
|
WriteSetting(QStringLiteral("room_nickname"), UISettings::values.room_nickname, QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("room_name"), UISettings::values.room_name, QString{});
|
|
|
|
|
WriteSetting(QStringLiteral("room_port"), UISettings::values.room_port,
|
|
|
|
|
QStringLiteral("24872"));
|
|
|
|
|
WriteSetting(QStringLiteral("host_type"), UISettings::values.host_type, 0);
|
|
|
|
|
WriteSetting(QStringLiteral("max_player"), UISettings::values.max_player, 8);
|
|
|
|
|
WriteSetting(QStringLiteral("game_id"), UISettings::values.game_id, 0);
|
|
|
|
|
WriteSetting(QStringLiteral("room_description"), UISettings::values.room_description,
|
|
|
|
|
QString{});
|
|
|
|
|
// Write ban list
|
|
|
|
|
qt_config->beginWriteArray(QStringLiteral("username_ban_list"));
|
|
|
|
|
for (std::size_t i = 0; i < UISettings::values.ban_list.first.size(); ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
WriteSetting(QStringLiteral("username"),
|
|
|
|
|
QString::fromStdString(UISettings::values.ban_list.first[i]));
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
|
|
|
|
qt_config->beginWriteArray(QStringLiteral("ip_ban_list"));
|
|
|
|
|
for (std::size_t i = 0; i < UISettings::values.ban_list.second.size(); ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
|
|
|
|
WriteSetting(QStringLiteral("ip"),
|
|
|
|
|
QString::fromStdString(UISettings::values.ban_list.second[i]));
|
|
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2018-09-23 05:22:44 +02:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SavePathValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Paths"));
|
2018-09-23 05:22:44 +02:00
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("romsPath"), UISettings::values.roms_path);
|
|
|
|
|
WriteSetting(QStringLiteral("symbolsPath"), UISettings::values.symbols_path);
|
|
|
|
|
WriteSetting(QStringLiteral("movieRecordPath"), UISettings::values.movie_record_path);
|
|
|
|
|
WriteSetting(QStringLiteral("moviePlaybackPath"), UISettings::values.movie_playback_path);
|
|
|
|
|
WriteSetting(QStringLiteral("screenshotPath"), UISettings::values.screenshot_path);
|
|
|
|
|
WriteSetting(QStringLiteral("videoDumpingPath"), UISettings::values.video_dumping_path);
|
|
|
|
|
qt_config->beginWriteArray(QStringLiteral("gamedirs"));
|
2018-04-20 02:56:24 +02:00
|
|
|
for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
|
|
|
|
|
qt_config->setArrayIndex(i);
|
2019-09-22 17:27:01 +02:00
|
|
|
const auto& game_dir = UISettings::values.game_dirs[i];
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("path"), game_dir.path);
|
|
|
|
|
WriteSetting(QStringLiteral("deep_scan"), game_dir.deep_scan, false);
|
|
|
|
|
WriteSetting(QStringLiteral("expanded"), game_dir.expanded, true);
|
2018-04-20 02:56:24 +02:00
|
|
|
}
|
|
|
|
|
qt_config->endArray();
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("recentFiles"), UISettings::values.recent_files);
|
|
|
|
|
WriteSetting(QStringLiteral("language"), UISettings::values.language, QString{});
|
|
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveRendererValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Renderer"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("use_hw_renderer"), Settings::values.use_hw_renderer, true);
|
2020-04-18 13:37:58 +02:00
|
|
|
WriteSetting(QStringLiteral("use_hw_shader"), Settings::values.use_hw_shader, true);
|
2019-11-07 17:33:41 +01:00
|
|
|
#ifdef __APPLE__
|
|
|
|
|
// Hardware shader is broken on macos thanks to poor drivers.
|
2020-04-18 13:37:58 +02:00
|
|
|
// TODO: enable this for none Intel GPUs
|
2020-04-18 15:55:19 +02:00
|
|
|
WriteSetting(QStringLiteral("use_separable_shader"), Settings::values.separable_shader, false);
|
2019-11-07 17:33:41 +01:00
|
|
|
#endif
|
|
|
|
|
WriteSetting(QStringLiteral("shaders_accurate_mul"), Settings::values.shaders_accurate_mul,
|
2020-11-06 19:07:59 +01:00
|
|
|
true);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("use_shader_jit"), Settings::values.use_shader_jit, true);
|
2020-11-06 19:07:59 +01:00
|
|
|
WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values.use_disk_shader_cache,
|
|
|
|
|
true);
|
2019-12-15 23:42:05 +01:00
|
|
|
WriteSetting(QStringLiteral("use_vsync_new"), Settings::values.use_vsync_new, true);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("resolution_factor"), Settings::values.resolution_factor, 1);
|
|
|
|
|
WriteSetting(QStringLiteral("frame_limit"), Settings::values.frame_limit, 100);
|
2020-06-20 20:52:14 +02:00
|
|
|
WriteSetting(QStringLiteral("use_frame_limit_alternate"),
|
|
|
|
|
Settings::values.use_frame_limit_alternate, false);
|
|
|
|
|
WriteSetting(QStringLiteral("frame_limit_alternate"), Settings::values.frame_limit_alternate,
|
|
|
|
|
200);
|
2019-11-07 17:33:41 +01:00
|
|
|
|
|
|
|
|
// Cast to double because Qt's written float values are not human-readable
|
|
|
|
|
WriteSetting(QStringLiteral("bg_red"), (double)Settings::values.bg_red, 0.0);
|
|
|
|
|
WriteSetting(QStringLiteral("bg_green"), (double)Settings::values.bg_green, 0.0);
|
|
|
|
|
WriteSetting(QStringLiteral("bg_blue"), (double)Settings::values.bg_blue, 0.0);
|
|
|
|
|
|
2020-03-16 15:42:05 +01:00
|
|
|
WriteSetting(QStringLiteral("texture_filter_name"),
|
|
|
|
|
QString::fromStdString(Settings::values.texture_filter_name),
|
|
|
|
|
QStringLiteral("none"));
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveShortcutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Shortcuts"));
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2018-12-30 11:09:16 +01:00
|
|
|
// Lengths of UISettings::values.shortcuts & default_hotkeys are same.
|
|
|
|
|
// However, their ordering must also be the same.
|
|
|
|
|
for (std::size_t i = 0; i < default_hotkeys.size(); i++) {
|
|
|
|
|
auto [name, group, shortcut] = UISettings::values.shortcuts[i];
|
|
|
|
|
qt_config->beginGroup(group);
|
|
|
|
|
qt_config->beginGroup(name);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("KeySeq"), shortcut.first, default_hotkeys[i].shortcut.first);
|
|
|
|
|
WriteSetting(QStringLiteral("Context"), shortcut.second,
|
|
|
|
|
default_hotkeys[i].shortcut.second);
|
2018-05-22 21:30:36 +02:00
|
|
|
qt_config->endGroup();
|
|
|
|
|
qt_config->endGroup();
|
2016-01-24 21:23:55 +01:00
|
|
|
}
|
2019-11-07 17:33:41 +01:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveSystemValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("System"));
|
|
|
|
|
|
2020-02-28 02:56:24 +01:00
|
|
|
WriteSetting(QStringLiteral("is_new_3ds"), Settings::values.is_new_3ds, true);
|
2019-11-07 17:33:41 +01:00
|
|
|
WriteSetting(QStringLiteral("region_value"), Settings::values.region_value,
|
|
|
|
|
Settings::REGION_VALUE_AUTO_SELECT);
|
|
|
|
|
WriteSetting(QStringLiteral("init_clock"), static_cast<u32>(Settings::values.init_clock),
|
|
|
|
|
static_cast<u32>(Settings::InitClock::SystemTime));
|
|
|
|
|
WriteSetting(QStringLiteral("init_time"),
|
|
|
|
|
static_cast<unsigned long long>(Settings::values.init_time), 946681277ULL);
|
2016-01-24 21:23:55 +01:00
|
|
|
|
2018-01-19 14:42:21 +01:00
|
|
|
qt_config->endGroup();
|
2019-11-07 17:33:41 +01:00
|
|
|
}
|
|
|
|
|
|
2020-01-29 07:57:16 +01:00
|
|
|
void Config::SaveVideoDumpingValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("VideoDumping"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("output_format"),
|
|
|
|
|
QString::fromStdString(Settings::values.output_format), QStringLiteral("webm"));
|
|
|
|
|
WriteSetting(QStringLiteral("format_options"),
|
|
|
|
|
QString::fromStdString(Settings::values.format_options));
|
|
|
|
|
WriteSetting(QStringLiteral("video_encoder"),
|
|
|
|
|
QString::fromStdString(Settings::values.video_encoder),
|
|
|
|
|
QStringLiteral("libvpx-vp9"));
|
|
|
|
|
WriteSetting(QStringLiteral("video_encoder_options"),
|
|
|
|
|
QString::fromStdString(Settings::values.video_encoder_options),
|
|
|
|
|
DEFAULT_VIDEO_ENCODER_OPTIONS);
|
|
|
|
|
WriteSetting(QStringLiteral("video_bitrate"),
|
|
|
|
|
static_cast<unsigned long long>(Settings::values.video_bitrate), 2500000);
|
|
|
|
|
WriteSetting(QStringLiteral("audio_encoder"),
|
|
|
|
|
QString::fromStdString(Settings::values.audio_encoder),
|
|
|
|
|
QStringLiteral("libvorbis"));
|
|
|
|
|
WriteSetting(QStringLiteral("audio_encoder_options"),
|
|
|
|
|
QString::fromStdString(Settings::values.audio_encoder_options),
|
|
|
|
|
DEFAULT_AUDIO_ENCODER_OPTIONS);
|
|
|
|
|
WriteSetting(QStringLiteral("audio_bitrate"),
|
|
|
|
|
static_cast<unsigned long long>(Settings::values.audio_bitrate), 64000);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-07 17:33:41 +01:00
|
|
|
void Config::SaveUIValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("UI"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("theme"), UISettings::values.theme,
|
|
|
|
|
QString::fromUtf8(UISettings::themes[0].second));
|
|
|
|
|
WriteSetting(QStringLiteral("enable_discord_presence"),
|
|
|
|
|
UISettings::values.enable_discord_presence, true);
|
|
|
|
|
WriteSetting(QStringLiteral("screenshot_resolution_factor"),
|
|
|
|
|
UISettings::values.screenshot_resolution_factor, 0);
|
|
|
|
|
|
|
|
|
|
SaveUpdaterValues();
|
|
|
|
|
SaveUILayoutValues();
|
|
|
|
|
SaveUIGameListValues();
|
|
|
|
|
SavePathValues();
|
|
|
|
|
SaveShortcutValues();
|
|
|
|
|
SaveMultiplayerValues();
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("singleWindowMode"), UISettings::values.single_window_mode, true);
|
|
|
|
|
WriteSetting(QStringLiteral("fullscreen"), UISettings::values.fullscreen, false);
|
|
|
|
|
WriteSetting(QStringLiteral("displayTitleBars"), UISettings::values.display_titlebar, true);
|
|
|
|
|
WriteSetting(QStringLiteral("showFilterBar"), UISettings::values.show_filter_bar, true);
|
|
|
|
|
WriteSetting(QStringLiteral("showStatusBar"), UISettings::values.show_status_bar, true);
|
|
|
|
|
WriteSetting(QStringLiteral("confirmClose"), UISettings::values.confirm_before_closing, true);
|
|
|
|
|
WriteSetting(QStringLiteral("firstStart"), UISettings::values.first_start, true);
|
|
|
|
|
WriteSetting(QStringLiteral("calloutFlags"), UISettings::values.callout_flags, 0);
|
|
|
|
|
WriteSetting(QStringLiteral("showConsole"), UISettings::values.show_console, false);
|
|
|
|
|
WriteSetting(QStringLiteral("pauseWhenInBackground"),
|
|
|
|
|
UISettings::values.pause_when_in_background, false);
|
2020-04-07 16:58:51 +02:00
|
|
|
WriteSetting(QStringLiteral("hideInactiveMouse"), UISettings::values.hide_mouse, false);
|
2019-11-07 17:33:41 +01:00
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveUIGameListValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("GameList"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("iconSize"),
|
|
|
|
|
static_cast<int>(UISettings::values.game_list_icon_size), 2);
|
|
|
|
|
WriteSetting(QStringLiteral("row1"), static_cast<int>(UISettings::values.game_list_row_1), 2);
|
|
|
|
|
WriteSetting(QStringLiteral("row2"), static_cast<int>(UISettings::values.game_list_row_2), 0);
|
|
|
|
|
WriteSetting(QStringLiteral("hideNoIcon"), UISettings::values.game_list_hide_no_icon, false);
|
|
|
|
|
WriteSetting(QStringLiteral("singleLineMode"), UISettings::values.game_list_single_line_mode,
|
|
|
|
|
false);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveUILayoutValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("UILayout"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("geometry"), UISettings::values.geometry);
|
|
|
|
|
WriteSetting(QStringLiteral("state"), UISettings::values.state);
|
|
|
|
|
WriteSetting(QStringLiteral("geometryRenderWindow"), UISettings::values.renderwindow_geometry);
|
|
|
|
|
WriteSetting(QStringLiteral("gameListHeaderState"), UISettings::values.gamelist_header_state);
|
|
|
|
|
WriteSetting(QStringLiteral("microProfileDialogGeometry"),
|
|
|
|
|
UISettings::values.microprofile_geometry);
|
|
|
|
|
WriteSetting(QStringLiteral("microProfileDialogVisible"),
|
|
|
|
|
UISettings::values.microprofile_visible, false);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveUpdaterValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("Updater"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("check_for_update_on_start"),
|
|
|
|
|
UISettings::values.check_for_update_on_start, true);
|
|
|
|
|
WriteSetting(QStringLiteral("update_on_close"), UISettings::values.update_on_close, false);
|
|
|
|
|
|
|
|
|
|
qt_config->endGroup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SaveWebServiceValues() {
|
|
|
|
|
qt_config->beginGroup(QStringLiteral("WebService"));
|
|
|
|
|
|
|
|
|
|
WriteSetting(QStringLiteral("enable_telemetry"), Settings::values.enable_telemetry, true);
|
|
|
|
|
WriteSetting(QStringLiteral("web_api_url"),
|
|
|
|
|
QString::fromStdString(Settings::values.web_api_url),
|
|
|
|
|
QStringLiteral("https://api.citra-emu.org"));
|
|
|
|
|
WriteSetting(QStringLiteral("citra_username"),
|
|
|
|
|
QString::fromStdString(Settings::values.citra_username));
|
|
|
|
|
WriteSetting(QStringLiteral("citra_token"),
|
|
|
|
|
QString::fromStdString(Settings::values.citra_token));
|
2018-01-19 14:42:21 +01:00
|
|
|
|
2016-01-24 21:23:55 +01:00
|
|
|
qt_config->endGroup();
|
2014-10-27 22:18:28 +01:00
|
|
|
}
|
|
|
|
|
|
2019-02-05 22:09:02 +01:00
|
|
|
QVariant Config::ReadSetting(const QString& name) const {
|
2018-07-09 14:07:59 +02:00
|
|
|
return qt_config->value(name);
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 22:09:02 +01:00
|
|
|
QVariant Config::ReadSetting(const QString& name, const QVariant& default_value) const {
|
2018-07-09 14:07:59 +02:00
|
|
|
QVariant result;
|
2020-02-11 13:12:09 +01:00
|
|
|
if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
|
2018-07-09 14:07:59 +02:00
|
|
|
result = default_value;
|
|
|
|
|
} else {
|
|
|
|
|
result = qt_config->value(name, default_value);
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::WriteSetting(const QString& name, const QVariant& value) {
|
|
|
|
|
qt_config->setValue(name, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::WriteSetting(const QString& name, const QVariant& value,
|
|
|
|
|
const QVariant& default_value) {
|
2020-02-11 13:12:09 +01:00
|
|
|
qt_config->setValue(name + QStringLiteral("/default"), value == default_value);
|
2018-07-09 14:07:59 +02:00
|
|
|
qt_config->setValue(name, value);
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-13 02:06:13 +02:00
|
|
|
void Config::Reload() {
|
2014-11-15 20:56:18 +01:00
|
|
|
ReadValues();
|
2018-07-09 14:07:59 +02:00
|
|
|
// To apply default value changes
|
|
|
|
|
SaveValues();
|
2016-04-11 14:38:42 +02:00
|
|
|
Settings::Apply();
|
2014-09-13 02:06:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::Save() {
|
2014-11-15 20:56:18 +01:00
|
|
|
SaveValues();
|
2014-09-13 02:06:13 +02:00
|
|
|
}
|
