mirror of
https://git.eden-emu.dev/eden-emu/eden
synced 2026-05-09 15:48:06 +00:00
1b4a79c7ee
This pr content and goal is to provide following to Eden's user base issues with settings, adjust default values on settings and refactor some handlings to improve the plug-and-play factor: -> Combo-box for ASTC Recompression Method Removed: The removal of this toggle was due to the redundant process inside Android devices, most drivers do suppot ASTC handling natively and meanwhile this option provided some benefits to some older Mali devices, the specifications from those and the real compatibility doesn't pay the need for this setting, unless something else is provided to be wrong, the default setting will be uncompressed and no longer available in UI to change. Removed some dead code along with it. -> Removal of ASTC Decode Method ifdef block for Android: Since Yuzu's, the handling for this option was strangely set on CPU, having a specific block for Android in settings, possibly due to the constant spikes on GPU usage that wouldn't be good to load GPU with the whole flow of operations; but since then and until today, Eden's constant effort to make operations more accurate and smartly resolved, have marked the difference that now CPU default on Android no longer provides the benefit to relief GPU stress than reducing performance in some heavy draw commands on some games; the default will be set to GPU to keep parity with PC configuration aiming for a global configuration with all platforms. The setting will be kept to user range, unless is proved to no longer be needed, right now low end devices could still have benefit from CPU/Async, but requires testing from community to show real potential. -> Adjusted default value of ExtendedDynamicState: Currently we're facing some issues of logic inside of ExtendedDynamicState implementation, that makes it a bit unstable when it comes to use the disabled mode, right now we jump to ExtendedDynamicState1 for more stability, meanwhile we fix the remaining issues in future updates (currently one fix will be presented - or would be merged along this pr, the 1st Global Vulkan Maintenance which has some fixes for this situation), so stock drivers and other mobile drivers will behave and benefit from this. -> Exposed hidden and defaulted settings to user's UI: Yuzu implemented some settings that were available on PC's UI but weren't presented on Android's UI or wasn't something expected to do, either way there are some strange behaviors due to this default settings and each of them do something different, i'm not gonna dive into a deep explanation, but to make it short, they stablish asynchronous operations for GPU operations, like Async GPU Emulation (to use a CPU thread to boost performance with GPU emulation, currently a performance hack), Asynchronous Vulkan Presentation this does something a like to disperse draw's/ syncing from TimelineSemaphores and set a thread of CPU to help in running some Vulkan operations (another performance Hack), meanwhile most of the Desktop drivers are mostly nice with this setting, Nvidia aren't due to the nature of the hack, so provokes black screen or failing into initialize games. Mostly Asynchronous operations are fast-paths/ hacks to improve performance to the cost of some graphical issues like the pop-in with Asynchronous Shader Building during the shader compilations, sometimes the trade-off could give random crashes and other issues. Android it's not the exception and currently by disabling GPU Async Emulation user's will be able to fix some strange flickering on Zelda - Link's Awakening (NCE) and other games suffering from similar issues, may also fix random crashes on games that are supposed to work. These settings will be exposed for a short amount of time, meanwhile I receive feedback of the usefulness of having them active or the whole operation being used on Android, aside that, disabling them or one of them will inevitable reduce performance a bit, not so notorious, but it will be up to user's decision now to use them or not. -> AMD FidelityFX's Super Resolution UI handling (a personal request): Now the slider default value will be 0% and will only appear whenever FSR is choosed among other window adapting filters, this will also work with the quick setting menu during runtime. -> Fixed the issue of changing drivers removing all games compiled shader cache: Currently our implementation to safeguard users from unknown issues when a different driver tries to load/ read compiled shaders from another version of Turnip/ QCOM driver, that will delete shaders if the driver is removed or changed; deleted all games compiled shader cache, which increased the annoyance on Android users along with adding unneeded complexity, this used to happen whenever a driver was changed in global settings or per-game settings. Now no longer will happen if the driver is changed on global settings and changing drivers in per-game configuration will only delete current game where the driver was change without affecting others, from here, I'll apologize for this unneeded situation. -> Refactored the input controller detection (another request of mine, hehehe...): This implementation will work to reduce the burden on a new installation (since I have to test everything personally, cuz testers are lazy ass mfs), the input detection is now more accurate to what kind of input a device has, whether is in-built or wireless gamepad, will map it once Eden detect's physical input by reading the controllers inputs that OS provides natively and set or disable touchscreen controllers automatically: - If in-built is detected (Ayaneo, Ayn, Retroid or any Android handheld), Eden will map it automatically and will disable touchscreen controller. - If Wireless gamepad is detected, the same behavior as described above will happen with the extra to recover touchscreen controller whenever the gamepad goes off. It was quite funny to do this, cuz Xiaomi and some other manufacturers always do strange shenanigans with how the inputs are detected (wasn't funny). Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3832 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: CamilleLaVey <camillelavey99@gmail.com> Co-committed-by: CamilleLaVey <camillelavey99@gmail.com>
884 lines
46 KiB
C++
884 lines
46 KiB
C++
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "common/common_types.h"
|
|
#include "common/settings_common.h"
|
|
#include "common/settings_enums.h"
|
|
#include "common/settings_input.h"
|
|
#include "common/settings_setting.h"
|
|
|
|
namespace Settings {
|
|
|
|
const char* TranslateCategory(Settings::Category category);
|
|
|
|
struct ResolutionScalingInfo {
|
|
u32 up_scale{1};
|
|
u32 down_shift{0};
|
|
f32 up_factor{1.0f};
|
|
f32 down_factor{1.0f};
|
|
bool active{};
|
|
bool downscale{};
|
|
|
|
s32 ScaleUp(s32 value) const {
|
|
if (value == 0) {
|
|
return 0;
|
|
}
|
|
return (std::max)((value * static_cast<s32>(up_scale)) >> static_cast<s32>(down_shift), 1);
|
|
}
|
|
|
|
u32 ScaleUp(u32 value) const {
|
|
if (value == 0U) {
|
|
return 0U;
|
|
}
|
|
return (std::max)((value * up_scale) >> down_shift, 1U);
|
|
}
|
|
};
|
|
|
|
#ifndef CANNOT_EXPLICITLY_INSTANTIATE
|
|
// Instantiate the classes elsewhere (settings.cpp) to reduce compiler/linker work
|
|
// TODO(crueter): Move new enums here
|
|
#define SETTING(TYPE, RANGED) extern template class Setting<TYPE, RANGED>
|
|
#define SWITCHABLE(TYPE, RANGED) extern template class SwitchableSetting<TYPE, RANGED>
|
|
|
|
SETTING(AudioEngine, false);
|
|
SETTING(bool, false);
|
|
SETTING(int, false);
|
|
SETTING(s32, false);
|
|
SETTING(std::string, false);
|
|
SETTING(std::string, false);
|
|
SETTING(u16, false);
|
|
SWITCHABLE(AnisotropyMode, true);
|
|
SWITCHABLE(AntiAliasing, false);
|
|
SWITCHABLE(AspectRatio, true);
|
|
SWITCHABLE(AstcDecodeMode, true);
|
|
SWITCHABLE(AstcRecompression, true);
|
|
SWITCHABLE(AudioMode, true);
|
|
SWITCHABLE(CpuBackend, true);
|
|
SWITCHABLE(CpuAccuracy, true);
|
|
SWITCHABLE(FullscreenMode, true);
|
|
SWITCHABLE(GpuAccuracy, true);
|
|
SWITCHABLE(Language, true);
|
|
SWITCHABLE(MemoryLayout, true);
|
|
SWITCHABLE(NvdecEmulation, false);
|
|
SWITCHABLE(Region, true);
|
|
SWITCHABLE(RendererBackend, true);
|
|
SWITCHABLE(ScalingFilter, false);
|
|
SWITCHABLE(SpirvOptimizeMode, true);
|
|
SWITCHABLE(TimeZone, true);
|
|
SETTING(VSyncMode, true);
|
|
SWITCHABLE(bool, false);
|
|
SWITCHABLE(int, false);
|
|
SWITCHABLE(int, true);
|
|
SWITCHABLE(s64, false);
|
|
SWITCHABLE(u16, true);
|
|
SWITCHABLE(u32, false);
|
|
SWITCHABLE(u8, false);
|
|
SWITCHABLE(u8, true);
|
|
|
|
// Used in UISettings
|
|
// TODO see if we can move this to uisettings.h
|
|
SWITCHABLE(ConfirmStop, true);
|
|
|
|
#undef SETTING
|
|
#undef SWITCHABLE
|
|
#endif
|
|
|
|
/**
|
|
* The InputSetting class allows for getting a reference to either the global or custom members.
|
|
* This is required as we cannot easily modify the values of user-defined types within containers
|
|
* using the SetValue() member function found in the Setting class. The primary purpose of this
|
|
* class is to store an array of 10 PlayerInput structs for both the global and custom setting and
|
|
* allows for easily accessing and modifying both settings.
|
|
*/
|
|
template <typename Type>
|
|
class InputSetting final {
|
|
public:
|
|
InputSetting() = default;
|
|
explicit InputSetting(Type val) : Setting<Type>(val) {}
|
|
~InputSetting() = default;
|
|
void SetGlobal(bool to_global) {
|
|
use_global = to_global;
|
|
}
|
|
[[nodiscard]] bool UsingGlobal() const {
|
|
return use_global;
|
|
}
|
|
[[nodiscard]] Type& GetValue(bool need_global = false) {
|
|
if (use_global || need_global) {
|
|
return global;
|
|
}
|
|
return custom;
|
|
}
|
|
|
|
private:
|
|
bool use_global{true}; ///< The setting's global state
|
|
Type global{}; ///< The setting
|
|
Type custom{}; ///< The custom setting value
|
|
};
|
|
|
|
struct TouchFromButtonMap {
|
|
std::string name;
|
|
std::vector<std::string> buttons;
|
|
};
|
|
|
|
struct Values {
|
|
Linkage linkage{};
|
|
|
|
// Applet
|
|
SwitchableSetting<AppletMode> cabinet_applet_mode{linkage, AppletMode::LLE, "cabinet_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> controller_applet_mode{linkage, AppletMode::HLE, "controller_applet_mode",
|
|
Category::LibraryApplet};
|
|
Setting<AppletMode> data_erase_applet_mode{linkage, AppletMode::HLE, "data_erase_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> error_applet_mode{linkage, AppletMode::LLE, "error_applet_mode",
|
|
Category::LibraryApplet};
|
|
Setting<AppletMode> net_connect_applet_mode{linkage, AppletMode::LLE, "net_connect_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> player_select_applet_mode{
|
|
linkage, AppletMode::LLE, "player_select_applet_mode", Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> swkbd_applet_mode{linkage, AppletMode::HLE, "swkbd_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> mii_edit_applet_mode{linkage, AppletMode::LLE, "mii_edit_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> web_applet_mode{linkage, AppletMode::HLE, "web_applet_mode",
|
|
Category::LibraryApplet};
|
|
Setting<AppletMode> shop_applet_mode{linkage, AppletMode::HLE, "shop_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> photo_viewer_applet_mode{
|
|
linkage, AppletMode::LLE, "photo_viewer_applet_mode", Category::LibraryApplet};
|
|
SwitchableSetting<AppletMode> offline_web_applet_mode{linkage, AppletMode::LLE, "offline_web_applet_mode",
|
|
Category::LibraryApplet};
|
|
Setting<AppletMode> login_share_applet_mode{linkage, AppletMode::HLE, "login_share_applet_mode",
|
|
Category::LibraryApplet};
|
|
Setting<AppletMode> wifi_web_auth_applet_mode{
|
|
linkage, AppletMode::HLE, "wifi_web_auth_applet_mode", Category::LibraryApplet};
|
|
Setting<AppletMode> my_page_applet_mode{linkage, AppletMode::LLE, "my_page_applet_mode",
|
|
Category::LibraryApplet};
|
|
SwitchableSetting<bool> enable_overlay{linkage, false, "enable_overlay", Category::LibraryApplet};
|
|
|
|
// Audio
|
|
SwitchableSetting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine",
|
|
Category::Audio, Specialization::RuntimeList};
|
|
SwitchableSetting<std::string> audio_output_device_id{
|
|
linkage, "auto", "output_device", Category::Audio, Specialization::RuntimeList};
|
|
SwitchableSetting<std::string> audio_input_device_id{
|
|
linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
|
|
SwitchableSetting<AudioMode, true> sound_index{
|
|
linkage, AudioMode::Stereo,
|
|
"sound_index", Category::SystemAudio, Specialization::Default, true,
|
|
true};
|
|
SwitchableSetting<u8, true> volume{linkage,
|
|
100,
|
|
0,
|
|
200,
|
|
"volume",
|
|
Category::Audio,
|
|
Specialization::Scalar | Specialization::Percentage,
|
|
true,
|
|
true};
|
|
Setting<bool, false> audio_muted{
|
|
linkage, false, "audio_muted", Category::Audio, Specialization::Default, true, true};
|
|
Setting<bool, false> dump_audio_commands{
|
|
linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
|
|
|
|
// Core
|
|
SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
|
|
SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
|
|
MemoryLayout::Memory_4Gb,
|
|
"memory_layout_mode",
|
|
Category::Core,
|
|
Specialization::Default,
|
|
true};
|
|
SwitchableSetting<bool> use_speed_limit{
|
|
linkage, true, "use_speed_limit", Category::Core, Specialization::Paired, true, true};
|
|
|
|
SwitchableSetting<u16, true> speed_limit{linkage,
|
|
100,
|
|
0,
|
|
9999,
|
|
"speed_limit",
|
|
Category::Core,
|
|
Specialization::Countable | Specialization::Percentage,
|
|
true,
|
|
true,
|
|
&use_speed_limit};
|
|
|
|
SwitchableSetting<u16, true> slow_speed_limit{linkage,
|
|
50,
|
|
0,
|
|
9999,
|
|
"slow_speed_limit",
|
|
Category::Core,
|
|
Specialization::Countable | Specialization::Percentage,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<u16, true> turbo_speed_limit{linkage,
|
|
200,
|
|
0,
|
|
9999,
|
|
"turbo_speed_limit",
|
|
Category::Core,
|
|
Specialization::Countable | Specialization::Percentage,
|
|
true,
|
|
true};
|
|
|
|
// The currently used speed mode.
|
|
Setting<SpeedMode> current_speed_mode{linkage, SpeedMode::Standard, "current_speed_mode", Category::Core, Specialization::Default, false, true};
|
|
|
|
SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core,
|
|
Specialization::Default};
|
|
|
|
// Cpu
|
|
SwitchableSetting<CpuBackend, true> cpu_backend{linkage,
|
|
#ifdef HAS_NCE
|
|
CpuBackend::Nce,
|
|
#else
|
|
CpuBackend::Dynarmic,
|
|
#endif
|
|
CpuBackend::Dynarmic,
|
|
#ifdef HAS_NCE
|
|
CpuBackend::Nce,
|
|
#else
|
|
CpuBackend::Dynarmic,
|
|
#endif
|
|
"cpu_backend",
|
|
Category::Cpu};
|
|
SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
|
|
"cpu_accuracy", Category::Cpu};
|
|
SwitchableSetting<CpuClock> fast_cpu_time{linkage,
|
|
CpuClock::Off,
|
|
"fast_cpu_time",
|
|
Category::Cpu,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<bool> use_custom_cpu_ticks{linkage,
|
|
false,
|
|
"use_custom_cpu_ticks",
|
|
Category::Cpu,
|
|
Specialization::Paired,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<u32, true> cpu_ticks{linkage,
|
|
16000,
|
|
77,
|
|
65535,
|
|
"cpu_ticks",
|
|
Category::Cpu,
|
|
Specialization::Countable,
|
|
true,
|
|
true,
|
|
&use_custom_cpu_ticks};
|
|
|
|
Setting<bool> cpuopt_page_tables{linkage, true, "cpuopt_page_tables", Category::CpuDebug};
|
|
Setting<bool> cpuopt_block_linking{linkage, true, "cpuopt_block_linking", Category::CpuDebug};
|
|
Setting<bool> cpuopt_return_stack_buffer{linkage, true, "cpuopt_return_stack_buffer",
|
|
Category::CpuDebug};
|
|
Setting<bool> cpuopt_fast_dispatcher{linkage, true, "cpuopt_fast_dispatcher",
|
|
Category::CpuDebug};
|
|
Setting<bool> cpuopt_context_elimination{linkage, true, "cpuopt_context_elimination",
|
|
Category::CpuDebug};
|
|
Setting<bool> cpuopt_const_prop{linkage, true, "cpuopt_const_prop", Category::CpuDebug};
|
|
Setting<bool> cpuopt_misc_ir{linkage, true, "cpuopt_misc_ir", Category::CpuDebug};
|
|
Setting<bool> cpuopt_reduce_misalign_checks{linkage, true, "cpuopt_reduce_misalign_checks",
|
|
Category::CpuDebug};
|
|
SwitchableSetting<bool> cpuopt_fastmem{linkage, true, "cpuopt_fastmem", Category::CpuDebug};
|
|
SwitchableSetting<bool> cpuopt_fastmem_exclusives{linkage, true, "cpuopt_fastmem_exclusives",
|
|
Category::CpuDebug};
|
|
Setting<bool> cpuopt_recompile_exclusives{linkage, true, "cpuopt_recompile_exclusives",
|
|
Category::CpuDebug};
|
|
Setting<bool> cpuopt_ignore_memory_aborts{linkage, true, "cpuopt_ignore_memory_aborts",
|
|
Category::CpuDebug};
|
|
|
|
SwitchableSetting<bool> cpuopt_unsafe_host_mmu{linkage,
|
|
#if !defined(__APPLE__) && !defined(__linux__) && !defined(__ANDROID__) && !defined(_WIN32)
|
|
false,
|
|
#else
|
|
true,
|
|
#endif
|
|
"cpuopt_unsafe_host_mmu",
|
|
Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
|
|
Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
|
|
linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
|
|
linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{
|
|
linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{
|
|
linkage, true, "cpuopt_unsafe_fastmem_check", Category::CpuUnsafe};
|
|
SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
|
|
linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::CpuUnsafe};
|
|
|
|
// Renderer
|
|
SwitchableSetting<RendererBackend, true> renderer_backend{linkage,
|
|
#if defined(__sun__) || defined(__managarm__)
|
|
RendererBackend::OpenGL_GLSL,
|
|
#else
|
|
RendererBackend::Vulkan,
|
|
#endif
|
|
"backend", Category::Renderer};
|
|
SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer, Specialization::RuntimeList};
|
|
|
|
// Graphics Settings
|
|
ResolutionScalingInfo resolution_info{};
|
|
SwitchableSetting<ResolutionSetup> resolution_setup{linkage, ResolutionSetup::Res1X,
|
|
"resolution_setup", Category::Renderer};
|
|
|
|
SwitchableSetting<VSyncMode, true> vsync_mode{linkage,
|
|
VSyncMode::Fifo,
|
|
"use_vsync",
|
|
Category::Renderer,
|
|
Specialization::RuntimeList,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<ScalingFilter> scaling_filter{linkage,
|
|
ScalingFilter::Bilinear,
|
|
"scaling_filter",
|
|
Category::Renderer,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
SwitchableSetting<int, true> fsr_sharpening_slider{linkage,
|
|
#ifdef ANDROID
|
|
0,
|
|
#else
|
|
25,
|
|
#endif
|
|
0,
|
|
200,
|
|
"fsr_sharpening_slider",
|
|
Category::Renderer,
|
|
Specialization::Scalar |
|
|
Specialization::Percentage,
|
|
true,
|
|
true};
|
|
SwitchableSetting<AspectRatio, true> aspect_ratio{linkage,
|
|
AspectRatio::R16_9,
|
|
"aspect_ratio",
|
|
Category::Renderer,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<AntiAliasing> anti_aliasing{linkage,
|
|
AntiAliasing::None,
|
|
"anti_aliasing",
|
|
Category::Renderer,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<SpirvOptimizeMode, true> optimize_spirv_output{linkage,
|
|
SpirvOptimizeMode::Never,
|
|
"optimize_spirv_output",
|
|
Category::Renderer};
|
|
SwitchableSetting<bool> use_asynchronous_gpu_emulation{
|
|
linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
|
|
// *nix platforms may have issues with the borderless windowed fullscreen mode.
|
|
// Default to exclusive fullscreen on these platforms for now.
|
|
SwitchableSetting<FullscreenMode, true> fullscreen_mode{linkage,
|
|
#ifdef _WIN32
|
|
FullscreenMode::Borderless,
|
|
#else
|
|
FullscreenMode::Exclusive,
|
|
#endif
|
|
"fullscreen_mode",
|
|
Category::Renderer,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<u8, false> bg_red{
|
|
linkage, 0, "bg_red", Category::Renderer, Specialization::Default, true, true};
|
|
SwitchableSetting<u8, false> bg_green{
|
|
linkage, 0, "bg_green", Category::Renderer, Specialization::Default, true, true};
|
|
SwitchableSetting<u8, false> bg_blue{
|
|
linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
|
|
|
|
SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
|
|
#ifdef ANDROID
|
|
GpuAccuracy::Low,
|
|
#else
|
|
GpuAccuracy::Medium,
|
|
#endif
|
|
"gpu_accuracy",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
GpuAccuracy current_gpu_accuracy{GpuAccuracy::Medium};
|
|
|
|
SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
|
|
DmaAccuracy::Default,
|
|
"dma_accuracy",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<VramUsageMode, true> vram_usage_mode{linkage,
|
|
VramUsageMode::Conservative,
|
|
"vram_usage_mode",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
|
|
"nvdec_emulation", Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<AnisotropyMode, true> max_anisotropy{linkage,
|
|
#ifdef ANDROID
|
|
AnisotropyMode::Default,
|
|
#else
|
|
AnisotropyMode::Automatic,
|
|
#endif
|
|
"max_anisotropy",
|
|
Category::RendererAdvanced};
|
|
SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
|
|
AstcDecodeMode::Gpu,
|
|
"accelerate_astc",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<FramePacingMode, true> frame_pacing_mode{linkage,
|
|
FramePacingMode::Target_Auto,
|
|
FramePacingMode::Target_Auto,
|
|
FramePacingMode::Target_120,
|
|
"frame_pacing_mode",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
|
|
AstcRecompression::Uncompressed,
|
|
"astc_recompression",
|
|
Category::RendererAdvanced};
|
|
|
|
|
|
SwitchableSetting<bool> sync_memory_operations{linkage,
|
|
false,
|
|
"sync_memory_operations",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> use_disk_shader_cache{linkage, true, "use_disk_shader_cache",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{
|
|
linkage, true, "use_vulkan_driver_pipeline_cache", Category::RendererAdvanced,
|
|
Specialization::Default};
|
|
|
|
SwitchableSetting<bool> enable_compute_pipelines{linkage, false, "enable_compute_pipelines",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> use_video_framerate{linkage, false, "use_video_framerate",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> use_reactive_flushing{linkage,
|
|
#ifdef ANDROID
|
|
false,
|
|
#else
|
|
true,
|
|
#endif
|
|
"use_reactive_flushing",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
|
|
Category::RendererAdvanced};
|
|
|
|
SwitchableSetting<bool> enable_buffer_history{linkage,
|
|
false,
|
|
"enable_buffer_history",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
#ifdef ANDROID
|
|
SwitchableSetting<bool> use_optimized_vertex_buffers{linkage,
|
|
false,
|
|
"use_optimized_vertex_buffers",
|
|
Category::RendererAdvanced,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
#endif
|
|
|
|
// Renderer Hacks //
|
|
SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,
|
|
GpuOverclock::Medium,
|
|
"fast_gpu_time",
|
|
Category::RendererHacks,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
SwitchableSetting<bool> skip_cpu_inner_invalidation{linkage,
|
|
false,
|
|
"skip_cpu_inner_invalidation",
|
|
Category::RendererHacks,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
SwitchableSetting<bool> async_presentation{linkage,
|
|
#ifdef ANDROID
|
|
true,
|
|
#else
|
|
false,
|
|
#endif
|
|
"async_presentation", Category::RendererHacks};
|
|
|
|
SwitchableSetting<bool> fix_bloom_effects{linkage, false, "fix_bloom_effects",
|
|
Category::RendererHacks};
|
|
|
|
SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
|
|
Category::RendererHacks};
|
|
|
|
SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
|
|
Category::RendererHacks};
|
|
|
|
SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
|
|
GpuUnswizzleSize::Large,
|
|
"gpu_unswizzle_texture_size",
|
|
Category::RendererHacks,
|
|
Specialization::Default};
|
|
|
|
SwitchableSetting<GpuUnswizzle> gpu_unswizzle_stream_size{linkage,
|
|
GpuUnswizzle::Medium,
|
|
"gpu_unswizzle_stream_size",
|
|
Category::RendererHacks,
|
|
Specialization::Default};
|
|
|
|
SwitchableSetting<GpuUnswizzleChunk> gpu_unswizzle_chunk_size{linkage,
|
|
GpuUnswizzleChunk::Medium,
|
|
"gpu_unswizzle_chunk_size",
|
|
Category::RendererHacks,
|
|
Specialization::Default};
|
|
|
|
SwitchableSetting<bool> gpu_unswizzle_enabled{linkage, false, "gpu_unswizzle_enabled",
|
|
Category::RendererHacks};
|
|
|
|
SwitchableSetting<ExtendedDynamicState> dyna_state{linkage,
|
|
#if defined(ANDROID)
|
|
ExtendedDynamicState::EDS1,
|
|
#elif defined(__APPLE__)
|
|
ExtendedDynamicState::Disabled,
|
|
#else
|
|
ExtendedDynamicState::EDS2,
|
|
#endif
|
|
"dyna_state",
|
|
Category::RendererExtensions};
|
|
|
|
SwitchableSetting<u32, true> sample_shading{linkage,
|
|
0,
|
|
0,
|
|
100,
|
|
"sample_shading_fraction",
|
|
Category::RendererExtensions,
|
|
Specialization::Scalar};
|
|
|
|
SwitchableSetting<bool> vertex_input_dynamic_state{linkage,
|
|
#if defined (ANDROID)
|
|
false,
|
|
#else
|
|
true,
|
|
#endif
|
|
"vertex_input_dynamic_state", Category::RendererExtensions};
|
|
SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex", Category::RendererExtensions};
|
|
SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing", Category::RendererExtensions};
|
|
|
|
Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
|
|
Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
|
|
Category::RendererDebug};
|
|
Setting<bool> enable_nsight_aftermath{linkage, false, "nsight_aftermath",
|
|
Category::RendererDebug};
|
|
Setting<bool> disable_shader_loop_safety_checks{
|
|
linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
|
|
Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
|
|
Category::RendererDebug};
|
|
#if defined(ANDROID) && defined(ARCHITECTURE_arm64)
|
|
// Debug override for automatic BCn patching detection
|
|
Setting<bool> patch_old_qcom_drivers{linkage, false, "patch_old_qcom_drivers",
|
|
Category::RendererDebug};
|
|
#endif
|
|
SwitchableSetting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
|
|
Category::RendererDebug,
|
|
Specialization::Default,
|
|
true,
|
|
true};
|
|
|
|
// System
|
|
SwitchableSetting<Language, true> language_index{linkage,
|
|
Language::EnglishAmerican,
|
|
"language_index",
|
|
Category::System};
|
|
SwitchableSetting<Region, true> region_index{linkage, Region::Usa, "region_index", Category::System};
|
|
SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto, "time_zone_index", Category::System};
|
|
Setting<u32> serial_battery{linkage, 0, "serial_battery", Category::System};
|
|
Setting<u32> serial_unit{linkage, 0, "serial_unit", Category::System};
|
|
// Measured in seconds since epoch
|
|
SwitchableSetting<bool> custom_rtc_enabled{linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
|
|
SwitchableSetting<s64> custom_rtc{
|
|
linkage, 0, "custom_rtc", Category::System, Specialization::Time,
|
|
false, true, &custom_rtc_enabled};
|
|
SwitchableSetting<s64, true> custom_rtc_offset{linkage,
|
|
0,
|
|
(std::numeric_limits<int>::min)(),
|
|
(std::numeric_limits<int>::max)(),
|
|
"custom_rtc_offset",
|
|
Category::System,
|
|
Specialization::Countable,
|
|
true,
|
|
true};
|
|
SwitchableSetting<bool> rng_seed_enabled{
|
|
linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
|
|
SwitchableSetting<u32> rng_seed{
|
|
linkage, 0, "rng_seed", Category::System, Specialization::Hex,
|
|
true, true, &rng_seed_enabled};
|
|
Setting<std::string> device_name{
|
|
linkage, "Eden", "device_name", Category::System, Specialization::Default, true, true};
|
|
|
|
Setting<s32> current_user{linkage, 0, "current_user", Category::System};
|
|
|
|
SwitchableSetting<ConsoleMode> use_docked_mode{linkage,
|
|
#ifdef ANDROID
|
|
ConsoleMode::Handheld,
|
|
#else
|
|
ConsoleMode::Docked,
|
|
#endif
|
|
"use_docked_mode",
|
|
Category::System,
|
|
Specialization::Radio,
|
|
true,
|
|
true};
|
|
|
|
// Controls
|
|
InputSetting<std::array<PlayerInput, 10>> players;
|
|
|
|
Setting<bool> enable_raw_input{
|
|
linkage, false, "enable_raw_input", Category::Controls, Specialization::Default,
|
|
// Only read/write enable_raw_input on Windows platforms
|
|
#ifdef _WIN32
|
|
true
|
|
#else
|
|
false
|
|
#endif
|
|
};
|
|
Setting<bool> controller_navigation{linkage, true, "controller_navigation", Category::Controls};
|
|
Setting<bool> enable_joycon_driver{linkage, true, "enable_joycon_driver", Category::Controls};
|
|
Setting<bool> enable_procon_driver{linkage, false, "enable_procon_driver", Category::Controls};
|
|
|
|
SwitchableSetting<bool> vibration_enabled{linkage, true, "vibration_enabled",
|
|
Category::Controls};
|
|
SwitchableSetting<bool> enable_accurate_vibrations{linkage, false, "enable_accurate_vibrations",
|
|
Category::Controls};
|
|
|
|
SwitchableSetting<bool> motion_enabled{linkage, true, "motion_enabled", Category::Controls};
|
|
Setting<std::string> udp_input_servers{linkage, "127.0.0.1:26760", "udp_input_servers",
|
|
Category::Controls};
|
|
Setting<bool> enable_udp_controller{linkage, false, "enable_udp_controller",
|
|
Category::Controls};
|
|
|
|
Setting<bool> pause_tas_on_load{linkage, true, "pause_tas_on_load", Category::Controls};
|
|
Setting<bool> tas_enable{linkage, false, "tas_enable", Category::Controls};
|
|
Setting<bool> tas_loop{linkage, false, "tas_loop", Category::Controls};
|
|
Setting<bool> tas_show_recording_dialog{linkage, true, "tas_show_recording_dialog", Category::Controls};
|
|
|
|
Setting<bool> mouse_panning{
|
|
linkage, false, "mouse_panning", Category::Controls, Specialization::Default, false};
|
|
Setting<u8, true> mouse_panning_sensitivity{
|
|
linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
|
|
Setting<bool> mouse_enabled{linkage, false, "mouse_enabled", Category::Controls};
|
|
|
|
Setting<u8, true> mouse_panning_x_sensitivity{
|
|
linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
|
|
Setting<u8, true> mouse_panning_y_sensitivity{
|
|
linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
|
|
Setting<u8, true> mouse_panning_deadzone_counterweight{
|
|
linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
|
|
Setting<u8, true> mouse_panning_decay_strength{
|
|
linkage, 18, 0, 100, "mouse_panning_decay_strength", Category::Controls};
|
|
Setting<u8, true> mouse_panning_min_decay{
|
|
linkage, 6, 0, 100, "mouse_panning_min_decay", Category::Controls};
|
|
|
|
Setting<bool> emulate_analog_keyboard{linkage, false, "emulate_analog_keyboard",
|
|
Category::Controls};
|
|
Setting<bool> keyboard_enabled{linkage, false, "keyboard_enabled", Category::Controls};
|
|
|
|
Setting<bool> debug_pad_enabled{linkage, false, "debug_pad_enabled", Category::Controls};
|
|
ButtonsRaw debug_pad_buttons;
|
|
AnalogsRaw debug_pad_analogs;
|
|
|
|
TouchscreenInput touchscreen;
|
|
|
|
Setting<std::string> touch_device{linkage, "min_x:100,min_y:50,max_x:1800,max_y:850",
|
|
"touch_device", Category::Controls};
|
|
Setting<int> touch_from_button_map_index{linkage, 0, "touch_from_button_map",
|
|
Category::Controls};
|
|
std::vector<TouchFromButtonMap> touch_from_button_maps;
|
|
|
|
Setting<bool> enable_ring_controller{linkage, true, "enable_ring_controller",
|
|
Category::Controls};
|
|
RingconRaw ringcon_analogs;
|
|
|
|
Setting<bool> enable_ir_sensor{linkage, false, "enable_ir_sensor", Category::Controls};
|
|
Setting<std::string> ir_sensor_device{linkage, "auto", "ir_sensor_device", Category::Controls};
|
|
|
|
Setting<bool> random_amiibo_id{linkage, false, "random_amiibo_id", Category::Controls};
|
|
|
|
// Data Storage
|
|
Setting<bool> use_virtual_sd{linkage, true, "use_virtual_sd", Category::DataStorage};
|
|
Setting<bool> gamecard_inserted{linkage, false, "gamecard_inserted", Category::DataStorage};
|
|
Setting<bool> gamecard_current_game{linkage, false, "gamecard_current_game",
|
|
Category::DataStorage};
|
|
Setting<std::string> gamecard_path{linkage, std::string(), "gamecard_path",
|
|
Category::DataStorage};
|
|
Setting<bool> ext_content_from_game_dirs{linkage, true, "ext_content_from_game_dirs",
|
|
Category::DataStorage};
|
|
std::vector<std::string> external_content_dirs;
|
|
|
|
// Debugging
|
|
bool record_frame_times;
|
|
Setting<bool> use_gdbstub{linkage, false, "use_gdbstub", Category::Debugging};
|
|
Setting<u16> gdbstub_port{linkage, 6543, "gdbstub_port", Category::Debugging};
|
|
Setting<std::string> program_args{linkage, std::string(), "program_args", Category::Debugging};
|
|
Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
|
|
Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
|
|
Setting<bool> dump_shaders{
|
|
linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
|
|
false};
|
|
Setting<bool> dump_macros{
|
|
linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
|
|
Setting<bool> enable_fs_access_log{linkage, false, "enable_fs_access_log", Category::Debugging};
|
|
Setting<bool> reporting_services{
|
|
linkage, false, "reporting_services", Category::Debugging, Specialization::Default, false};
|
|
Setting<bool> quest_flag{linkage, false, "quest_flag", Category::Debugging};
|
|
Setting<bool> use_dev_keys{linkage, false, "use_dev_keys", Category::Debugging};
|
|
Setting<bool> disable_macro_jit{linkage, false, "disable_macro_jit",
|
|
Category::DebuggingGraphics};
|
|
Setting<bool> disable_macro_hle{linkage, false, "disable_macro_hle",
|
|
Category::DebuggingGraphics};
|
|
Setting<bool> extended_logging{
|
|
linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
|
|
Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
|
|
Setting<bool> use_auto_stub{
|
|
linkage, false, "use_auto_stub", Category::Debugging};
|
|
Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
|
|
Category::Debugging};
|
|
Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};
|
|
Setting<bool> disable_web_applet{linkage, true, "disable_web_applet", Category::Debugging};
|
|
|
|
// GPU Logging
|
|
Setting<bool> gpu_logging_enabled{linkage, false, "gpu_logging_enabled", Category::Debugging};
|
|
SwitchableSetting<GpuLogLevel> gpu_log_level{linkage, GpuLogLevel::Standard, "gpu_log_level",
|
|
Category::Debugging};
|
|
Setting<bool> gpu_log_vulkan_calls{linkage, true, "gpu_log_vulkan_calls", Category::Debugging};
|
|
Setting<bool> gpu_log_shader_dumps{linkage, false, "gpu_log_shader_dumps", Category::Debugging};
|
|
Setting<bool> gpu_log_memory_tracking{linkage, true, "gpu_log_memory_tracking",
|
|
Category::Debugging};
|
|
Setting<bool> gpu_log_driver_debug{linkage, true, "gpu_log_driver_debug", Category::Debugging};
|
|
Setting<s32> gpu_log_ring_buffer_size{linkage, 512, "gpu_log_ring_buffer_size",
|
|
Category::Debugging};
|
|
|
|
SwitchableSetting<u16, true> debug_knobs{linkage,
|
|
0,
|
|
0,
|
|
65535,
|
|
"debug_knobs",
|
|
Category::Core,
|
|
Specialization::Countable,
|
|
true,
|
|
true};
|
|
|
|
// Miscellaneous
|
|
Setting<std::string> log_filter{linkage, "*:Info", "log_filter", Category::Miscellaneous};
|
|
Setting<bool> log_flush_line{linkage, false, "flush_line", Category::Miscellaneous, Specialization::Default, true, true};
|
|
Setting<bool> censor_username{linkage, true, "censor_username", Category::Miscellaneous};
|
|
Setting<bool> first_launch{linkage, true, "first_launch", Category::Miscellaneous};
|
|
|
|
// Network
|
|
Setting<std::string> network_interface{linkage, std::string(), "network_interface",
|
|
Category::Network};
|
|
SwitchableSetting<bool> airplane_mode{linkage, false, "airplane_mode", Category::Network};
|
|
|
|
// WebService
|
|
Setting<std::string> web_api_url{linkage, "api.ynet-fun.xyz", "web_api_url",
|
|
Category::WebService};
|
|
Setting<std::string> eden_username{linkage, "Eden", "eden_username",
|
|
Category::WebService};
|
|
Setting<std::string> eden_token{linkage, "",
|
|
"eden_token", Category::WebService};
|
|
|
|
// Add-Ons
|
|
std::map<u64, std::vector<std::string>> disabled_addons;
|
|
|
|
// Per-game overrides
|
|
bool use_squashed_iterated_blend;
|
|
};
|
|
|
|
extern Values values;
|
|
|
|
bool getDebugKnobAt(u8 i);
|
|
|
|
void UpdateGPUAccuracy();
|
|
bool IsGPULevelLow();
|
|
bool IsGPULevelMedium();
|
|
bool IsGPULevelHigh();
|
|
|
|
bool IsDMALevelDefault();
|
|
bool IsDMALevelSafe();
|
|
|
|
bool IsFastmemEnabled();
|
|
void SetNceEnabled(bool is_64bit);
|
|
bool IsNceEnabled();
|
|
|
|
bool IsDockedMode();
|
|
|
|
float Volume();
|
|
|
|
// speed limit ops
|
|
u16 SpeedLimit();
|
|
void SetSpeedMode(const SpeedMode &mode);
|
|
void ToggleStandardMode();
|
|
void ToggleTurboMode();
|
|
void ToggleSlowMode();
|
|
|
|
std::string GetTimeZoneString(TimeZone time_zone);
|
|
|
|
void LogSettings();
|
|
|
|
void TranslateResolutionInfo(ResolutionSetup setup, ResolutionScalingInfo& info);
|
|
void UpdateRescalingInfo();
|
|
|
|
// Restore the global state of all applicable settings in the Values struct
|
|
void RestoreGlobalState(bool is_powered_on);
|
|
|
|
bool IsConfiguringGlobal();
|
|
void SetConfiguringGlobal(bool is_global);
|
|
|
|
} // namespace Settings
|