DieMitchell/ReSkate
1
0 Fork 0
mirror of https://github.com/Dingo-Shenanigans/ReSkate.git synced 2026-10-27 16:17:08 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
c29cffdf9beeff56002f82b5e6f4a89d22a26d22
ReSkate/Extension/Customization/board_material.cpp
T

306 lines
15 KiB
C++
Raw Blame History

#include "board_material.h"
#include "worn_items.h"
#include "Engine/Game/Build/supported_build.h"
#include "local_customization_runtime.h"
#include "Engine/Core/Log/logging.h"
#include "Engine/Core/Platform/memory.h"
#include "Engine/Vfs/content_catalogs.h"
#include "Engine/Vfs/mod_catalog.h"
#include "Engine/Vfs/mod_item_sources.h"
#include "Extension/Multiplayer/Remote/native_pose_layout.h"
#include "Extension/Multiplayer/Remote/native_skater.h"
#include <Windows.h>
#include <format>
#include <fstream>
#include <iterator>
#include <memory>
#include <mutex>
#include <thread>
namespace dingosdk::board_material {
namespace {
struct State {
std::uintptr_t base{}, client{};
std::vector<detail::Hold> holds;
std::vector<detail::Saved> saved;
std::optional<bool> functions; // the material publisher's bytes, once checked
std::optional<bool> setter; // the typed setter's bytes and the ColorRgb descriptor, once checked
std::uint16_t colour_type{}; // the ColorRgb descriptor's type index
std::uint64_t reported{};
std::uint64_t apply_reported{};
// The board's items as last read (worn_items::worn_board), and when.
std::vector<worn_items::Worn> worn;
std::uint64_t worn_at{};
std::array<detail::Gate, part_names.size()> gates;
// The item each part was last reported as wearing: once per change, so a mod's maker can read
// the key their reskate-materials.json has to name from the log.
std::array<std::string, part_names.size()> reported_items;
std::array<std::size_t, part_names.size()> reported_counts{};
};
State& state() {
static auto* value = new State; // what is held may still be out at exit
return *value;
}
const auto peek = [](std::uintptr_t address, void* out, std::size_t size) { return memory::peek_bytes(address, out, size); };
bool write_value(std::uintptr_t material, std::uintptr_t node, const float* value, std::size_t bytes) noexcept {
__try {
std::memcpy(reinterpret_cast<void*>(node + addr::native_cosmetics::parameter_value), value, bytes);
*reinterpret_cast<std::uint8_t*>(material + addr::native_cosmetics::material_changed) = 1;
return true;
} __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
bool publish_materials(std::uintptr_t base, std::uintptr_t item) noexcept {
__try {
reinterpret_cast<void (*)(std::uintptr_t, int)>(base + addr::native_cosmetics::publish_materials)(item, 0);
return true;
} __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
// A declared colour the material does not hold yet, added by the engine's own typed setter
// (MaterialInstance:addEsVector's, as developer_board.cpp adds the board's colours): it allocates,
// hashes and links the node itself. Priority zero, a native preset's, so a later preset replaces it.
bool insert_colour(std::uintptr_t base, std::uint16_t type_index, std::uintptr_t material, const detail::Declared& declared,
const Colour& value) noexcept {
const developer_hoodie_detail::ParameterKey key{declared.identity, sizeof(Colour), type_index, 1, declared.key};
const developer_board_detail::NativeColor native{value, 0, base + addr::native_cosmetics::color_rgb_type};
__try {
return reinterpret_cast<std::uint64_t (*)(std::uintptr_t, const developer_hoodie_detail::ParameterKey*,
const developer_board_detail::NativeColor*, std::uint8_t)>(
base + addr::native_cosmetics::set_shader_parameter)(material, &key, &native, 0) != 0;
} __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
bool functions_match(State& s) {
if (!s.functions) {
std::array<unsigned char, addr::native_cosmetics::publish_materials_prefix.size()> bytes{};
s.functions = peek(s.base + addr::native_cosmetics::publish_materials, bytes.data(), bytes.size()) &&
bytes == addr::native_cosmetics::publish_materials_prefix;
if (!*s.functions)
logging::log(logging::Level::warning, logging::Channel::customization,
"Board parameters: the material publisher differs from the supported build; plugins cannot set them.");
}
return *s.functions;
}
// The typed setter, and the ColorRgb type it is given, as the supported build has them (checked as
// developer_board_detail::materials checks the descriptor). Without them nothing declared is added.
bool setter_matches(State& s) {
if (!s.setter) {
namespace n = addr::native_cosmetics;
std::array<unsigned char, n::set_shader_parameter_prefix.size()> bytes{};
std::uintptr_t info{};
std::uint32_t hash{};
std::uint16_t size{}, index{};
const auto type = s.base + n::color_rgb_type;
s.setter = peek(s.base + n::set_shader_parameter, bytes.data(), bytes.size()) && bytes == n::set_shader_parameter_prefix &&
peek(type, &info, sizeof(info)) && info >= s.base && info < s.base + supported_build::game_image_size && peek(info, &hash, sizeof(hash)) &&
hash == n::color_rgb_type_hash && peek(info + 6, &size, sizeof(size)) && size == sizeof(Colour) &&
peek(type + 8, &index, sizeof(index));
s.colour_type = index;
if (!*s.setter)
logging::log(logging::Level::warning, logging::Channel::customization,
"Board parameters: the material setter differs from the supported build; declared colours cannot be added.");
}
return *s.setter;
}
// ---- declarations: every enabled mod's reskate-materials.json -------------------------------------------
// Read on a thread of their own and again only when a file changes, as the mods' music is
// (local_music_assets.cpp): the game's frame never waits on the disk.
struct DeclarationSet {
std::vector<mods::MaterialDeclaration> materials;
std::vector<mods::ItemSource> sources;
};
struct Declarations {
std::mutex mutex;
std::shared_ptr<const DeclarationSet> ready;
bool reading{};
std::uint64_t looked{};
};
Declarations& declarations() {
static auto* value = new Declarations;
return *value;
}
DeclarationSet read_declarations() {
DeclarationSet result;
const auto active=mods::load_catalog(mods::catalog().data_root,{},false);
result.sources=mods::read_item_sources(active.root/L".reskate"/mods::item_sources_file);
for (const auto& mod : active.mods) {
const auto path = mod.directory / L"reskate-materials.json";
std::error_code error;
if (!std::filesystem::is_regular_file(path, error) || std::filesystem::file_size(path, error) > 64 * 1024) continue;
try {
std::ifstream in(path, std::ios::binary);
auto read = mods::parse_material_declarations(mod.name, std::string((std::istreambuf_iterator<char>(in)), {}));
std::size_t count{};
for (const auto& d : read) count += d.parameters.size();
logging::log(logging::Level::info, logging::Channel::customization,
"Board parameters: {} declares {} shader input{} for its items.", mod.name, count, count == 1 ? "" : "s");
std::move(read.begin(), read.end(), std::back_inserter(result.materials));
} catch (const std::exception& failure) {
logging::log(logging::Level::warning, logging::Channel::customization,
"Board parameters: {}'s reskate-materials.json is left out: {}", mod.name, failure.what());
}
}
return result;
}
void read_declarations_now() noexcept {
auto& d = declarations();
std::shared_ptr<const DeclarationSet> read;
try {
read = std::make_shared<const DeclarationSet>(read_declarations());
} catch (...) {}
std::lock_guard lock(d.mutex);
if (read) {
d.ready = std::move(read);
} else if (!d.ready) {
d.ready = std::make_shared<const DeclarationSet>();
}
d.reading = false;
}
// What was last read, and a read started when the last began two seconds ago or more.
std::shared_ptr<const DeclarationSet> current_declarations() {
auto& d = declarations();
std::lock_guard lock(d.mutex);
const auto now = GetTickCount64();
if (!d.reading && (!d.ready || now - d.looked >= 2000)) {
d.reading = true;
d.looked = now;
try {
std::thread(read_declarations_now).detach();
} catch (...) {
d.reading = false;
}
}
return d.ready;
}
// All stock/developer items are excluded, free or paid. Unknown catalogue
// state is refused too; ownership is additionally checked against item sources.
bool sold(std::string_view item) {
std::string key(item); for(auto& c:key)if(c>='A'&&c<='Z')c=static_cast<char>(c+32);
const auto& catalog=content_cache::catalogs();
return !catalog.available || catalog.items.contains(key) || key.starts_with("dev_") || key.starts_with("own_dev_") || profile_runtime::reserved_cosmetic(item);
}
constexpr std::array<std::string_view, part_names.size()> worn_slots{"Deck", "Grip tape", "Trucks", "Wheels"};
// The equipped items' declarations, on the board found: a part's apply once its item and material
// have settled (detail::settled).
void declare(State& s, detail::Found& found) {
const auto all = current_declarations();
if (!all) { found.pending=true; return; }
const auto now = GetTickCount64();
if (now - s.worn_at >= 250 || s.worn.empty()) {
s.worn = worn_items::worn_board(false);
s.worn_at = now;
}
for (std::size_t part = 0; part < part_names.size(); ++part) {
std::string_view item;
for (const auto& w : s.worn)
if (w.slot == worn_slots[part]) item = w.item;
std::uintptr_t material{};
for (const auto& m : found.materials)
if (static_cast<std::size_t>(m.part) == part) { material = m.address; break; }
if (!detail::settled(s.gates[part], item, material, now) || found.pending) {
found.declarations_pending[part]=true;
continue;
}
auto is_sold = [](std::string_view i) { return sold(i); };
std::string key(item);for(auto& c:key)if(c>='A'&&c<='Z')c=static_cast<char>(c+32);
std::string_view owner;
for(const auto& source:all->sources) {
if(std::find(source.keys.begin(),source.keys.end(),key)!=source.keys.end()){owner=source.mod;break;}
}
auto add = detail::declared_for(all->materials, static_cast<Part>(part), item, is_sold, owner);
// Report a hot-reloaded declaration even when the worn item did not change.
if (s.reported_items[part] != item || s.reported_counts[part] != add.size()) {
s.reported_items[part] = std::string(item);
s.reported_counts[part] = add.size();
logging::log(logging::Level::info, logging::Channel::customization,
"Board parameters: the {} is {}; {} declared shader input{} apply.", part_names[part], item,
add.size(), add.size() == 1 ? "" : "s");
}
found.declared.insert(found.declared.end(), add.begin(), add.end());
}
}
// The local player's board as it is now (a change of cosmetics can replace it); none out of play.
std::optional<detail::Found> board(State& s) {
if (!s.base || !s.client) return std::nullopt;
try {
const auto local = multiplayer::capture_local(s.base, s.client, false);
if (!local.ready) return std::nullopt;
const auto entity = multiplayer::read_native_board(peek, s.base, local.entity).entity;
if (!entity) return std::nullopt;
auto found = detail::walk(peek, s.base, entity);
declare(s, found);
return found;
} catch (const std::exception& error) {
// (Once in a while: a board being built reads as unfinished for a few ticks.)
if (const auto now = GetTickCount64(); now - s.reported > 10000) {
s.reported = now;
logging::log(logging::Level::debug, logging::Channel::customization, "Board parameters: {}", error.what());
}
return std::nullopt;
}
}
} // namespace
std::optional<std::vector<Parameter>> read(Part part) {
auto& s = state();
const auto found = board(s);
if (!found) return std::nullopt;
return detail::listed(*found, part);
}
std::string set(std::string_view owner, Part part, std::uint64_t key, const Colour& value, bool colour) {
auto& s = state();
const auto found = board(s);
if (!found) return "there is no board in play";
Kind kind{};
if (auto why = detail::refusal(*found, part, key, value, colour, kind); !why.empty()) return why;
if (!functions_match(s)) return "board parameters are unavailable with this game build";
if (detail::declared(*found, part, key) && !detail::live(*found, part, key) && !setter_matches(s))
return "declared colours cannot be added with this game build";
return detail::take(s.holds, *found, owner, part, key, value, colour);
}
void clear(std::string_view owner, std::optional<Part> part, std::optional<std::uint64_t> key) {
detail::release(state().holds, owner, part, key);
}
void tick(std::uintptr_t base, std::uintptr_t client) noexcept {
try {
auto& s = state();
s.base = base, s.client = client;
if (s.holds.empty() && s.saved.empty()) return;
if (!functions_match(s)) return;
const auto found = board(s);
if (!found) return;
if (const auto dropped = detail::drop_undeclared(s.holds, *found))
logging::log(logging::Level::info, logging::Channel::customization,
"Board parameters: {} declared value{} let go: the item that declared {} is no longer on the board.", dropped,
dropped == 1 ? "" : "s", dropped == 1 ? "it" : "them");
auto write = [](std::uintptr_t material, std::uintptr_t node, Kind kind, const Colour& value) {
return write_value(material, node, value.data(), kind == Kind::colour ? sizeof(Colour) : sizeof(float));
};
std::size_t inserted{}, refused{}, published{}, publish_failed{};
auto publish = [&](std::uintptr_t item) {
const bool ok = publish_materials(s.base, item);
if (ok) ++published;
else ++publish_failed;
};
auto insert = [&](std::uintptr_t material, const detail::Declared& declared, const Colour& value) {
const bool added = setter_matches(s) && insert_colour(s.base, s.colour_type, material, declared, value);
if (added) ++inserted;
else ++refused;
return added;
};
detail::apply(s.saved, s.holds, *found, write, publish, insert);
// Lua accepts a hold before this tick applies it; report native failures separately.
if ((inserted || refused || publish_failed) && GetTickCount64() - s.apply_reported >= 5000) {
s.apply_reported = GetTickCount64();
logging::log(logging::Level::info, logging::Channel::customization,
"Board parameter apply: {} inserted, {} refused, {} published, {} publication failures.",
inserted, refused, published, publish_failed);
}
} catch (...) {}
}
} // namespace dingosdk::board_material
Reference in new issue View Git Blame Copy Permalink