thirdpartymirrors/N64ModernRuntime
1
0
Fork 0
mirror of https://github.com/N64Recomp/N64ModernRuntime.git synced 2025-10-30 08:02:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Implement mod configuration, mod reordering, and extended exports (#95)

Browse source 
* init recomp config_store

* Use a custom hash class to enable hetereogenous lookup

* Added config registry/option files

* switch to using usings

* dropdown config type

* Added TextField option type

* parse/validate button config type

* wip callback registry

* Add auto enabled.

* Cleanup.

* Add support for config schema.

* Add float arg1 helpers

* Config storage for mods.

* Proper enum parsing.

* Persist mod order and enable.

* Enable new mods by default.

* Mods directory.

* Parse thumbnail when opening mods.

* Auto-enabled mods.

* Implement extended function exports that pass the caller mod's index as an extra argument

* Fix mod configs not saving and default value not getting parsed

* Implement API to allow mods to read their config values

* Fix config value parsing to allow integral values for double fields

* Change construction of ModConfigQueueSaveMod.

* Fix N64Recomp commit after rebase

---------

Co-authored-by: Dario <dariosamo@gmail.com>
Co-authored-by: thecozies <79979276+thecozies@users.noreply.github.com>
This commit is contained in:
Wiseguy 2025-03-23 21:30:27 -04:00 • committed by GitHub
parent ec56fb39b0
commit 2ed84f46c5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 1181 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
librecomp/CMakeLists.txt
View file

@ -20,6 +20,7 @@ add_library(librecomp STATIC
"${CMAKE_CURRENT_SOURCE_DIR}/src/mod_events.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/mod_hooks.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/mod_manifest.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/mod_config_api.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/overlays.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/pak.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/pi.cpp"
@ -35,6 +36,7 @@ add_library(librecomp STATIC
target_include_directories(librecomp PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src"
"${PROJECT_SOURCE_DIR}/../ultramodern/include"
"${PROJECT_SOURCE_DIR}/../thirdparty"
"${PROJECT_SOURCE_DIR}/../thirdparty/concurrentqueue"

37
librecomp/include/librecomp/helpers.hpp
View file

@ -1,6 +1,8 @@
#ifndef __RECOMP_HELPERS__
#define __RECOMP_HELPERS__
#include <string>
#include "recomp.h"
#include <ultramodern/ultra64.h>
@ -36,6 +38,41 @@ T _arg(uint8_t* rdram, recomp_context* ctx) {
}
}
inline float _arg_float_a1(uint8_t* rdram, recomp_context* ctx) {
(void)rdram;
union {
u32 as_u32;
float as_float;
} ret{};
ret.as_u32 = _arg<1, u32>(rdram, ctx);
return ret.as_float;
}
inline float _arg_float_f14(uint8_t* rdram, recomp_context* ctx) {
(void)rdram;
return ctx->f14.fl;
}
template <int arg_index>
std::string _arg_string(uint8_t* rdram, recomp_context* ctx) {
PTR(char) str = _arg<arg_index, PTR(char)>(rdram, ctx);
// Get the length of the byteswapped string.
size_t len = 0;
while (MEM_B(str, len) != 0x00) {
len++;
}
std::string ret{};
ret.reserve(len + 1);
for (size_t i = 0; i < len; i++) {
ret += (char)MEM_B(str, i);
}
return ret;
}
template <typename T>
void _return(recomp_context* ctx, T val) {
static_assert(sizeof(T) <= 4 && "Only 32-bit value returns supported currently");

119
librecomp/include/librecomp/mods.hpp
View file

@ -13,6 +13,9 @@
#include <array>
#include <cstddef>
#include <variant>
#include <mutex>
#include "blockingconcurrentqueue.h"
#define MINIZ_NO_DEFLATE_APIS
#define MINIZ_NO_ARCHIVE_WRITING_APIS
@ -27,6 +30,7 @@
namespace N64Recomp {
class Context;
struct LiveGeneratorOutput;
class ShimFunction;
};
namespace recomp {
@ -55,6 +59,9 @@ struct std::hash<recomp::mods::HookDefinition>
namespace recomp {
namespace mods {
static constexpr std::string_view mods_directory = "mods";
static constexpr std::string_view mod_config_directory = "mod_config";
enum class ModOpenError {
Good,
DoesNotExist,
@ -65,6 +72,9 @@ namespace recomp {
FailedToParseManifest,
InvalidManifestSchema,
IncorrectManifestFieldType,
MissingConfigSchemaField,
IncorrectConfigSchemaType,
InvalidConfigSchemaDefault,
InvalidVersionString,
InvalidMinimumRecompVersionString,
InvalidDependencyString,
@ -115,6 +125,13 @@ namespace recomp {
std::string error_to_string(CodeModLoadError);
enum class ConfigOptionType {
None,
Enum,
Number,
String
};
struct ModFileHandle {
virtual ~ModFileHandle() = default;
virtual std::vector<char> read_file(const std::string& filepath, bool& exists) const = 0;
@ -154,6 +171,45 @@ namespace recomp {
Version version;
};
struct ConfigOptionEnum {
std::vector<std::string> options;
uint32_t default_value = 0;
};
struct ConfigOptionNumber {
double min = 0.0;
double max = 0.0;
double step = 0.0;
int precision = 0;
bool percent = false;
double default_value = 0.0;
};
struct ConfigOptionString {
std::string default_value;
};
typedef std::variant<ConfigOptionEnum, ConfigOptionNumber, ConfigOptionString> ConfigOptionVariant;
struct ConfigOption {
std::string id;
std::string name;
std::string description;
ConfigOptionType type;
ConfigOptionVariant variant;
};
struct ConfigSchema {
std::vector<ConfigOption> options;
std::unordered_map<std::string, size_t> options_by_id;
};
typedef std::variant<std::monostate, uint32_t, double, std::string> ConfigValueVariant;
struct ConfigStorage {
std::unordered_map<std::string, ConfigValueVariant> value_map;
};
struct ModDetails {
std::string mod_id;
std::string display_name;
@ -176,6 +232,7 @@ namespace recomp {
std::vector<std::string> authors;
std::vector<Dependency> dependencies;
std::unordered_map<std::string, size_t> dependencies_by_id;
ConfigSchema config_schema;
Version minimum_recomp_version;
Version version;
bool runtime_toggleable;
@ -203,6 +260,7 @@ namespace recomp {
};
std::vector<ModDetails> get_mod_details(const std::string& mod_game_id);
void set_mod_index(const std::string &mod_game_id, const std::string &mod_id, size_t index);
// Internal functions, TODO move to an internal header.
struct PatchData {
@ -244,6 +302,20 @@ namespace recomp {
bool requires_manifest;
};
struct ModConfigQueueSaveMod {
std::string mod_id;
};
struct ModConfigQueueSave {
uint32_t pad;
};
struct ModConfigQueueEnd {
uint32_t pad;
};
typedef std::variant<ModConfigQueueSaveMod, ModConfigQueueSave, ModConfigQueueEnd> ModConfigQueueVariant;
class LiveRecompilerCodeHandle;
class ModContext {
public:
@ -252,12 +324,23 @@ namespace recomp {
void register_game(const std::string& mod_game_id);
std::vector<ModOpenErrorDetails> scan_mod_folder(const std::filesystem::path& mod_folder);
void enable_mod(const std::string& mod_id, bool enabled);
void load_mods_config();
void enable_mod(const std::string& mod_id, bool enabled, bool trigger_save);
bool is_mod_enabled(const std::string& mod_id);
bool is_mod_auto_enabled(const std::string& mod_id);
size_t num_opened_mods();
std::vector<ModLoadErrorDetails> load_mods(const GameEntry& game_entry, uint8_t* rdram, int32_t load_address, uint32_t& ram_used);
void unload_mods();
std::vector<ModDetails> get_mod_details(const std::string& mod_game_id);
void set_mod_index(const std::string &mod_game_id, const std::string &mod_id, size_t index);
const ConfigSchema &get_mod_config_schema(const std::string &mod_id) const;
const std::vector<char> &get_mod_thumbnail(const std::string &mod_id) const;
void set_mod_config_value(size_t mod_index, const std::string &option_id, const ConfigValueVariant &value);
void set_mod_config_value(const std::string &mod_id, const std::string &option_id, const ConfigValueVariant &value);
ConfigValueVariant get_mod_config_value(size_t mod_index, const std::string &option_id);
ConfigValueVariant get_mod_config_value(const std::string &mod_id, const std::string &option_id);
void set_mods_config_path(const std::filesystem::path &path);
void set_mod_config_directory(const std::filesystem::path &path);
ModContentTypeId register_content_type(const ModContentType& type);
bool register_container_type(const std::string& extension, const std::vector<ModContentTypeId>& content_types, bool requires_manifest);
ModContentTypeId get_code_content_type() const { return code_content_type_id; }
@ -268,14 +351,15 @@ namespace recomp {
void check_dependencies(ModHandle& mod, std::vector<std::pair<ModLoadError, std::string>>& errors);
CodeModLoadError init_mod_code(uint8_t* rdram, const std::unordered_map<uint32_t, uint16_t>& section_vrom_map, ModHandle& mod, int32_t load_address, bool hooks_available, uint32_t& ram_used, std::string& error_param);
CodeModLoadError load_mod_code(uint8_t* rdram, ModHandle& mod, uint32_t base_event_index, std::string& error_param);
CodeModLoadError resolve_code_dependencies(ModHandle& mod, const std::unordered_map<recomp_func_t*, recomp::overlays::BasePatchedFunction>& base_patched_funcs, std::string& error_param);
void add_opened_mod(ModManifest&& manifest, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& detected_content_types);
CodeModLoadError resolve_code_dependencies(ModHandle& mod, size_t mod_index, const std::unordered_map<recomp_func_t*, recomp::overlays::BasePatchedFunction>& base_patched_funcs, std::string& error_param);
void add_opened_mod(ModManifest&& manifest, ConfigStorage&& config_storage, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& detected_content_types, std::vector<char>&& thumbnail);
void close_mods();
std::vector<ModLoadErrorDetails> regenerate_with_hooks(
const std::vector<std::pair<HookDefinition, size_t>>& sorted_unprocessed_hooks,
const std::unordered_map<uint32_t, uint16_t>& section_vrom_map,
const std::unordered_map<recomp_func_t*, overlays::BasePatchedFunction>& base_patched_funcs,
std::span<const uint8_t> decompressed_rom);
void dirty_mod_configuration_thread_process();
static void on_code_mod_enabled(ModContext& context, const ModHandle& mod);
@ -285,10 +369,18 @@ namespace recomp {
std::unordered_map<std::string, size_t> mod_game_ids;
std::vector<ModHandle> opened_mods;
std::unordered_map<std::string, size_t> opened_mods_by_id;
std::vector<size_t> opened_mods_order;
std::mutex opened_mods_mutex;
std::unordered_set<std::string> mod_ids;
std::unordered_set<std::string> enabled_mods;
std::unordered_set<std::string> auto_enabled_mods;
std::unordered_map<recomp_func_t*, PatchData> patched_funcs;
std::unordered_map<std::string, size_t> loaded_mods_by_id;
std::unique_ptr<std::thread> mod_configuration_thread;
moodycamel::BlockingConcurrentQueue<ModConfigQueueVariant> mod_configuration_thread_queue;
std::filesystem::path mods_config_path;
std::filesystem::path mod_config_directory;
std::mutex mod_config_storage_mutex;
std::vector<size_t> loaded_code_mods;
// Code handle for vanilla code that was regenerated to add hooks.
std::unique_ptr<LiveRecompilerCodeHandle> regenerated_code_handle;
@ -299,6 +391,10 @@ namespace recomp {
// Tracks which hook slots have already been processed. Used to regenerate vanilla functions as needed
// to add hooks to any functions that weren't already replaced by a mod.
std::vector<bool> processed_hook_slots;
// Generated shim functions to use for implementing shim exports.
std::vector<std::unique_ptr<N64Recomp::ShimFunction>> shim_functions;
ConfigSchema empty_schema;
std::vector<char> empty_bytes;
size_t num_events = 0;
ModContentTypeId code_content_type_id;
size_t active_game = (size_t)-1;
@ -321,13 +417,15 @@ namespace recomp {
public:
// TODO make these private and expose methods for the functionality they're currently used in.
ModManifest manifest;
ConfigStorage config_storage;
std::unique_ptr<ModCodeHandle> code_handle;
std::unique_ptr<N64Recomp::Context> recompiler_context;
std::vector<uint32_t> section_load_addresses;
// Content types present in this mod.
std::vector<ModContentTypeId> content_types;
std::vector<char> thumbnail;
ModHandle(const ModContext& context, ModManifest&& manifest, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& content_types);
ModHandle(const ModContext& context, ModManifest&& manifest, ConfigStorage&& config_storage, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& content_types, std::vector<char>&& thumbnail);
ModHandle(const ModHandle& rhs) = delete;
ModHandle& operator=(const ModHandle& rhs) = delete;
ModHandle(ModHandle&& rhs);
@ -457,12 +555,23 @@ namespace recomp {
CodeModLoadError validate_api_version(uint32_t api_version, std::string& error_param);
void initialize_mod_recompiler();
void initialize_mods();
void scan_mods();
std::filesystem::path get_mods_directory();
void enable_mod(const std::string& mod_id, bool enabled);
bool is_mod_enabled(const std::string& mod_id);
bool is_mod_auto_enabled(const std::string& mod_id);
const ConfigSchema &get_mod_config_schema(const std::string &mod_id);
const std::vector<char> &get_mod_thumbnail(const std::string &mod_id);
void set_mod_config_value(size_t mod_index, const std::string &option_id, const ConfigValueVariant &value);
void set_mod_config_value(const std::string &mod_id, const std::string &option_id, const ConfigValueVariant &value);
ConfigValueVariant get_mod_config_value(size_t mod_index, const std::string &option_id);
ConfigValueVariant get_mod_config_value(const std::string &mod_id, const std::string &option_id);
ModContentTypeId register_mod_content_type(const ModContentType& type);
bool register_mod_container_type(const std::string& extension, const std::vector<ModContentTypeId>& content_types, bool requires_manifest);
void register_config_exports();
}
};

2
librecomp/include/librecomp/overlays.hpp
View file

@ -25,6 +25,7 @@ namespace recomp {
void register_patches(const char* patch_data, size_t patch_size, SectionTableEntry* code_sections, size_t num_sections);
void register_base_export(const std::string& name, recomp_func_t* func);
void register_ext_base_export(const std::string& name, recomp_func_ext_t* func);
void register_base_exports(const FunctionExport* exports);
void register_base_events(char const* const* event_names);
void register_manual_patch_symbols(const ManualPatchSymbol* manual_patch_symbols);
@ -38,6 +39,7 @@ namespace recomp {
bool get_func_entry_by_section_index_function_offset(uint16_t code_section_index, uint32_t function_offset, FuncEntry& func_out);
recomp_func_t* get_func_by_section_index_function_offset(uint16_t code_section_index, uint32_t function_offset);
recomp_func_t* get_base_export(const std::string& export_name);
recomp_func_ext_t* get_ext_base_export(const std::string& export_name);
size_t get_base_event_index(const std::string& event_name);
size_t num_base_events();

66
librecomp/src/mod_config_api.cpp Normal file
View file

@ -0,0 +1,66 @@
#include "librecomp/mods.hpp"
#include "librecomp/helpers.hpp"
#include "librecomp/addresses.hpp"
void recomp_get_config_u32(uint8_t* rdram, recomp_context* ctx, size_t mod_index) {
recomp::mods::ConfigValueVariant val = recomp::mods::get_mod_config_value(mod_index, _arg_string<0>(rdram, ctx));
if (uint32_t* as_u32 = std::get_if<uint32_t>(&val)) {
_return(ctx, *as_u32);
}
else if (double* as_double = std::get_if<double>(&val)) {
_return(ctx, uint32_t(int32_t(*as_double)));
}
else {
_return(ctx, uint32_t{0});
}
}
void recomp_get_config_double(uint8_t* rdram, recomp_context* ctx, size_t mod_index) {
recomp::mods::ConfigValueVariant val = recomp::mods::get_mod_config_value(mod_index, _arg_string<0>(rdram, ctx));
if (uint32_t* as_u32 = std::get_if<uint32_t>(&val)) {
ctx->f0.d = double(*as_u32);
}
else if (double* as_double = std::get_if<double>(&val)) {
ctx->f0.d = *as_double;
}
else {
ctx->f0.d = 0.0;
}
}
void recomp_get_config_string(uint8_t* rdram, recomp_context* ctx, size_t mod_index) {
recomp::mods::ConfigValueVariant val = recomp::mods::get_mod_config_value(mod_index, _arg_string<0>(rdram, ctx));
if (std::string* as_string = std::get_if<std::string>(&val)) {
const std::string& str = *as_string;
// Allocate space in the recomp heap to hold the string, including the null terminator.
size_t alloc_size = (str.size() + 1 + 15) & ~15;
gpr offset = reinterpret_cast<uint8_t*>(recomp::alloc(rdram, alloc_size)) - rdram;
gpr addr = offset + 0xFFFFFFFF80000000ULL;
// Copy the string's data into the allocated memory and null terminate it.
for (size_t i = 0; i < str.size(); i++) {
MEM_B(i, addr) = str[i];
}
MEM_B(str.size(), addr) = 0;
// Return the allocated memory.
ctx->r2 = addr;
}
else {
_return(ctx, NULLPTR);
}
}
void recomp_free_config_string(uint8_t* rdram, recomp_context* ctx) {
gpr str_rdram = (gpr)_arg<0, PTR(char)>(rdram, ctx);
gpr offset = str_rdram - 0xFFFFFFFF80000000ULL;
recomp::free(rdram, rdram + offset);
}
void recomp::mods::register_config_exports() {
recomp::overlays::register_ext_base_export("recomp_get_config_u32", recomp_get_config_u32);
recomp::overlays::register_ext_base_export("recomp_get_config_double", recomp_get_config_double);
recomp::overlays::register_ext_base_export("recomp_get_config_string", recomp_get_config_string);
recomp::overlays::register_base_export("recomp_free_config_string", recomp_free_config_string);
}

381
librecomp/src/mod_manifest.cpp
View file

@ -3,8 +3,38 @@
#include "json/json.hpp"
#include "recompiler/context.h"
#include "librecomp/files.hpp"
#include "librecomp/mods.hpp"
static bool read_json(std::ifstream input_file, nlohmann::json &json_out) {
if (!input_file.good()) {
return false;
}
try {
input_file >> json_out;
}
catch (nlohmann::json::parse_error &) {
return false;
}
return true;
}
static bool read_json_with_backups(const std::filesystem::path &path, nlohmann::json &json_out) {
// Try reading and parsing the base file.
if (read_json(std::ifstream{ path }, json_out)) {
return true;
}
// Try reading and parsing the backup file.
if (read_json(recomp::open_input_backup_file(path), json_out)) {
return true;
}
// Both reads failed.
return false;
}
recomp::mods::ZipModFileHandle::~ZipModFileHandle() {
if (file_handle) {
fclose(file_handle);
@ -131,16 +161,6 @@ bool recomp::mods::LooseModFileHandle::file_exists(const std::string& filepath)
return true;
}
enum class ManifestField {
GameModId,
Id,
Version,
Authors,
MinimumRecompVersion,
Dependencies,
NativeLibraries,
};
const std::string game_mod_id_key = "game_id";
const std::string mod_id_key = "id";
const std::string display_name_key = "display_name";
@ -151,16 +171,7 @@ const std::string authors_key = "authors";
const std::string minimum_recomp_version_key = "minimum_recomp_version";
const std::string dependencies_key = "dependencies";
const std::string native_libraries_key = "native_libraries";
std::unordered_map<std::string, ManifestField> field_map {
{ game_mod_id_key, ManifestField::GameModId },
{ mod_id_key, ManifestField::Id },
{ version_key, ManifestField::Version },
{ authors_key, ManifestField::Authors },
{ minimum_recomp_version_key, ManifestField::MinimumRecompVersion },
{ dependencies_key, ManifestField::Dependencies },
{ native_libraries_key, ManifestField::NativeLibraries },
};
const std::string config_schema_key = "config_schema";
template <typename T1, typename T2>
bool get_to(const nlohmann::json& val, T2& out) {
@ -298,6 +309,206 @@ recomp::mods::ModOpenError try_get_vec(std::vector<T2>& out, const nlohmann::jso
return recomp::mods::ModOpenError::Good;
}
constexpr std::string_view config_schema_id_key = "id";
constexpr std::string_view config_schema_name_key = "name";
constexpr std::string_view config_schema_description_key = "description";
constexpr std::string_view config_schema_type_key = "type";
constexpr std::string_view config_schema_min_key = "min";
constexpr std::string_view config_schema_max_key = "max";
constexpr std::string_view config_schema_step_key = "step";
constexpr std::string_view config_schema_precision_key = "precision";
constexpr std::string_view config_schema_percent_key = "percent";
constexpr std::string_view config_schema_options_key = "options";
constexpr std::string_view config_schema_default_key = "default";
std::unordered_map<std::string, recomp::mods::ConfigOptionType> config_option_map{
{ "Enum", recomp::mods::ConfigOptionType::Enum},
{ "Number", recomp::mods::ConfigOptionType::Number},
{ "String", recomp::mods::ConfigOptionType::String},
};
recomp::mods::ModOpenError parse_manifest_config_schema_option(const nlohmann::json &config_schema_json, recomp::mods::ModManifest &ret, std::string &error_param) {
using json = nlohmann::json;
recomp::mods::ConfigOption option;
auto id = config_schema_json.find(config_schema_id_key);
if (id != config_schema_json.end()) {
if (!get_to<json::string_t>(*id, option.id)) {
error_param = config_schema_id_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
else {
error_param = config_schema_id_key;
return recomp::mods::ModOpenError::MissingConfigSchemaField;
}
auto name = config_schema_json.find(config_schema_name_key);
if (name != config_schema_json.end()) {
if (!get_to<json::string_t>(*name, option.name)) {
error_param = config_schema_name_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
else {
error_param = config_schema_name_key;
return recomp::mods::ModOpenError::MissingConfigSchemaField;
}
auto description = config_schema_json.find(config_schema_description_key);
if (description != config_schema_json.end()) {
if (!get_to<json::string_t>(*description, option.description)) {
error_param = config_schema_description_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
auto type = config_schema_json.find(config_schema_type_key);
if (type != config_schema_json.end()) {
std::string type_string;
if (!get_to<json::string_t>(*type, type_string)) {
error_param = config_schema_type_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
else {
auto it = config_option_map.find(type_string);
if (it != config_option_map.end()) {
option.type = it->second;
}
else {
error_param = config_schema_type_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
}
else {
error_param = config_schema_type_key;
return recomp::mods::ModOpenError::MissingConfigSchemaField;
}
switch (option.type) {
case recomp::mods::ConfigOptionType::Enum:
{
recomp::mods::ConfigOptionEnum option_enum;
auto options = config_schema_json.find(config_schema_options_key);
if (options != config_schema_json.end()) {
if (!get_to_vec<std::string>(*options, option_enum.options)) {
error_param = config_schema_options_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
auto default_value = config_schema_json.find(config_schema_default_key);
if (default_value != config_schema_json.end()) {
std::string default_value_string;
if (get_to<json::string_t>(*default_value, default_value_string)) {
auto it = std::find(option_enum.options.begin(), option_enum.options.end(), default_value_string);
if (it != option_enum.options.end()) {
option_enum.default_value = uint32_t(it - option_enum.options.begin());
}
else {
error_param = config_schema_default_key;
return recomp::mods::ModOpenError::InvalidConfigSchemaDefault;
}
}
else {
error_param = config_schema_default_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
option.variant = option_enum;
}
break;
case recomp::mods::ConfigOptionType::Number:
{
recomp::mods::ConfigOptionNumber option_number;
auto min = config_schema_json.find(config_schema_min_key);
if (min != config_schema_json.end()) {
if (!min->is_number()) {
error_param = config_schema_min_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
option_number.min = min->template get<double>();
}
auto max = config_schema_json.find(config_schema_max_key);
if (max != config_schema_json.end()) {
if (!max->is_number()) {
error_param = config_schema_max_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
option_number.max = max->template get<double>();
}
auto step = config_schema_json.find(config_schema_step_key);
if (step != config_schema_json.end()) {
if (!step->is_number()) {
error_param = config_schema_step_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
option_number.step = step->template get<double>();
}
auto precision = config_schema_json.find(config_schema_precision_key);
if (precision != config_schema_json.end()) {
int64_t precision_int64;
if (get_to<int64_t>(*precision, precision_int64)) {
option_number.precision = precision_int64;
}
else {
error_param = config_schema_precision_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
auto percent = config_schema_json.find(config_schema_percent_key);
if (percent != config_schema_json.end()) {
if (!get_to<bool>(*percent, option_number.percent)) {
error_param = config_schema_percent_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
auto default_value = config_schema_json.find(config_schema_default_key);
if (default_value != config_schema_json.end()) {
if (!default_value->is_number()) {
error_param = config_schema_default_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
option_number.default_value = default_value->template get<double>();
}
option.variant = option_number;
}
break;
case recomp::mods::ConfigOptionType::String:
{
recomp::mods::ConfigOptionString option_string;
auto default_value = config_schema_json.find(config_schema_default_key);
if (default_value != config_schema_json.end()) {
if (!get_to<json::string_t>(*default_value, option_string.default_value)) {
error_param = config_schema_default_key;
return recomp::mods::ModOpenError::IncorrectConfigSchemaType;
}
}
option.variant = option_string;
}
break;
default:
break;
}
ret.config_schema.options_by_id.emplace(option.id, ret.config_schema.options.size());
ret.config_schema.options.emplace_back(option);
return recomp::mods::ModOpenError::Good;
}
recomp::mods::ModOpenError parse_manifest(recomp::mods::ModManifest& ret, const std::vector<char>& manifest_data, std::string& error_param) {
using json = nlohmann::json;
json manifest_json = json::parse(manifest_data.begin(), manifest_data.end(), nullptr, false);
@ -399,9 +610,117 @@ recomp::mods::ModOpenError parse_manifest(recomp::mods::ModManifest& ret, const
}
}
// Config schema (optional)
auto find_config_schema_it = manifest_json.find(config_schema_key);
if (find_config_schema_it != manifest_json.end()) {
auto& val = *find_config_schema_it;
if (!val.is_object()) {
error_param = config_schema_key;
return recomp::mods::ModOpenError::IncorrectManifestFieldType;
}
auto options = val.find(config_schema_options_key);
if (options != val.end()) {
if (!options->is_array()) {
error_param = config_schema_options_key;
return recomp::mods::ModOpenError::IncorrectManifestFieldType;
}
for (const json &option : *options) {
recomp::mods::ModOpenError open_error = parse_manifest_config_schema_option(option, ret, error_param);
if (open_error != recomp::mods::ModOpenError::Good) {
return open_error;
}
}
}
else {
error_param = config_schema_options_key;
return recomp::mods::ModOpenError::MissingConfigSchemaField;
}
}
return recomp::mods::ModOpenError::Good;
}
bool parse_mod_config_storage(const std::filesystem::path &path, const std::string &expected_mod_id, recomp::mods::ConfigStorage &config_storage, const recomp::mods::ConfigSchema &config_schema) {
using json = nlohmann::json;
json config_json;
if (!read_json_with_backups(path, config_json)) {
return false;
}
auto mod_id = config_json.find("mod_id");
if (mod_id != config_json.end()) {
std::string mod_id_str;
if (get_to<json::string_t>(*mod_id, mod_id_str)) {
if (*mod_id != expected_mod_id) {
// The mod's ID doesn't match.
return false;
}
}
else {
// The mod ID is not a string.
return false;
}
}
else {
// The configuration file doesn't have a mod ID.
return false;
}
auto storage_json = config_json.find("storage");
if (storage_json == config_json.end()) {
// The configuration file doesn't have a storage object.
return false;
}
if (!storage_json->is_object()) {
// The storage key does not correspond to an object.
return false;
}
// Only parse the object for known option types based on the schema.
std::string value_str;
for (const recomp::mods::ConfigOption &option : config_schema.options) {
auto option_json = storage_json->find(option.id);
if (option_json == storage_json->end()) {
// Option doesn't exist in storage.
continue;
}
switch (option.type) {
case recomp::mods::ConfigOptionType::Enum:
if (get_to<json::string_t>(*option_json, value_str)) {
const recomp::mods::ConfigOptionEnum &option_enum = std::get<recomp::mods::ConfigOptionEnum>(option.variant);
auto option_it = std::find(option_enum.options.begin(), option_enum.options.end(), value_str);
if (option_it != option_enum.options.end()) {
config_storage.value_map[option.id] = uint32_t(option_it - option_enum.options.begin());
}
}
break;
case recomp::mods::ConfigOptionType::Number:
if (option_json->is_number()) {
config_storage.value_map[option.id] = option_json->template get<double>();
}
break;
case recomp::mods::ConfigOptionType::String: {
if (get_to<json::string_t>(*option_json, value_str)) {
config_storage.value_map[option.id] = value_str;
}
break;
}
default:
assert(false && "Unknown option type.");
break;
}
}
return true;
}
recomp::mods::ModOpenError recomp::mods::ModContext::open_mod(const std::filesystem::path& mod_path, std::string& error_param, const std::vector<ModContentTypeId>& supported_content_types, bool requires_manifest) {
ModManifest manifest{};
std::error_code ec;
@ -520,9 +839,23 @@ recomp::mods::ModOpenError recomp::mods::ModContext::open_mod(const std::filesys
}
}
// Read the mod config if it exists.
ConfigStorage config_storage;
std::filesystem::path config_path = mod_config_directory / (manifest.mod_id + ".json");
parse_mod_config_storage(config_path, manifest.mod_id, config_storage, manifest.config_schema);
// Read the mod thumbnail if it exists.
static const std::string thumbnail_dds_name = "thumb.dds";
static const std::string thumbnail_png_name = "thumb.png";
bool exists = false;
std::vector<char> thumbnail_data = manifest.file_handle->read_file(thumbnail_dds_name, exists);
if (!exists) {
thumbnail_data = manifest.file_handle->read_file(thumbnail_png_name, exists);
}
// Store the loaded mod manifest in a new mod handle.
manifest.mod_root_path = mod_path;
add_opened_mod(std::move(manifest), std::move(game_indices), std::move(detected_content_types));
add_opened_mod(std::move(manifest), std::move(config_storage), std::move(game_indices), std::move(detected_content_types), std::move(thumbnail_data));
return ModOpenError::Good;
}
@ -547,6 +880,12 @@ std::string recomp::mods::error_to_string(ModOpenError error) {
return "Mod's mod.json has an invalid schema";
case ModOpenError::IncorrectManifestFieldType:
return "Incorrect type for field in mod.json";
case ModOpenError::MissingConfigSchemaField:
return "Missing required field in config schema in mod.json";
case ModOpenError::IncorrectConfigSchemaType:
return "Incorrect type for field in config schema in mod.json";
case ModOpenError::InvalidConfigSchemaDefault:
return "Invalid default for option in config schema in mod.json";
case ModOpenError::InvalidVersionString:
return "Invalid version string in mod.json";
case ModOpenError::InvalidMinimumRecompVersionString:

542
librecomp/src/mods.cpp
View file

@ -3,12 +3,65 @@
#include <sstream>
#include <functional>
#include "librecomp/files.hpp"
#include "librecomp/mods.hpp"
#include "librecomp/overlays.hpp"
#include "librecomp/game.hpp"
#include "recompiler/context.h"
#include "recompiler/live_recompiler.h"
static bool read_json(std::ifstream input_file, nlohmann::json &json_out) {
if (!input_file.good()) {
return false;
}
try {
input_file >> json_out;
}
catch (nlohmann::json::parse_error &) {
return false;
}
return true;
}
static bool read_json_with_backups(const std::filesystem::path &path, nlohmann::json &json_out) {
// Try reading and parsing the base file.
if (read_json(std::ifstream{ path }, json_out)) {
return true;
}
// Try reading and parsing the backup file.
if (read_json(recomp::open_input_backup_file(path), json_out)) {
return true;
}
// Both reads failed.
return false;
}
template <typename T1, typename T2>
bool get_to_vec(const nlohmann::json& val, std::vector<T2>& out) {
const nlohmann::json::array_t* ptr = val.get_ptr<const nlohmann::json::array_t*>();
if (ptr == nullptr) {
return false;
}
out.clear();
for (const nlohmann::json& cur_val : *ptr) {
const T1* temp_ptr = cur_val.get_ptr<const T1*>();
if (temp_ptr == nullptr) {
out.clear();
return false;
}
out.emplace_back(*temp_ptr);
}
return true;
}
// Architecture detection.
// MSVC x86_64
@ -213,11 +266,13 @@ recomp::mods::CodeModLoadError recomp::mods::validate_api_version(uint32_t api_v
}
}
recomp::mods::ModHandle::ModHandle(const ModContext& context, ModManifest&& manifest, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& content_types) :
recomp::mods::ModHandle::ModHandle(const ModContext& context, ModManifest&& manifest, ConfigStorage&& config_storage, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& content_types, std::vector<char>&& thumbnail) :
manifest(std::move(manifest)),
config_storage(std::move(config_storage)),
code_handle(),
recompiler_context{std::make_unique<N64Recomp::Context>()},
content_types{std::move(content_types)},
thumbnail{ std::move(thumbnail) },
game_indices{std::move(game_indices)}
{
runtime_toggleable = true;
@ -539,10 +594,12 @@ void unpatch_func(void* target_func, const recomp::mods::PatchData& data) {
protect(target_func, old_flags);
}
void recomp::mods::ModContext::add_opened_mod(ModManifest&& manifest, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& detected_content_types) {
void recomp::mods::ModContext::add_opened_mod(ModManifest&& manifest, ConfigStorage&& config_storage, std::vector<size_t>&& game_indices, std::vector<ModContentTypeId>&& detected_content_types, std::vector<char>&& thumbnail) {
std::unique_lock lock(opened_mods_mutex);
size_t mod_index = opened_mods.size();
opened_mods_by_id.emplace(manifest.mod_id, mod_index);
opened_mods.emplace_back(*this, std::move(manifest), std::move(game_indices), std::move(detected_content_types));
opened_mods.emplace_back(*this, std::move(manifest), std::move(config_storage), std::move(game_indices), std::move(detected_content_types), std::move(thumbnail));
opened_mods_order.emplace_back(mod_index);
}
recomp::mods::ModLoadError recomp::mods::ModContext::load_mod(recomp::mods::ModHandle& mod, std::string& error_param) {
@ -567,10 +624,172 @@ void recomp::mods::ModContext::register_game(const std::string& mod_game_id) {
}
void recomp::mods::ModContext::close_mods() {
std::unique_lock lock(opened_mods_mutex);
opened_mods_by_id.clear();
opened_mods.clear();
opened_mods_order.clear();
mod_ids.clear();
enabled_mods.clear();
auto_enabled_mods.clear();
}
bool save_mod_config_storage(const std::filesystem::path &path, const std::string &mod_id, const recomp::Version &mod_version, const recomp::mods::ConfigStorage &config_storage, const recomp::mods::ConfigSchema &config_schema) {
using json = nlohmann::json;
json config_json;
config_json["mod_id"] = mod_id;
config_json["mod_version"] = mod_version.to_string();
config_json["recomp_version"] = recomp::get_project_version().to_string();
json &storage_json = config_json["storage"];
for (auto it : config_storage.value_map) {
auto id_it = config_schema.options_by_id.find(it.first);
if (id_it == config_schema.options_by_id.end()) {
continue;
}
const recomp::mods::ConfigOption &config_option = config_schema.options[id_it->second];
switch (config_option.type) {
case recomp::mods::ConfigOptionType::Enum:
storage_json[it.first] = std::get<recomp::mods::ConfigOptionEnum>(config_option.variant).options[std::get<uint32_t>(it.second)];
break;
case recomp::mods::ConfigOptionType::Number:
storage_json[it.first] = std::get<double>(it.second);
break;
case recomp::mods::ConfigOptionType::String:
storage_json[it.first] = std::get<std::string>(it.second);
break;
default:
assert(false && "Unknown config type.");
break;
}
}
std::ofstream output_file = recomp::open_output_file_with_backup(path);
if (!output_file.good()) {
return false;
}
output_file << std::setw(4) << config_json;
output_file.close();
return recomp::finalize_output_file_with_backup(path);
}
bool parse_mods_config(const std::filesystem::path &path, std::unordered_set<std::string> &enabled_mods, std::vector<std::string> &mod_order) {
using json = nlohmann::json;
json config_json;
if (!read_json_with_backups(path, config_json)) {
return false;
}
auto enabled_mods_json = config_json.find("enabled_mods");
if (enabled_mods_json != config_json.end()) {
std::vector<std::string> enabled_mods_vector;
if (get_to_vec<std::string>(*enabled_mods_json, enabled_mods_vector)) {
for (const std::string &mod_id : enabled_mods_vector) {
enabled_mods.emplace(mod_id);
}
}
}
auto mod_order_json = config_json.find("mod_order");
if (mod_order_json != config_json.end()) {
get_to_vec<std::string>(*mod_order_json, mod_order);
}
return true;
}
bool save_mods_config(const std::filesystem::path &path, const std::unordered_set<std::string> &enabled_mods, const std::vector<std::string> &mod_order) {
nlohmann::json config_json;
config_json["enabled_mods"] = enabled_mods;
config_json["mod_order"] = mod_order;
std::ofstream output_file = recomp::open_output_file_with_backup(path);
if (!output_file.good()) {
return false;
}
output_file << std::setw(4) << config_json;
output_file.close();
return recomp::finalize_output_file_with_backup(path);
}
void recomp::mods::ModContext::dirty_mod_configuration_thread_process() {
using namespace std::chrono_literals;
ModConfigQueueVariant variant;
ModConfigQueueSaveMod save_mod;
std::unordered_set<std::string> pending_mods;
std::unordered_map<std::string, ConfigStorage> pending_mod_storage;
std::unordered_map<std::string, ConfigSchema> pending_mod_schema;
std::unordered_map<std::string, Version> pending_mod_version;
std::unordered_set<std::string> config_enabled_mods;
std::vector<std::string> config_mod_order;
bool pending_config_save = false;
std::filesystem::path config_path;
bool active = true;
auto handle_variant = [&](const ModConfigQueueVariant &variant) {
if (std::get_if<ModConfigQueueEnd>(&variant) != nullptr) {
active = false;
}
else if (std::get_if<ModConfigQueueSave>(&variant) != nullptr) {
pending_config_save = true;
}
else if (const ModConfigQueueSaveMod* queue_save_mod = std::get_if<ModConfigQueueSaveMod>(&variant)) {
pending_mods.emplace(queue_save_mod->mod_id);
}
};
while (active) {
// Wait for at least one mod to require writing.
mod_configuration_thread_queue.wait_dequeue(variant);
handle_variant(variant);
// Clear out the entire queue to coalesce all writes with a timeout.
while (active && mod_configuration_thread_queue.wait_dequeue_timed(variant, 1s)) {
handle_variant(variant);
}
if (active && !pending_mods.empty()) {
{
std::unique_lock opened_mods_lock(opened_mods_mutex);
for (const std::string &id : pending_mods) {
auto it = opened_mods_by_id.find(id);
if (it != opened_mods_by_id.end()) {
const ModHandle &mod = opened_mods[it->second];
std::unique_lock config_storage_lock(mod_config_storage_mutex);
pending_mod_storage[id] = mod.config_storage;
pending_mod_schema[id] = mod.manifest.config_schema;
pending_mod_version[id] = mod.manifest.version;
}
}
}
for (const std::string &id : pending_mods) {
config_path = mod_config_directory / std::string(id + ".json");
save_mod_config_storage(config_path, id, pending_mod_version[id], pending_mod_storage[id], pending_mod_schema[id]);
}
pending_mods.clear();
}
if (active && pending_config_save) {
{
// Store the enabled mods and the order.
std::unique_lock lock(opened_mods_mutex);
config_enabled_mods = enabled_mods;
config_mod_order.clear();
for (size_t mod_index : opened_mods_order) {
config_mod_order.emplace_back(opened_mods[mod_index].manifest.mod_id);
}
}
save_mods_config(mods_config_path, config_enabled_mods, config_mod_order);
pending_config_save = false;
}
}
}
std::vector<recomp::mods::ModOpenErrorDetails> recomp::mods::ModContext::scan_mod_folder(const std::filesystem::path& mod_folder) {
@ -611,6 +830,40 @@ std::vector<recomp::mods::ModOpenErrorDetails> recomp::mods::ModContext::scan_mo
return ret;
}
void recomp::mods::ModContext::load_mods_config() {
std::unordered_set<std::string> config_enabled_mods;
std::vector<std::string> config_mod_order;
std::vector<bool> opened_mod_is_known;
parse_mods_config(mods_config_path, config_enabled_mods, config_mod_order);
// Fill a vector with the relative order of the mods. Existing mods will get ordered below new mods.
std::vector<size_t> sort_order;
sort_order.resize(opened_mods.size());
opened_mod_is_known.resize(opened_mods.size(), false);
std::iota(sort_order.begin(), sort_order.end(), 0);
for (size_t i = 0; i < config_mod_order.size(); i++) {
auto it = opened_mods_by_id.find(config_mod_order[i]);
if (it != opened_mods_by_id.end()) {
sort_order[it->second] = opened_mods.size() + i;
opened_mod_is_known[it->second] = true;
}
}
// Run the sort using the relative order computed before.
std::iota(opened_mods_order.begin(), opened_mods_order.end(), 0);
std::sort(opened_mods_order.begin(), opened_mods_order.end(), [&](size_t i, size_t j) {
return sort_order[i] < sort_order[j];
});
// Enable mods that are specified in the configuration or mods that are considered new.
for (size_t i = 0; i < opened_mods.size(); i++) {
const std::string &mod_id = opened_mods[i].manifest.mod_id;
if (!opened_mod_is_known[i] || (config_enabled_mods.find(mod_id) != config_enabled_mods.end())) {
enable_mod(mod_id, true, false);
}
}
}
recomp::mods::ModContext::ModContext() {
// Register the code content type.
ModContentType code_content_type {
@ -623,6 +876,8 @@ recomp::mods::ModContext::ModContext() {
// Register the default mod container type (.nrm) and allow it to have any content type by passing an empty vector.
register_container_type(std::string{ modpaths::default_mod_extension }, {}, true);
mod_configuration_thread = std::make_unique<std::thread>(&ModContext::dirty_mod_configuration_thread_process, this);
}
void recomp::mods::ModContext::on_code_mod_enabled(ModContext& context, const ModHandle& mod) {
@ -635,8 +890,11 @@ void recomp::mods::ModContext::on_code_mod_enabled(ModContext& context, const Mo
}
}
// Nothing needed for this, it just need to be explicitly declared outside the header to allow forward declaration of ModHandle.
recomp::mods::ModContext::~ModContext() = default;
recomp::mods::ModContext::~ModContext() {
mod_configuration_thread_queue.enqueue(ModConfigQueueEnd());
mod_configuration_thread->join();
mod_configuration_thread.reset();
}
recomp::mods::ModContentTypeId recomp::mods::ModContext::register_content_type(const ModContentType& type) {
size_t ret = content_types.size();
@ -682,8 +940,9 @@ bool recomp::mods::ModContext::is_content_runtime_toggleable(ModContentTypeId co
return content_types[content_type.value].allow_runtime_toggle;
}
void recomp::mods::ModContext::enable_mod(const std::string& mod_id, bool enabled) {
void recomp::mods::ModContext::enable_mod(const std::string& mod_id, bool enabled, bool trigger_save) {
// Check that the mod exists.
std::unique_lock lock(opened_mods_mutex);
auto find_it = opened_mods_by_id.find(mod_id);
if (find_it == opened_mods_by_id.end()) {
return;
@ -704,21 +963,94 @@ void recomp::mods::ModContext::enable_mod(const std::string& mod_id, bool enable
if (enabled) {
bool was_enabled = enabled_mods.emplace(mod_id).second;
// If mods have been loaded and a mod was successfully enabled by this call, call the on_enabled handlers for its content types.
if (was_enabled && mods_loaded) {
for (ModContentTypeId type_id : mod.content_types) {
content_types[type_id.value].on_enabled(*this, mod);
}
}
if (was_enabled) {
std::vector<std::string> mod_stack;
mod_stack.emplace_back(mod_id);
while (!mod_stack.empty()) {
std::string mod_from_stack = std::move(mod_stack.back());
mod_stack.pop_back();
auto mod_from_stack_it = opened_mods_by_id.find(mod_from_stack);
if (mod_from_stack_it != opened_mods_by_id.end()) {
const ModHandle &mod_from_stack_handle = opened_mods[mod_from_stack_it->second];
for (const Dependency &dependency : mod_from_stack_handle.manifest.dependencies) {
if (!auto_enabled_mods.contains(dependency.mod_id)) {
auto_enabled_mods.emplace(dependency.mod_id);
mod_stack.emplace_back(dependency.mod_id);
if (mods_loaded) {
for (ModContentTypeId type_id : mod_from_stack_handle.content_types) {
content_types[type_id.value].on_enabled(*this, mod_from_stack_handle);
}
}
}
}
}
}
}
}
else {
bool was_disabled = enabled_mods.erase(mod_id) != 0;
// If mods have been loaded and a mod was successfully disabled by this call, call the on_disabled handlers for its content types.
if (was_disabled && mods_loaded) {
for (ModContentTypeId type_id : mod.content_types) {
content_types[type_id.value].on_disabled(*this, mod);
}
}
if (was_disabled) {
// The algorithm needs to be run again with a new set of auto-enabled mods from scratch for all enabled mods.
std::unordered_set<std::string> new_auto_enabled_mods;
for (const std::string &enabled_mod_id : enabled_mods) {
std::vector<std::string> mod_stack;
mod_stack.emplace_back(enabled_mod_id);
while (!mod_stack.empty()) {
std::string mod_from_stack = std::move(mod_stack.back());
mod_stack.pop_back();
auto mod_from_stack_it = opened_mods_by_id.find(mod_from_stack);
if (mod_from_stack_it != opened_mods_by_id.end()) {
const ModHandle &mod_from_stack_handle = opened_mods[mod_from_stack_it->second];
for (const Dependency &dependency : mod_from_stack_handle.manifest.dependencies) {
if (!new_auto_enabled_mods.contains(dependency.mod_id)) {
new_auto_enabled_mods.emplace(dependency.mod_id);
mod_stack.emplace_back(dependency.mod_id);
}
}
}
}
}
if (mods_loaded) {
// Before replacing the old set with the new one, whatever does not exist in the new set anymore should trigger it's on_disabled callback.
for (const std::string &enabled_mod_id : auto_enabled_mods) {
if (!new_auto_enabled_mods.contains(enabled_mod_id)) {
auto enabled_mod_it = opened_mods_by_id.find(enabled_mod_id);
if (enabled_mod_it != opened_mods_by_id.end()) {
const ModHandle &enabled_mod_handle = opened_mods[enabled_mod_it->second];
for (ModContentTypeId type_id : enabled_mod_handle.content_types) {
content_types[type_id.value].on_disabled(*this, enabled_mod_handle);
}
}
}
}
}
auto_enabled_mods = new_auto_enabled_mods;
}
}
if (trigger_save) {
mod_configuration_thread_queue.enqueue(ModConfigQueueSave());
}
}
@ -726,11 +1058,15 @@ bool recomp::mods::ModContext::is_mod_enabled(const std::string& mod_id) {
return enabled_mods.contains(mod_id);
}
bool recomp::mods::ModContext::is_mod_auto_enabled(const std::string& mod_id) {
return auto_enabled_mods.contains(mod_id);
}
size_t recomp::mods::ModContext::num_opened_mods() {
return opened_mods.size();
}
std::vector<recomp::mods::ModDetails> recomp::mods::ModContext::get_mod_details(const std::string& mod_game_id) {
std::vector<recomp::mods::ModDetails> recomp::mods::ModContext::get_mod_details(const std::string &mod_game_id) {
std::vector<ModDetails> ret{};
bool all_games = mod_game_id.empty();
size_t game_index = (size_t)-1;
@ -740,7 +1076,8 @@ std::vector<recomp::mods::ModDetails> recomp::mods::ModContext::get_mod_details(
game_index = find_game_it->second;
}
for (const ModHandle& mod : opened_mods) {
for (size_t mod_index : opened_mods_order) {
const ModHandle &mod = opened_mods[mod_index];
if (all_games || mod.is_for_game(game_index)) {
std::vector<Dependency> cur_dependencies{};
@ -881,6 +1218,177 @@ N64Recomp::Context context_from_regenerated_list(const RegeneratedList& regenlis
return ret;
}
void recomp::mods::ModContext::set_mod_index(const std::string &mod_game_id, const std::string &mod_id, size_t index) {
std::unique_lock lock(opened_mods_mutex);
bool all_games = mod_game_id.empty();
size_t game_index = (size_t)-1;
auto find_game_it = mod_game_ids.find(mod_game_id);
if (find_game_it != mod_game_ids.end()) {
game_index = find_game_it->second;
}
auto id_it = opened_mods_by_id.find(mod_id);
if (id_it == opened_mods_by_id.end()) {
return;
}
size_t mod_index = id_it->second;
size_t search_index = 0;
bool inserted = false;
bool erased = false;
for (size_t i = 0; i < opened_mods_order.size() && (!inserted || !erased); i++) {
size_t current_index = opened_mods_order[i];
const ModHandle &mod = opened_mods[current_index];
if (all_games || mod.is_for_game(game_index)) {
if (index == search_index) {
// This index corresponds to the one from the view. Insert the mod here.
opened_mods_order.insert(opened_mods_order.begin() + i, mod_index);
inserted = true;
}
else if (mod_index == current_index) {
// This index corresponds to the previous position the mod had. Erase it.
opened_mods_order.erase(opened_mods_order.begin() + i);
erased = true;
}
search_index++;
}
}
if (!inserted) {
opened_mods_order.push_back(mod_index);
}
mod_configuration_thread_queue.enqueue(ModConfigQueueSave());
}
const recomp::mods::ConfigSchema &recomp::mods::ModContext::get_mod_config_schema(const std::string &mod_id) const {
// Check that the mod exists.
auto find_it = opened_mods_by_id.find(mod_id);
if (find_it == opened_mods_by_id.end()) {
return empty_schema;
}
const ModHandle &mod = opened_mods[find_it->second];
return mod.manifest.config_schema;
}
const std::vector<char> &recomp::mods::ModContext::get_mod_thumbnail(const std::string &mod_id) const {
// Check that the mod exists.
auto find_it = opened_mods_by_id.find(mod_id);
if (find_it == opened_mods_by_id.end()) {
return empty_bytes;
}
const ModHandle &mod = opened_mods[find_it->second];
return mod.thumbnail;
}
void recomp::mods::ModContext::set_mod_config_value(size_t mod_index, const std::string &option_id, const ConfigValueVariant &value) {
// Check that the mod exists.
if (mod_index >= opened_mods.size()) {
return;
}
ModHandle &mod = opened_mods[mod_index];
std::unique_lock lock(mod_config_storage_mutex);
auto option_by_id_it = mod.manifest.config_schema.options_by_id.find(option_id);
if (option_by_id_it != mod.manifest.config_schema.options_by_id.end()) {
// Only accept setting values if the value exists and the variant is the right type.
const ConfigOption &option = mod.manifest.config_schema.options[option_by_id_it->second];
switch (option.type) {
case ConfigOptionType::Enum:
if (std::holds_alternative<uint32_t>(value)) {
if (std::get<uint32_t>(value) < std::get<ConfigOptionEnum>(option.variant).options.size()) {
mod.config_storage.value_map[option_id] = value;
}
}
break;
case ConfigOptionType::Number:
if (std::holds_alternative<double>(value)) {
mod.config_storage.value_map[option_id] = value;
}
break;
case ConfigOptionType::String:
if (std::holds_alternative<std::string>(value)) {
mod.config_storage.value_map[option_id] = value;
}
break;
default:
assert(false && "Unknown config option type.");
return;
}
}
// Notify the asynchronous thread it should save the configuration for this mod.
mod_configuration_thread_queue.enqueue(ModConfigQueueSaveMod{ mod.manifest.mod_id });
}
void recomp::mods::ModContext::set_mod_config_value(const std::string &mod_id, const std::string &option_id, const ConfigValueVariant &value) {
// Check that the mod exists.
auto find_it = opened_mods_by_id.find(mod_id);
if (find_it == opened_mods_by_id.end()) {
return;
}
set_mod_config_value(find_it->second, option_id, value);
}
recomp::mods::ConfigValueVariant recomp::mods::ModContext::get_mod_config_value(size_t mod_index, const std::string &option_id) {
// Check that the mod exists.
if (mod_index >= opened_mods.size()) {
return std::monostate();
}
const ModHandle &mod = opened_mods[mod_index];
std::unique_lock lock(mod_config_storage_mutex);
auto it = mod.config_storage.value_map.find(option_id);
if (it != mod.config_storage.value_map.end()) {
return it->second;
}
else {
// Attempt to see if we can find a default value from the schema.
auto option_by_id_it = mod.manifest.config_schema.options_by_id.find(option_id);
if (option_by_id_it == mod.manifest.config_schema.options_by_id.end()) {
return std::monostate();
}
const ConfigOption &option = mod.manifest.config_schema.options[option_by_id_it->second];
switch (option.type) {
case ConfigOptionType::Enum:
return std::get<ConfigOptionEnum>(option.variant).default_value;
case ConfigOptionType::Number:
return std::get<ConfigOptionNumber>(option.variant).default_value;
case ConfigOptionType::String:
return std::get<ConfigOptionString>(option.variant).default_value;
default:
assert(false && "Unknown config option type.");
return std::monostate();
}
}
}
recomp::mods::ConfigValueVariant recomp::mods::ModContext::get_mod_config_value(const std::string &mod_id, const std::string &option_id) {
// Check that the mod exists.
auto find_it = opened_mods_by_id.find(mod_id);
if (find_it == opened_mods_by_id.end()) {
return std::monostate();
}
return get_mod_config_value(find_it->second, option_id);
}
void recomp::mods::ModContext::set_mods_config_path(const std::filesystem::path &path) {
mods_config_path = path;
}
void recomp::mods::ModContext::set_mod_config_directory(const std::filesystem::path &path) {
mod_config_directory = path;
}
std::vector<recomp::mods::ModLoadErrorDetails> recomp::mods::ModContext::load_mods(const GameEntry& game_entry, uint8_t* rdram, int32_t load_address, uint32_t& ram_used) {
std::vector<recomp::mods::ModLoadErrorDetails> ret{};
ram_used = 0;
@ -925,7 +1433,7 @@ std::vector<recomp::mods::ModLoadErrorDetails> recomp::mods::ModContext::load_mo
// Find and load active mods.
for (size_t mod_index = 0; mod_index < opened_mods.size(); mod_index++) {
auto& mod = opened_mods[mod_index];
if (mod.is_for_game(mod_game_index) && enabled_mods.contains(mod.manifest.mod_id)) {
if (mod.is_for_game(mod_game_index) && (enabled_mods.contains(mod.manifest.mod_id) || auto_enabled_mods.contains(mod.manifest.mod_id))) {
active_mods.push_back(mod_index);
loaded_mods_by_id.emplace(mod.manifest.mod_id, mod_index);
@ -1033,7 +1541,7 @@ std::vector<recomp::mods::ModLoadErrorDetails> recomp::mods::ModContext::load_mo
for (size_t mod_index : loaded_code_mods) {
auto& mod = opened_mods[mod_index];
std::string cur_error_param;
CodeModLoadError cur_error = resolve_code_dependencies(mod, base_patched_funcs, cur_error_param);
CodeModLoadError cur_error = resolve_code_dependencies(mod, mod_index, base_patched_funcs, cur_error_param);
if (cur_error != CodeModLoadError::Good) {
if (cur_error_param.empty()) {
ret.emplace_back(mod.manifest.mod_id, ModLoadError::FailedToLoadCode, error_to_string(cur_error));
@ -1685,7 +2193,7 @@ recomp::mods::CodeModLoadError recomp::mods::ModContext::load_mod_code(uint8_t*
return CodeModLoadError::Good;
}
recomp::mods::CodeModLoadError recomp::mods::ModContext::resolve_code_dependencies(recomp::mods::ModHandle& mod, const std::unordered_map<recomp_func_t*, overlays::BasePatchedFunction>& base_patched_funcs, std::string& error_param) {
recomp::mods::CodeModLoadError recomp::mods::ModContext::resolve_code_dependencies(recomp::mods::ModHandle& mod, size_t mod_index, const std::unordered_map<recomp_func_t*, overlays::BasePatchedFunction>& base_patched_funcs, std::string& error_param) {
// Reference symbols.
std::string reference_syms_error_param{};
CodeModLoadError reference_syms_error = mod.code_handle->populate_reference_symbols(*mod.recompiler_context, reference_syms_error_param);
@ -1714,6 +2222,13 @@ recomp::mods::CodeModLoadError recomp::mods::ModContext::resolve_code_dependenci
if (dependency_id == N64Recomp::DependencyBaseRecomp) {
recomp_func_t* func_ptr = recomp::overlays::get_base_export(imported_func.base.name);
did_find_func = func_ptr != nullptr;
if (!did_find_func) {
recomp_func_ext_t* func_ext_ptr = recomp::overlays::get_ext_base_export(imported_func.base.name);
did_find_func = func_ext_ptr != nullptr;
if (did_find_func) {
func_ptr = shim_functions.emplace_back(std::make_unique<N64Recomp::ShimFunction>(func_ext_ptr, mod_index)).get()->get_func();
}
}
func_handle = func_ptr;
}
else if (dependency_id == N64Recomp::DependencySelf) {
@ -1856,12 +2371,9 @@ void recomp::mods::ModContext::unload_mods() {
loaded_mods_by_id.clear();
hook_slots.clear();
processed_hook_slots.clear();
shim_functions.clear();
recomp::mods::reset_events();
recomp::mods::reset_hooks();
num_events = recomp::overlays::num_base_events();
active_game = (size_t)-1;
}
void recomp::mods::initialize_mod_recompiler() {
N64Recomp::live_recompiler_init();
}

13
librecomp/src/overlays.cpp
View file

@ -38,6 +38,7 @@ static std::unordered_map<uint32_t, uint16_t> patch_code_sections_by_rom{};
static std::vector<LoadedSection> loaded_sections{};
static std::unordered_map<int32_t, recomp_func_t*> func_map{};
static std::unordered_map<std::string, recomp_func_t*> base_exports{};
static std::unordered_map<std::string, recomp_func_ext_t*> ext_base_exports{};
static std::unordered_map<std::string, size_t> base_events;
static std::unordered_map<uint32_t, recomp_func_t*> manual_patch_symbols_by_vram;
@ -67,6 +68,10 @@ void recomp::overlays::register_base_export(const std::string& name, recomp_func
base_exports.emplace(name, func);
}
void recomp::overlays::register_ext_base_export(const std::string& name, recomp_func_ext_t* func) {
ext_base_exports.emplace(name, func);
}
void recomp::overlays::register_base_exports(const FunctionExport* export_list) {
std::unordered_map<uint32_t, recomp_func_t*> patch_func_vram_map{};
@ -98,6 +103,14 @@ recomp_func_t* recomp::overlays::get_base_export(const std::string& export_name)
return it->second;
}
recomp_func_ext_t* recomp::overlays::get_ext_base_export(const std::string& export_name) {
auto it = ext_base_exports.find(export_name);
if (it == ext_base_exports.end()) {
return nullptr;
}
return it->second;
}
void recomp::overlays::register_base_events(char const* const* event_names) {
for (size_t event_index = 0; event_names[event_index] != nullptr; event_index++) {
base_events.emplace(event_names[event_index], event_index);

73
librecomp/src/recomp.cpp
View file

@ -23,6 +23,7 @@
#include "ultramodern/error_handling.hpp"
#include "librecomp/addresses.hpp"
#include "librecomp/mods.hpp"
#include "recompiler/live_recompiler.h"
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
@ -37,16 +38,6 @@
#define PATHFMT "%s"
#endif
#ifdef _MSC_VER
inline uint32_t byteswap(uint32_t val) {
return _byteswap_ulong(val);
}
#else
constexpr uint32_t byteswap(uint32_t val) {
return __builtin_bswap32(val);
}
#endif
enum GameStatus {
None,
Running,
@ -91,15 +82,29 @@ bool recomp::register_game(const recomp::GameEntry& entry) {
return true;
}
void recomp::mods::initialize_mods() {
N64Recomp::live_recompiler_init();
std::filesystem::create_directories(config_path / mods_directory);
std::filesystem::create_directories(config_path / mod_config_directory);
mod_context->set_mods_config_path(config_path / "mods.json");
mod_context->set_mod_config_directory(config_path / mod_config_directory);
}
void recomp::mods::scan_mods() {
std::vector<recomp::mods::ModOpenErrorDetails> mod_open_errors;
{
std::lock_guard mod_lock{ mod_context_mutex };
mod_open_errors = mod_context->scan_mod_folder(config_path / "mods");
mod_open_errors = mod_context->scan_mod_folder(config_path / mods_directory);
}
for (const auto& cur_error : mod_open_errors) {
printf("Error opening mod " PATHFMT ": %s (%s)\n", cur_error.mod_path.c_str(), recomp::mods::error_to_string(cur_error.error).c_str(), cur_error.error_param.c_str());
}
mod_context->load_mods_config();
}
std::filesystem::path recomp::mods::get_mods_directory() {
return config_path / mods_directory;
}
recomp::mods::ModContentTypeId recomp::mods::register_mod_content_type(const ModContentType& type) {
@ -502,7 +507,7 @@ void ultramodern::quit() {
void recomp::mods::enable_mod(const std::string& mod_id, bool enabled) {
std::lock_guard lock { mod_context_mutex };
return mod_context->enable_mod(mod_id, enabled);
return mod_context->enable_mod(mod_id, enabled, true);
}
bool recomp::mods::is_mod_enabled(const std::string& mod_id) {
@ -510,11 +515,51 @@ bool recomp::mods::is_mod_enabled(const std::string& mod_id) {
return mod_context->is_mod_enabled(mod_id);
}
bool recomp::mods::is_mod_auto_enabled(const std::string& mod_id) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->is_mod_auto_enabled(mod_id);
}
const recomp::mods::ConfigSchema &recomp::mods::get_mod_config_schema(const std::string &mod_id) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->get_mod_config_schema(mod_id);
}
const std::vector<char> &recomp::mods::get_mod_thumbnail(const std::string &mod_id) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->get_mod_thumbnail(mod_id);
}
void recomp::mods::set_mod_config_value(size_t mod_index, const std::string &option_id, const ConfigValueVariant &value) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->set_mod_config_value(mod_index, option_id, value);
}
void recomp::mods::set_mod_config_value(const std::string &mod_id, const std::string &option_id, const ConfigValueVariant &value) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->set_mod_config_value(mod_id, option_id, value);
}
recomp::mods::ConfigValueVariant recomp::mods::get_mod_config_value(size_t mod_index, const std::string &option_id) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->get_mod_config_value(mod_index, option_id);
}
recomp::mods::ConfigValueVariant recomp::mods::get_mod_config_value(const std::string &mod_id, const std::string &option_id) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->get_mod_config_value(mod_id, option_id);
}
std::vector<recomp::mods::ModDetails> recomp::mods::get_mod_details(const std::string& mod_game_id) {
std::lock_guard lock { mod_context_mutex };
return mod_context->get_mod_details(mod_game_id);
}
void recomp::mods::set_mod_index(const std::string &mod_game_id, const std::string &mod_id, size_t index) {
std::lock_guard lock{ mod_context_mutex };
return mod_context->set_mod_index(mod_game_id, mod_id, index);
}
bool wait_for_game_started(uint8_t* rdram, recomp_context* context) {
game_status.wait(GameStatus::None);
@ -643,7 +688,8 @@ void recomp::start(
}
}
recomp::mods::initialize_mod_recompiler();
recomp::mods::initialize_mods();
recomp::mods::scan_mods();
// Allocate rdram without comitting it. Use a platform-specific virtual allocation function
// that initializes to zero. Protect the region above the memory size to catch accesses to invalid addresses.
@ -678,6 +724,7 @@ void recomp::start(
}
recomp::register_heap_exports();
recomp::mods::register_config_exports();
std::thread game_thread{[](ultramodern::renderer::WindowHandle window_handle, uint8_t* rdram) {
debug_printf("[Recomp] Starting\n");