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

settings: split Settings::values into two different structs

Browse Source 
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
This commit is contained in:
lat9nq
2020-06-18 21:03:34 -04:00
parent 94fb90596a
commit 2d01d76ae5
39 changed files with 399 additions and 391 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/arm/dynarmic/arm_dynarmic_64.cpp
View File

@@ -192,7 +192,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
config.define_unpredictable_behaviour = true;
// Optimizations
if (Settings::values->disable_cpu_opt) {
if (Settings::base_values.disable_cpu_opt) {
config.enable_optimizations = false;
config.enable_fast_dispatch = false;
}

8
src/core/core.cpp
View File

@@ -241,12 +241,12 @@ struct System::Impl {
main_process->Run(load_parameters->main_thread_priority,
load_parameters->main_thread_stack_size);
if (Settings::values->gamecard_inserted) {
if (Settings::values->gamecard_current_game) {
if (Settings::base_values.gamecard_inserted) {
if (Settings::base_values.gamecard_current_game) {
fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
} else if (!Settings::values->gamecard_path.empty()) {
} else if (!Settings::base_values.gamecard_path.empty()) {
fs_controller.SetGameCard(
GetGameFileFromPath(virtual_filesystem, Settings::values->gamecard_path));
GetGameFileFromPath(virtual_filesystem, Settings::base_values.gamecard_path));
}
}

6
src/core/file_sys/bis_factory.cpp
View File

@@ -117,7 +117,7 @@ u64 BISFactory::GetSystemNANDFreeSpace() const {
}
u64 BISFactory::GetSystemNANDTotalSpace() const {
return static_cast<u64>(Settings::values->nand_system_size);
return static_cast<u64>(Settings::base_values.nand_system_size);
}
u64 BISFactory::GetUserNANDFreeSpace() const {
@@ -129,11 +129,11 @@ u64 BISFactory::GetUserNANDFreeSpace() const {
}
u64 BISFactory::GetUserNANDTotalSpace() const {
return static_cast<u64>(Settings::values->nand_user_size);
return static_cast<u64>(Settings::base_values.nand_user_size);
}
u64 BISFactory::GetFullNANDTotalSpace() const {
return static_cast<u64>(Settings::values->nand_total_size);
return static_cast<u64>(Settings::base_values.nand_total_size);
}
VirtualDir BISFactory::GetBCATDirectory(u64 title_id) const {

16
src/core/file_sys/patch_manager.cpp
View File

@@ -80,7 +80,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
if (exefs == nullptr)
return exefs;
if (Settings::values->dump_exefs) {
if (Settings::base_values.dump_exefs) {
LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
const auto dump_dir =
Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
@@ -92,7 +92,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
const auto& installed = Core::System::GetInstance().GetContentProvider();
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
const auto update_disabled =
std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
@@ -140,7 +140,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
const std::string& build_id) const {
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
std::vector<VirtualFile> out;
out.reserve(patch_dirs.size());
@@ -192,7 +192,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
const auto build_id_raw = Common::HexToString(header.build_id);
const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
if (Settings::values->dump_nso) {
if (Settings::base_values.dump_nso) {
LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
title_id);
const auto dump_dir =
@@ -302,7 +302,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
return {};
}
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
auto patch_dirs = load_dir->GetSubdirectories();
std::sort(patch_dirs.begin(), patch_dirs.end(),
[](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -344,7 +344,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
return;
}
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
auto patch_dirs = load_dir->GetSubdirectories();
std::sort(patch_dirs.begin(), patch_dirs.end(),
[](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -409,7 +409,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
const auto update_tid = GetUpdateTitleID(title_id);
const auto update = installed.GetEntryRaw(update_tid, type);
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
const auto update_disabled =
std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
@@ -453,7 +453,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
return {};
std::map<std::string, std::string, std::less<>> out;
const auto& installed = Core::System::GetInstance().GetContentProvider();
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
// Game Updates
const auto update_tid = GetUpdateTitleID(title_id);

2
src/core/file_sys/sdmc_factory.cpp
View File

@@ -46,7 +46,7 @@ u64 SDMCFactory::GetSDMCFreeSpace() const {
}
u64 SDMCFactory::GetSDMCTotalSpace() const {
return static_cast<u64>(Settings::values->sdmc_size);
return static_cast<u64>(Settings::base_values.sdmc_size);
}
} // namespace FileSys

4
src/core/hle/service/aoc/aoc_u.cpp
View File

@@ -91,7 +91,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
const auto current = system.CurrentProcess()->GetTitleID();
const auto& disabled = Settings::global_values.disabled_addons[current];
const auto& disabled = Settings::base_values.disabled_addons[current];
if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
rb.Push<u32>(0);
return;
@@ -119,7 +119,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
const auto current = system.CurrentProcess()->GetTitleID();
std::vector<u32> out;
const auto& disabled = Settings::global_values.disabled_addons[current];
const auto& disabled = Settings::base_values.disabled_addons[current];
if (std::find(disabled.begin(), disabled.end(), "DLC") == disabled.end()) {
for (u64 content_id : add_on_content) {
if ((content_id & DLC_BASE_TITLE_ID_MASK) != current) {

6
src/core/hle/service/bcat/backend/boxcat.cpp
View File

@@ -271,7 +271,7 @@ void SynchronizeInternal(AM::Applets::AppletManager& applet_manager, DirectoryGe
std::optional<std::string> dir_name = {}) {
progress.SetNeedHLELock(true);
if (Settings::values->bcat_boxcat_local) {
if (Settings::base_values.bcat_boxcat_local) {
LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
const auto dir = dir_getter(title.title_id);
if (dir)
@@ -384,7 +384,7 @@ bool Boxcat::SynchronizeDirectory(TitleIDVersion title, std::string name,
}
bool Boxcat::Clear(u64 title_id) {
if (Settings::values->bcat_boxcat_local) {
if (Settings::base_values.bcat_boxcat_local) {
LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping clear.");
return true;
}
@@ -412,7 +412,7 @@ void Boxcat::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title) {
const auto path{GetBINFilePath(title.title_id)};
if (Settings::values->bcat_boxcat_local) {
if (Settings::base_values.bcat_boxcat_local) {
LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
} else {
Boxcat::Client client{path, title.title_id, title.build_id};

2
src/core/hle/service/bcat/module.cpp
View File

@@ -571,7 +571,7 @@ void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(
std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
DirectoryGetter getter) {
#ifdef YUZU_ENABLE_BOXCAT
if (Settings::values->bcat_backend == "boxcat") {
if (Settings::base_values.bcat_backend == "boxcat") {
return std::make_unique<Boxcat>(system.GetAppletManager(), std::move(getter));
}
#endif

8
src/core/hle/service/hid/controllers/debug_pad.cpp
View File

@@ -71,12 +71,12 @@ void Controller_DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing,
}
void Controller_DebugPad::OnLoadInputDevices() {
std::transform(Settings::values->debug_pad_buttons.begin(),
Settings::values->debug_pad_buttons.begin() +
std::transform(Settings::base_values.debug_pad_buttons.begin(),
Settings::base_values.debug_pad_buttons.begin() +
Settings::NativeButton::NUM_BUTTONS_HID,
buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
std::transform(Settings::values->debug_pad_analogs.begin(),
Settings::values->debug_pad_analogs.end(), analogs.begin(),
std::transform(Settings::base_values.debug_pad_analogs.begin(),
Settings::base_values.debug_pad_analogs.end(), analogs.begin(),
Input::CreateDevice<Input::AnalogDevice>);
}
} // namespace Service::HID

4
src/core/hle/service/hid/controllers/keyboard.cpp
View File

@@ -53,9 +53,9 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
}
void Controller_Keyboard::OnLoadInputDevices() {
std::transform(Settings::values->keyboard_keys.begin(), Settings::values->keyboard_keys.end(),
std::transform(Settings::base_values.keyboard_keys.begin(), Settings::base_values.keyboard_keys.end(),
keyboard_keys.begin(), Input::CreateDevice<Input::ButtonDevice>);
std::transform(Settings::values->keyboard_mods.begin(), Settings::values->keyboard_mods.end(),
std::transform(Settings::base_values.keyboard_mods.begin(), Settings::base_values.keyboard_mods.end(),
keyboard_mods.begin(), Input::CreateDevice<Input::ButtonDevice>);
}
} // namespace Service::HID

6
src/core/hle/service/hid/controllers/mouse.cpp
View File

@@ -36,7 +36,7 @@ void Controller_Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
cur_entry.sampling_number = last_entry.sampling_number + 1;
cur_entry.sampling_number2 = cur_entry.sampling_number;
if (Settings::values->mouse_enabled) {
if (Settings::base_values.mouse_enabled) {
const auto [px, py, sx, sy] = mouse_device->GetStatus();
const auto x = static_cast<s32>(px * Layout::ScreenUndocked::Width);
const auto y = static_cast<s32>(py * Layout::ScreenUndocked::Height);
@@ -56,8 +56,8 @@ void Controller_Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
}
void Controller_Mouse::OnLoadInputDevices() {
mouse_device = Input::CreateDevice<Input::MouseDevice>(Settings::values->mouse_device);
std::transform(Settings::values->mouse_buttons.begin(), Settings::values->mouse_buttons.end(),
mouse_device = Input::CreateDevice<Input::MouseDevice>(Settings::base_values.mouse_device);
std::transform(Settings::base_values.mouse_buttons.begin(), Settings::base_values.mouse_buttons.end(),
mouse_button_devices.begin(), Input::CreateDevice<Input::ButtonDevice>);
}
} // namespace Service::HID

14
src/core/hle/service/hid/controllers/npad.cpp
View File

@@ -159,11 +159,11 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
controller.single_color.button_color = 0;
controller.dual_color_error = ColorReadError::ReadOk;
controller.left_color.body_color = Settings::values->players[controller_idx].body_color_left;
controller.left_color.button_color = Settings::values->players[controller_idx].button_color_left;
controller.right_color.body_color = Settings::values->players[controller_idx].body_color_right;
controller.left_color.body_color = Settings::base_values.players[controller_idx].body_color_left;
controller.left_color.button_color = Settings::base_values.players[controller_idx].button_color_left;
controller.right_color.body_color = Settings::base_values.players[controller_idx].body_color_right;
controller.right_color.button_color =
Settings::values->players[controller_idx].button_color_right;
Settings::base_values.players[controller_idx].button_color_right;
controller.battery_level[0] = BATTERY_FULL;
controller.battery_level[1] = BATTERY_FULL;
@@ -193,7 +193,7 @@ void Controller_NPad::OnInit() {
}
std::transform(
Settings::values->players.begin(), Settings::values->players.end(),
Settings::base_values.players.begin(), Settings::base_values.players.end(),
connected_controllers.begin(), [](const Settings::PlayerInput& player) {
return ControllerHolder{MapSettingsTypeToNPad(player.type), player.connected};
});
@@ -227,7 +227,7 @@ void Controller_NPad::OnInit() {
}
void Controller_NPad::OnLoadInputDevices() {
const auto& players = Settings::values->players;
const auto& players = Settings::base_values.players;
for (std::size_t i = 0; i < players.size(); ++i) {
std::transform(players[i].buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
players[i].buttons.begin() + Settings::NativeButton::BUTTON_HID_END,
@@ -459,7 +459,7 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
continue;
}
const auto requested_controller =
i <= MAX_NPAD_ID ? MapSettingsTypeToNPad(Settings::values->players[i].type)
i <= MAX_NPAD_ID ? MapSettingsTypeToNPad(Settings::base_values.players[i].type)
: NPadControllerType::Handheld;
if (!IsControllerSupported(requested_controller)) {
const auto is_handheld = requested_controller == NPadControllerType::Handheld;

13
src/core/hle/service/hid/controllers/touchscreen.cpp
View File

@@ -43,16 +43,16 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
const auto [x, y, pressed] = touch_device->GetStatus();
auto& touch_entry = cur_entry.states[0];
touch_entry.attribute.raw = 0;
if (pressed && Settings::values->touchscreen.enabled) {
if (pressed && Settings::base_values.touchscreen.enabled) {
touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
touch_entry.diameter_x = Settings::values->touchscreen.diameter_x;
touch_entry.diameter_y = Settings::values->touchscreen.diameter_y;
touch_entry.rotation_angle = Settings::values->touchscreen.rotation_angle;
touch_entry.diameter_x = Settings::base_values.touchscreen.diameter_x;
touch_entry.diameter_y = Settings::base_values.touchscreen.diameter_y;
touch_entry.rotation_angle = Settings::base_values.touchscreen.rotation_angle;
const u64 tick = core_timing.GetCPUTicks();
touch_entry.delta_time = tick - last_touch;
last_touch = tick;
touch_entry.finger = Settings::values->touchscreen.finger;
touch_entry.finger = Settings::base_values.touchscreen.finger;
cur_entry.entry_count = 1;
} else {
cur_entry.entry_count = 0;
@@ -62,6 +62,7 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
}
void Controller_Touchscreen::OnLoadInputDevices() {
touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values->touchscreen.device);
touch_device = Input::CreateDevice<Input::TouchDevice>(
Settings::base_values.touchscreen.device);
}
} // namespace Service::HID

4
src/core/hle/service/hid/hid.cpp
View File

@@ -110,7 +110,7 @@ void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
void IAppletResource::UpdateControllers(u64 userdata, s64 ns_late) {
auto& core_timing = system.CoreTiming();
const bool should_reload = Settings::values->is_device_reload_pending.exchange(false);
const bool should_reload = Settings::base_values.is_device_reload_pending.exchange(false);
for (const auto& controller : controllers) {
if (should_reload) {
controller->OnLoadInputDevices();
@@ -1281,7 +1281,7 @@ public:
};
void ReloadInputDevices() {
Settings::values->is_device_reload_pending.store(true);
Settings::base_values.is_device_reload_pending.store(true);
}
void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {

6
src/core/hle/service/nifm/nifm.cpp
View File

@@ -88,7 +88,7 @@ private:
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(RESULT_SUCCESS);
if (Settings::values->bcat_backend == "none") {
if (Settings::base_values.bcat_backend == "none") {
rb.PushEnum(RequestState::NotSubmitted);
} else {
rb.PushEnum(RequestState::Connected);
@@ -201,7 +201,7 @@ private:
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(RESULT_SUCCESS);
if (Settings::values->bcat_backend == "none") {
if (Settings::base_values.bcat_backend == "none") {
rb.Push<u8>(0);
} else {
rb.Push<u8>(1);
@@ -212,7 +212,7 @@ private:
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(RESULT_SUCCESS);
if (Settings::values->bcat_backend == "none") {
if (Settings::base_values.bcat_backend == "none") {
rb.Push<u8>(0);
} else {
rb.Push<u8>(1);

2
src/core/hle/service/set/set.cpp
View File

@@ -159,7 +159,7 @@ void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(RESULT_SUCCESS);
rb.Push(static_cast<u32>(Settings::values->quest_flag));
rb.Push(static_cast<u32>(Settings::base_values.quest_flag));
}
void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {

4
src/core/loader/nro.cpp
View File

@@ -157,8 +157,8 @@ static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data,
codeset.segments[i].size = PageAlignSize(nro_header.segments[i].size);
}
if (!Settings::values->program_args.empty()) {
const auto arg_data = Settings::values->program_args;
if (!Settings::base_values.program_args.empty()) {
const auto arg_data = Settings::base_values.program_args;
codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
NSOArgumentHeader args_header{
NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};

6
src/core/loader/nso.cpp
View File

@@ -105,8 +105,8 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
codeset.segments[i].size = nso_header.segments[i].size;
}
if (should_pass_arguments && !Settings::values->program_args.empty()) {
const auto arg_data{Settings::values->program_args};
if (should_pass_arguments && !Settings::base_values.program_args.empty()) {
const auto arg_data{Settings::base_values.program_args};
codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
NSOArgumentHeader args_header{
@@ -129,7 +129,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
}
// Apply patches if necessary
if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values->dump_nso)) {
if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::base_values.dump_nso)) {
std::vector<u8> pi_header;
pi_header.insert(pi_header.begin(), reinterpret_cast<u8*>(&nso_header),
reinterpret_cast<u8*>(&nso_header) + sizeof(NSOHeader));

2
src/core/perf_stats.cpp
View File

@@ -30,7 +30,7 @@ namespace Core {
PerfStats::PerfStats(u64 title_id) : title_id(title_id) {}
PerfStats::~PerfStats() {
if (!Settings::values->record_frame_times || title_id == 0) {
if (!Settings::base_values.record_frame_times || title_id == 0) {
return;
}

2
src/core/reporter.cpp
View File

@@ -439,7 +439,7 @@ void Reporter::SaveUserReport() const {
}
bool Reporter::IsReportingEnabled() const {
return Settings::values->reporting_services;
return Settings::base_values.reporting_services;
}
} // namespace Core

97
src/core/settings.cpp
View File

@@ -63,6 +63,7 @@ const std::array<const char*, NumMouseButtons> mapping = {{
}};
}
NonSwitchingValues base_values;
Values global_values;
Values game_values;
Values *values = &global_values;
@@ -70,55 +71,55 @@ Values *config_values = &global_values;
void CopyValues(Values& dst, const Values& src) {
// Controls
dst.players = src.players;
dst.mouse_enabled = src.mouse_enabled;
dst.mouse_device = src.mouse_device;
//~ dst.players = src.players;
//~ dst.mouse_enabled = src.mouse_enabled;
//~ dst.mouse_device = src.mouse_device;
dst.keyboard_enabled = src.keyboard_enabled;
dst.keyboard_keys = src.keyboard_keys;
dst.keyboard_mods = src.keyboard_mods;
//~ dst.keyboard_enabled = src.keyboard_enabled;
//~ dst.keyboard_keys = src.keyboard_keys;
//~ dst.keyboard_mods = src.keyboard_mods;
dst.debug_pad_enabled = src.debug_pad_enabled;
dst.debug_pad_buttons = src.debug_pad_buttons;
dst.debug_pad_analogs = src.debug_pad_analogs;
//~ dst.debug_pad_enabled = src.debug_pad_enabled;
//~ dst.debug_pad_buttons = src.debug_pad_buttons;
//~ dst.debug_pad_analogs = src.debug_pad_analogs;
dst.motion_device = src.motion_device;
dst.touchscreen = src.touchscreen;
dst.udp_input_address = src.udp_input_address;
dst.udp_input_port = src.udp_input_port;
dst.udp_pad_index = src.udp_pad_index;
//~ dst.motion_device = src.motion_device;
//~ dst.touchscreen = src.touchscreen;
//~ dst.udp_input_address = src.udp_input_address;
//~ dst.udp_input_port = src.udp_input_port;
//~ dst.udp_pad_index = src.udp_pad_index;
dst.use_virtual_sd = src.use_virtual_sd;
dst.gamecard_inserted = src.gamecard_inserted;
dst.gamecard_current_game = src.gamecard_current_game;
dst.gamecard_path = src.gamecard_path;
dst.nand_total_size = src.nand_total_size;
dst.nand_system_size = src.nand_system_size;
dst.nand_user_size = src.nand_user_size;
dst.sdmc_size = src.sdmc_size;
//~ dst.use_virtual_sd = src.use_virtual_sd;
//~ dst.gamecard_inserted = src.gamecard_inserted;
//~ dst.gamecard_current_game = src.gamecard_current_game;
//~ dst.gamecard_path = src.gamecard_path;
//~ dst.nand_total_size = src.nand_total_size;
//~ dst.nand_system_size = src.nand_system_size;
//~ dst.nand_user_size = src.nand_user_size;
//~ dst.sdmc_size = src.sdmc_size;
dst.log_filter = src.log_filter;
//~ dst.log_filter = src.log_filter;
dst.use_dev_keys = src.use_dev_keys;
//~ dst.use_dev_keys = src.use_dev_keys;
dst.record_frame_times = src.record_frame_times;
dst.use_gdbstub = src.use_gdbstub;
dst.gdbstub_port = src.gdbstub_port;
dst.program_args = src.program_args;
dst.dump_exefs = src.dump_exefs;
dst.dump_nso = src.dump_nso;
dst.reporting_services = src.reporting_services;
dst.quest_flag = src.quest_flag;
dst.disable_cpu_opt = src.disable_cpu_opt;
dst.disable_macro_jit = src.disable_macro_jit;
//~ dst.record_frame_times = src.record_frame_times;
//~ dst.use_gdbstub = src.use_gdbstub;
//~ dst.gdbstub_port = src.gdbstub_port;
//~ dst.program_args = src.program_args;
//~ dst.dump_exefs = src.dump_exefs;
//~ dst.dump_nso = src.dump_nso;
//~ dst.reporting_services = src.reporting_services;
//~ dst.quest_flag = src.quest_flag;
//~ dst.disable_cpu_opt = src.disable_cpu_opt;
//~ dst.disable_macro_jit = src.disable_macro_jit;
dst.bcat_backend = src.bcat_backend;
dst.bcat_boxcat_local = src.bcat_boxcat_local;
//~ dst.bcat_backend = src.bcat_backend;
//~ dst.bcat_boxcat_local = src.bcat_boxcat_local;
dst.enable_telemetry = src.enable_telemetry;
dst.web_api_url = src.web_api_url;
dst.yuzu_username = src.yuzu_username;
dst.yuzu_token = src.yuzu_token;
//~ dst.enable_telemetry = src.enable_telemetry;
//~ dst.web_api_url = src.web_api_url;
//~ dst.yuzu_username = src.yuzu_username;
//~ dst.yuzu_token = src.yuzu_token;
}
void SwapValues(ValuesSwapTarget target) {
@@ -157,8 +158,8 @@ std::string GetTimeZoneString() {
}
void Apply() {
GDBStub::SetServerPort(values->gdbstub_port);
GDBStub::ToggleServer(values->use_gdbstub);
GDBStub::SetServerPort(base_values.gdbstub_port);
GDBStub::ToggleServer(base_values.use_gdbstub);
auto& system_instance = Core::System::GetInstance();
if (system_instance.IsPoweredOn()) {
@@ -195,14 +196,14 @@ void LogSettings() {
LogSetting("Audio_OutputEngine", Settings::values->sink_id);
LogSetting("Audio_EnableAudioStretching", Settings::values->enable_audio_stretching);
LogSetting("Audio_OutputDevice", Settings::values->audio_device_id);
LogSetting("DataStorage_UseVirtualSd", Settings::values->use_virtual_sd);
LogSetting("DataStorage_UseVirtualSd", Settings::base_values.use_virtual_sd);
LogSetting("DataStorage_NandDir", FileUtil::GetUserPath(FileUtil::UserPath::NANDDir));
LogSetting("DataStorage_SdmcDir", FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir));
LogSetting("Debugging_UseGdbstub", Settings::values->use_gdbstub);
LogSetting("Debugging_GdbstubPort", Settings::values->gdbstub_port);
LogSetting("Debugging_ProgramArgs", Settings::values->program_args);
LogSetting("Services_BCATBackend", Settings::values->bcat_backend);
LogSetting("Services_BCATBoxcatLocal", Settings::values->bcat_boxcat_local);
LogSetting("Debugging_UseGdbstub", Settings::base_values.use_gdbstub);
LogSetting("Debugging_GdbstubPort", Settings::base_values.gdbstub_port);
LogSetting("Debugging_ProgramArgs", Settings::base_values.program_args);
LogSetting("Services_BCATBackend", Settings::base_values.bcat_backend);
LogSetting("Services_BCATBoxcatLocal", Settings::base_values.bcat_boxcat_local);
}
float Volume() {

112
src/core/settings.h
View File

@@ -383,54 +383,19 @@ enum class GPUAccuracy : u32 {
};
struct Values {
// System
bool use_docked_mode;
std::optional<u32> rng_seed;
// Measured in seconds since epoch
std::optional<std::chrono::seconds> custom_rtc;
// Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
std::chrono::seconds custom_rtc_differential;
s32 current_user;
s32 language_index;
s32 region_index;
s32 time_zone_index;
s32 sound_index;
// Controls
std::array<PlayerInput, 10> players;
bool mouse_enabled;
std::string mouse_device;
MouseButtonsRaw mouse_buttons;
bool keyboard_enabled;
KeyboardKeysRaw keyboard_keys;
KeyboardModsRaw keyboard_mods;
bool debug_pad_enabled;
ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs;
std::string motion_device;
TouchscreenInput touchscreen;
std::atomic_bool is_device_reload_pending{true};
std::string udp_input_address;
u16 udp_input_port;
u8 udp_pad_index;
// Audio
std::string sink_id;
bool enable_audio_stretching;
std::string audio_device_id;
float volume;
// Core
bool use_multi_core;
// Data Storage
bool use_virtual_sd;
bool gamecard_inserted;
bool gamecard_current_game;
std::string gamecard_path;
NANDTotalSize nand_total_size;
NANDSystemSize nand_system_size;
NANDUserSize nand_user_size;
SDMCSize sdmc_size;
// Misceallaneous
std::string log_filter;
bool use_dev_keys;
bool use_global_values;
// Renderer
RendererBackend renderer_backend;
@@ -454,16 +419,53 @@ struct Values {
float bg_green;
float bg_blue;
std::string log_filter;
// System
bool use_docked_mode;
std::optional<u32> rng_seed;
// Measured in seconds since epoch
std::optional<std::chrono::seconds> custom_rtc;
// Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
std::chrono::seconds custom_rtc_differential;
bool use_dev_keys;
s32 current_user;
s32 language_index;
s32 region_index;
s32 time_zone_index;
s32 sound_index;
};
// Audio
bool audio_muted;
std::string sink_id;
bool enable_audio_stretching;
std::string audio_device_id;
float volume;
struct NonSwitchingValues {
// Controls
std::array<PlayerInput, 10> players;
bool mouse_enabled;
std::string mouse_device;
MouseButtonsRaw mouse_buttons;
bool keyboard_enabled;
KeyboardKeysRaw keyboard_keys;
KeyboardModsRaw keyboard_mods;
bool debug_pad_enabled;
ButtonsRaw debug_pad_buttons;
AnalogsRaw debug_pad_analogs;
std::string motion_device;
TouchscreenInput touchscreen;
std::atomic_bool is_device_reload_pending{true};
std::string udp_input_address;
u16 udp_input_port;
u8 udp_pad_index;
// Data Storage
bool use_virtual_sd;
bool gamecard_inserted;
bool gamecard_current_game;
std::string gamecard_path;
NANDTotalSize nand_total_size;
NANDSystemSize nand_system_size;
NANDUserSize nand_user_size;
SDMCSize sdmc_size;
// Debugging
bool record_frame_times;
@@ -477,7 +479,7 @@ struct Values {
bool disable_cpu_opt;
bool disable_macro_jit;
// BCAT
// Services
std::string bcat_backend;
bool bcat_boxcat_local;
@@ -489,11 +491,9 @@ struct Values {
// Add-Ons
std::map<u64, std::vector<std::string>> disabled_addons;
// Per-Game Settings
bool use_global_values;
};
extern NonSwitchingValues base_values;
extern Values global_values;
extern Values game_values;
extern Values *values;

10
src/core/telemetry_session.cpp
View File

@@ -116,7 +116,7 @@ u64 RegenerateTelemetryId() {
bool VerifyLogin(const std::string& username, const std::string& token) {
#ifdef ENABLE_WEB_SERVICE
return WebService::VerifyLogin(Settings::values->web_api_url, username, token);
return WebService::VerifyLogin(Settings::base_values.web_api_url, username, token);
#else
return false;
#endif
@@ -133,14 +133,15 @@ TelemetrySession::~TelemetrySession() {
#ifdef ENABLE_WEB_SERVICE
auto backend = std::make_unique<WebService::TelemetryJson>(
Settings::values->web_api_url, Settings::values->yuzu_username, Settings::values->yuzu_token);
Settings::base_values.web_api_url, Settings::base_values.yuzu_username,
Settings::base_values.yuzu_token);
#else
auto backend = std::make_unique<Telemetry::NullVisitor>();
#endif
// Complete the session, submitting to the web service backend if necessary
field_collection.Accept(*backend);
if (Settings::values->enable_telemetry) {
if (Settings::base_values.enable_telemetry) {
backend->Complete();
}
}
@@ -208,7 +209,8 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
bool TelemetrySession::SubmitTestcase() {
#ifdef ENABLE_WEB_SERVICE
auto backend = std::make_unique<WebService::TelemetryJson>(
Settings::values->web_api_url, Settings::values->yuzu_username, Settings::values->yuzu_token);
Settings::base_values.web_api_url, Settings::base_values.yuzu_username,
Settings::base_values.yuzu_token);
field_collection.Accept(*backend);
return backend->SubmitTestcase();
#else

10
src/input_common/udp/udp.cpp
View File

@@ -74,8 +74,9 @@ private:
State::State() {
auto status = std::make_shared<DeviceStatus>();
client =
std::make_unique<Client>(status, Settings::values->udp_input_address,
Settings::values->udp_input_port, Settings::values->udp_pad_index);
std::make_unique<Client>(status, Settings::base_values.udp_input_address,
Settings::base_values.udp_input_port,
Settings::base_values.udp_pad_index);
Input::RegisterFactory<Input::TouchDevice>("cemuhookudp",
std::make_shared<UDPTouchFactory>(status));
@@ -89,8 +90,9 @@ State::~State() {
}
void State::ReloadUDPClient() {
client->ReloadSocket(Settings::values->udp_input_address, Settings::values->udp_input_port,
Settings::values->udp_pad_index);
client->ReloadSocket(Settings::base_values.udp_input_address,
Settings::base_values.udp_input_port,
Settings::base_values.udp_pad_index);
}
std::unique_ptr<State> Init() {

2
src/video_core/macro/macro.cpp
View File

@@ -78,7 +78,7 @@ void MacroEngine::Execute(Engines::Maxwell3D& maxwell3d, u32 method,
}
std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d) {
if (Settings::values->disable_macro_jit) {
if (Settings::base_values.disable_macro_jit) {
return std::make_unique<MacroInterpreter>(maxwell3d);
}
#ifdef ARCHITECTURE_x86_64

198
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::config_values->players.size(); ++p) {
auto& player = Settings::config_values->players[p];
for (std::size_t p = 0; p < Settings::base_values.players.size(); ++p) {
auto& player = Settings::base_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::config_values->players.begin(),
Settings::config_values->players.begin() +
Settings::base_values.players.begin(),
Settings::base_values.players.begin() +
Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
[](const auto& player) { return player.connected; });
}
void Config::ReadDebugValues() {
Settings::config_values->debug_pad_enabled =
Settings::base_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::config_values->debug_pad_buttons[i];
auto& debug_pad_buttons = Settings::base_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::config_values->debug_pad_analogs[i];
auto& debug_pad_analogs = Settings::base_values.debug_pad_analogs[i];
debug_pad_analogs = qt_config
->value(QStringLiteral("debug_pad_") +
@@ -343,29 +343,29 @@ void Config::ReadDebugValues() {
}
void Config::ReadKeyboardValues() {
Settings::config_values->keyboard_enabled =
Settings::base_values.keyboard_enabled =
ReadSetting(QStringLiteral("keyboard_enabled"), false).toBool();
std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
Settings::config_values->keyboard_keys.begin(),
Settings::base_values.keyboard_keys.begin(),
InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::config_values->keyboard_keys.begin() +
Settings::base_values.keyboard_keys.begin() +
Settings::NativeKeyboard::LeftControlKey,
InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::config_values->keyboard_mods.begin(),
Settings::base_values.keyboard_mods.begin(),
InputCommon::GenerateKeyboardParam);
}
void Config::ReadMouseValues() {
Settings::config_values->mouse_enabled =
Settings::base_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::config_values->mouse_buttons[i];
auto& mouse_buttons = Settings::base_values.mouse_buttons[i];
mouse_buttons = qt_config
->value(QStringLiteral("mouse_") +
@@ -380,26 +380,26 @@ void Config::ReadMouseValues() {
}
void Config::ReadTouchscreenValues() {
Settings::config_values->touchscreen.enabled =
Settings::base_values.touchscreen.enabled =
ReadSetting(QStringLiteral("touchscreen_enabled"), true).toBool();
Settings::config_values->touchscreen.device =
Settings::base_values.touchscreen.device =
ReadSetting(QStringLiteral("touchscreen_device"), QStringLiteral("engine:emu_window"))
.toString()
.toStdString();
Settings::config_values->touchscreen.finger =
Settings::base_values.touchscreen.finger =
ReadSetting(QStringLiteral("touchscreen_finger"), 0).toUInt();
Settings::config_values->touchscreen.rotation_angle =
Settings::base_values.touchscreen.rotation_angle =
ReadSetting(QStringLiteral("touchscreen_angle"), 0).toUInt();
Settings::config_values->touchscreen.diameter_x =
Settings::base_values.touchscreen.diameter_x =
ReadSetting(QStringLiteral("touchscreen_diameter_x"), 15).toUInt();
Settings::config_values->touchscreen.diameter_y =
Settings::base_values.touchscreen.diameter_y =
ReadSetting(QStringLiteral("touchscreen_diameter_y"), 15).toUInt();
}
void Config::ApplyDefaultProfileIfInputInvalid() {
if (!std::any_of(Settings::config_values->players.begin(),
Settings::config_values->players.end(),
if (!std::any_of(Settings::base_values.players.begin(),
Settings::base_values.players.end(),
[](const Settings::PlayerInput& in) { return in.connected; })) {
ApplyInputProfileConfiguration(UISettings::values.profile_index);
}
@@ -432,20 +432,20 @@ void Config::ReadControlValues() {
ReadMouseValues();
ReadTouchscreenValues();
Settings::config_values->motion_device =
Settings::base_values.motion_device =
ReadSetting(QStringLiteral("motion_device"),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
.toString()
.toStdString();
Settings::config_values->udp_input_address =
Settings::base_values.udp_input_address =
ReadSetting(QStringLiteral("udp_input_address"),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
.toString()
.toStdString();
Settings::config_values->udp_input_port = static_cast<u16>(
Settings::base_values.udp_input_port = static_cast<u16>(
ReadSetting(QStringLiteral("udp_input_port"), InputCommon::CemuhookUDP::DEFAULT_PORT)
.toInt());
Settings::config_values->udp_pad_index =
Settings::base_values.udp_pad_index =
static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
qt_config->endGroup();
@@ -463,7 +463,7 @@ void Config::ReadCoreValues() {
void Config::ReadDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
Settings::config_values->use_virtual_sd =
Settings::base_values.use_virtual_sd =
ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
FileUtil::GetUserPath(
FileUtil::UserPath::NANDDir,
@@ -500,25 +500,25 @@ void Config::ReadDataStorageValues() {
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir)))
.toString()
.toStdString());
Settings::config_values->gamecard_inserted =
Settings::base_values.gamecard_inserted =
ReadSetting(QStringLiteral("gamecard_inserted"), false).toBool();
Settings::config_values->gamecard_current_game =
Settings::base_values.gamecard_current_game =
ReadSetting(QStringLiteral("gamecard_current_game"), false).toBool();
Settings::config_values->gamecard_path =
Settings::base_values.gamecard_path =
ReadSetting(QStringLiteral("gamecard_path"), QStringLiteral("")).toString().toStdString();
Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
Settings::base_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::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
Settings::base_values.nand_user_size = static_cast<Settings::NANDUserSize>(
ReadSetting(QStringLiteral("nand_user_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::NANDUserSize::S26GB)))
.toULongLong());
Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
Settings::base_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::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
Settings::base_values.sdmc_size = static_cast<Settings::SDMCSize>(
ReadSetting(QStringLiteral("sdmc_size"),
QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)))
.toULongLong());
@@ -530,22 +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::config_values->record_frame_times =
Settings::base_values.record_frame_times =
qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
Settings::config_values->use_gdbstub =
Settings::base_values.use_gdbstub =
ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
Settings::config_values->gdbstub_port =
Settings::base_values.gdbstub_port =
ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
Settings::config_values->program_args =
Settings::base_values.program_args =
ReadSetting(QStringLiteral("program_args"), QStringLiteral("")).toString().toStdString();
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 =
Settings::base_values.dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
Settings::base_values.dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
Settings::base_values.reporting_services =
ReadSetting(QStringLiteral("reporting_services"), false).toBool();
Settings::config_values->quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
Settings::config_values->disable_cpu_opt =
Settings::base_values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
Settings::base_values.disable_cpu_opt =
ReadSetting(QStringLiteral("disable_cpu_opt"), false).toBool();
Settings::config_values->disable_macro_jit =
Settings::base_values.disable_macro_jit =
ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
qt_config->endGroup();
@@ -553,11 +553,11 @@ void Config::ReadDebuggingValues() {
void Config::ReadServiceValues() {
qt_config->beginGroup(QStringLiteral("Services"));
Settings::config_values->bcat_backend =
Settings::base_values.bcat_backend =
ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("null"))
.toString()
.toStdString();
Settings::config_values->bcat_boxcat_local =
Settings::base_values.bcat_boxcat_local =
ReadSetting(QStringLiteral("bcat_boxcat_local"), false).toBool();
qt_config->endGroup();
}
@@ -576,7 +576,7 @@ void Config::ReadDisabledAddOnValues() {
ReadSetting(QStringLiteral("d"), QStringLiteral("")).toString().toStdString());
}
qt_config->endArray();
Settings::global_values.disabled_addons.insert_or_assign(title_id, out);
Settings::base_values.disabled_addons.insert_or_assign(title_id, out);
}
qt_config->endArray();
@@ -810,15 +810,15 @@ void Config::ReadUILayoutValues() {
void Config::ReadWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
Settings::config_values->enable_telemetry =
Settings::base_values.enable_telemetry =
ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
Settings::config_values->web_api_url =
Settings::base_values.web_api_url =
ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.yuzu-emu.org"))
.toString()
.toStdString();
Settings::config_values->yuzu_username =
Settings::base_values.yuzu_username =
ReadSetting(QStringLiteral("yuzu_username")).toString().toStdString();
Settings::config_values->yuzu_token =
Settings::base_values.yuzu_token =
ReadSetting(QStringLiteral("yuzu_token")).toString().toStdString();
qt_config->endGroup();
@@ -826,24 +826,24 @@ void Config::ReadWebServiceValues() {
void Config::ReadValues() {
if (global) {
ReadDebuggingValues();
ReadDataStorageValues();
ReadWebServiceValues();
ReadDisabledAddOnValues();
ReadUIValues();
ReadControlValues();
ReadDataStorageValues();
ReadDebuggingValues();
ReadDisabledAddOnValues();
ReadServiceValues();
ReadUIValues();
ReadWebServiceValues();
}
ReadCoreValues();
ReadRendererValues();
ReadAudioValues();
ReadSystemValues();
ReadMiscellaneousValues();
ReadServiceValues();
}
void Config::SavePlayerValues() {
for (std::size_t p = 0; p < Settings::config_values->players.size(); ++p) {
const auto& player = Settings::config_values->players[p];
for (std::size_t p = 0; p < Settings::base_values.players.size(); ++p) {
const auto& player = Settings::base_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),
@@ -879,13 +879,13 @@ void Config::SavePlayerValues() {
}
void Config::SaveDebugValues() {
WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::config_values->debug_pad_enabled,
WriteSetting(QStringLiteral("debug_pad_enabled"), Settings::base_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::config_values->debug_pad_buttons[i]),
QString::fromStdString(Settings::base_values.debug_pad_buttons[i]),
QString::fromStdString(default_param));
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
@@ -894,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::config_values->debug_pad_analogs[i]),
QString::fromStdString(Settings::base_values.debug_pad_analogs[i]),
QString::fromStdString(default_param));
}
}
void Config::SaveMouseValues() {
WriteSetting(QStringLiteral("mouse_enabled"), Settings::config_values->mouse_enabled, false);
WriteSetting(QStringLiteral("mouse_enabled"), Settings::base_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::config_values->mouse_buttons[i]),
QString::fromStdString(Settings::base_values.mouse_buttons[i]),
QString::fromStdString(default_param));
}
}
void Config::SaveTouchscreenValues() {
const auto& touchscreen = Settings::config_values->touchscreen;
const auto& touchscreen = Settings::base_values.touchscreen;
WriteSetting(QStringLiteral("touchscreen_enabled"), touchscreen.enabled, true);
WriteSetting(QStringLiteral("touchscreen_device"), QString::fromStdString(touchscreen.device),
@@ -927,19 +927,19 @@ void Config::SaveTouchscreenValues() {
void Config::SaveValues() {
if (global) {
SaveDebuggingValues();
SaveDataStorageValues();
SaveWebServiceValues();
SaveDisabledAddOnValues();
SaveUIValues();
SaveControlValues();
SaveDataStorageValues();
SaveDebuggingValues();
SaveDisabledAddOnValues();
SaveServiceValues();
SaveUIValues();
SaveWebServiceValues();
}
SaveCoreValues();
SaveRendererValues();
SaveAudioValues();
SaveSystemValues();
SaveMiscellaneousValues();
SaveServiceValues();
}
void Config::SaveAudioValues() {
@@ -967,16 +967,16 @@ void Config::SaveControlValues() {
SaveTouchscreenValues();
WriteSetting(QStringLiteral("motion_device"),
QString::fromStdString(Settings::config_values->motion_device),
QString::fromStdString(Settings::base_values.motion_device),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::config_values->keyboard_enabled,
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::base_values.keyboard_enabled,
false);
WriteSetting(QStringLiteral("udp_input_address"),
QString::fromStdString(Settings::config_values->udp_input_address),
QString::fromStdString(Settings::base_values.udp_input_address),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
WriteSetting(QStringLiteral("udp_input_port"), Settings::config_values->udp_input_port,
WriteSetting(QStringLiteral("udp_input_port"), Settings::base_values.udp_input_port,
InputCommon::CemuhookUDP::DEFAULT_PORT);
WriteSetting(QStringLiteral("udp_pad_index"), Settings::config_values->udp_pad_index, 0);
WriteSetting(QStringLiteral("udp_pad_index"), Settings::base_values.udp_pad_index, 0);
qt_config->endGroup();
}
@@ -992,7 +992,7 @@ void Config::SaveCoreValues() {
void Config::SaveDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::config_values->use_virtual_sd, true);
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::base_values.use_virtual_sd, true);
WriteSetting(QStringLiteral("nand_directory"),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
@@ -1008,27 +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::config_values->gamecard_inserted,
WriteSetting(QStringLiteral("gamecard_inserted"), Settings::base_values.gamecard_inserted,
false);
WriteSetting(QStringLiteral("gamecard_current_game"),
Settings::config_values->gamecard_current_game, false);
Settings::base_values.gamecard_current_game, false);
WriteSetting(QStringLiteral("gamecard_path"),
QString::fromStdString(Settings::config_values->gamecard_path),
QString::fromStdString(Settings::base_values.gamecard_path),
QStringLiteral(""));
WriteSetting(QStringLiteral("nand_total_size"),
QVariant::fromValue<u64>(static_cast<u64>(
Settings::config_values->nand_total_size)),
Settings::base_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::config_values->nand_user_size)),
Settings::base_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::config_values->nand_system_size)),
static_cast<u64>(Settings::base_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::config_values->sdmc_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::base_values.sdmc_size)),
QVariant::fromValue<u64>(static_cast<u64>(Settings::SDMCSize::S16GB)));
qt_config->endGroup();
}
@@ -1038,17 +1038,17 @@ void Config::SaveDebuggingValues() {
// 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::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);
Settings::base_values.record_frame_times);
WriteSetting(QStringLiteral("use_gdbstub"), Settings::base_values.use_gdbstub, false);
WriteSetting(QStringLiteral("gdbstub_port"), Settings::base_values.gdbstub_port, 24689);
WriteSetting(QStringLiteral("program_args"),
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,
QString::fromStdString(Settings::base_values.program_args), QStringLiteral(""));
WriteSetting(QStringLiteral("dump_exefs"), Settings::base_values.dump_exefs, false);
WriteSetting(QStringLiteral("dump_nso"), Settings::base_values.dump_nso, false);
WriteSetting(QStringLiteral("quest_flag"), Settings::base_values.quest_flag, false);
WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::base_values.disable_cpu_opt,
false);
WriteSetting(QStringLiteral("disable_macro_jit"), Settings::config_values->disable_macro_jit,
WriteSetting(QStringLiteral("disable_macro_jit"), Settings::base_values.disable_macro_jit,
false);
qt_config->endGroup();
@@ -1057,9 +1057,9 @@ void Config::SaveDebuggingValues() {
void Config::SaveServiceValues() {
qt_config->beginGroup(QStringLiteral("Services"));
WriteSetting(QStringLiteral("bcat_backend"),
QString::fromStdString(Settings::config_values->bcat_backend),
QString::fromStdString(Settings::base_values.bcat_backend),
QStringLiteral("null"));
WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::config_values->bcat_boxcat_local,
WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::base_values.bcat_boxcat_local,
false);
qt_config->endGroup();
}
@@ -1068,7 +1068,7 @@ void Config::SaveDisabledAddOnValues() {
qt_config->beginWriteArray(QStringLiteral("DisabledAddOns"));
int i = 0;
for (const auto& elem : Settings::global_values.disabled_addons) {
for (const auto& elem : Settings::base_values.disabled_addons) {
qt_config->setArrayIndex(i);
WriteSetting(QStringLiteral("title_id"), QVariant::fromValue<u64>(elem.first), 0);
qt_config->beginWriteArray(QStringLiteral("disabled"));
@@ -1262,14 +1262,14 @@ void Config::SaveWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
WriteSetting(QStringLiteral("enable_telemetry"),
Settings::config_values->enable_telemetry, true);
Settings::base_values.enable_telemetry, true);
WriteSetting(QStringLiteral("web_api_url"),
QString::fromStdString(Settings::config_values->web_api_url),
QString::fromStdString(Settings::base_values.web_api_url),
QStringLiteral("https://api.yuzu-emu.org"));
WriteSetting(QStringLiteral("yuzu_username"),
QString::fromStdString(Settings::config_values->yuzu_username));
QString::fromStdString(Settings::base_values.yuzu_username));
WriteSetting(QStringLiteral("yuzu_token"),
QString::fromStdString(Settings::config_values->yuzu_token));
QString::fromStdString(Settings::base_values.yuzu_token));
qt_config->endGroup();
}

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

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

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::config_values->gamecard_path));
ui->gamecard_path_edit->setText(QString::fromStdString(Settings::base_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::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->gamecard_inserted->setChecked(Settings::base_values.gamecard_inserted);
ui->gamecard_current_game->setChecked(Settings::base_values.gamecard_current_game);
ui->dump_exefs->setChecked(Settings::base_values.dump_exefs);
ui->dump_nso->setChecked(Settings::base_values.dump_nso);
ui->cache_game_list->setChecked(UISettings::values.cache_game_list);
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);
SetComboBoxFromData(ui->nand_size, Settings::base_values.nand_total_size);
SetComboBoxFromData(ui->usrnand_size, Settings::base_values.nand_user_size);
SetComboBoxFromData(ui->sysnand_size, Settings::base_values.nand_system_size);
SetComboBoxFromData(ui->sdmc_size, Settings::base_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::config_values->gamecard_path = ui->gamecard_path_edit->text().toStdString();
Settings::base_values.gamecard_path = ui->gamecard_path_edit->text().toStdString();
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();
Settings::base_values.gamecard_inserted = ui->gamecard_inserted->isChecked();
Settings::base_values.gamecard_current_game = ui->gamecard_current_game->isChecked();
Settings::base_values.dump_exefs = ui->dump_exefs->isChecked();
Settings::base_values.dump_nso = ui->dump_nso->isChecked();
UISettings::values.cache_game_list = ui->cache_game_list->isChecked();
Settings::config_values->nand_total_size = static_cast<Settings::NANDTotalSize>(
Settings::base_values.nand_total_size = static_cast<Settings::NANDTotalSize>(
ui->nand_size->itemData(ui->nand_size->currentIndex()).toULongLong());
Settings::config_values->nand_system_size = static_cast<Settings::NANDSystemSize>(
Settings::base_values.nand_system_size = static_cast<Settings::NANDSystemSize>(
ui->nand_size->itemData(ui->sysnand_size->currentIndex()).toULongLong());
Settings::config_values->nand_user_size = static_cast<Settings::NANDUserSize>(
Settings::base_values.nand_user_size = static_cast<Settings::NANDUserSize>(
ui->nand_size->itemData(ui->usrnand_size->currentIndex()).toULongLong());
Settings::config_values->sdmc_size = static_cast<Settings::SDMCSize>(
Settings::base_values.sdmc_size = static_cast<Settings::SDMCSize>(
ui->nand_size->itemData(ui->sdmc_size->currentIndex()).toULongLong());
}

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::config_values->players[i].connected = controller_type_index != 0;
Settings::base_values.players[i].connected = controller_type_index != 0;
if (controller_type_index > 0) {
Settings::config_values->players[i].type =
Settings::base_values.players[i].type =
static_cast<Settings::ControllerType>(controller_type_index - 1);
} else {
Settings::config_values->players[i].type = Settings::ControllerType::DualJoycon;
Settings::base_values.players[i].type = Settings::ControllerType::DualJoycon;
}
}
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)]
Settings::base_values
.players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
.connected = ui->handheld_connected->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();
Settings::base_values.debug_pad_enabled = ui->debug_enabled->isChecked();
Settings::base_values.mouse_enabled = ui->mouse_enabled->isChecked();
Settings::base_values.keyboard_enabled = ui->keyboard_enabled->isChecked();
Settings::base_values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
}
void ConfigureInput::changeEvent(QEvent* event) {
@@ -194,8 +194,8 @@ void ConfigureInput::UpdateUIEnabled() {
void ConfigureInput::LoadConfiguration() {
std::stable_partition(
Settings::config_values->players.begin(),
Settings::config_values->players.begin() +
Settings::base_values.players.begin(),
Settings::base_values.players.begin() +
Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
[](const auto& player) { return player.connected; });
@@ -203,22 +203,22 @@ void ConfigureInput::LoadConfiguration() {
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)]
Settings::base_values
.players[Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD)]
.connected);
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);
ui->debug_enabled->setChecked(Settings::base_values.debug_pad_enabled);
ui->mouse_enabled->setChecked(Settings::base_values.mouse_enabled);
ui->keyboard_enabled->setChecked(Settings::base_values.keyboard_enabled);
ui->touchscreen_enabled->setChecked(Settings::base_values.touchscreen.enabled);
UpdateUIEnabled();
}
void ConfigureInput::LoadPlayerControllerIndices() {
for (std::size_t i = 0; i < players_controller.size(); ++i) {
const auto connected = Settings::config_values->players[i].connected;
const auto connected = Settings::base_values.players[i].connected;
players_controller[i]->setCurrentIndex(
connected ? static_cast<u8>(Settings::config_values->players[i].type) + 1 : 0);
connected ? static_cast<u8>(Settings::base_values.players[i].type) + 1 : 0);
}
}

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

28
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::config_values->players[HANDHELD_INDEX].connected = true;
Settings::config_values->players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
Settings::base_values.players[HANDHELD_INDEX].connected = true;
Settings::base_values.players[HANDHELD_INDEX].type = Settings::ControllerType::DualJoycon;
for (std::size_t player = 0; player < HANDHELD_INDEX; ++player) {
Settings::config_values->players[player].connected = false;
Settings::base_values.players[player].connected = false;
}
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;
Settings::base_values.keyboard_enabled = false;
Settings::base_values.mouse_enabled = false;
Settings::base_values.debug_pad_enabled = false;
Settings::base_values.touchscreen.enabled = true;
}
void DualJoyconsDockedOnProfileSelect() {
Settings::config_values->players[PLAYER_0_INDEX].connected = true;
Settings::config_values->players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
Settings::base_values.players[PLAYER_0_INDEX].connected = true;
Settings::base_values.players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
for (std::size_t player = 1; player <= HANDHELD_INDEX; ++player) {
Settings::config_values->players[player].connected = false;
Settings::base_values.players[player].connected = false;
}
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;
Settings::base_values.keyboard_enabled = false;
Settings::base_values.mouse_enabled = false;
Settings::base_values.debug_pad_enabled = false;
Settings::base_values.touchscreen.enabled = true;
}
// Name, OnProfileSelect (called when selected in drop down), OnConfigure (called when configure

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

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

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

@@ -72,7 +72,7 @@ void ConfigurePerGameAddons::ApplyConfiguration() {
disabled_addons.push_back(item.front()->text().toStdString());
}
auto current = Settings::global_values.disabled_addons[title_id];
auto current = Settings::base_values.disabled_addons[title_id];
std::sort(disabled_addons.begin(), disabled_addons.end());
std::sort(current.begin(), current.end());
if (disabled_addons != current) {
@@ -80,7 +80,7 @@ void ConfigurePerGameAddons::ApplyConfiguration() {
"game_list" + DIR_SEP + fmt::format("{:016X}.pv.txt", title_id));
}
Settings::global_values.disabled_addons[title_id] = disabled_addons;
Settings::base_values.disabled_addons[title_id] = disabled_addons;
}
void ConfigurePerGameAddons::LoadFromFile(FileSys::VirtualFile file) {
@@ -115,7 +115,7 @@ void ConfigurePerGameAddons::LoadConfiguration() {
FileSys::VirtualFile update_raw;
loader->ReadUpdateRaw(update_raw);
const auto& disabled = Settings::global_values.disabled_addons[title_id];
const auto& disabled = Settings::base_values.disabled_addons[title_id];
for (const auto& patch : pm.GetPatchVersionNames(update_raw)) {
const auto name =

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

@@ -54,7 +54,7 @@ ConfigureService::ConfigureService(QWidget* parent)
ConfigureService::~ConfigureService() = default;
void ConfigureService::ApplyConfiguration() {
Settings::config_values->bcat_backend = ui->bcat_source->currentText().toLower().toStdString();
Settings::base_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::config_values->bcat_backend));
ui->bcat_source->findData(QString::fromStdString(Settings::base_values.bcat_backend));
ui->bcat_source->setCurrentIndex(index == -1 ? 0 : index);
}

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

@@ -33,17 +33,17 @@ void ConfigureTouchscreenAdvanced::RetranslateUI() {
}
void ConfigureTouchscreenAdvanced::ApplyConfiguration() {
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();
Settings::base_values.touchscreen.finger = ui->finger_box->value();
Settings::base_values.touchscreen.diameter_x = ui->diameter_x_box->value();
Settings::base_values.touchscreen.diameter_y = ui->diameter_y_box->value();
Settings::base_values.touchscreen.rotation_angle = ui->angle_box->value();
}
void ConfigureTouchscreenAdvanced::LoadConfiguration() {
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);
ui->finger_box->setValue(Settings::base_values.touchscreen.finger);
ui->diameter_x_box->setValue(Settings::base_values.touchscreen.diameter_x);
ui->diameter_y_box->setValue(Settings::base_values.touchscreen.diameter_y);
ui->angle_box->setValue(Settings::base_values.touchscreen.rotation_angle);
}
void ConfigureTouchscreenAdvanced::RestoreDefaults() {

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

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

4
src/yuzu/main.cpp
View File

@@ -162,7 +162,7 @@ void GMainWindow::ShowTelemetryCallout() {
"data is collected</a> to help improve yuzu. "
"<br/><br/>Would you like to share your usage data with us?");
if (QMessageBox::question(this, tr("Telemetry"), telemetry_message) != QMessageBox::Yes) {
Settings::values->enable_telemetry = false;
Settings::base_values.enable_telemetry = false;
Settings::Apply();
}
}
@@ -1850,7 +1850,7 @@ void GMainWindow::ErrorDisplayDisplayError(QString body) {
}
void GMainWindow::OnMenuReportCompatibility() {
if (!Settings::values->yuzu_token.empty() && !Settings::values->yuzu_username.empty()) {
if (!Settings::base_values.yuzu_token.empty() && !Settings::base_values.yuzu_username.empty()) {
CompatDB compatdb{this};
compatdb.exec();
} else {

14
src/yuzu_cmd/config.cpp
View File

@@ -226,24 +226,24 @@ static const std::array<int, 8> keyboard_mods{
void Config::ReadValues() {
// Controls
for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
for (std::size_t p = 0; p < Settings::global_values.players.size(); ++p) {
const auto group = fmt::format("ControlsP{}", p);
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
Settings::values->players[p].buttons[i] =
Settings::global_values.players[p].buttons[i] =
sdl2_config->Get(group, Settings::NativeButton::mapping[i], default_param);
if (Settings::values->players[p].buttons[i].empty())
Settings::values->players[p].buttons[i] = default_param;
if (Settings::global_values.players[p].buttons[i].empty())
Settings::global_values.players[p].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);
Settings::values->players[p].analogs[i] =
Settings::global_values.players[p].analogs[i] =
sdl2_config->Get(group, Settings::NativeAnalog::mapping[i], default_param);
if (Settings::values->players[p].analogs[i].empty())
Settings::values->players[p].analogs[i] = default_param;
if (Settings::global_values.players[p].analogs[i].empty())
Settings::global_values.players[p].analogs[i] = default_param;
}
}

6
src/yuzu_tester/config.cpp
View File

@@ -46,13 +46,13 @@ bool Config::LoadINI(const std::string& default_contents, bool retry) {
void Config::ReadValues() {
// Controls
for (std::size_t p = 0; p < Settings::values->players.size(); ++p) {
for (std::size_t p = 0; p < Settings::global_values.players.size(); ++p) {
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
Settings::values->players[p].buttons[i] = "";
Settings::global_values.players[p].buttons[i] = "";
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
Settings::values->players[p].analogs[i] = "";
Settings::global_values.players[p].analogs[i] = "";
}
}