mirror of
https://github.com/Dingo-Shenanigans/ReSkate.git
synced 2026-10-23 10:45:55 +02:00
AyeZeeBB
719cba1166
Players reported the game hanging for about a second while skating. A profile showed the memory line in the log walking every heap (HeapSummary) on the client thread, 0.5 to 2 s every two minutes. An audit of everything that runs on the game's update and render threads found more of the same, and Sentry's top crashes had causes of ours. Freezes: - Memory log line: no heap walk or thread snapshot; the GPU part and the write happen on a thread of their own. - Profile database: synchronous=NORMAL in WAL mode. A save is still kept when the game crashes; every play event no longer waits for the disk inside the game's hooks. - ReSkate's own preferences and values (menu clicks, session sliders, Discord) are saved by a background writer in order; reads see a value until it is saved. - Input: the foreground window and the keyboard are sampled on a thread of their own (GetAncestor and GetAsyncKeyState stalled the client tick 40-50 ms when another program held Windows' lock); flight input uses the sample; ClipCursor at most twice a second while a menu has the pointer. - Hooks installed while the game runs go in one transaction per place (HookBatch): throwdowns, remote players, the party, Hall of Meat. - Off the update thread: the host's map package lookup (one table read in the background, not the Mods folder per offer), the trainer's map file and settings save, Board Break's settings save, mod music playlists and their covers, the Spotify station covers. - Off the render thread: the Modding page's and the deck card's Mods folder reads. The overlay's three startup waits share five seconds. - Less work per frame: Steam names reused while one a frame is asked again, 2 friends a tick, steam_api64.dll checked once per process, cosmetic names read in place rather than a system call per character, an outfit load no longer copies the inventory per slot, the throwdown type scan runs at background priority over resident memory, the Board Break deck label is kept a minute. Crashes: - Render-resource pool: the metadata fields are written to the state owner only. The other renderer is 0x2daa00 bytes, and +0x11aae28 is far past its end (store_field crash; heap corruption in every release). - Other players' skateboard effects: a stale skateboard component is no longer followed, and the joint lookup is walked with a bound first (an endless loop in reused memory ended in GameStall). - Launcher: Oodle decodes into the buffer it asks for with corrupt data possible, and its assertions no longer stop the process (heap corruption in the store-copy scan; a breakpoint in oo2core). Timings (Send performance timings): - A frame of half a second or more in a level is sent as game.freeze: where the time went (ReSkate's tick, the game's frame, or outside it), whether the renderer kept presenting, and ReSkate's busiest zones. - Closing the game sends the level session it was in. Music after a connection drop: - Spotify device: an account Spotify could not be reached with is kept and tried again (3 s doubling to a minute); a session that drops is taken up again. Only an account Spotify refuses is asked for anew. - YouTube playlist pictures that could not be fetched are tried again, from 30 s to 10 minutes apart.
67 lines
4.2 KiB
C++
67 lines
4.2 KiB
C++
#pragma once
|
|
#include <array>
|
|
#include <cstdint>
|
|
|
|
// Skater effects (sparks, dust, landing puffs, costume and board effects): the game's skater
|
|
// effects manager.
|
|
namespace dingosdk::game::build::v20260929::native_vfx {
|
|
struct Function {
|
|
std::uintptr_t rva;
|
|
std::array<unsigned char, 16> prefix;
|
|
};
|
|
// (manager, key, component): a skater's effects component registers with the manager.
|
|
inline constexpr Function register_skater{
|
|
0x4874800, {0x48,0x8b,0xc4,0x53,0x48,0x83,0xec,0x60,0x48,0x89,0x68,0x08,0x48,0x8d,0x59,0x78}};
|
|
// (manager, key, impact): the effect of one contact with the world, chosen by the surface's
|
|
// material and the speed. Each call is one effect that ends by itself. Reads the calling
|
|
// thread's world.
|
|
inline constexpr Function impact{
|
|
0x486cda0, {0x48,0x8b,0xc4,0x4c,0x89,0x40,0x18,0x48,0x89,0x50,0x10,0x48,0x89,0x48,0x08,0x48}};
|
|
// (manager, key): the skater's effects are stopped and built again from its settings at the
|
|
// manager's next update. Takes the manager's own lock.
|
|
inline constexpr Function refresh{
|
|
0x4874a20, {0x40,0x53,0x48,0x83,0xec,0x40,0x48,0x89,0x6c,0x24,0x50,0x48,0x8d,0x99,0xb0,0x00}};
|
|
// (manager, uint64 *effects_entity, int id, settings, char flag, char queued): builds a skater's
|
|
// effects from its settings, a pointer to an array of effect sets (pointers, bit 2 a flag;
|
|
// the count sits four bytes before the first). Called for each refreshed skater from the
|
|
// manager's update.
|
|
inline constexpr Function build_effects{
|
|
0x48700c0, {0x44,0x89,0x44,0x24,0x18,0x48,0x89,0x54,0x24,0x10,0x48,0x89,0x4c,0x24,0x08,0x55}};
|
|
// Manager: the root of its map of registered skaters; a node's id and effects component.
|
|
inline constexpr std::size_t manager_skaters_root = 0x58, skater_node_id = 0x20, skater_node_component = 0x30;
|
|
// An effects component: what holds its entity.
|
|
inline constexpr std::size_t component_owner = 0x18;
|
|
// (rig, joint id, 1): the joint's index in the rig's skeleton, or -1. Reads no pose.
|
|
inline constexpr Function joint_index{
|
|
0x12e08b0, {0x48,0x8b,0x89,0x38,0x01,0x00,0x00,0xe9,0x84,0x76,0x5b,0x03,0xcc,0xcc,0xcc,0xcc}};
|
|
// joint_index looks the joint up in the skeleton's map (EASTL: a node's right child at +0, its
|
|
// left at +8, its joint id at +0x20; the root at skeleton +0x68), with no bound on the walk
|
|
// (0x4897f40).
|
|
inline constexpr std::size_t skeleton_joints_root = 0x68, joint_node_right = 0, joint_node_left = 8, joint_node_id = 0x20;
|
|
// An effects component's rig: component -> its rig's owner -> the rig; the rig's skeleton. An
|
|
// effect set's effects (an array of pointers), and the joint each sits on (-1: none).
|
|
inline constexpr std::size_t component_rig_owner = 0x50, rig_owner_rig = 0x78, rig_skeleton = 0x138, set_items = 0x30,
|
|
item_joint = 0x44;
|
|
// How an effect set is started, and the value for one that is always on.
|
|
inline constexpr std::size_t set_trigger = 0x80;
|
|
inline constexpr std::int32_t trigger_always = 3;
|
|
// (out): the calling thread's world, or null.
|
|
inline constexpr Function thread_world{
|
|
0x18b6ae0, {0x48,0x89,0x5c,0x24,0x08,0x57,0x48,0x83,0xec,0x20,0x65,0x48,0x8b,0x04,0x25,0x58}};
|
|
// Offsets into the world, each stored as a 32-bit value: the effects manager, and the object
|
|
// that holds the level's material grid.
|
|
inline constexpr std::uintptr_t manager_offset = 0x77abaa8, materials_offset = 0x74f8e38;
|
|
inline constexpr std::size_t manager_ready = 0x240; // byte: the manager is in use
|
|
inline constexpr std::size_t materials_ready = 0x50; // byte: the grid object is in use
|
|
inline constexpr std::size_t materials_grid = 0x28; // the grid
|
|
inline constexpr std::size_t grid_data = 8; // its data (bit 2 is a flag)
|
|
inline constexpr std::size_t grid_index_table = 0x48; // data: pointer to the index table
|
|
// The effects component of a skater entity.
|
|
inline constexpr std::uintptr_t component_vtable = 0x65ec508;
|
|
inline constexpr std::size_t component_size = 0x68;
|
|
// The impact: position, velocity and normal as four floats each, then the material.
|
|
inline constexpr std::size_t impact_size = 0x40, impact_velocity = 0x10, impact_normal = 0x20, impact_material = 0x30;
|
|
inline constexpr std::uint32_t material_valid = 0x20;
|
|
inline constexpr unsigned material_shift = 6;
|
|
}
|