mirror of
https://github.com/spice2x/spice2x.github.io.git
synced 2026-08-01 22:30:42 -07:00
bicarus-dev
41d0dce6e9
## Link to GitHub Issue, if one exists n/a ## Description of change For JSON config files of the following features: * patch manager * screen resize * IIDX camera hook * card manager when saving a new file, store them in %appdata%\spice2x instead of %appdata%. On load: 1. If the JSON file exists in %appdata%\spice2x, use that (new path) 1. If the JSON file exists in %appdata%, continue to use that (legacy path) It's common for people to have mixed versions of spicetools/spice2x so we'll continue to read from the %appdata% root if the files are there, but with a preference for the new path. We will not forcibly move files. spicetools.xml will continue to live in the %appdata% root. Moving this will confuse a lot of people, so I'm avoiding this. Also, this fixes `-patchcfgpath` and `-resizecfgpath` to create directories as needed (previously the parent directory must have existed first) ## Testing Tested - * existing config files are continued to be read from %appdata% * new files get created in %appdata%\spice2x\... (both in spicecfg and in overlay) * can provide custom path for `-patchcfgpath` `-resizecfgpath` and observe directories + file created in custom path, try absolute or local relative paths
229 lines
8.6 KiB
C++
229 lines
8.6 KiB
C++
#include "screen_resize.h"
|
|
|
|
#include "external/rapidjson/document.h"
|
|
#include "external/rapidjson/pointer.h"
|
|
#include "external/rapidjson/prettywriter.h"
|
|
#include "misc/eamuse.h"
|
|
#include "util/utils.h"
|
|
#include "util/fileutils.h"
|
|
#include "hooks/graphics/graphics.h"
|
|
|
|
namespace cfg {
|
|
|
|
// globals
|
|
std::unique_ptr<cfg::ScreenResize> SCREENRESIZE;
|
|
std::optional<std::string> SCREEN_RESIZE_CFG_PATH_OVERRIDE;
|
|
|
|
ScreenResize::ScreenResize() {
|
|
bool file_exists = false;
|
|
if (SCREEN_RESIZE_CFG_PATH_OVERRIDE.has_value()) {
|
|
this->config_path = SCREEN_RESIZE_CFG_PATH_OVERRIDE.value();
|
|
if (fileutils::file_exists(this->config_path)) {
|
|
log_info("ScreenResize", "loading config from: {}", this->config_path.string());
|
|
file_exists = true;
|
|
}
|
|
} else {
|
|
this->config_path =
|
|
fileutils::get_config_file_path("ScreenResize", "spicetools_screen_resize.json", &file_exists);
|
|
}
|
|
if (file_exists) {
|
|
this->config_load();
|
|
}
|
|
}
|
|
|
|
ScreenResize::~ScreenResize() {
|
|
}
|
|
|
|
void ScreenResize::config_load() {
|
|
std::string config = fileutils::text_read(this->config_path);
|
|
if (config.empty()) {
|
|
log_info("ScreenResize", "config is empty");
|
|
return;
|
|
}
|
|
|
|
// parse document
|
|
rapidjson::Document doc;
|
|
doc.Parse(config.c_str());
|
|
|
|
// check parse error
|
|
auto error = doc.GetParseError();
|
|
if (error) {
|
|
log_warning("ScreenResize", "config parse error: {}", error);
|
|
return;
|
|
}
|
|
|
|
// verify root is a dict
|
|
if (!doc.IsObject()) {
|
|
log_warning("ScreenResize", "config not found");
|
|
return;
|
|
}
|
|
|
|
bool use_game_setting = false;
|
|
|
|
std::string root("/");
|
|
// try to find game-specific setting, if one exists
|
|
{
|
|
const auto game = rapidjson::Pointer("/sp2x_games/" + eamuse_get_game()).Get(doc);
|
|
if (game && game->IsObject()) {
|
|
use_game_setting = true;
|
|
root = "/sp2x_games/" + eamuse_get_game() + "/";
|
|
}
|
|
}
|
|
|
|
log_misc(
|
|
"ScreenResize",
|
|
"Loading fullscreen image settings. Game = {}, is_global = {}, JSON path: {}",
|
|
eamuse_get_game(),
|
|
use_game_setting,
|
|
root);
|
|
|
|
load_bool_value(doc, root + "enable_screen_resize", this->enable_screen_resize);
|
|
load_bool_value(doc, root + "enable_linear_filter", this->enable_linear_filter);
|
|
for (size_t i = 0; i < std::size(this->scene_settings); i++) {
|
|
auto& scene = this->scene_settings[i];
|
|
const std::string prefix = fmt::format("scenes/{}/", i);
|
|
load_int_value(doc, root + prefix + "offset_x", scene.offset_x);
|
|
load_int_value(doc, root + prefix + "offset_y", scene.offset_y);
|
|
load_float_value(doc, root + prefix + "scale_x", scene.scale_x);
|
|
load_float_value(doc, root + prefix + "scale_y", scene.scale_y);
|
|
load_bool_value(doc, root + prefix + "keep_aspect_ratio", scene.keep_aspect_ratio);
|
|
}
|
|
|
|
// windowed settings are always under game settings
|
|
root = "/sp2x_games/" + eamuse_get_game() + "/";
|
|
log_misc(
|
|
"ScreenResize",
|
|
"Loading window settings. Game = {}, JSON path: {}",
|
|
eamuse_get_game(),
|
|
root);
|
|
load_bool_value(doc, root + "w_always_on_top", this->window_always_on_top);
|
|
load_bool_value(doc, root + "w_enable_resize", this->enable_window_resize);
|
|
load_bool_value(doc, root + "w_keep_aspect_ratio", this->client_keep_aspect_ratio);
|
|
load_int_value(doc, root + "w_border_type", this->window_decoration);
|
|
load_uint32_value(doc, root + "w_width", this->client_width);
|
|
load_uint32_value(doc, root + "w_height", this->client_height);
|
|
load_int_value(doc, root + "w_offset_x", this->window_offset_x);
|
|
load_int_value(doc, root + "w_offset_y", this->window_offset_y);
|
|
}
|
|
|
|
bool ScreenResize::load_bool_value(rapidjson::Document& doc, std::string path, bool& value) {
|
|
const auto v = rapidjson::Pointer(path).Get(doc);
|
|
if (!v) {
|
|
log_misc("ScreenResize", "{} not found", path);
|
|
return false;
|
|
}
|
|
if (!v->IsBool()) {
|
|
log_warning("ScreenResize", "{} is invalid type", path);
|
|
return false;
|
|
}
|
|
value = v->GetBool();
|
|
return true;
|
|
}
|
|
|
|
bool ScreenResize::load_int_value(rapidjson::Document& doc, std::string path, int& value) {
|
|
const auto v = rapidjson::Pointer(path).Get(doc);
|
|
if (!v) {
|
|
log_misc("ScreenResize", "{} not found", path);
|
|
return false;
|
|
}
|
|
if (!v->IsInt()) {
|
|
log_warning("ScreenResize", "{} is invalid type", path);
|
|
return false;
|
|
}
|
|
value = v->GetInt();
|
|
return true;
|
|
}
|
|
|
|
bool ScreenResize::load_uint32_value(rapidjson::Document& doc, std::string path, uint32_t& value) {
|
|
const auto v = rapidjson::Pointer(path).Get(doc);
|
|
if (!v) {
|
|
log_misc("ScreenResize", "{} not found", path);
|
|
return false;
|
|
}
|
|
if (!v->IsUint()) {
|
|
log_warning("ScreenResize", "{} is invalid type", path);
|
|
return false;
|
|
}
|
|
value = v->GetUint();
|
|
return true;
|
|
}
|
|
|
|
bool ScreenResize::load_float_value(rapidjson::Document& doc, std::string path, float& value) {
|
|
const auto v = rapidjson::Pointer(path).Get(doc);
|
|
if (!v) {
|
|
log_misc("ScreenResize", "{} not found", path);
|
|
return false;
|
|
}
|
|
if (v->IsInt()) {
|
|
value = v->GetInt();
|
|
return true;
|
|
}
|
|
if (v->IsDouble()) {
|
|
value = v->GetDouble();
|
|
return true;
|
|
}
|
|
if (v->IsFloat()) {
|
|
value = v->GetFloat();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ScreenResize::config_save() {
|
|
rapidjson::Document doc;
|
|
std::string config = fileutils::text_read(this->config_path);
|
|
if (!config.empty()) {
|
|
doc.Parse(config.c_str());
|
|
log_misc("ScreenResize", "existing config file found");
|
|
}
|
|
if (!doc.IsObject()) {
|
|
log_misc("ScreenResize", "clearing out config file");
|
|
doc.SetObject();
|
|
}
|
|
|
|
// always save under per-game settings
|
|
std::string root("/sp2x_games/" + eamuse_get_game() + "/");
|
|
|
|
log_misc(
|
|
"ScreenResize",
|
|
"Game = {}, JSON path = {}",
|
|
eamuse_get_game(),
|
|
root);
|
|
|
|
// full screen image settings
|
|
rapidjson::Pointer(root + "enable_screen_resize").Set(doc, this->enable_screen_resize);
|
|
rapidjson::Pointer(root + "enable_linear_filter").Set(doc, this->enable_linear_filter);
|
|
for (size_t i = 0; i < std::size(this->scene_settings); i++) {
|
|
auto& scene = this->scene_settings[i];
|
|
const std::string prefix = fmt::format("scenes/{}/", i);
|
|
rapidjson::Pointer(root + prefix + "offset_x").Set(doc, scene.offset_x);
|
|
rapidjson::Pointer(root + prefix + "offset_y").Set(doc, scene.offset_y);
|
|
rapidjson::Pointer(root + prefix + "scale_x").Set(doc, scene.scale_x);
|
|
rapidjson::Pointer(root + prefix + "scale_y").Set(doc, scene.scale_y);
|
|
rapidjson::Pointer(root + prefix + "keep_aspect_ratio").Set(doc, scene.keep_aspect_ratio);
|
|
}
|
|
|
|
// windowed mode settings
|
|
rapidjson::Pointer(root + "w_always_on_top").Set(doc, this->window_always_on_top);
|
|
rapidjson::Pointer(root + "w_enable_resize").Set(doc, this->enable_window_resize);
|
|
rapidjson::Pointer(root + "w_keep_aspect_ratio").Set(doc, this->client_keep_aspect_ratio);
|
|
rapidjson::Pointer(root + "w_border_type").Set(doc, this->window_decoration);
|
|
rapidjson::Pointer(root + "w_width").Set(doc, this->client_width);
|
|
rapidjson::Pointer(root + "w_height").Set(doc, this->client_height);
|
|
rapidjson::Pointer(root + "w_offset_x").Set(doc, this->window_offset_x);
|
|
rapidjson::Pointer(root + "w_offset_y").Set(doc, this->window_offset_y);
|
|
|
|
// build JSON
|
|
rapidjson::StringBuffer buffer;
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
|
|
doc.Accept(writer);
|
|
|
|
// save to file
|
|
if (fileutils::write_config_file("ScreenResize", this->config_path, buffer.GetString())) {
|
|
// this->config_dirty = false;
|
|
} else {
|
|
log_warning("ScreenResize", "unable to save config file");
|
|
}
|
|
}
|
|
}
|