RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2026-04-20 22:05:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'master' into spu_llvm

Browse source
This commit is contained in:
Elad 2026-04-20 16:39:08 +03:00 • committed by GitHub
commit 5b9638399c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
31 changed files with 735 additions and 371 deletions
Download patch file Download diff file Expand all files Collapse all files

25
.ci/deploy-mac.sh
View file

@ -31,21 +31,18 @@ rm -rf "rpcs3.app/Contents/Frameworks/QtPdf.framework" \
# Download translations
mkdir -p "rpcs3.app/Contents/translations"
ZIP_URL=$(curl -fsSL "https://api.github.com/repos/RPCS3/rpcs3_translations/releases/latest" \
| grep "browser_download_url" \
| grep "RPCS3-languages.zip" \
| cut -d '"' -f 4)
if [ -z "$ZIP_URL" ]; then
echo "Failed to find RPCS3-languages.zip in the latest release. Continuing without translations."
else
echo "Downloading translations from: $ZIP_URL"
curl -L -o translations.zip "$ZIP_URL" || {
echo "Failed to download translations.zip. Continuing without translations."
exit 0
}
unzip -o translations.zip -d "rpcs3.app/Contents/translations" >/dev/null 2>&1 || \
ZIP_URL="https://github.com/RPCS3/rpcs3_translations/releases/latest/download/RPCS3-languages.zip"
echo "Downloading translations from: $ZIP_URL"
if curl -fsSL "$ZIP_URL" -o "translations.zip"; then
echo "Successfully downloaded translations."
if unzip -o translations.zip -d "rpcs3.app/Contents/translations" >/dev/null 2>&1; then
rm -f translations.zip
else
echo "Failed to extract translations.zip. Continuing without translations."
rm -f translations.zip
rm -f translations.zip
fi
else
echo "Warning: Failed to download translations. Skipping..."
fi
# Copy Qt translations manually

30
3rdparty/curl/CMakeLists.txt vendored
View file

@ -7,24 +7,24 @@ if(USE_SYSTEM_CURL)
target_link_libraries(3rdparty_libcurl INTERFACE CURL::libcurl)
else()
message(STATUS "RPCS3: building libcurl + wolfssl submodules")
set(BUILD_CURL_EXE OFF CACHE BOOL "Set to ON to build curl executable.")
set(BUILD_STATIC_CURL OFF CACHE BOOL "Set to ON to build curl executable with static libcurl.")
set(BUILD_STATIC_LIBS ON CACHE BOOL "Set to ON to build static libcurl.")
set(BUILD_SHARED_LIBS OFF CACHE BOOL "Set to ON to build shared libcurl.")
set(BUILD_CURL_EXE OFF CACHE INTERNAL "")
set(BUILD_STATIC_CURL OFF CACHE INTERNAL "")
set(BUILD_STATIC_LIBS ON CACHE INTERNAL "")
set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "")
find_package(WolfSSL REQUIRED)
set(CURL_USE_WOLFSSL ON CACHE BOOL "enable wolfSSL for SSL/TLS")
set(CURL_USE_OPENSSL OFF CACHE BOOL "Use OpenSSL code. Experimental")
set(HTTP_ONLY ON CACHE BOOL "disables all protocols except HTTP (This overrides all CURL_DISABLE_* options)")
set(USE_LIBIDN2 OFF CACHE BOOL "Use libidn2 for IDN support") # Disabled because MacOS CI doesn't work otherwise
set(CURL_CA_PATH "none" CACHE STRING "Location of default CA path. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
option(CURL_DISABLE_INSTALL "Disable installation targets" ON)
set(CURL_USE_WOLFSSL ON CACHE INTERNAL "")
set(CURL_USE_OPENSSL OFF CACHE INTERNAL "")
set(HTTP_ONLY ON CACHE INTERNAL "")
set(USE_LIBIDN2 OFF CACHE INTERNAL "") # Disabled because MacOS CI doesn't work otherwise
set(CURL_CA_PATH "none" CACHE INTERNAL "")
set(CURL_DISABLE_INSTALL ON CACHE INTERNAL "")
if(WIN32)
set(ENABLE_UNICODE ON CACHE BOOL "enable Unicode")
set(ENABLE_UNICODE ON CACHE INTERNAL "")
endif()
set(CURL_USE_LIBSSH2 OFF CACHE BOOL "Use libSSH2")
set(CURL_USE_LIBPSL OFF CACHE BOOL "Use libPSL")
option(BUILD_TESTING "Build tests" OFF)
option(BUILD_EXAMPLES "Build libcurl examples" OFF)
set(CURL_USE_LIBSSH2 OFF CACHE INTERNAL "")
set(CURL_USE_LIBPSL OFF CACHE INTERNAL "")
set(BUILD_TESTING OFF CACHE INTERNAL "")
set(BUILD_EXAMPLES OFF CACHE INTERNAL "")
add_subdirectory(curl EXCLUDE_FROM_ALL)

2
3rdparty/libpng/libpng vendored

@ -1 +1 @@
Subproject commit 95ab3fdca83ea294efd3b092e9a53c5a39886444
Subproject commit 3061454d980de7d53608f594194cfac722721d2a

9
3rdparty/version_check.sh vendored
View file

@ -119,7 +119,8 @@ echo -e "\n\nResult:\n"
# Find the max length of the paths (before '->')
max_len=0
while IFS='->' read -r left _; do
while read -r line; do
left="${line%%->*}"
len=$(echo -n "$left" | wc -c)
if (( len > max_len )); then
max_len=$len
@ -127,8 +128,10 @@ while IFS='->' read -r left _; do
done < "$resultfile"
# Print with padding so '->' lines up
while IFS='->' read -r left right; do
right=$(echo "$right" | sed 's/^[[:space:]]*>*[[:space:]]*//')
while read -r line; do
left="${line%%->*}"
right="${line#*->}"
right=$(echo "$right" | sed 's/^[[:space:]]*//')
printf "%-${max_len}s -> %s\n" "$left" "$right"
done < "$resultfile"

31
3rdparty/wolfssl/CMakeLists.txt vendored
View file

@ -4,23 +4,22 @@ if(USE_SYSTEM_WOLFSSL)
add_library(wolfssl INTERFACE)
target_link_libraries(wolfssl INTERFACE PkgConfig::WolfSSL)
else()
option(WOLFSSL_TLS13 "Enable wolfSSL TLS v1.3 (default: enabled)" OFF)
set(WOLFSSL_SHA3 ON CACHE STRING "Enable wolfSSL SHA-3 support (default: enabled on x86_64/aarch64)")
set(WOLFSSL_SHAKE256 ON CACHE STRING "Enable wolfSSL SHAKE256 support (default: enabled on x86_64/aarch64)")
option(WOLFSSL_BASE64_ENCODE "Enable Base64 encoding (default: enabled on x86_64)" OFF)
option(WOLFSSL_DES3 "Enable DES3 (default: disabled)" ON)
option(WOLFSSL_PWDBASED "Enable PWDBASED (default: disabled)" ON)
option(WOLFSSL_FAST_MATH "Enable fast math ops (default: disabled)" ON)
option(WOLFSSL_EXAMPLES "Enable examples (default: enabled)" OFF)
option(WOLFSSL_CRYPT_TESTS "Enable Crypt Bench/Test (default: enabled)" OFF)
option(WOLFSSL_ASYNC_THREADS "Enable Asynchronous Threading (default: enabled)" OFF)
option(WOLFSSL_BUILD_OUT_OF_TREE "Don't generate files in the source tree (default: yes)" ON)
option(WOLFSSL_SNI "Enable SNI (default: disabled)" ON)
option(WOLFSSL_OPENSSLEXTRA "Enable extra OpenSSL API, size+ (default: disabled)" ON)
option(WOLFSSL_HARDEN "Enable Hardened build, Enables Timing Resistance and Blinding (default: enabled)" OFF)
option(WOLFSSL_ALT_CERT_CHAINS "Enable support for Alternate certification chains (default: disabled)" ON)
set(WOLFSSL_TLS13 OFF CACHE INTERNAL "")
set(WOLFSSL_SHA3 ON CACHE INTERNAL "")
set(WOLFSSL_SHAKE256 ON CACHE INTERNAL "")
set(WOLFSSL_BASE64_ENCODE OFF CACHE INTERNAL "")
set(WOLFSSL_DES3 ON CACHE INTERNAL "")
set(WOLFSSL_PWDBASED ON CACHE INTERNAL "")
set(WOLFSSL_FAST_MATH ON CACHE INTERNAL "")
set(WOLFSSL_EXAMPLES OFF CACHE INTERNAL "")
set(WOLFSSL_CRYPT_TESTS OFF CACHE INTERNAL "")
set(WOLFSSL_ASYNC_THREADS OFF CACHE INTERNAL "")
set(WOLFSSL_BUILD_OUT_OF_TREE ON CACHE INTERNAL "")
set(WOLFSSL_SNI ON CACHE INTERNAL "")
set(WOLFSSL_OPENSSLEXTRA ON CACHE INTERNAL "")
set(WOLFSSL_ALT_CERT_CHAINS ON CACHE INTERNAL "")
add_subdirectory(wolfssl EXCLUDE_FROM_ALL)
target_compile_definitions(wolfssl PUBLIC WOLFSSL_DES_ECB HAVE_WRITE_DUP FP_MAX_BITS=8192 WOLFSSL_NO_OPTIONS_H)
target_compile_definitions(wolfssl PUBLIC WOLFSSL_DES_ECB HAVE_WRITE_DUP FP_MAX_BITS=8192 WOLFSSL_USE_OPTIONS_H)
endif()

75
Utilities/Config.cpp
View file

@ -479,8 +479,9 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
{
case type::node:
{
if (data.IsScalar() || data.IsSequence())
if (!data.IsMap())
{
cfg_log.error("node node is not a map");
return false;
}
@ -491,17 +492,22 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
if (!pair.first.IsScalar()) continue;
// Find the key among existing nodes
for (const auto& node : static_cast<node&>(rhs).get_nodes())
{
if (node->get_name() == pair.first.Scalar())
{
if (!decode(pair.second, *node, dynamic, strict) && strict)
{
success = false;
}
const auto& nodes = static_cast<node&>(rhs).get_nodes();
const auto it = std::find_if(nodes.cbegin(), nodes.cend(), [&pair](const auto& node) { return ensure(node)->get_name() == pair.first.Scalar(); });
break;
if (it == nodes.cend())
{
if (strict)
{
cfg_log.error("Unknown key found: '%s'", pair.first.Scalar());
success = false;
}
continue;
}
if (!decode(pair.second, *ensure(*it), dynamic, strict) && strict)
{
success = false;
}
}
@ -513,7 +519,10 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
if (YAML::convert<decltype(values)>::decode(data, values))
{
rhs.from_list(std::move(values));
if (!rhs.from_list(std::move(values)) && strict)
{
return false;
}
}
break;
@ -523,6 +532,7 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
{
if (!data.IsMap())
{
cfg_log.error("map node is not a map");
return false;
}
@ -540,8 +550,9 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
}
case type::log:
{
if (data.IsScalar() || data.IsSequence())
if (!data.IsMap())
{
cfg_log.error("log node is not a map");
return false;
}
@ -549,7 +560,18 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
for (const auto& pair : data)
{
if (!pair.first.IsScalar() || !pair.second.IsScalar()) continue;
if (!pair.first.IsScalar() || !pair.second.IsScalar())
{
if (strict)
{
if (!pair.first.IsScalar())
cfg_log.error("Key in map is not a scalar");
else
cfg_log.error("Value in map is not a scalar. key='%s'", pair.first.Scalar());
return false;
}
continue;
}
u64 value;
if (!cfg::try_to_enum_value(&value, &fmt_class_string<logs::level>::format, pair.second.Scalar(), pair.first.Scalar()) && strict)
@ -567,6 +589,7 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
{
if (!data.IsMap())
{
cfg_log.error("device node is not a map");
return false;
}
@ -574,13 +597,35 @@ bool cfg::decode(const YAML::Node& data, cfg::_base& rhs, bool dynamic, bool str
for (const auto& pair : data)
{
if (!pair.first.IsScalar() || !pair.second.IsMap()) continue;
if (!pair.first.IsScalar() || !pair.second.IsMap())
{
if (strict)
{
if (!pair.first.IsScalar())
cfg_log.error("Key in device map is not a scalar");
else
cfg_log.error("Value in device map is not a map. key='%s'", pair.first.Scalar());
return false;
}
continue;
}
device_info info{};
for (const auto& key_value : pair.second)
{
if (!key_value.first.IsScalar() || !key_value.second.IsScalar()) continue;
if (!key_value.first.IsScalar() || !key_value.second.IsScalar())
{
if (strict)
{
if (!key_value.first.IsScalar())
cfg_log.error("Key in device info map is not a scalar");
else
cfg_log.error("Value in device map is not a scalar. key='%s'", key_value.first.Scalar());
return false;
}
continue;
}
if (key_value.first.Scalar() == "Path")
info.path = key_value.second.Scalar();

9
rpcs3/Emu/Cell/Modules/cellGame.cpp
View file

@ -520,10 +520,11 @@ error_code cellHddGameCheck(ppu_thread& ppu, u32 version, vm::cptr<char> dirName
return CELL_GAMEDATA_ERROR_PARAM;
}
if (!fs::create_path(vfs::get(usrdir)))
{
return {CELL_GAME_ERROR_ACCESS_ERROR, usrdir};
}
// Nuked until correctly reversed engineered
//if (!fs::create_path(vfs::get(usrdir)))
//{
// return {CELL_GAME_ERROR_ACCESS_ERROR, usrdir};
//}
}
// Nuked until correctly reversed engineered

4
rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
View file

@ -239,7 +239,7 @@ namespace rsx
home_menu_settings_performance_overlay::home_menu_settings_performance_overlay(s16 x, s16 y, u16 width, u16 height, bool use_separators, home_menu_page* parent)
: home_menu_settings_page(x, y, width, height, use_separators, parent, get_localized_string(localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY))
{
add_checkbox(&g_cfg.video.perf_overlay.perf_overlay_enabled, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE);
add_checkbox(&g_cfg.video.perf_overlay.enabled, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE);
add_checkbox(&g_cfg.video.perf_overlay.framerate_graph_enabled, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMERATE_GRAPH);
add_checkbox(&g_cfg.video.perf_overlay.frametime_graph_enabled, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMETIME_GRAPH);
@ -258,7 +258,7 @@ namespace rsx
add_float_slider(&g_cfg.video.perf_overlay.margin_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y, " %", 0.25f);
add_unsigned_slider(&g_cfg.video.perf_overlay.font_size, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE, " px", 1);
add_unsigned_slider(&g_cfg.video.perf_overlay.opacity, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY, " %", 1);
add_checkbox(&g_cfg.video.perf_overlay.perf_overlay_use_window_space, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE);
add_checkbox(&g_cfg.video.perf_overlay.use_window_space, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE);
apply_layout();
}

4
rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
View file

@ -934,7 +934,7 @@ namespace rsx
auto& perf_settings = g_cfg.video.perf_overlay;
auto perf_overlay = manager->get<rsx::overlays::perf_metrics_overlay>();
if (perf_settings.perf_overlay_enabled)
if (perf_settings.enabled)
{
if (!perf_overlay)
{
@ -949,7 +949,7 @@ namespace rsx
perf_overlay->set_font(perf_settings.font);
perf_overlay->set_font_size(perf_settings.font_size);
perf_overlay->set_margins(static_cast<f32>(perf_settings.margin_x.get()), static_cast<f32>(perf_settings.margin_y.get()), perf_settings.center_x.get(), perf_settings.center_y.get());
perf_overlay->use_window_space = perf_settings.perf_overlay_use_window_space.get();
perf_overlay->use_window_space = perf_settings.use_window_space.get();
perf_overlay->set_opacity(perf_settings.opacity / 100.f);
perf_overlay->set_body_colors(perf_settings.color_body, perf_settings.background_body);
perf_overlay->set_title_colors(perf_settings.color_title, perf_settings.background_title);

2
rpcs3/Emu/RSX/RSXThread.cpp
View file

@ -3414,7 +3414,7 @@ namespace rsx
current_display_buffer = buffer;
m_queued_flip.emu_flip = true;
m_queued_flip.in_progress = true;
m_queued_flip.skip_frame |= g_cfg.video.disable_video_output && !g_cfg.video.perf_overlay.perf_overlay_enabled;
m_queued_flip.skip_frame |= g_cfg.video.disable_video_output && !g_cfg.video.perf_overlay.enabled;
flip(m_queued_flip);

33
rpcs3/Emu/System.cpp
View file

@ -933,7 +933,7 @@ game_boot_result Emulator::GetElfPathFromDir(std::string& elf_path, const std::s
return game_boot_result::invalid_file_or_folder;
}
game_boot_result Emulator::BootGame(const std::string& path, const std::string& title_id, bool direct, cfg_mode config_mode, const std::string& config_path, const std::string& db_config)
game_boot_result Emulator::BootGame(const std::string& path, const std::string& title_id, bool direct, cfg_mode config_mode, const std::string& config_path, const std::optional<std::string>& db_config)
{
if (m_restrict_emu_state_change)
{
@ -1565,8 +1565,23 @@ game_boot_result Emulator::Load(const std::string& title_id, bool is_disc_patch,
sys_log.notice("Version: APP_VER=%s VERSION=%s", version_app, version_disc);
{
// We add the database configuration if it is set, unless we are using a mode that specifically selects a different configuration.
bool add_database_config = !m_db_config.empty() && (m_config_mode == cfg_mode::database_config || m_config_mode == cfg_mode::custom || m_config_mode == cfg_mode::continuous);
if (m_config_mode == cfg_mode::database_config || m_config_mode == cfg_mode::custom)
{
if (!m_db_config)
{
// Get database config if possible. This only happens if the database config hasn't been set by the UI (e.g. if booted with no-gui).
// We only know the title_id for sure at this point, so it doesn't make sense to retrieve it earlier.
m_db_config = Emu.GetCallbacks().get_database_config(m_title_id);
}
// We add the database configuration if it is set, unless we are using a mode that specifically selects a different configuration.
m_add_database_config = m_db_config && !m_db_config->empty();
}
else if (m_config_mode != cfg_mode::continuous)
{
// Reset flag unless in continuous mode
m_add_database_config = false;
}
if (m_config_mode == cfg_mode::custom_selection || (m_config_mode == cfg_mode::continuous && !m_config_path.empty()))
{
@ -1610,7 +1625,7 @@ game_boot_result Emulator::Load(const std::string& title_id, bool is_disc_patch,
{
g_cfg.name = config_path;
m_config_path = config_path;
add_database_config = false; // A custom config exists. Do not add the database config.
m_add_database_config = false; // A custom config exists. Do not add the database config.
break;
}
@ -1619,12 +1634,12 @@ game_boot_result Emulator::Load(const std::string& title_id, bool is_disc_patch,
}
}
if (add_database_config)
if (m_add_database_config && m_db_config && !m_db_config->empty())
{
// Add database config
sys_log.notice("Applying database config");
if (g_cfg.from_string(m_db_config))
if (g_cfg.from_string(*m_db_config))
{
g_cfg.name = "database_config";
}
@ -3373,7 +3388,7 @@ void Emulator::Kill(bool allow_autoexit, bool savestate, savestate_stage* save_s
klic.clear();
hdd1.clear();
init_mem_containers = nullptr;
m_db_config.clear();
m_db_config = std::nullopt;
m_config_path.clear();
m_config_mode = cfg_mode::custom;
read_used_savestate_versions();
@ -4018,7 +4033,9 @@ void Emulator::Kill(bool allow_autoexit, bool savestate, savestate_stage* save_s
if (allow_autoexit)
{
Quit(g_cfg.misc.autoexit.get());
const bool autoexit = g_cfg.misc.autoexit.get();
sys_log.notice("Quit with main_window::closeEvent. (autoexit=%d)", autoexit);
Quit(autoexit);
}
if (after_kill_callback)

9
rpcs3/Emu/System.h
View file

@ -115,6 +115,7 @@ struct EmuCallbacks
std::function<void()> check_microphone_permissions;
std::function<std::unique_ptr<class video_source>()> make_video_source;
std::function<void(bool)> enable_gamemode;
std::function<std::string(const std::string&)> get_database_config;
};
namespace utils
@ -146,7 +147,7 @@ class Emulator final
cfg_mode m_config_mode = cfg_mode::custom;
std::string m_config_path;
std::string m_db_config;
std::optional<std::string> m_db_config; // std::nullopt means it has not been retrieved yet
std::string m_path;
std::string m_path_old;
std::string m_path_original;
@ -171,6 +172,7 @@ class Emulator final
bool m_continuous_mode = false;
bool m_has_gui = true;
bool m_add_database_config = false;
bool m_state_inspection_savestate = false;
@ -370,7 +372,8 @@ public:
const std::string& GetUsedDatabaseConfig() const
{
return m_db_config;
static std::string empty_db_config;
return m_db_config ? *m_db_config : empty_db_config;
}
bool IsChildProcess() const
@ -422,7 +425,7 @@ public:
return emulation_state_guard_t{this};
}
game_boot_result BootGame(const std::string& path, const std::string& title_id = "", bool direct = false, cfg_mode config_mode = cfg_mode::custom, const std::string& config_path = "", const std::string& db_config = "");
game_boot_result BootGame(const std::string& path, const std::string& title_id = "", bool direct = false, cfg_mode config_mode = cfg_mode::custom, const std::string& config_path = "", const std::optional<std::string>& db_config = std::nullopt);
bool BootRsxCapture(const std::string& path);
void SetForceBoot(bool force_boot);

6
rpcs3/Emu/system_config.h
View file

@ -198,7 +198,7 @@ struct cfg_root : cfg::node
{
node_perf_overlay(cfg::node* _this) : cfg::node(_this, "Performance Overlay") {}
cfg::_bool perf_overlay_enabled{ this, "Enabled", false, true };
cfg::_bool enabled{ this, "Enabled", false, true };
cfg::_bool framerate_graph_enabled{ this, "Enable Framerate Graph", false, true };
cfg::_bool frametime_graph_enabled{ this, "Enable Frametime Graph", false, true };
cfg::uint<2, 6000> framerate_datapoint_count{ this, "Framerate datapoints", 50, true };
@ -219,7 +219,7 @@ struct cfg_root : cfg::node
cfg::string background_body{ this, "Body Background (hex)", "#002339FF", true };
cfg::string color_title{ this, "Title Color (hex)", "#F26C24FF", true };
cfg::string background_title{ this, "Title Background (hex)", "#00000000", true };
cfg::_bool perf_overlay_use_window_space{this, "Use Window Space", false, true};
cfg::_bool use_window_space{this, "Use Window Space", false, true};
} perf_overlay{ this };
@ -282,7 +282,7 @@ struct cfg_root : cfg::node
cfg::_bool paint_move_spheres{this, "Paint move spheres", false, true};
cfg::_bool allow_move_hue_set_by_game{this, "Allow move hue set by game", false, true};
cfg::_bool lock_overlay_input_to_player_one{this, "Lock overlay input to player one", false, true};
cfg::string midi_devices{this, "Emulated Midi devices", "ßßß@@@ßßß@@@ßßß@@@"};
cfg::string midi_devices{this, "Emulated Midi devices", "Keyboardßßß@@@Keyboardßßß@@@Keyboardßßß@@@"};
cfg::_bool load_sdl_mappings{ this, "Load SDL GameController Mappings", true };
cfg::_bool pad_debug_overlay{ this, "IO Debug overlay", false, true };
cfg::_bool mouse_debug_overlay{ this, "Mouse Debug overlay", false, true };

2
rpcs3/Loader/ISO.cpp
View file

@ -199,7 +199,7 @@ bool iso_file_decryption::init(const std::string& path)
const u32 region_count = char_arr_BE_to_uint(sec0_sec1.data());
// Ensure the region count is a proper value
if (region_count < 1 || region_count > 31) // It's non-PS3ISO
if (region_count < 1 || region_count > 127) // It's non-PS3ISO
{
iso_log.error("init: Failed to read region information: '%s' (region_count=%d)", path, region_count);
return false;

2
rpcs3/headless_application.cpp
View file

@ -58,7 +58,7 @@ void headless_application::InitializeCallbacks()
on_exit();
}
sys_log.notice("Quitting headless application");
sys_log.notice("Quitting headless application (force_quit=%d)", force_quit);
quit();
return true;
}

25
rpcs3/main_application.cpp
View file

@ -2,6 +2,8 @@
#include "main_application.h"
#include "display_sleep_control.h"
#include "gamemode_control.h"
#include "rpcs3qt/gui_settings.h"
#include "rpcs3qt/config_database.h"
#include "util/types.hpp"
#include "util/logs.hpp"
@ -409,5 +411,28 @@ EmuCallbacks main_application::CreateCallbacks()
return path + suffix;
};
callbacks.get_database_config = [](const std::string& title_id)
{
if (title_id.empty())
return std::string();
sys_log.notice("Trying to retrieve database config for: '%s'", title_id);
const auto settings = std::make_shared<gui_settings>();
config_database config_db(settings, nullptr);
config_db.request_config_database(false);
if (!config_db.has_config(title_id))
return std::string();
if (const auto config = config_db.get_config(title_id))
{
sys_log.notice("Found database config for: '%s'", title_id);
return config.value();
}
return std::string();
};
return callbacks;
}

1
rpcs3/rpcs3.vcxproj
View file

@ -837,6 +837,7 @@
<ClCompile Include="rpcs3qt\breakpoint_list.cpp" />
<ClCompile Include="rpcs3qt\call_stack_list.cpp" />
<ClCompile Include="rpcs3qt\camera_settings_dialog.cpp" />
<ClCompile Include="rpcs3qt\emu_settings_type.cpp" />
<ClCompile Include="rpcs3qt\gui_game_info.cpp" />
<ClCompile Include="rpcs3qt\log_level_dialog.cpp" />
<ClCompile Include="rpcs3qt\permissions.cpp" />

3
rpcs3/rpcs3.vcxproj.filters
View file

@ -1299,6 +1299,9 @@
<ClCompile Include="rpcs3qt\steam_utils.cpp">
<Filter>Gui\utils</Filter>
</ClCompile>
<ClCompile Include="rpcs3qt\emu_settings_type.cpp">
<Filter>Gui\settings</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Input\ds4_pad_handler.h">

1
rpcs3/rpcs3qt/CMakeLists.txt
View file

@ -22,6 +22,7 @@ add_library(rpcs3_ui STATIC
dimensions_dialog.cpp
_discord_utils.cpp
emu_settings.cpp
emu_settings_type.cpp
elf_memory_dumping_dialog.cpp
emulated_pad_settings_dialog.cpp
emulated_logitech_g27_settings_dialog.cpp

287
rpcs3/rpcs3qt/config_checker.cpp
View file

@ -1,76 +1,127 @@
#include "stdafx.h"
#include "config_checker.h"
#include "midi_creator.h"
#include "microphone_creator.h"
#include "Emu/system_config.h"
#include "Emu/system_utils.hpp"
#include <QComboBox>
#include <QDialog>
#include <QDialogButtonBox>
#include <QMessageBox>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QLabel>
LOG_CHANNEL(gui_log, "GUI");
config_checker::config_checker(QWidget* parent, const QString& content, bool is_log) : QDialog(parent)
config_checker::config_checker(QWidget* parent, const QString& content_or_serial, checker_mode mode, const std::string& db_config)
: QDialog(parent)
, m_checker_mode(mode)
, m_content_or_serial(content_or_serial)
, m_db_config(db_config)
{
setObjectName("config_checker");
setWindowTitle(tr("Config Checker"));
setAttribute(Qt::WA_DeleteOnClose);
QVBoxLayout* layout = new QVBoxLayout();
QLabel* label = new QLabel(this);
layout->addWidget(label);
QComboBox* combo = nullptr;
QString result;
if (check_config(content, result, is_log))
if (mode == checker_mode::gamelist)
{
setWindowTitle(tr("Interesting!"));
m_serial = content_or_serial.toStdString();
if (result.isEmpty())
combo = new QComboBox(this);
std::string custom_config_path;
if (std::string config_path = rpcs3::utils::get_custom_config_path(m_serial); fs::is_file(config_path))
{
label->setText(tr("Found config.\nIt seems to match the default config."));
custom_config_path = std::move(config_path);
combo->addItem(tr("Custom Configuration"), static_cast<int>(cfg_mode::custom));
}
else
combo->addItem(tr("Database + Global Configuration"), static_cast<int>(cfg_mode::database_config));
combo->setCurrentIndex(combo->findData(static_cast<int>(custom_config_path.empty() ? cfg_mode::database_config : cfg_mode::custom)));
connect(combo, &QComboBox::currentIndexChanged, this, [this, combo]()
{
label->setText(tr("Found config.\nSome settings seem to deviate from the default config:"));
check_config(static_cast<cfg_mode>(combo->currentData().toInt()));
});
QTextEdit* text_box = new QTextEdit();
text_box->setReadOnly(true);
text_box->setHtml(result);
layout->addWidget(text_box);
layout->addWidget(combo);
}
resize(400, 600);
}
}
else
{
setWindowTitle(tr("Ooops!"));
label->setText(result);
}
m_label = new QLabel(this);
layout->addWidget(m_label);
m_text_box = new QTextEdit();
m_text_box->setReadOnly(true);
layout->addWidget(m_text_box);
QDialogButtonBox* box = new QDialogButtonBox(QDialogButtonBox::Close);
connect(box, &QDialogButtonBox::rejected, this, &QDialog::reject);
layout->addWidget(box);
setLayout(layout);
resize(400, 600);
check_config(combo ? static_cast<cfg_mode>(combo->currentData().toInt()) : cfg_mode::database_config);
}
bool config_checker::check_config(QString content, QString& result, bool is_log)
void config_checker::check_config(cfg_mode mode)
{
cfg_root config{};
QString result;
if (is_log)
if (check_config(mode, m_content_or_serial, result))
{
if (m_checker_mode == checker_mode::gamelist)
{
if (result.isEmpty())
{
m_label->setText(tr("The configuration seems to match the default config."));
}
else
{
m_label->setText(tr("Config database settings are marked with an * in front of the name.\nSome settings seem to deviate from the default config:"));
}
}
else
{
if (result.isEmpty())
{
m_label->setText(tr("Found config.\nIt seems to match the default config."));
}
else
{
m_label->setText(tr("Found config.\nSome settings seem to deviate from the default config:"));
}
}
m_text_box->setVisible(!result.isEmpty());
m_text_box->setHtml(result);
}
else
{
m_label->setText(result);
}
}
bool config_checker::check_config(cfg_mode mode, QString content_or_serial, QString& result)
{
std::unique_ptr<cfg_root> config = std::make_unique<cfg_root>();
std::unique_ptr<cfg_root> config_db_only;
if (m_checker_mode == checker_mode::log)
{
const QString start_token = "SYS: Used configuration:\n";
const QString end_token = "\n·";
qsizetype start = content.indexOf(start_token);
qsizetype start = content_or_serial.indexOf(start_token);
qsizetype end = -1;
if (start >= 0)
{
start += start_token.size();
end = content.indexOf(end_token, start);
end = content_or_serial.indexOf(end_token, start);
}
if (end < 0)
@ -79,24 +130,93 @@ bool config_checker::check_config(QString content, QString& result, bool is_log)
return false;
}
content = content.mid(start, end - start);
content_or_serial = content_or_serial.mid(start, end - start);
}
if (!config.from_string(content.toStdString()))
if (m_checker_mode == checker_mode::gamelist)
{
gui_log.error("log_viewer: Failed to parse config:\n%s", content);
config->from_default();
// Load global config
const std::string cfg_path = fs::get_config_dir(true) + "config.yml";
if (const fs::file cfg_file{cfg_path})
{
gui_log.notice("config_checker: Applying global config: %s", cfg_path);
if (!config->from_string(cfg_file.to_string()))
{
gui_log.error("config_checker: Failed to apply global config: %s", cfg_path);
result = tr("Failed to apply global config!");
return false;
}
}
// Load custom config
const std::string custom_config_path = rpcs3::utils::get_custom_config_path(m_serial);
if (mode == cfg_mode::custom && !custom_config_path.empty())
{
if (const fs::file cfg_file{custom_config_path})
{
gui_log.notice("config_checker: Applying custom config: %s", custom_config_path);
if (!config->from_string(cfg_file.to_string()))
{
gui_log.error("config_checker: Failed to apply custom config: %s", custom_config_path);
result = tr("Failed to apply custom config!");
return false;
}
}
}
if (mode == cfg_mode::database_config && !m_db_config.empty())
{
gui_log.notice("config_checker: Applying database config: %s", custom_config_path);
if (!config->from_string(m_db_config))
{
gui_log.error("config_checker: Failed to apply database config:\n%s", m_db_config);
result = tr("Failed to apply database config!");
return false;
}
config_db_only = std::make_unique<cfg_root>();
config_db_only->from_default();
if (!config_db_only->from_string(m_db_config))
{
gui_log.error("config_checker: Failed to apply database config:\n%s", m_db_config);
result = tr("Failed to apply database config!");
return false;
}
}
}
else if (!config->from_string(content_or_serial.toStdString()))
{
gui_log.error("config_checker: Failed to parse config:\n%s", content_or_serial);
result = tr("Cannot find any config!");
return false;
}
std::function<void(const cfg::_base*, std::string&, int)> print_diff_recursive;
print_diff_recursive = [&print_diff_recursive](const cfg::_base* base, std::string& diff, int indentation) -> void
std::function<void(const cfg::_base*, const cfg::_base*, std::string&, int)> print_diff_recursive;
print_diff_recursive = [this, &print_diff_recursive, &config](const cfg::_base* base, const cfg::_base* base_db_only, std::string& diff, int indentation) -> void
{
if (!base)
{
return;
}
// Ignore some irrelevant settings in gamelist mode
if (m_checker_mode == checker_mode::gamelist && base->get_type() != cfg::type::node)
{
const std::string key = base->get_name();
if (key == config->sys.console_psid.get_name() ||
key == config->sys.system_name.get_name() ||
key == config->video.vk.adapter.get_name())
{
return;
}
}
const auto indent = [](std::string& str, int indentation)
{
for (int i = 0; i < indentation * 2; i++)
@ -105,6 +225,16 @@ bool config_checker::check_config(QString content, QString& result, bool is_log)
}
};
const auto base_name_db = [base](bool is_db_config)
{
if (is_db_config)
{
return "*" + base->get_name();
}
return base->get_name();
};
switch (base->get_type())
{
case cfg::type::node:
@ -115,7 +245,20 @@ bool config_checker::check_config(QString content, QString& result, bool is_log)
for (const auto& n : node->get_nodes())
{
print_diff_recursive(n, diff_tmp, indentation + 1);
const cfg::_base* n_db_only = nullptr;
if (const auto& node_db_only = static_cast<const cfg::node*>(base_db_only))
{
for (const auto& n_db : node_db_only->get_nodes())
{
if (n_db->get_name() == n->get_name())
{
n_db_only = n_db;
break;
}
}
}
print_diff_recursive(n, n_db_only, diff_tmp, indentation + 1);
}
if (!diff_tmp.empty())
@ -142,19 +285,75 @@ bool config_checker::check_config(QString content, QString& result, bool is_log)
const std::string val = base->to_string();
const std::string def = base->def_to_string();
if (val != def)
{
indent(diff, indentation);
if (val == def)
break;
if (def.empty())
indent(diff, indentation);
if (m_checker_mode == checker_mode::gamelist)
{
if (base->get_name() == config->io.midi_devices.get_name())
{
fmt::append(diff, "%s: <span style=\"color:red;\">%s</span><br>", base->get_name(), val);
fmt::append(diff, "%s:<br>", base->get_name());
midi_creator mc {};
mc.parse_devices(def);
const std::array<midi_device, max_midi_devices> def_devices = mc.get_selection_list();
mc.parse_devices(val);
const std::array<midi_device, max_midi_devices> devices = mc.get_selection_list();
for (usz i = 0; i < devices.size(); i++)
{
const midi_device& def_device = def_devices[i];
const midi_device& device = devices[i];
if (device.name == def_device.name)
continue;
indent(diff, indentation + 1);
fmt::append(diff, "Device %d: <span style=\"color:red;\">%s: %s</span><br>", i + 1, device.type, device.name);
}
break;
}
else
else if (base->get_name() == config->audio.microphone_devices.get_name())
{
fmt::append(diff, "%s: <span style=\"color:red;\">%s</span> <span style=\"color:gray;\">default:</span> <span style=\"color:green;\">%s</span><br>", base->get_name(), val, def);
fmt::append(diff, "%s:<br>", base->get_name());
microphone_creator mc {};
mc.parse_devices(def);
const std::array<std::string, 4> def_devices = mc.get_selection_list();
mc.parse_devices(val);
const std::array<std::string, 4> devices = mc.get_selection_list();
for (usz i = 0; i < devices.size(); i++)
{
const std::string& def_device = def_devices[i];
const std::string& device = devices[i];
if (device == def_device)
continue;
indent(diff, indentation + 1);
fmt::append(diff, "Device %d: <span style=\"color:red;\">%s</span><br>", i + 1, device);
}
break;
}
}
const bool is_db_config = base_db_only && base_db_only->to_string() != def;
if (def.empty())
{
fmt::append(diff, "%s: <span style=\"color:red;\">%s</span><br>", base_name_db(is_db_config), val);
}
else
{
fmt::append(diff, "%s: <span style=\"color:red;\">%s</span> <span style=\"color:gray;\">default:</span> <span style=\"color:green;\">%s</span><br>", base_name_db(is_db_config), val, def);
}
break;
}
case cfg::type::set:
@ -208,7 +407,7 @@ bool config_checker::check_config(QString content, QString& result, bool is_log)
};
std::string diff;
print_diff_recursive(&config, diff, 0);
print_diff_recursive(config.get(), config_db_only.get(), diff, 0);
result = QString::fromStdString(diff);
return true;

25
rpcs3/rpcs3qt/config_checker.h
View file

@ -1,13 +1,34 @@
#pragma once
#include "Emu/config_mode.h"
#include <QDialog>
#include <QLabel>
#include <QTextEdit>
class config_checker : public QDialog
{
Q_OBJECT
public:
config_checker(QWidget* parent, const QString& path, bool is_log);
enum class checker_mode
{
config,
log,
gamelist
};
bool check_config(QString content, QString& result, bool is_log);
config_checker(QWidget* parent, const QString& content_or_serial, checker_mode mode, const std::string& db_config = {});
private:
void check_config(cfg_mode mode);
bool check_config(cfg_mode mode, QString content_or_serial, QString& result);
QLabel* m_label = nullptr;
QTextEdit* m_text_box = nullptr;
checker_mode m_checker_mode = checker_mode::config;
QString m_content_or_serial;
std::string m_db_config;
std::string m_serial;
};

4
rpcs3/rpcs3qt/downloader.cpp
View file

@ -103,7 +103,7 @@ void downloader::start(const std::string& url, bool follow_location, bool show_p
{
if (m_curl_abort)
{
network_log.notice("Download aborted");
network_log.notice("Download aborted (url='%s')", url);
return;
}
@ -114,7 +114,7 @@ void downloader::start(const std::string& url, bool follow_location, bool show_p
if (m_curl_success)
{
network_log.notice("Download finished");
network_log.notice("Download finished (url='%s')", url);
if (check_return_code && m_download_attempts < 3)
{

2
rpcs3/rpcs3qt/emu_settings.cpp
View file

@ -1531,7 +1531,7 @@ QString emu_settings::GetLocalizedSetting(const QString& original, emu_settings_
std::string type_string;
if (const auto it = settings_location.find(type); it != settings_location.cend())
{
for (const char* loc : it->second)
for (const std::string& loc : it->second)
{
if (!type_string.empty()) type_string += ": ";
type_string += loc;

240
rpcs3/rpcs3qt/emu_settings_type.cpp Normal file
View file

@ -0,0 +1,240 @@
#include "stdafx.h"
#include "emu_settings_type.h"
#include "Emu/system_config.h"
const cfg_root local_cfg {}; // Local config to ensure we have an initialized object
cfg_location get_cfg_location(const cfg::_base& leaf)
{
cfg_location loc {};
loc.push_back(leaf.get_name());
for (const cfg::_base* node = leaf.get_parent(); node && !node->get_name().empty(); node = node->get_parent())
{
loc.push_front(node->get_name());
}
return loc;
}
const std::map<emu_settings_type, cfg_location> settings_location =
{
// Core Tab
{ emu_settings_type::PPUDecoder, get_cfg_location(local_cfg.core.ppu_decoder) },
{ emu_settings_type::SPUDecoder, get_cfg_location(local_cfg.core.spu_decoder) },
{ emu_settings_type::HookStaticFuncs, get_cfg_location(local_cfg.core.hook_functions) },
{ emu_settings_type::ThreadSchedulerMode, get_cfg_location(local_cfg.core.thread_scheduler) },
{ emu_settings_type::SPULoopDetection, get_cfg_location(local_cfg.core.spu_loop_detection) },
{ emu_settings_type::PreferredSPUThreads, get_cfg_location(local_cfg.core.preferred_spu_threads) },
{ emu_settings_type::PPUDebug, get_cfg_location(local_cfg.core.ppu_debug) },
{ emu_settings_type::SPUDebug, get_cfg_location(local_cfg.core.spu_debug) },
{ emu_settings_type::MFCDebug, get_cfg_location(local_cfg.core.mfc_debug) },
{ emu_settings_type::MaxLLVMThreads, get_cfg_location(local_cfg.core.llvm_threads) },
{ emu_settings_type::LLVMPrecompilation, get_cfg_location(local_cfg.core.llvm_precompilation) },
{ emu_settings_type::AccurateSpuDMA, get_cfg_location(local_cfg.core.spu_accurate_dma) },
{ emu_settings_type::AccurateClineStores, get_cfg_location(local_cfg.core.accurate_cache_line_stores) },
{ emu_settings_type::AccurateRSXAccess, get_cfg_location(local_cfg.core.rsx_accurate_res_access) },
{ emu_settings_type::FIFOAccuracy, get_cfg_location(local_cfg.core.rsx_fifo_accuracy) },
{ emu_settings_type::XFloatAccuracy, get_cfg_location(local_cfg.core.spu_xfloat_accuracy) },
{ emu_settings_type::MFCCommandsShuffling, get_cfg_location(local_cfg.core.mfc_transfers_shuffling) },
{ emu_settings_type::SetDAZandFTZ, get_cfg_location(local_cfg.core.set_daz_and_ftz) },
{ emu_settings_type::SPUBlockSize, get_cfg_location(local_cfg.core.spu_block_size) },
{ emu_settings_type::SPUCache, get_cfg_location(local_cfg.core.spu_cache) },
{ emu_settings_type::DebugConsoleMode, get_cfg_location(local_cfg.core.debug_console_mode) },
{ emu_settings_type::MaxSPURSThreads, get_cfg_location(local_cfg.core.max_spurs_threads) },
{ emu_settings_type::SleepTimersAccuracy, get_cfg_location(local_cfg.core.sleep_timers_accuracy) },
{ emu_settings_type::ClocksScale, get_cfg_location(local_cfg.core.clocks_scale) },
{ emu_settings_type::AccuratePPU128Loop, get_cfg_location(local_cfg.core.ppu_128_reservations_loop_max_length) },
{ emu_settings_type::PerformanceReport, get_cfg_location(local_cfg.core.perf_report) },
{ emu_settings_type::NumPPUThreads, get_cfg_location(local_cfg.core.ppu_threads) },
{ emu_settings_type::PPUNJFixup, get_cfg_location(local_cfg.core.ppu_llvm_nj_fixup) },
{ emu_settings_type::PPUVNANFixup, get_cfg_location(local_cfg.core.ppu_fix_vnan) },
{ emu_settings_type::AccurateDFMA, get_cfg_location(local_cfg.core.use_accurate_dfma) },
{ emu_settings_type::AccuratePPUSAT, get_cfg_location(local_cfg.core.ppu_set_sat_bit) },
{ emu_settings_type::AccuratePPUNJ, get_cfg_location(local_cfg.core.ppu_use_nj_bit) },
{ emu_settings_type::AccuratePPUVNAN, get_cfg_location(local_cfg.core.ppu_set_vnan) },
{ emu_settings_type::AccuratePPUFPCC, get_cfg_location(local_cfg.core.ppu_set_fpcc) },
{ emu_settings_type::MaxPreemptCount, get_cfg_location(local_cfg.core.max_cpu_preempt_count_per_frame) },
{ emu_settings_type::SPUProfiler, get_cfg_location(local_cfg.core.spu_prof) },
{ emu_settings_type::DisableSpinOptimization, get_cfg_location(local_cfg.core.spu_getllar_spin_optimization_disabled) },
{ emu_settings_type::EnabledSPUEventsBusyLoop, get_cfg_location(local_cfg.core.spu_reservation_busy_waiting_enabled) },
// Graphics Tab
{ emu_settings_type::Renderer, get_cfg_location(local_cfg.video.renderer) },
{ emu_settings_type::Resolution, get_cfg_location(local_cfg.video.resolution) },
{ emu_settings_type::AspectRatio, get_cfg_location(local_cfg.video.aspect_ratio) },
{ emu_settings_type::FrameLimit, get_cfg_location(local_cfg.video.frame_limit) },
{ emu_settings_type::MSAA, get_cfg_location(local_cfg.video.antialiasing_level) },
{ emu_settings_type::LogShaderPrograms, get_cfg_location(local_cfg.video.log_programs) },
{ emu_settings_type::WriteDepthBuffer, get_cfg_location(local_cfg.video.write_depth_buffer) },
{ emu_settings_type::WriteColorBuffers, get_cfg_location(local_cfg.video.write_color_buffers) },
{ emu_settings_type::ReadColorBuffers, get_cfg_location(local_cfg.video.read_color_buffers) },
{ emu_settings_type::ReadDepthBuffer, get_cfg_location(local_cfg.video.read_depth_buffer) },
{ emu_settings_type::HandleRSXTiledMemory, get_cfg_location(local_cfg.video.handle_tiled_memory) },
{ emu_settings_type::VSync, get_cfg_location(local_cfg.video.vsync) },
{ emu_settings_type::DebugOutput, get_cfg_location(local_cfg.video.debug_output) },
{ emu_settings_type::DebugOverlay, get_cfg_location(local_cfg.video.debug_overlay) },
{ emu_settings_type::RenderdocCompatibility, get_cfg_location(local_cfg.video.renderdoc_compatiblity) },
{ emu_settings_type::GPUTextureScaling, get_cfg_location(local_cfg.video.use_gpu_texture_scaling) },
{ emu_settings_type::StretchToDisplayArea, get_cfg_location(local_cfg.video.stretch_to_display_area) },
{ emu_settings_type::ForceHighpZ, get_cfg_location(local_cfg.video.force_high_precision_z_buffer) },
{ emu_settings_type::StrictRenderingMode, get_cfg_location(local_cfg.video.strict_rendering_mode) },
{ emu_settings_type::DisableVertexCache, get_cfg_location(local_cfg.video.disable_vertex_cache) },
{ emu_settings_type::DisableOcclusionQueries, get_cfg_location(local_cfg.video.disable_zcull_queries) },
{ emu_settings_type::DisableVideoOutput, get_cfg_location(local_cfg.video.disable_video_output) },
{ emu_settings_type::DisableFIFOReordering, get_cfg_location(local_cfg.video.disable_FIFO_reordering) },
{ emu_settings_type::StereoRenderEnabled, get_cfg_location(local_cfg.video.stereo_enabled) },
{ emu_settings_type::StereoRenderMode, get_cfg_location(local_cfg.video.stereo_render_mode) },
{ emu_settings_type::ScreenSize, get_cfg_location(local_cfg.video.screen_size) },
{ emu_settings_type::StrictTextureFlushing, get_cfg_location(local_cfg.video.strict_texture_flushing) },
{ emu_settings_type::ForceCPUBlitEmulation, get_cfg_location(local_cfg.video.force_cpu_blit_processing) },
{ emu_settings_type::DisableOnDiskShaderCache, get_cfg_location(local_cfg.video.disable_on_disk_shader_cache) },
{ emu_settings_type::DisableVulkanMemAllocator, get_cfg_location(local_cfg.video.disable_vulkan_mem_allocator) },
{ emu_settings_type::ShaderMode, get_cfg_location(local_cfg.video.shadermode) },
{ emu_settings_type::ShaderCompilerNumThreads, get_cfg_location(local_cfg.video.shader_compiler_threads_count) },
{ emu_settings_type::ShaderPrecisionQuality, get_cfg_location(local_cfg.video.shader_precision) },
{ emu_settings_type::MultithreadedRSX, get_cfg_location(local_cfg.video.multithreaded_rsx) },
{ emu_settings_type::RelaxedZCULL, get_cfg_location(local_cfg.video.relaxed_zcull_sync) },
{ emu_settings_type::PreciseZCULL, get_cfg_location(local_cfg.video.precise_zpass_count) },
{ emu_settings_type::AnisotropicFilterOverride, get_cfg_location(local_cfg.video.anisotropic_level_override) },
{ emu_settings_type::TextureLodBias, get_cfg_location(local_cfg.video.texture_lod_bias) },
{ emu_settings_type::ResolutionScale, get_cfg_location(local_cfg.video.resolution_scale_percent) },
{ emu_settings_type::MinimumScalableDimension, get_cfg_location(local_cfg.video.min_scalable_dimension) },
{ emu_settings_type::VBlankRate, get_cfg_location(local_cfg.video.vblank_rate) },
{ emu_settings_type::VBlankNTSCFixup, get_cfg_location(local_cfg.video.vblank_ntsc) },
{ emu_settings_type::DriverWakeUpDelay, get_cfg_location(local_cfg.video.driver_wakeup_delay) },
{ emu_settings_type::AllowHostGPULabels, get_cfg_location(local_cfg.video.host_label_synchronization) },
{ emu_settings_type::DisableMSLFastMath, get_cfg_location(local_cfg.video.disable_msl_fast_math) },
{ emu_settings_type::OutputScalingMode, get_cfg_location(local_cfg.video.output_scaling) },
{ emu_settings_type::ForceHwMSAAResolve, get_cfg_location(local_cfg.video.force_hw_MSAA_resolve) },
{ emu_settings_type::DisableAsyncHostMM, get_cfg_location(local_cfg.video.disable_async_host_memory_manager) },
{ emu_settings_type::RecordWithOverlays, get_cfg_location(local_cfg.video.record_with_overlays) },
{ emu_settings_type::DisableHWTexelRemapping, get_cfg_location(local_cfg.video.disable_hardware_texel_remapping) },
{ emu_settings_type::FsrSharpeningStrength, get_cfg_location(local_cfg.video.rcas_sharpening_intensity) },
// Vulkan
{ emu_settings_type::VulkanAdapter, get_cfg_location(local_cfg.video.vk.adapter) },
{ emu_settings_type::VulkanAsyncTextureUploads, get_cfg_location(local_cfg.video.vk.asynchronous_texture_streaming) },
{ emu_settings_type::VulkanAsyncSchedulerDriver, get_cfg_location(local_cfg.video.vk.asynchronous_scheduler) },
{ emu_settings_type::ExclusiveFullscreenMode, get_cfg_location(local_cfg.video.vk.exclusive_fullscreen_mode) },
{ emu_settings_type::UseReBAR, get_cfg_location(local_cfg.video.vk.use_rebar_upload_heap) },
// Performance Overlay
{ emu_settings_type::PerfOverlayEnabled, get_cfg_location(local_cfg.video.perf_overlay.enabled) },
{ emu_settings_type::PerfOverlayFramerateGraphEnabled, get_cfg_location(local_cfg.video.perf_overlay.framerate_graph_enabled) },
{ emu_settings_type::PerfOverlayFrametimeGraphEnabled, get_cfg_location(local_cfg.video.perf_overlay.frametime_graph_enabled) },
{ emu_settings_type::PerfOverlayFramerateDatapoints, get_cfg_location(local_cfg.video.perf_overlay.framerate_datapoint_count) },
{ emu_settings_type::PerfOverlayFrametimeDatapoints, get_cfg_location(local_cfg.video.perf_overlay.frametime_datapoint_count) },
{ emu_settings_type::PerfOverlayDetailLevel, get_cfg_location(local_cfg.video.perf_overlay.level) },
{ emu_settings_type::PerfOverlayFramerateDetailLevel, get_cfg_location(local_cfg.video.perf_overlay.framerate_graph_detail_level) },
{ emu_settings_type::PerfOverlayFrametimeDetailLevel, get_cfg_location(local_cfg.video.perf_overlay.frametime_graph_detail_level) },
{ emu_settings_type::PerfOverlayPosition, get_cfg_location(local_cfg.video.perf_overlay.position) },
{ emu_settings_type::PerfOverlayUpdateInterval, get_cfg_location(local_cfg.video.perf_overlay.update_interval) },
{ emu_settings_type::PerfOverlayFontSize, get_cfg_location(local_cfg.video.perf_overlay.font_size) },
{ emu_settings_type::PerfOverlayOpacity, get_cfg_location(local_cfg.video.perf_overlay.opacity) },
{ emu_settings_type::PerfOverlayMarginX, get_cfg_location(local_cfg.video.perf_overlay.margin_x) },
{ emu_settings_type::PerfOverlayMarginY, get_cfg_location(local_cfg.video.perf_overlay.margin_y) },
{ emu_settings_type::PerfOverlayCenterX, get_cfg_location(local_cfg.video.perf_overlay.center_x) },
{ emu_settings_type::PerfOverlayCenterY, get_cfg_location(local_cfg.video.perf_overlay.center_y) },
{ emu_settings_type::PerfOverlayUseWindowSpace, get_cfg_location(local_cfg.video.perf_overlay.use_window_space) },
// Shader Loading Dialog
{ emu_settings_type::ShaderLoadBgEnabled, get_cfg_location(local_cfg.video.shader_preloading_dialog.use_custom_background) },
{ emu_settings_type::ShaderLoadBgDarkening, get_cfg_location(local_cfg.video.shader_preloading_dialog.darkening_strength) },
{ emu_settings_type::ShaderLoadBgBlur, get_cfg_location(local_cfg.video.shader_preloading_dialog.blur_strength) },
// Audio
{ emu_settings_type::AudioRenderer, get_cfg_location(local_cfg.audio.renderer) },
{ emu_settings_type::DumpToFile, get_cfg_location(local_cfg.audio.dump_to_file) },
{ emu_settings_type::ConvertTo16Bit, get_cfg_location(local_cfg.audio.convert_to_s16) },
{ emu_settings_type::AudioFormat, get_cfg_location(local_cfg.audio.format) },
{ emu_settings_type::AudioFormats, get_cfg_location(local_cfg.audio.formats) },
{ emu_settings_type::AudioProvider, get_cfg_location(local_cfg.audio.provider) },
{ emu_settings_type::AudioAvport, get_cfg_location(local_cfg.audio.rsxaudio_port) },
{ emu_settings_type::AudioDevice, get_cfg_location(local_cfg.audio.audio_device) },
{ emu_settings_type::AudioChannelLayout, get_cfg_location(local_cfg.audio.channel_layout) },
{ emu_settings_type::MasterVolume, get_cfg_location(local_cfg.audio.volume) },
{ emu_settings_type::EnableBuffering, get_cfg_location(local_cfg.audio.enable_buffering) },
{ emu_settings_type::AudioBufferDuration, get_cfg_location(local_cfg.audio.desired_buffer_duration) },
{ emu_settings_type::EnableTimeStretching, get_cfg_location(local_cfg.audio.enable_time_stretching) },
{ emu_settings_type::TimeStretchingThreshold, get_cfg_location(local_cfg.audio.time_stretching_threshold) },
{ emu_settings_type::MicrophoneType, get_cfg_location(local_cfg.audio.microphone_type) },
{ emu_settings_type::MicrophoneDevices, get_cfg_location(local_cfg.audio.microphone_devices) },
{ emu_settings_type::MusicHandler, get_cfg_location(local_cfg.audio.music) },
// Input / Output
{ emu_settings_type::BackgroundInput, get_cfg_location(local_cfg.io.background_input_enabled) },
{ emu_settings_type::ShowMoveCursor, get_cfg_location(local_cfg.io.show_move_cursor) },
{ emu_settings_type::LockOvlIptToP1, get_cfg_location(local_cfg.io.lock_overlay_input_to_player_one) },
{ emu_settings_type::PadHandlerMode, get_cfg_location(local_cfg.io.pad_mode) },
{ emu_settings_type::PadConnection, get_cfg_location(local_cfg.io.keep_pads_connected) },
{ emu_settings_type::KeyboardHandler, get_cfg_location(local_cfg.io.keyboard) },
{ emu_settings_type::MouseHandler, get_cfg_location(local_cfg.io.mouse) },
{ emu_settings_type::Camera, get_cfg_location(local_cfg.io.camera) },
{ emu_settings_type::CameraType, get_cfg_location(local_cfg.io.camera_type) },
{ emu_settings_type::CameraFlip, get_cfg_location(local_cfg.io.camera_flip_option) },
{ emu_settings_type::CameraID, get_cfg_location(local_cfg.io.camera_id) },
{ emu_settings_type::Move, get_cfg_location(local_cfg.io.move) },
{ emu_settings_type::Buzz, get_cfg_location(local_cfg.io.buzz) },
{ emu_settings_type::Turntable, get_cfg_location(local_cfg.io.turntable) },
{ emu_settings_type::GHLtar, get_cfg_location(local_cfg.io.ghltar) },
{ emu_settings_type::MidiDevices, get_cfg_location(local_cfg.io.midi_devices) },
{ emu_settings_type::SDLMappings, get_cfg_location(local_cfg.io.load_sdl_mappings) },
{ emu_settings_type::IoDebugOverlay, get_cfg_location(local_cfg.io.pad_debug_overlay) },
{ emu_settings_type::MouseDebugOverlay, get_cfg_location(local_cfg.io.mouse_debug_overlay) },
// Misc
{ emu_settings_type::ExitRPCS3OnFinish, get_cfg_location(local_cfg.misc.autoexit) },
{ emu_settings_type::StartOnBoot, get_cfg_location(local_cfg.misc.autostart) },
{ emu_settings_type::PauseOnFocusLoss, get_cfg_location(local_cfg.misc.autopause) },
{ emu_settings_type::StartGameFullscreen, get_cfg_location(local_cfg.misc.start_fullscreen) },
{ emu_settings_type::PreventDisplaySleep, get_cfg_location(local_cfg.misc.prevent_display_sleep) },
{ emu_settings_type::ShowTrophyPopups, get_cfg_location(local_cfg.misc.show_trophy_popups) },
{ emu_settings_type::ShowRpcnPopups, get_cfg_location(local_cfg.misc.show_rpcn_popups) },
{ emu_settings_type::UseNativeInterface, get_cfg_location(local_cfg.misc.use_native_interface) },
{ emu_settings_type::ShowShaderCompilationHint, get_cfg_location(local_cfg.misc.show_shader_compilation_hint) },
{ emu_settings_type::ShowPPUCompilationHint, get_cfg_location(local_cfg.misc.show_ppu_compilation_hint) },
{ emu_settings_type::ShowAutosaveAutoloadHint, get_cfg_location(local_cfg.misc.show_autosave_autoload_hint) },
{ emu_settings_type::ShowPressureIntensityToggleHint, get_cfg_location(local_cfg.misc.show_pressure_intensity_toggle_hint) },
{ emu_settings_type::ShowAnalogLimiterToggleHint, get_cfg_location(local_cfg.misc.show_analog_limiter_toggle_hint) },
{ emu_settings_type::ShowMouseAndKeyboardToggleHint, get_cfg_location(local_cfg.misc.show_mouse_and_keyboard_toggle_hint) },
{ emu_settings_type::ShowFatalErrorHints, get_cfg_location(local_cfg.misc.show_fatal_error_hints) },
{ emu_settings_type::ShowCaptureHints, get_cfg_location(local_cfg.misc.show_capture_hints) },
{ emu_settings_type::SilenceAllLogs, get_cfg_location(local_cfg.misc.silence_all_logs) },
{ emu_settings_type::WindowTitleFormat, get_cfg_location(local_cfg.misc.title_format) },
{ emu_settings_type::PauseDuringHomeMenu, get_cfg_location(local_cfg.misc.pause_during_home_menu) },
{ emu_settings_type::PlayMusicDuringBoot, get_cfg_location(local_cfg.misc.play_music_during_boot) },
{ emu_settings_type::EnableGamemode, get_cfg_location(local_cfg.misc.enable_gamemode) },
// Networking
{ emu_settings_type::InternetStatus, get_cfg_location(local_cfg.net.net_active) },
{ emu_settings_type::DNSAddress, get_cfg_location(local_cfg.net.dns) },
{ emu_settings_type::IpSwapList, get_cfg_location(local_cfg.net.swap_list) },
{ emu_settings_type::PSNStatus, get_cfg_location(local_cfg.net.psn_status) },
{ emu_settings_type::BindAddress, get_cfg_location(local_cfg.net.bind_address) },
{ emu_settings_type::EnableUpnp, get_cfg_location(local_cfg.net.upnp_enabled) },
{ emu_settings_type::PSNCountry, get_cfg_location(local_cfg.net.country) },
{ emu_settings_type::EnableClans, get_cfg_location(local_cfg.net.clans_enabled) },
// System
{ emu_settings_type::LicenseArea, get_cfg_location(local_cfg.sys.license_area) },
{ emu_settings_type::Language, get_cfg_location(local_cfg.sys.language) },
{ emu_settings_type::KeyboardType, get_cfg_location(local_cfg.sys.keyboard_type) },
{ emu_settings_type::EnterButtonAssignment, get_cfg_location(local_cfg.sys.enter_button_assignment) },
{ emu_settings_type::DateFormat, get_cfg_location(local_cfg.sys.date_fmt) },
{ emu_settings_type::TimeFormat, get_cfg_location(local_cfg.sys.time_fmt) },
{ emu_settings_type::ConsoleTimeOffset, get_cfg_location(local_cfg.sys.console_time_offset) },
{ emu_settings_type::EnableHostRoot, get_cfg_location(local_cfg.vfs.host_root) },
{ emu_settings_type::EmptyHdd0Tmp, get_cfg_location(local_cfg.vfs.empty_hdd0_tmp) },
{ emu_settings_type::LimitCacheSize, get_cfg_location(local_cfg.vfs.limit_cache_size) },
{ emu_settings_type::MaximumCacheSize, get_cfg_location(local_cfg.vfs.cache_max_size) },
// Savestates
{ emu_settings_type::SuspendEmulationSavestateMode, get_cfg_location(local_cfg.savestate.suspend_emu) },
{ emu_settings_type::CompatibleEmulationSavestateMode, get_cfg_location(local_cfg.savestate.compatible_mode) },
{ emu_settings_type::StartSavestatePaused, get_cfg_location(local_cfg.savestate.start_paused) },
// Logs
{ emu_settings_type::Log, get_cfg_location(local_cfg.log)},
};

229
rpcs3/rpcs3qt/emu_settings_type.h
View file

@ -1,10 +1,11 @@
#pragma once
#include <deque>
#include <map>
#include <vector>
#include <string>
// Node location
using cfg_location = std::vector<const char*>;
using cfg_location = std::deque<std::string>;
enum class emu_settings_type
{
@ -40,7 +41,6 @@ enum class emu_settings_type
SleepTimersAccuracy,
ClocksScale,
PerformanceReport,
FullWidthAVX512,
PPUNJFixup,
PPUVNANFixup,
AccurateDFMA,
@ -227,225 +227,4 @@ enum class emu_settings_type
};
/** A helper map that keeps track of where a given setting type is located*/
inline static const std::map<emu_settings_type, cfg_location> settings_location =
{
// Core Tab
{ emu_settings_type::PPUDecoder, { "Core", "PPU Decoder"}},
{ emu_settings_type::SPUDecoder, { "Core", "SPU Decoder"}},
{ emu_settings_type::HookStaticFuncs, { "Core", "Hook static functions"}},
{ emu_settings_type::ThreadSchedulerMode, { "Core", "Thread Scheduler Mode"}},
{ emu_settings_type::SPULoopDetection, { "Core", "SPU loop detection"}},
{ emu_settings_type::PreferredSPUThreads, { "Core", "Preferred SPU Threads"}},
{ emu_settings_type::PPUDebug, { "Core", "PPU Debug"}},
{ emu_settings_type::SPUDebug, { "Core", "SPU Debug"}},
{ emu_settings_type::MFCDebug, { "Core", "MFC Debug"}},
{ emu_settings_type::MaxLLVMThreads, { "Core", "Max LLVM Compile Threads"}},
{ emu_settings_type::LLVMPrecompilation, { "Core", "LLVM Precompilation"}},
{ emu_settings_type::AccurateSpuDMA, { "Core", "Accurate SPU DMA"}},
{ emu_settings_type::AccurateClineStores, { "Core", "Accurate Cache Line Stores"}},
{ emu_settings_type::AccurateRSXAccess, { "Core", "Accurate RSX reservation access"}},
{ emu_settings_type::FIFOAccuracy, { "Core", "RSX FIFO Fetch Accuracy"}},
{ emu_settings_type::XFloatAccuracy, { "Core", "SPU XFloat Accuracy"}},
{ emu_settings_type::MFCCommandsShuffling, { "Core", "MFC Commands Shuffling Limit"}},
{ emu_settings_type::SetDAZandFTZ, { "Core", "Set DAZ and FTZ"}},
{ emu_settings_type::SPUBlockSize, { "Core", "SPU Block Size"}},
{ emu_settings_type::SPUCache, { "Core", "SPU Cache"}},
{ emu_settings_type::DebugConsoleMode, { "Core", "Debug Console Mode"}},
{ emu_settings_type::MaxSPURSThreads, { "Core", "Max SPURS Threads"}},
{ emu_settings_type::SleepTimersAccuracy, { "Core", "Sleep Timers Accuracy"}},
{ emu_settings_type::ClocksScale, { "Core", "Clocks scale"}},
{ emu_settings_type::AccuratePPU128Loop, { "Core", "Accurate PPU 128-byte Reservation Op Max Length"}},
{ emu_settings_type::PerformanceReport, { "Core", "Enable Performance Report"}},
{ emu_settings_type::FullWidthAVX512, { "Core", "Full Width AVX-512"}},
{ emu_settings_type::NumPPUThreads, { "Core", "PPU Threads"}},
{ emu_settings_type::PPUNJFixup, { "Core", "PPU LLVM Java Mode Handling"}},
{ emu_settings_type::PPUVNANFixup, { "Core", "PPU Vector NaN Handling"}},
{ emu_settings_type::AccurateDFMA, { "Core", "Use Accurate DFMA"}},
{ emu_settings_type::AccuratePPUSAT, { "Core", "PPU Set Saturation Bit"}},
{ emu_settings_type::AccuratePPUNJ, { "Core", "PPU Accurate Non-Java Mode"}},
{ emu_settings_type::AccuratePPUVNAN, { "Core", "PPU Accurate Vector NaN Values"}},
{ emu_settings_type::AccuratePPUFPCC, { "Core", "PPU Set FPCC Bits"}},
{ emu_settings_type::MaxPreemptCount, { "Core", "Max CPU Preempt Count"}},
{ emu_settings_type::SPUProfiler, { "Core", "SPU Profiler"}},
{ emu_settings_type::DisableSpinOptimization, { "Core", "Disable SPU GETLLAR Spin Optimization"}},
{ emu_settings_type::EnabledSPUEventsBusyLoop, { "Core", "SPU Reservation Busy Waiting Enabled"}},
// Graphics Tab
{ emu_settings_type::Renderer, { "Video", "Renderer"}},
{ emu_settings_type::Resolution, { "Video", "Resolution"}},
{ emu_settings_type::AspectRatio, { "Video", "Aspect ratio"}},
{ emu_settings_type::FrameLimit, { "Video", "Frame limit"}},
{ emu_settings_type::MSAA, { "Video", "MSAA"}},
{ emu_settings_type::LogShaderPrograms, { "Video", "Log shader programs"}},
{ emu_settings_type::WriteDepthBuffer, { "Video", "Write Depth Buffer"}},
{ emu_settings_type::WriteColorBuffers, { "Video", "Write Color Buffers"}},
{ emu_settings_type::ReadColorBuffers, { "Video", "Read Color Buffers"}},
{ emu_settings_type::ReadDepthBuffer, { "Video", "Read Depth Buffer"}},
{ emu_settings_type::HandleRSXTiledMemory, { "Video", "Handle RSX Memory Tiling"}},
{ emu_settings_type::VSync, { "Video", "VSync Mode"}},
{ emu_settings_type::DebugOutput, { "Video", "Debug output"}},
{ emu_settings_type::DebugOverlay, { "Video", "Debug overlay"}},
{ emu_settings_type::RenderdocCompatibility, { "Video", "Renderdoc Compatibility Mode"}},
{ emu_settings_type::GPUTextureScaling, { "Video", "Use GPU texture scaling"}},
{ emu_settings_type::StretchToDisplayArea, { "Video", "Stretch To Display Area"}},
{ emu_settings_type::ForceHighpZ, { "Video", "Force High Precision Z buffer"}},
{ emu_settings_type::StrictRenderingMode, { "Video", "Strict Rendering Mode"}},
{ emu_settings_type::DisableVertexCache, { "Video", "Disable Vertex Cache"}},
{ emu_settings_type::DisableOcclusionQueries, { "Video", "Disable ZCull Occlusion Queries"}},
{ emu_settings_type::DisableVideoOutput, { "Video", "Disable Video Output"}},
{ emu_settings_type::DisableFIFOReordering, { "Video", "Disable FIFO Reordering"}},
{ emu_settings_type::StereoRenderEnabled, { "Video", "3D Display Enabled"}},
{ emu_settings_type::StereoRenderMode, { "Video", "3D Display Mode"}},
{ emu_settings_type::ScreenSize, { "Video", "Screen size in inches"}},
{ emu_settings_type::StrictTextureFlushing, { "Video", "Strict Texture Flushing"}},
{ emu_settings_type::ForceCPUBlitEmulation, { "Video", "Force CPU Blit"}},
{ emu_settings_type::DisableOnDiskShaderCache, { "Video", "Disable On-Disk Shader Cache"}},
{ emu_settings_type::DisableVulkanMemAllocator, { "Video", "Disable Vulkan Memory Allocator"}},
{ emu_settings_type::ShaderMode, { "Video", "Shader Mode"}},
{ emu_settings_type::ShaderCompilerNumThreads, { "Video", "Shader Compiler Threads"}},
{ emu_settings_type::ShaderPrecisionQuality, { "Video", "Shader Precision"}},
{ emu_settings_type::MultithreadedRSX, { "Video", "Multithreaded RSX"}},
{ emu_settings_type::RelaxedZCULL, { "Video", "Relaxed ZCULL Sync"}},
{ emu_settings_type::PreciseZCULL, { "Video", "Accurate ZCULL stats"}},
{ emu_settings_type::AnisotropicFilterOverride, { "Video", "Anisotropic Filter Override"}},
{ emu_settings_type::TextureLodBias, { "Video", "Texture LOD Bias Addend"}},
{ emu_settings_type::ResolutionScale, { "Video", "Resolution Scale"}},
{ emu_settings_type::MinimumScalableDimension, { "Video", "Minimum Scalable Dimension"}},
{ emu_settings_type::VulkanAdapter, { "Video", "Vulkan", "Adapter"}},
{ emu_settings_type::VBlankRate, { "Video", "Vblank Rate"}},
{ emu_settings_type::VBlankNTSCFixup, { "Video", "Vblank NTSC Fixup"}},
{ emu_settings_type::DriverWakeUpDelay, { "Video", "Driver Wake-Up Delay"}},
{ emu_settings_type::AllowHostGPULabels, { "Video", "Allow Host GPU Labels"}},
{ emu_settings_type::DisableMSLFastMath, { "Video", "Disable MSL Fast Math"}},
{ emu_settings_type::OutputScalingMode, { "Video", "Output Scaling Mode"}},
{ emu_settings_type::ForceHwMSAAResolve, { "Video", "Force Hardware MSAA Resolve"}},
{ emu_settings_type::DisableAsyncHostMM, { "Video", "Disable Asynchronous Memory Manager"}},
{ emu_settings_type::RecordWithOverlays, { "Video", "Record With Overlays"}},
{ emu_settings_type::DisableHWTexelRemapping, { "Video", "Disable Hardware ColorSpace Remapping"}},
{ emu_settings_type::FsrSharpeningStrength, { "Video", "FidelityFX CAS Sharpening Intensity"}},
// Vulkan
{ emu_settings_type::VulkanAsyncTextureUploads, { "Video", "Vulkan", "Asynchronous Texture Streaming"}},
{ emu_settings_type::VulkanAsyncSchedulerDriver, { "Video", "Vulkan", "Asynchronous Queue Scheduler"}},
{ emu_settings_type::ExclusiveFullscreenMode, { "Video", "Vulkan", "Exclusive Fullscreen Mode"}},
{ emu_settings_type::UseReBAR, { "Video", "Vulkan", "Use Re-BAR for GPU uploads"}},
// Performance Overlay
{ emu_settings_type::PerfOverlayEnabled, { "Video", "Performance Overlay", "Enabled" } },
{ emu_settings_type::PerfOverlayFramerateGraphEnabled, { "Video", "Performance Overlay", "Enable Framerate Graph" } },
{ emu_settings_type::PerfOverlayFrametimeGraphEnabled, { "Video", "Performance Overlay", "Enable Frametime Graph" } },
{ emu_settings_type::PerfOverlayFramerateDatapoints, { "Video", "Performance Overlay", "Framerate datapoints" } },
{ emu_settings_type::PerfOverlayFrametimeDatapoints, { "Video", "Performance Overlay", "Frametime datapoints" } },
{ emu_settings_type::PerfOverlayDetailLevel, { "Video", "Performance Overlay", "Detail level" } },
{ emu_settings_type::PerfOverlayFramerateDetailLevel, { "Video", "Performance Overlay", "Framerate graph detail level" } },
{ emu_settings_type::PerfOverlayFrametimeDetailLevel, { "Video", "Performance Overlay", "Frametime graph detail level" } },
{ emu_settings_type::PerfOverlayPosition, { "Video", "Performance Overlay", "Position" } },
{ emu_settings_type::PerfOverlayUpdateInterval, { "Video", "Performance Overlay", "Metrics update interval (ms)" } },
{ emu_settings_type::PerfOverlayFontSize, { "Video", "Performance Overlay", "Font size (px)" } },
{ emu_settings_type::PerfOverlayOpacity, { "Video", "Performance Overlay", "Opacity (%)" } },
{ emu_settings_type::PerfOverlayMarginX, { "Video", "Performance Overlay", "Horizontal Margin (%)" } },
{ emu_settings_type::PerfOverlayMarginY, { "Video", "Performance Overlay", "Vertical Margin (%)" } },
{ emu_settings_type::PerfOverlayCenterX, { "Video", "Performance Overlay", "Center Horizontally" } },
{ emu_settings_type::PerfOverlayCenterY, { "Video", "Performance Overlay", "Center Vertically" } },
{ emu_settings_type::PerfOverlayUseWindowSpace, { "Video", "Performance Overlay", "Use Window Space"}},
// Shader Loading Dialog
{ emu_settings_type::ShaderLoadBgEnabled, { "Video", "Shader Loading Dialog", "Allow custom background" } },
{ emu_settings_type::ShaderLoadBgDarkening, { "Video", "Shader Loading Dialog", "Darkening effect strength" } },
{ emu_settings_type::ShaderLoadBgBlur, { "Video", "Shader Loading Dialog", "Blur effect strength" } },
// Audio
{ emu_settings_type::AudioRenderer, { "Audio", "Renderer"}},
{ emu_settings_type::DumpToFile, { "Audio", "Dump to file"}},
{ emu_settings_type::ConvertTo16Bit, { "Audio", "Convert to 16 bit"}},
{ emu_settings_type::AudioFormat, { "Audio", "Audio Format"}},
{ emu_settings_type::AudioFormats, { "Audio", "Audio Formats"}},
{ emu_settings_type::AudioProvider, { "Audio", "Audio Provider"}},
{ emu_settings_type::AudioAvport, { "Audio", "RSXAudio Avport"}},
{ emu_settings_type::AudioDevice, { "Audio", "Audio Device"}},
{ emu_settings_type::AudioChannelLayout, { "Audio", "Audio Channel Layout"}},
{ emu_settings_type::MasterVolume, { "Audio", "Master Volume"}},
{ emu_settings_type::EnableBuffering, { "Audio", "Enable Buffering"}},
{ emu_settings_type::AudioBufferDuration, { "Audio", "Desired Audio Buffer Duration"}},
{ emu_settings_type::EnableTimeStretching, { "Audio", "Enable Time Stretching"}},
{ emu_settings_type::TimeStretchingThreshold, { "Audio", "Time Stretching Threshold"}},
{ emu_settings_type::MicrophoneType, { "Audio", "Microphone Type" }},
{ emu_settings_type::MicrophoneDevices, { "Audio", "Microphone Devices" }},
{ emu_settings_type::MusicHandler, { "Audio", "Music Handler"}},
// Input / Output
{ emu_settings_type::BackgroundInput, { "Input/Output", "Background input enabled"}},
{ emu_settings_type::ShowMoveCursor, { "Input/Output", "Show move cursor"}},
{ emu_settings_type::LockOvlIptToP1, { "Input/Output", "Lock overlay input to player one"}},
{ emu_settings_type::PadHandlerMode, { "Input/Output", "Pad handler mode"}},
{ emu_settings_type::PadConnection, { "Input/Output", "Keep pads connected" }},
{ emu_settings_type::KeyboardHandler, { "Input/Output", "Keyboard"}},
{ emu_settings_type::MouseHandler, { "Input/Output", "Mouse"}},
{ emu_settings_type::Camera, { "Input/Output", "Camera"}},
{ emu_settings_type::CameraType, { "Input/Output", "Camera type"}},
{ emu_settings_type::CameraFlip, { "Input/Output", "Camera flip"}},
{ emu_settings_type::CameraID, { "Input/Output", "Camera ID"}},
{ emu_settings_type::Move, { "Input/Output", "Move" }},
{ emu_settings_type::Buzz, { "Input/Output", "Buzz emulated controller" }},
{ emu_settings_type::Turntable, { "Input/Output", "Turntable emulated controller" }},
{ emu_settings_type::GHLtar, { "Input/Output", "GHLtar emulated controller" }},
{ emu_settings_type::MidiDevices, { "Input/Output", "Emulated Midi devices" }},
{ emu_settings_type::SDLMappings, { "Input/Output", "Load SDL GameController Mappings" }},
{ emu_settings_type::IoDebugOverlay, { "Input/Output", "IO Debug overlay" }},
{ emu_settings_type::MouseDebugOverlay, { "Input/Output", "Mouse Debug overlay" }},
// Misc
{ emu_settings_type::ExitRPCS3OnFinish, { "Miscellaneous", "Exit RPCS3 when process finishes" }},
{ emu_settings_type::StartOnBoot, { "Miscellaneous", "Automatically start games after boot" }},
{ emu_settings_type::PauseOnFocusLoss, { "Miscellaneous", "Pause emulation on RPCS3 focus loss" }},
{ emu_settings_type::StartGameFullscreen, { "Miscellaneous", "Start games in fullscreen mode"}},
{ emu_settings_type::PreventDisplaySleep, { "Miscellaneous", "Prevent display sleep while running games"}},
{ emu_settings_type::ShowTrophyPopups, { "Miscellaneous", "Show trophy popups"}},
{ emu_settings_type::ShowRpcnPopups, { "Miscellaneous", "Show RPCN popups"}},
{ emu_settings_type::UseNativeInterface, { "Miscellaneous", "Use native user interface"}},
{ emu_settings_type::ShowShaderCompilationHint, { "Miscellaneous", "Show shader compilation hint"}},
{ emu_settings_type::ShowPPUCompilationHint, { "Miscellaneous", "Show PPU compilation hint"}},
{ emu_settings_type::ShowAutosaveAutoloadHint, { "Miscellaneous", "Show autosave/autoload hint"}},
{ emu_settings_type::ShowPressureIntensityToggleHint, { "Miscellaneous", "Show pressure intensity toggle hint"}},
{ emu_settings_type::ShowAnalogLimiterToggleHint, { "Miscellaneous", "Show analog limiter toggle hint"}},
{ emu_settings_type::ShowMouseAndKeyboardToggleHint, { "Miscellaneous", "Show mouse and keyboard toggle hint"}},
{ emu_settings_type::ShowFatalErrorHints, { "Miscellaneous", "Show fatal error hints"}},
{ emu_settings_type::ShowCaptureHints, { "Miscellaneous", "Show capture hints" }},
{ emu_settings_type::SilenceAllLogs, { "Miscellaneous", "Silence All Logs" }},
{ emu_settings_type::WindowTitleFormat, { "Miscellaneous", "Window Title Format" }},
{ emu_settings_type::PauseDuringHomeMenu, { "Miscellaneous", "Pause Emulation During Home Menu" }},
{ emu_settings_type::PlayMusicDuringBoot, { "Miscellaneous", "Play music during boot sequence" }},
{ emu_settings_type::EnableGamemode, { "Miscellaneous", "Enable GameMode" }},
// Networking
{ emu_settings_type::InternetStatus, { "Net", "Internet enabled"}},
{ emu_settings_type::DNSAddress, { "Net", "DNS address"}},
{ emu_settings_type::IpSwapList, { "Net", "IP swap list"}},
{ emu_settings_type::PSNStatus, { "Net", "PSN status"}},
{ emu_settings_type::BindAddress, { "Net", "Bind address"}},
{ emu_settings_type::EnableUpnp, { "Net", "UPNP Enabled"}},
{ emu_settings_type::PSNCountry, { "Net", "PSN Country"}},
{ emu_settings_type::EnableClans, { "Net", "Clans Enabled"}},
// System
{ emu_settings_type::LicenseArea, { "System", "License Area"}},
{ emu_settings_type::Language, { "System", "Language"}},
{ emu_settings_type::KeyboardType, { "System", "Keyboard Type"}},
{ emu_settings_type::EnterButtonAssignment, { "System", "Enter button assignment"}},
{ emu_settings_type::DateFormat, { "System", "Date Format"}},
{ emu_settings_type::TimeFormat, { "System", "Time Format"}},
{ emu_settings_type::ConsoleTimeOffset, { "System", "Console time offset (s)"}},
{ emu_settings_type::EnableHostRoot, { "VFS", "Enable /host_root/"}},
{ emu_settings_type::EmptyHdd0Tmp, { "VFS", "Empty /dev_hdd0/tmp/"}},
{ emu_settings_type::LimitCacheSize, { "VFS", "Limit disk cache size"}},
{ emu_settings_type::MaximumCacheSize, { "VFS", "Disk cache maximum size (MB)"}},
// Savestates
{ emu_settings_type::SuspendEmulationSavestateMode, { "Savestate", "Suspend Emulation Savestate Mode" }},
{ emu_settings_type::CompatibleEmulationSavestateMode, { "Savestate", "Compatible Savestate Mode" }},
{ emu_settings_type::StartSavestatePaused, { "Savestate", "Start Paused" }},
// Logs
{ emu_settings_type::Log, { "Log" }},
};
extern const std::map<emu_settings_type, cfg_location> settings_location;

21
rpcs3/rpcs3qt/game_list_context_menu.cpp
View file

@ -12,6 +12,7 @@
#include "patch_manager_dialog.h"
#include "persistent_settings.h"
#include "config_database.h"
#include "config_checker.h"
#include "Utilities/File.h"
#include "Emu/system_utils.hpp"
@ -167,6 +168,26 @@ void game_list_context_menu::show_single_selection_context_menu(const game_info&
QAction* pad_configure = addAction(gameinfo->has_custom_pad_config
? tr("&Change Custom Gamepad Configuration")
: tr("&Create Custom Gamepad Configuration"));
QAction* compare_config = addAction(tr("&Compare Configurations"));
connect(compare_config, &QAction::triggered, this, [this, serial]()
{
std::string db_config;
if (config_database* db = m_game_list_frame->GetConfigDatabase(); db->has_config(serial))
{
if (const std::optional<std::string> config = db->get_config(serial))
{
db_config = *config;
}
else
{
game_list_log.error("No database config found for '%s'", serial);
}
}
config_checker* dlg = new config_checker(m_game_list_frame, QString::fromStdString(serial), config_checker::checker_mode::gamelist, db_config);
dlg->open();
});
QAction* configure_patches = addAction(tr("&Manage Game Patches"));
addSeparator();

4
rpcs3/rpcs3qt/gui_application.cpp
View file

@ -640,13 +640,15 @@ void gui_application::InitializeCallbacks()
on_exit();
}
const bool no_gui = !m_main_window;
if (m_main_window)
{
// Close main window in order to save its window state
m_main_window->close();
}
gui_log.notice("Quitting gui application");
gui_log.notice("Quitting gui application (force_quit=%d, no-gui=%d)", force_quit, no_gui);
quit();
return true;
}

2
rpcs3/rpcs3qt/log_viewer.cpp
View file

@ -201,7 +201,7 @@ void log_viewer::show_context_menu(const QPoint& pos)
connect(config, &QAction::triggered, this, [this]()
{
config_checker* dlg = new config_checker(this, m_full_log, true);
config_checker* dlg = new config_checker(this, m_full_log, config_checker::checker_mode::log);
dlg->open();
});

10
rpcs3/rpcs3qt/main_window.cpp
View file

@ -557,7 +557,7 @@ void main_window::Boot(const std::string& path, const std::string& title_id, boo
// Get database config if possible or if we are in database_config mode (to ensure we see an error on invalid use)
if (config_database* db = m_game_list_frame->GetConfigDatabase();
db->has_config(title_id) || config_mode == cfg_mode::database_config)
db->has_config(title_id))
{
const std::optional<std::string> config = db->get_config(title_id);
@ -984,7 +984,7 @@ bool main_window::HandlePackageInstallation(QStringList file_paths, bool from_bo
const game_compatibility* compat = m_game_list_frame ? m_game_list_frame->GetGameCompatibility() : nullptr;
// Let the user choose the packages to install and select the order in which they shall be installed.
pkg_install_dialog dlg(file_paths, compat, this);
pkg_install_dialog dlg(file_paths, from_boot, compat, this);
connect(&dlg, &QDialog::finished, this, [&](int result)
{
if (result != QDialog::Accepted)
@ -1009,7 +1009,8 @@ bool main_window::HandlePackageInstallation(QStringList file_paths, bool from_bo
if (canceled)
{
return false;
// return "true" if installation of optional packages (requested by some games at first boot) is skipped
return from_boot;
}
if (!from_boot)
@ -3249,7 +3250,7 @@ void main_window::CreateConnects()
m_gui_settings->SetValue(gui::fd_cfg_check, file_info.path());
config_checker* dlg = new config_checker(this, content, file_path.endsWith(".log") || file_path.endsWith(".log.gz"));
config_checker* dlg = new config_checker(this, content, (file_path.endsWith(".log") || file_path.endsWith(".log.gz")) ? config_checker::checker_mode::log : config_checker::checker_mode::config);
dlg->open();
});
@ -3943,6 +3944,7 @@ void main_window::closeEvent(QCloseEvent* closeEvent)
Q_EMIT NotifyWindowCloseEvent(true);
gui_log.notice("Quit with main_window::closeEvent");
Emu.Quit(true);
}

7
rpcs3/rpcs3qt/pkg_install_dialog.cpp
View file

@ -24,7 +24,7 @@ enum Roles
DataSizeRole = Qt::UserRole + 5,
};
pkg_install_dialog::pkg_install_dialog(const QStringList& paths, const game_compatibility* compat, QWidget* parent)
pkg_install_dialog::pkg_install_dialog(const QStringList& paths, bool from_boot, const game_compatibility* compat, QWidget* parent)
: QDialog(parent)
{
ensure(!paths.empty());
@ -148,6 +148,11 @@ pkg_install_dialog::pkg_install_dialog(const QStringList& paths, const game_comp
buttons->button(QDialogButtonBox::Ok)->setText(tr("Install"));
buttons->button(QDialogButtonBox::Ok)->setDefault(true);
if (from_boot)
{
buttons->button(QDialogButtonBox::Cancel)->setText(tr("Skip"));
}
m_dir_list->sortItems();
m_dir_list->setCurrentRow(0);
m_dir_list->setMinimumWidth((m_dir_list->sizeHintForColumn(0) * 125) / 100);

2
rpcs3/rpcs3qt/pkg_install_dialog.h
View file

@ -17,7 +17,7 @@ class pkg_install_dialog : public QDialog
Q_OBJECT
public:
explicit pkg_install_dialog(const QStringList& paths, const game_compatibility* compat, QWidget* parent = nullptr);
explicit pkg_install_dialog(const QStringList& paths, bool from_boot, const game_compatibility* compat, QWidget* parent = nullptr);
std::vector<compat::package_info> get_paths_to_install() const;
bool precompile_caches() const { return m_precompile_caches; }
bool create_desktop_shortcuts() const { return m_create_desktop_shortcuts; }