mirror of
https://github.com/Dingo-Shenanigans/ReSkate.git
synced 2026-10-24 20:36:19 +02:00
AyeZeeBB
b67fe93e55
From 2.1.1's Sentry reports (60,000 in three days, 2026-10-21): - Textures: a stale render texture handle takes the game's default texture instead of reading through null (Skate.exe+0x3e897fb, a third of all reports, every one with TheVlixOne-Nike_Pack 2.3.x). - Physics: the wake pass's bitset is made as long as the world's owner list once indices pass 20000, after long multiplayer sessions (+0x3d99e2f, +0x3d9ee43, +0x3d9ee47). - Music: more than 1024 candidates are picked by ReSkate; the game's shuffle wrote past its stack table. - Streaming: a staged read's piece that reaches past its 64 KB buffer is left unfilled (VCRUNTIME memcpy). - Multiplayer: a remote skater or board whose parent bus link is damaged is left alive instead of destroyed (+0x2b94cd0). - Mesh pool: on an integrated GPU its budget is capped by the RAM and page file free; the Memory line says what the PC has left. Launcher: - A folder with non-ASCII letters is a hard stop (the boot crash +0x18df4cf came after "Start anyway"). - The game's data files are checked against the supported build's sizes (from Steam's manifest); missing, cut-short or online-only files send the player to verifying. - One game per folder: the launcher will not merge or start while one runs there, and ReSkate.dll holds the folder's mutex. - Advice on the ready screen for PCs short of RAM and page file; reports carry pc.ram_gb and pc.commit_free_gb. Stuck loads: - A load in one stage for two minutes sends a stuck-load report (every thread's stack and the log, error.type stall, load.stage, load.seconds) while the game goes on (crash protocol 6). - A load the player closes sends its timing with the stage it was in. Logs: the PanelTrace diagnostics and the neighborhood unlock override's observation lines are gone.
63 lines
2.6 KiB
C++
63 lines
2.6 KiB
C++
#include "texture_handle_guard.h"
|
|
#include "Engine/Core/Hooks/hooks.h"
|
|
#include "Engine/Core/Log/logging.h"
|
|
#include "Engine/Core/Platform/memory.h"
|
|
#include "Engine/Game/Build/addresses.h"
|
|
#include "Engine/Game/Build/20260929/texture_handles.h"
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <bit>
|
|
|
|
namespace dingosdk::texture_handle_guard {
|
|
namespace {
|
|
namespace th = addr::texture_handles;
|
|
using Redirect = std::uintptr_t* (*)(std::uintptr_t, std::uint16_t);
|
|
Redirect original{};
|
|
std::atomic<bool> installed{};
|
|
std::atomic<std::uint64_t> misses{};
|
|
// What both callers read when there is nothing: a holder with no texture in it, which sends them
|
|
// to the pool's default for the id.
|
|
std::uintptr_t no_texture{};
|
|
|
|
// Said for the first few, then each power of two: a stale handle is resolved on every frame it
|
|
// is drawn.
|
|
__declspec(noinline) void note(std::uint16_t id) noexcept {
|
|
const auto count = misses.fetch_add(1, std::memory_order_relaxed) + 1;
|
|
if (count > 4 && !std::has_single_bit(count)) return;
|
|
try {
|
|
logging::log(logging::Level::warning, logging::Channel::runtime,
|
|
"Textures: a texture handle ({:#x}) names a texture that is gone, where the game would have crashed; the default "
|
|
"texture is drawn for it ({} time(s) since the game started). A mod's material that keeps a texture another "
|
|
"bundle unloaded does this.", id, count);
|
|
} catch (...) {}
|
|
}
|
|
|
|
std::uintptr_t* guarded(std::uintptr_t pool, std::uint16_t id) {
|
|
if (auto* const holder = original(pool, id)) return holder;
|
|
note(id);
|
|
return &no_texture;
|
|
}
|
|
} // namespace
|
|
|
|
bool install(std::uintptr_t base) noexcept {
|
|
if (installed.exchange(true)) return original != nullptr;
|
|
if (!base) return false;
|
|
std::array<unsigned char, 32> head{};
|
|
if (!memory::peek(base + th::redirect.rva, head) || head != th::redirect.bytes) {
|
|
logging::log(logging::Level::warning, logging::Channel::runtime,
|
|
"Texture handle guard: this build's texture code differs; it is left as it is.");
|
|
return false;
|
|
}
|
|
const auto target = reinterpret_cast<void*>(base + th::redirect.rva);
|
|
if (hook_prepare(target, reinterpret_cast<void*>(&guarded), reinterpret_cast<void**>(&original)) != HookOk ||
|
|
hook_enable(target) != HookOk) {
|
|
original = nullptr;
|
|
logging::log(logging::Level::warning, logging::Channel::runtime, "Texture handle guard: the game's function could not be hooked.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::uint64_t stale() noexcept { return misses.load(std::memory_order_relaxed); }
|
|
} // namespace dingosdk::texture_handle_guard
|