Replace old configuration with new one.

TODO: Implement per-game directories
TODO: Implement loading multiple configs
TODO: Fix build issues
This commit is contained in:
kiwidoggie 2024-08-30 17:20:07 -04:00
parent ca1613258f
commit d95b1be7c3
2 changed files with 684 additions and 562 deletions

View File

@ -1,513 +1,457 @@
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <fstream>
#include <string>
#include <fmt/core.h>
#include <toml.hpp>
#include "config.h" #include "config.h"
namespace Config { #include <filesystem>
#include <iostream>
static bool isNeo = false; using namespace Config;
static bool isFullscreen = false;
static u32 screenWidth = 1280;
static u32 screenHeight = 720;
static s32 gpuId = -1; // Vulkan physical device index. Set to negative for auto select
static std::string logFilter;
static std::string logType = "async";
static std::string userName = "shadPS4";
static bool useSpecialPad = false;
static int specialPadClass = 1;
static bool isDebugDump = false;
static bool isShowSplash = false;
static bool isNullGpu = false;
static bool shouldCopyGPUBuffers = false;
static bool shouldDumpShaders = false;
static bool shouldDumpPM4 = false;
static u32 vblankDivider = 1;
static bool vkValidation = false;
static bool vkValidationSync = false;
static bool vkValidationGpu = false;
static bool rdocEnable = false;
static bool rdocMarkersEnable = false;
// Gui
std::string settings_install_dir = "";
u32 main_window_geometry_x = 400;
u32 main_window_geometry_y = 400;
u32 main_window_geometry_w = 1280;
u32 main_window_geometry_h = 720;
u32 mw_themes = 0;
u32 m_icon_size = 36;
u32 m_icon_size_grid = 69;
u32 m_slider_pos = 0;
u32 m_slider_pos_grid = 0;
u32 m_table_mode = 0;
u32 m_window_size_W = 1280;
u32 m_window_size_H = 720;
std::vector<std::string> m_pkg_viewer;
std::vector<std::string> m_elf_viewer;
std::vector<std::string> m_recent_files;
std::string emulator_language = "en";
// Settings
u32 m_language = 1; // english
bool isNeoMode() { Config::Configuration::Configuration() {
return isNeo; setDefaultValues();
} }
bool isFullscreenMode() { Config::Configuration::Configuration(const std::filesystem::path& path) : Config::Configuration() {
return isFullscreen; load(path);
} }
u32 getScreenWidth() { void Config::Configuration::load(const std::filesystem::path& path) {
return screenWidth; // Validate that the incoming configuration file exists
}
u32 getScreenHeight() {
return screenHeight;
}
s32 getGpuId() {
return gpuId;
}
std::string getLogFilter() {
return logFilter;
}
std::string getLogType() {
return logType;
}
std::string getUserName() {
return userName;
}
bool getUseSpecialPad() {
return useSpecialPad;
}
int getSpecialPadClass() {
return specialPadClass;
}
bool debugDump() {
return isDebugDump;
}
bool showSplash() {
return isShowSplash;
}
bool nullGpu() {
return isNullGpu;
}
bool copyGPUCmdBuffers() {
return shouldCopyGPUBuffers;
}
bool dumpShaders() {
return shouldDumpShaders;
}
bool dumpPM4() {
return shouldDumpPM4;
}
bool isRdocEnabled() {
return rdocEnable;
}
bool isMarkersEnabled() {
return rdocMarkersEnable;
}
u32 vblankDiv() {
return vblankDivider;
}
bool vkValidationEnabled() {
return vkValidation;
}
bool vkValidationSyncEnabled() {
return vkValidationSync;
}
bool vkValidationGpuEnabled() {
return vkValidationGpu;
}
void setGpuId(s32 selectedGpuId) {
gpuId = selectedGpuId;
}
void setScreenWidth(u32 width) {
screenWidth = width;
}
void setScreenHeight(u32 height) {
screenHeight = height;
}
void setDebugDump(bool enable) {
isDebugDump = enable;
}
void setShowSplash(bool enable) {
isShowSplash = enable;
}
void setNullGpu(bool enable) {
isNullGpu = enable;
}
void setCopyGPUCmdBuffers(bool enable) {
shouldCopyGPUBuffers = enable;
}
void setDumpShaders(bool enable) {
shouldDumpShaders = enable;
}
void setDumpPM4(bool enable) {
shouldDumpPM4 = enable;
}
void setVkValidation(bool enable) {
vkValidation = enable;
}
void setVkSyncValidation(bool enable) {
vkValidationSync = enable;
}
void setRdocEnabled(bool enable) {
rdocEnable = enable;
}
void setVblankDiv(u32 value) {
vblankDivider = value;
}
void setFullscreenMode(bool enable) {
isFullscreen = enable;
}
void setLanguage(u32 language) {
m_language = language;
}
void setNeoMode(bool enable) {
isNeo = enable;
}
void setLogType(const std::string& type) {
logType = type;
}
void setLogFilter(const std::string& type) {
logFilter = type;
}
void setUserName(const std::string& type) {
userName = type;
}
void setUseSpecialPad(bool use) {
useSpecialPad = use;
}
void setSpecialPadClass(int type) {
specialPadClass = type;
}
void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h) {
main_window_geometry_x = x;
main_window_geometry_y = y;
main_window_geometry_w = w;
main_window_geometry_h = h;
}
void setGameInstallDir(const std::string& dir) {
settings_install_dir = dir;
}
void setMainWindowTheme(u32 theme) {
mw_themes = theme;
}
void setIconSize(u32 size) {
m_icon_size = size;
}
void setIconSizeGrid(u32 size) {
m_icon_size_grid = size;
}
void setSliderPosition(u32 pos) {
m_slider_pos = pos;
}
void setSliderPositionGrid(u32 pos) {
m_slider_pos_grid = pos;
}
void setTableMode(u32 mode) {
m_table_mode = mode;
}
void setMainWindowWidth(u32 width) {
m_window_size_W = width;
}
void setMainWindowHeight(u32 height) {
m_window_size_H = height;
}
void setPkgViewer(const std::vector<std::string>& pkgList) {
m_pkg_viewer.resize(pkgList.size());
m_pkg_viewer = pkgList;
}
void setElfViewer(const std::vector<std::string>& elfList) {
m_elf_viewer.resize(elfList.size());
m_elf_viewer = elfList;
}
void setRecentFiles(const std::vector<std::string>& recentFiles) {
m_recent_files.resize(recentFiles.size());
m_recent_files = recentFiles;
}
void setEmulatorLanguage(std::string language) {
emulator_language = language;
}
u32 getMainWindowGeometryX() {
return main_window_geometry_x;
}
u32 getMainWindowGeometryY() {
return main_window_geometry_y;
}
u32 getMainWindowGeometryW() {
return main_window_geometry_w;
}
u32 getMainWindowGeometryH() {
return main_window_geometry_h;
}
std::string getGameInstallDir() {
return settings_install_dir;
}
u32 getMainWindowTheme() {
return mw_themes;
}
u32 getIconSize() {
return m_icon_size;
}
u32 getIconSizeGrid() {
return m_icon_size_grid;
}
u32 getSliderPosition() {
return m_slider_pos;
}
u32 getSliderPositionGrid() {
return m_slider_pos_grid;
}
u32 getTableMode() {
return m_table_mode;
}
u32 getMainWindowWidth() {
return m_window_size_W;
}
u32 getMainWindowHeight() {
return m_window_size_H;
}
std::vector<std::string> getPkgViewer() {
return m_pkg_viewer;
}
std::vector<std::string> getElfViewer() {
return m_elf_viewer;
}
std::vector<std::string> getRecentFiles() {
return m_recent_files;
}
std::string getEmulatorLanguage() {
return emulator_language;
}
u32 GetLanguage() {
return m_language;
}
void load(const std::filesystem::path& path) {
// If the configuration file does not exist, create it and return
std::error_code error; std::error_code error;
if (!std::filesystem::exists(path, error)) { if (!std::filesystem::exists(path, error)) {
save(path); save(path);
std::cerr << "file path (" << path << ") does not exist." << std::endl;
return; return;
} }
toml::value data; // Attempt to parse the configuration data
try { try {
data = toml::parse(path); data = toml::parse(path);
} catch (std::exception& ex) { } catch (std::exception& ex) {
fmt::print("Got exception trying to load config file. Exception: {}\n", ex.what()); std::cerr << "got exception: " << ex.what() << std::endl;
return; return;
} }
if (data.contains("General")) {
const toml::value& general = data.at("General");
isNeo = toml::find_or<bool>(general, "isPS4Pro", false);
isFullscreen = toml::find_or<bool>(general, "Fullscreen", false);
logFilter = toml::find_or<std::string>(general, "logFilter", "");
logType = toml::find_or<std::string>(general, "logType", "sync");
userName = toml::find_or<std::string>(general, "userName", "shadPS4");
isShowSplash = toml::find_or<bool>(general, "showSplash", true);
}
if (data.contains("Input")) {
const toml::value& input = data.at("Input");
useSpecialPad = toml::find_or<bool>(input, "useSpecialPad", false);
specialPadClass = toml::find_or<int>(input, "specialPadClass", 1);
}
if (data.contains("GPU")) {
const toml::value& gpu = data.at("GPU");
screenWidth = toml::find_or<int>(gpu, "screenWidth", screenWidth);
screenHeight = toml::find_or<int>(gpu, "screenHeight", screenHeight);
isNullGpu = toml::find_or<bool>(gpu, "nullGpu", false);
shouldCopyGPUBuffers = toml::find_or<bool>(gpu, "copyGPUBuffers", false);
shouldDumpShaders = toml::find_or<bool>(gpu, "dumpShaders", false);
shouldDumpPM4 = toml::find_or<bool>(gpu, "dumpPM4", false);
vblankDivider = toml::find_or<int>(gpu, "vblankDivider", 1);
}
if (data.contains("Vulkan")) {
const toml::value& vk = data.at("Vulkan");
gpuId = toml::find_or<int>(vk, "gpuId", -1);
vkValidation = toml::find_or<bool>(vk, "validation", false);
vkValidationSync = toml::find_or<bool>(vk, "validation_sync", false);
vkValidationGpu = toml::find_or<bool>(vk, "validation_gpu", true);
rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
rdocMarkersEnable = toml::find_or<bool>(vk, "rdocMarkersEnable", false);
}
if (data.contains("Debug")) {
const toml::value& debug = data.at("Debug");
isDebugDump = toml::find_or<bool>(debug, "DebugDump", false);
}
if (data.contains("GUI")) {
const toml::value& gui = data.at("GUI");
m_icon_size = toml::find_or<int>(gui, "iconSize", 0);
m_icon_size_grid = toml::find_or<int>(gui, "iconSizeGrid", 0);
m_slider_pos = toml::find_or<int>(gui, "sliderPos", 0);
m_slider_pos_grid = toml::find_or<int>(gui, "sliderPosGrid", 0);
mw_themes = toml::find_or<int>(gui, "theme", 0);
m_window_size_W = toml::find_or<int>(gui, "mw_width", 0);
m_window_size_H = toml::find_or<int>(gui, "mw_height", 0);
settings_install_dir = toml::find_or<std::string>(gui, "installDir", "");
main_window_geometry_x = toml::find_or<int>(gui, "geometry_x", 0);
main_window_geometry_y = toml::find_or<int>(gui, "geometry_y", 0);
main_window_geometry_w = toml::find_or<int>(gui, "geometry_w", 0);
main_window_geometry_h = toml::find_or<int>(gui, "geometry_h", 0);
m_pkg_viewer = toml::find_or<std::vector<std::string>>(gui, "pkgDirs", {});
m_elf_viewer = toml::find_or<std::vector<std::string>>(gui, "elfDirs", {});
m_recent_files = toml::find_or<std::vector<std::string>>(gui, "recentFiles", {});
m_table_mode = toml::find_or<int>(gui, "gameTableMode", 0);
emulator_language = toml::find_or<std::string>(gui, "emulatorLanguage", "en");
}
if (data.contains("Settings")) {
const toml::value& settings = data.at("Settings");
m_language = toml::find_or<int>(settings, "consoleLanguage", 1);
}
} }
void save(const std::filesystem::path& path) {
toml::value data;
void Config::Configuration::save(const std::filesystem::path& path) {
std::error_code error; std::error_code error;
if (std::filesystem::exists(path, error)) { if (std::filesystem::exists(path, error)) {
try { try {
data = toml::parse(path); data = toml::parse(path);
} catch (const std::exception& ex) { } catch (const std::exception& ex) {
fmt::print("Exception trying to parse config file. Exception: {}\n", ex.what());
return; return;
} }
} else { } else {
if (error) { if (error) {
fmt::print("Filesystem error accessing {} (error: {})\n", path.string(),
error.message().c_str());
}
fmt::print("Saving new configuration file {}\n", path.string());
} }
data["General"]["isPS4Pro"] = isNeo; std::cout << "saving new configuration file (" << path << ")." << std::endl;
data["General"]["Fullscreen"] = isFullscreen; }
data["General"]["logFilter"] = logFilter;
data["General"]["logType"] = logType;
data["General"]["userName"] = userName;
data["General"]["showSplash"] = isShowSplash;
data["Input"]["useSpecialPad"] = useSpecialPad;
data["Input"]["specialPadClass"] = specialPadClass;
data["GPU"]["screenWidth"] = screenWidth;
data["GPU"]["screenHeight"] = screenHeight;
data["GPU"]["nullGpu"] = isNullGpu;
data["GPU"]["copyGPUBuffers"] = shouldCopyGPUBuffers;
data["GPU"]["dumpShaders"] = shouldDumpShaders;
data["GPU"]["dumpPM4"] = shouldDumpPM4;
data["GPU"]["vblankDivider"] = vblankDivider;
data["Vulkan"]["gpuId"] = gpuId;
data["Vulkan"]["validation"] = vkValidation;
data["Vulkan"]["validation_sync"] = vkValidationSync;
data["Vulkan"]["validation_gpu"] = vkValidationGpu;
data["Vulkan"]["rdocEnable"] = rdocEnable;
data["Vulkan"]["rdocMarkersEnable"] = rdocMarkersEnable;
data["Debug"]["DebugDump"] = isDebugDump;
data["GUI"]["theme"] = mw_themes;
data["GUI"]["iconSize"] = m_icon_size;
data["GUI"]["sliderPos"] = m_slider_pos;
data["GUI"]["iconSizeGrid"] = m_icon_size_grid;
data["GUI"]["sliderPosGrid"] = m_slider_pos_grid;
data["GUI"]["gameTableMode"] = m_table_mode;
data["GUI"]["mw_width"] = m_window_size_W;
data["GUI"]["mw_height"] = m_window_size_H;
data["GUI"]["installDir"] = settings_install_dir;
data["GUI"]["geometry_x"] = main_window_geometry_x;
data["GUI"]["geometry_y"] = main_window_geometry_y;
data["GUI"]["geometry_w"] = main_window_geometry_w;
data["GUI"]["geometry_h"] = main_window_geometry_h;
data["GUI"]["pkgDirs"] = m_pkg_viewer;
data["GUI"]["elfDirs"] = m_elf_viewer;
data["GUI"]["recentFiles"] = m_recent_files;
data["GUI"]["emulatorLanguage"] = emulator_language;
data["Settings"]["consoleLanguage"] = m_language; std::ofstream saveFile(path, std::ios::out);
saveFile << data;
std::ofstream file(path, std::ios::out); saveFile.close();
file << data;
file.close();
} }
void setDefaultValues() { bool Configuration::configVersionDifference(const std::filesystem::path& path) {
isNeo = false; // Validate that the incoming configuration file exists
isFullscreen = false; std::error_code error;
screenWidth = 1280; if (!std::filesystem::exists(path, error)) {
screenHeight = 720; std::cerr << "file path (" << path << ") does not exist." << std::endl;
logFilter = ""; return true;
logType = "async"; }
userName = "shadPS4";
useSpecialPad = false; // Attempt to parse the configuration data
specialPadClass = 1; toml::value oldConfigData;
isDebugDump = false; try {
isShowSplash = false; oldConfigData = toml::parse(path);
isNullGpu = false; } catch (std::exception& ex) {
shouldDumpShaders = false; std::cerr << "got exception: " << ex.what() << std::endl;
shouldDumpPM4 = false; return true;
vblankDivider = 1; }
vkValidation = false;
rdocEnable = false; // Iterate checking for new entries that do not exist in the provided config
emulator_language = "en"; for (auto& item : c_defaultConfig) {
m_language = 1; // Get the key name
gpuId = -1; auto& defaultFirst = item.first;
auto& defaultSecond = item.second;
std::cout << "checking for key (" << defaultFirst << ") in old config." << std::endl;
// Check to see if the old configuration contains the key provided
if (oldConfigData.contains(defaultFirst)) {
std::cout << "checking (" << defaultFirst.c_str() << ") type (" << defaultSecond.type()
<< " = " << oldConfigData[defaultFirst].type() << ")" << std::endl;
// Check to see that the types match for the second
if (oldConfigData[defaultFirst].type() != defaultSecond.type()) {
std::cout << "mismatch type found!" << std::endl;
return true;
}
} else // If the key does not exist in the old config but exists in the new, mark difference
{
std::cout << "key (" << defaultFirst << ") is not found in old config." << std::endl;
return true;
}
auto& oldConfigSecond = oldConfigData[defaultFirst];
// If there is a nested table, check the sub-entries
if (defaultSecond.is_table()) {
toml::table secondTable = defaultSecond.as_table();
for (auto& tableItemPair : secondTable) {
auto& secondItemFirst = tableItemPair.first;
auto& secondItemSecond = tableItemPair.second;
std::cout << "checking for key (" << secondItemFirst << ") in old config."
<< std::endl;
if (oldConfigSecond.contains(secondItemFirst)) {
std::cout << "checking (" << secondItemFirst.c_str() << ") type ("
<< secondItemSecond.type() << " = "
<< oldConfigSecond[secondItemFirst].type() << ")" << std::endl;
// Check for type match
if (oldConfigSecond[secondItemFirst].type() != secondItemSecond.type()) {
std::cout << "mismatch type found!" << std::endl;
return true;
}
} else {
std::cout << "key (" << secondItemFirst << ") is not found in old config."
<< std::endl;
return true;
}
}
}
}
return false;
} }
} // namespace Config bool Config::Configuration::isNeoMode() {
return getValue<bool>("General", "isPS4Pro");
}
void Config::Configuration::setNeoMode(bool enable) {
setValue("General", "isPS4Pro", enable);
}
bool Config::Configuration::isFullscreenMode() {
return getValue<bool>("General", "Fullscreen");
}
void Config::Configuration::setFullscreenMode(bool enable) {
setValue("General", "Fullscreen", enable);
}
std::string Config::Configuration::getLogFilter() {
return getValue<std::string>("General", "logFilter");
}
void Config::Configuration::setLogFilter(const std::string& type) {
setValue("General", "logFilter", type);
}
std::string Config::Configuration::getLogType() {
return getValue<std::string>("General", "logType");
}
void Config::Configuration::setLogType(const std::string& type) {
setValue("General", "logType", type);
}
std::string Config::Configuration::getUserName() {
return getValue<std::string>("General", "userName");
}
void Config::Configuration::setUserName(const std::string& type) {
setValue("General", "userName", type);
}
bool Config::Configuration::showSplash() {
return getValue<bool>("General", "showSplash");
}
void Config::Configuration::setShowSplash(bool enable) {
return setValue("General", "showSplash", enable);
}
bool Config::Configuration::getUseSpecialPad() {
return getValue<bool>("General", "useSpecialPad");
}
void Config::Configuration::setUseSpecialPad(bool use) {
setValue("General", "useSpecialPad", use);
}
int Config::Configuration::getSpecialPadClass() {
return getValue<int>("General", "specialPadClass");
}
void Config::Configuration::setSpecialPadClass(int type) {
setValue("General", "specialPadClass", type);
}
u32 Config::Configuration::getScreenWidth() {
return getValue<uint32_t>("General", "screenWidth");
}
void Config::Configuration::setScreenWidth(u32 width) {
setValue("General", "screenWidth", width);
}
u32 Config::Configuration::getScreenHeight() {
return getValue<uint32_t>("General", "screenHeight");
}
void Config::Configuration::setScreenHeight(u32 height) {
setValue("General", "screenHeight", height);
}
bool Config::Configuration::nullGpu() {
return getValue<bool>("General", "nullGpu");
}
void Config::Configuration::setNullGpu(bool enable) {
setValue("General", "nullGpu", enable);
}
bool Config::Configuration::copyGPUCmdBuffers() {
return getValue<bool>("General", "copyGPUBuffers");
}
void Config::Configuration::setCopyGPUCmdBuffers(bool enable) {
setValue("General", "copyGPUBuffers", enable);
}
bool Config::Configuration::dumpShaders() {
return getValue<bool>("General", "dumpShaders");
}
void Config::Configuration::setDumpShaders(bool enable) {
setValue("General", "dumpShader", enable);
}
bool Config::Configuration::dumpPM4() {
return getValue<bool>("General", "dumpPM4");
}
void Config::Configuration::setDumpPM4(bool enable) {
setValue("General", "dumpPM4", enable);
}
u32 Config::Configuration::vblankDiv() {
return getValue<u32>("General", "vblankDivider");
}
void Config::Configuration::setVblankDiv(u32 value) {
setValue("General", "vblankDivider", value);
}
s32 Config::Configuration::getGpuId() {
return getValue<s32>("Vulkan", "gpuId");
}
void Config::Configuration::setGpuId(s32 selectedGpuId) {
setValue("Vulkan", "gpuId", selectedGpuId);
}
bool Config::Configuration::vkValidationEnabled() {
return getValue<bool>("Vulkan", "validation");
}
void Config::Configuration::setVkValidation(bool enable) {
setValue("Vulkan", "validation", enable);
}
bool Config::Configuration::vkValidationSyncEnabled() {
return getValue<bool>("Vulkan", "validationSync");
}
void Config::Configuration::setVkSyncValidation(bool enable) {
setValue("Vulkan", "validationSync", enable);
}
bool Config::Configuration::vkValidationGpuEnabled() {
return getValue<bool>("Vulkan", "validationGpu");
}
void Config::Configuration::setVkValidationGpuEnabled(bool enable) {
setValue("Vulkan", "validationGpu", enable);
}
bool Config::Configuration::isRdocEnabled() {
return getValue<bool>("Vulkan", "rdocEnable");
}
void Config::Configuration::setRdocEnabled(bool enable) {
setValue("Vulkan", "rdocEnable", enable);
}
bool Config::Configuration::isMarkersEnabled() {
return getValue<bool>("Vulkan", "rdocMarkersEnable");
}
void Config::Configuration::setIsMarkersEnabled(bool enable) {
setValue("Vulkan", "rdocMarkersEnable", enable);
}
bool Config::Configuration::debugDump() {
return getValue<bool>("Vulkan", "debugDump");
}
void Config::Configuration::setDebugDump(bool enable) {
setValue("Vulkan", "debugDump", enable);
}
u32 Config::Configuration::getMainWindowTheme() {
return getValue<u32>("GUI", "theme");
}
void Config::Configuration::setMainWindowTheme(u32 theme) {
setValue("GUI", "theme", theme);
}
u32 Config::Configuration::getIconSize() {
return getValue<u32>("GUI", "iconSize");
}
void Config::Configuration::setIconSize(u32 size) {
setValue("GUI", "iconSize", size);
}
u32 Config::Configuration::getIconSizeGrid() {
return getValue<u32>("GUI", "iconSizeGrid");
}
void Config::Configuration::setIconSizeGrid(u32 size) {
setValue("GUI", "iconSizeGrid", size);
}
u32 Config::Configuration::getSliderPosition() {
return getValue<u32>("GUI", "sliderPos");
}
void Config::Configuration::setSliderPosition(u32 pos) {
setValue("GUI", "sliderPos", pos);
}
u32 Config::Configuration::getSliderPositionGrid() {
return getValue<u32>("GUI", "sliderPosGrid");
}
void Config::Configuration::setSliderPositionGrid(u32 pos) {
setValue("GUI", "sliderPosGrid", pos);
}
u32 Config::Configuration::getTableMode() {
return getValue<u32>("GUI", "gameTableMode");
}
void Config::Configuration::setTableMode(u32 mode) {
setValue("GUI", "gameTableMode", mode);
}
u32 Config::Configuration::getMainWindowWidth() {
return getValue<u32>("GUI", "mwWidth");
}
void Config::Configuration::setMainWindowWidth(u32 width) {
setValue("GUI", "mwWidth", width);
}
u32 Config::Configuration::getMainWindowHeight() {
return getValue<u32>("GUI", "mwHeight");
}
void Config::Configuration::setMainWindowHeight(u32 height) {
setValue("GUI", "mwHeight", height);
}
std::string Config::Configuration::getGameInstallDir() {
return getValue<std::string>("GUI", "installDir");
}
void Config::Configuration::setGameInstallDir(const std::string& dir) {
setValue("GUI", "installDir", dir);
}
u32 Config::Configuration::getMainWindowGeometryX() {
return getValue<u32>("GUI", "geometryX");
}
u32 Config::Configuration::getMainWindowGeometryY() {
return getValue<u32>("GUI", "geometryY");
}
u32 Config::Configuration::getMainWindowGeometryW() {
return getValue<u32>("GUI", "geometryW");
}
u32 Config::Configuration::getMainWindowGeometryH() {
return getValue<u32>("GUI", "geometryH");
}
void Config::Configuration::setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h) {
setValue("GUI", "geometryX", x);
setValue("GUI", "geometryY", y);
setValue("GUI", "geometryW", w);
setValue("GUI", "geometryH", h);
}
std::vector<std::string> Config::Configuration::getPkgViewer() {
if (!data.contains("GUI"))
return std::vector<std::string>();
auto& gui = data["GUI"];
return toml::find_or<std::vector<std::string>>(gui, "pkgDirs", {});
}
void Config::Configuration::setPkgViewer(const std::vector<std::string>& pkgList) {
data["GUI"]["pkgDirs"] = pkgList;
}
std::vector<std::string> Config::Configuration::getElfViewer() {
if (!data.contains("GUI"))
return std::vector<std::string>();
auto& gui = data["GUI"];
return toml::find_or<std::vector<std::string>>(gui, "elfDirs", {});
}
void Config::Configuration::setElfViewer(const std::vector<std::string>& elfList) {
data["GUI"]["elfDirs"] = elfList;
}
std::vector<std::string> Config::Configuration::getRecentFiles() {
if (!data.contains("GUI"))
return std::vector<std::string>();
auto& gui = data["GUI"];
return toml::find_or<std::vector<std::string>>(gui, "recentFiles", {});
}
void Config::Configuration::setRecentFiles(const std::vector<std::string>& recentFiles) {
data["GUI"]["recentFiles"] = recentFiles;
}
std::string Config::Configuration::getEmulatorLanguage() {
return getValue<std::string>("GUI", "emulatorLanguage");
}
void Config::Configuration::setEmulatorLanguage(std::string language) {
setValue("GUI", "emulatorLanguage", language);
}
u32 Config::Configuration::getConsoleLanguage() {
return getValue<u32>("Settings", "consoleLanauge");
}
void Config::Configuration::setLanguage(u32 language) {
setValue("Settings", "consoleLanauge", language);
}
void Config::Configuration::setDefaultValues() {
data = toml::table(c_defaultConfig);
}

View File

@ -1,104 +1,282 @@
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include <array>
#include <cstdint>
#include <filesystem> #include <filesystem>
#include <string>
#include <vector> #include <vector>
#include "types.h"
#include <toml.hpp>
#define u32 uint32_t
#define s32 int32_t
namespace Config { namespace Config {
void load(const std::filesystem::path& path); class Configuration {
void save(const std::filesystem::path& path); private:
const std::string c_globalTitleId = "global";
const std::string c_configFolderName = "config";
const toml::table c_defaultConfig = {
{"titleId", c_globalTitleId},
{"General",
toml::table{
{"isPS4Pro", false},
{"Fullscreen", false},
{"logFilter", ""},
{"logType", "async"},
{"userName", "shadPS4"},
{"showSplash", false},
{"useSpecialPad", false},
{"specialPadClass", 1},
{"screenWidth", 1280},
{"screenHeight", 720},
{"nullGpu", false},
{"copyGPUBuffers", false},
{"dumpShaders", false},
{"dumpPM4", false},
{"vblankDivider", 1},
}},
{
"Vulkan",
toml::table{
{"gpuId", (-1)},
{"validation", false},
{"validationSync", false}, // Breaking change
{"validationGpu", false}, // Breaking change
{"rdocEnable", false},
{"rdocMarkersEnable", false},
{"debugDump", false}, // Breaking change
},
},
{
"GUI",
toml::table{{"theme", 0},
{"iconSize", 0},
{"iconSizeGrid", 0},
{"sliderPos", 0},
{"sliderPosGrid", 0},
{"gameTableMode", 0},
{"mwWidth", 0}, // Breaking change
{"mwHeight", 0}, // Breaking change
{"installDir", ""},
{"geometryX", 0}, // Breaking change
{"geometryY", 0}, // Breaking change
{"geometryW", 0}, // Breaking change
{"geometryH", 0}, // Breaking change
{"pkgDirs", toml::array{}},
{"elfDirs", toml::array{}},
{"recentFiles", toml::array{}},
{"emulatorLanguage", "en"}},
},
{
"Settings",
toml::table{{"consoleLanguage", 1}},
},
};
bool isNeoMode(); protected:
bool isFullscreenMode(); // Title id of the game, or "global" for global settings
std::string getLogFilter(); std::string titleId;
std::string getLogType();
std::string getUserName();
bool getUseSpecialPad(); // Toml data, do not modify this directly
int getSpecialPadClass(); toml::value data;
u32 getScreenWidth(); public:
u32 getScreenHeight(); /// <summary>
s32 getGpuId(); /// Create a new configuration with defaults
/// </summary>
Configuration();
bool debugDump(); /// <summary>
bool showSplash(); /// Load configuration from file path
bool nullGpu(); /// </summary>
bool copyGPUCmdBuffers(); /// <param name="path">Path of configuration file</param>
bool dumpShaders(); Configuration(const std::filesystem::path& path);
bool dumpPM4();
bool isRdocEnabled();
bool isMarkersEnabled();
u32 vblankDiv();
void setDebugDump(bool enable); /// <summary>
void setShowSplash(bool enable); /// Loads a configuration from file path
void setNullGpu(bool enable); /// </summary>
void setCopyGPUCmdBuffers(bool enable); /// <param name="path">Path of configuration file</param>
void setDumpShaders(bool enable); void load(const std::filesystem::path& path);
void setDumpPM4(bool enable);
void setVblankDiv(u32 value);
void setGpuId(s32 selectedGpuId);
void setScreenWidth(u32 width);
void setScreenHeight(u32 height);
void setFullscreenMode(bool enable);
void setLanguage(u32 language);
void setNeoMode(bool enable);
void setUserName(const std::string& type);
void setUseSpecialPad(bool use); /// <summary>
void setSpecialPadClass(int type); /// Saves a configuration to file path
/// </summary>
/// <param name="path">Path of configuration file</param>
void save(const std::filesystem::path& path);
void setLogType(const std::string& type); /// <summary>
void setLogFilter(const std::string& type); /// This function will iterate through all of the section and entries in the default
/// configuration
///
/// It will check to make sure that all of the categories, and keys match in both name and type
/// </summary>
/// <param name="path">Path of configuration file to check</param>
/// <returns>True if there is a structural difference in config files, false if no
/// difference</returns>
bool configVersionDifference(const std::filesystem::path& path);
void setVkValidation(bool enable); template <typename T>
void setVkSyncValidation(bool enable); T getValue(const char* category, const char* key) {
void setRdocEnabled(bool enable); if (!c_defaultConfig.contains(category))
return T();
bool vkValidationEnabled(); const toml::value& defaultGeneral = c_defaultConfig.at(category);
bool vkValidationSyncEnabled();
bool vkValidationGpuEnabled();
// Gui auto defaultValue = toml::find_or<T>(defaultGeneral, key, T());
void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h);
void setGameInstallDir(const std::string& dir);
void setMainWindowTheme(u32 theme);
void setIconSize(u32 size);
void setIconSizeGrid(u32 size);
void setSliderPosition(u32 pos);
void setSliderPositionGrid(u32 pos);
void setTableMode(u32 mode);
void setMainWindowWidth(u32 width);
void setMainWindowHeight(u32 height);
void setPkgViewer(const std::vector<std::string>& pkgList);
void setElfViewer(const std::vector<std::string>& elfList);
void setRecentFiles(const std::vector<std::string>& recentFiles);
void setEmulatorLanguage(std::string language);
u32 getMainWindowGeometryX(); if (data.contains(category)) {
u32 getMainWindowGeometryY(); const toml::value& general = data.at(category);
u32 getMainWindowGeometryW();
u32 getMainWindowGeometryH();
std::string getGameInstallDir();
u32 getMainWindowTheme();
u32 getIconSize();
u32 getIconSizeGrid();
u32 getSliderPosition();
u32 getSliderPositionGrid();
u32 getTableMode();
u32 getMainWindowWidth();
u32 getMainWindowHeight();
std::vector<std::string> getPkgViewer();
std::vector<std::string> getElfViewer();
std::vector<std::string> getRecentFiles();
std::string getEmulatorLanguage();
void setDefaultValues(); return toml::find_or<T>(general, key, defaultValue);
}
// settings return T();
u32 GetLanguage(); }
}; // namespace Config
template <typename T>
void setValue(const char* category, const char* key, T value) {
if (!data.contains(category))
return;
auto& dataCategory = data[category];
if (!dataCategory.contains(key))
return;
data[category][key] = value;
}
/*
* Alright, making some changes here, first is keeping the
* default config and the C++ functions in the same order
*/
#pragma region General settings
bool isNeoMode();
void setNeoMode(bool enable);
bool isFullscreenMode();
void setFullscreenMode(bool enable);
std::string getLogFilter();
void setLogFilter(const std::string& type);
std::string getLogType();
void setLogType(const std::string& type);
std::string getUserName();
void setUserName(const std::string& type);
bool showSplash();
void setShowSplash(bool enable);
bool getUseSpecialPad();
void setUseSpecialPad(bool use);
int getSpecialPadClass();
void setSpecialPadClass(int type);
u32 getScreenWidth();
void setScreenWidth(u32 width);
u32 getScreenHeight();
void setScreenHeight(u32 height);
bool nullGpu();
void setNullGpu(bool enable);
bool copyGPUCmdBuffers();
void setCopyGPUCmdBuffers(bool enable);
bool dumpShaders();
void setDumpShaders(bool enable);
bool dumpPM4();
void setDumpPM4(bool enable);
u32 vblankDiv();
void setVblankDiv(u32 value);
#pragma endregion
#pragma region Vulkan settings
s32 getGpuId();
void setGpuId(s32 selectedGpuId);
bool vkValidationEnabled();
void setVkValidation(bool enable);
bool vkValidationSyncEnabled();
void setVkSyncValidation(bool enable);
bool vkValidationGpuEnabled();
void setVkValidationGpuEnabled(bool enable);
bool isRdocEnabled();
void setRdocEnabled(bool enable);
bool isMarkersEnabled();
void setIsMarkersEnabled(bool enable);
bool debugDump();
void setDebugDump(bool enable);
#pragma endregion
#pragma region GUI settings
u32 getMainWindowTheme();
void setMainWindowTheme(u32 theme);
u32 getIconSize();
void setIconSize(u32 size);
u32 getIconSizeGrid();
void setIconSizeGrid(u32 size);
u32 getSliderPosition();
void setSliderPosition(u32 pos);
u32 getSliderPositionGrid();
void setSliderPositionGrid(u32 pos);
u32 getTableMode();
void setTableMode(u32 mode);
u32 getMainWindowWidth();
void setMainWindowWidth(u32 width);
u32 getMainWindowHeight();
void setMainWindowHeight(u32 height);
std::string getGameInstallDir();
void setGameInstallDir(const std::string& dir);
u32 getMainWindowGeometryX();
u32 getMainWindowGeometryY();
u32 getMainWindowGeometryW();
u32 getMainWindowGeometryH();
void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h);
std::vector<std::string> getPkgViewer();
void setPkgViewer(const std::vector<std::string>& pkgList);
std::vector<std::string> getElfViewer();
void setElfViewer(const std::vector<std::string>& elfList);
std::vector<std::string> getRecentFiles();
void setRecentFiles(const std::vector<std::string>& recentFiles);
std::string getEmulatorLanguage();
void setEmulatorLanguage(std::string language);
#pragma endregion
#pragma region Console settings
u32 getConsoleLanguage();
void setLanguage(u32 language);
#pragma endregion
/// <summary>
/// Sets the data to the default values
/// </summary>
void setDefaultValues();
};
} // namespace Config