mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-22 13:05:57 +00:00
Merge branch 'dev' into task/uboverlay
# Conflicts: # runtime/cfg.c
This commit is contained in:
commit
4402b030fe
52 files changed
+3772
-259
No files matched your search
@@ -307,6 +307,7 @@ void rt_frame_presented(const tex_t *t, uint64_t n) {
|
||||
fflush(stderr);
|
||||
fs_save_flush();
|
||||
vk_pipeline_save(); // no-op without the Vulkan back end
|
||||
playtime_save();
|
||||
prof_write();
|
||||
fflush(stderr);
|
||||
plat_exit(0);
|
||||
|
||||
+56
-11
@@ -7,6 +7,7 @@
|
||||
// cfg_get handed out stays valid) and cfg_save writes only the changed keys back, keeping the rest of the file.
|
||||
// Readers take no lock: an entry is complete before n_entries counts it, and value pointers are swapped atomically.
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -41,15 +42,16 @@ static const char *const known[] = {
|
||||
"COLOR_PRESET", "COLOR_SATURATION", "CONTACT_DEBUG", "CONTACT_SHADOWS", "CORE_DIAG", "CRIT", "CRIT_OUT",
|
||||
"DESC_TEMPLATE", "DEVICE_PROFILE", "DISCORD_APP_ID", "DISCORD_IMAGE", "DISCORD_RPC", "DLAA", "DLAA_JITTER", "DLAA_MV", "DLAA_MASKDEBUG", "DLAA_MVDEBUG", "DLAA_OBJMV", "DLAA_SURVEY", "DLAA_TIMES", "DLSS", "DLSS_CHAR_MASK", "DLSS_PRESET", "DLSS_REACTIVE", "DUMP", "DUMP_BUF", "DUMP_DIR",
|
||||
"DUMP_LOG", "EXEFS", "FEEDBACK", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES",
|
||||
"FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FLUSH_SPAN", "FOV", "FOV_PATCH", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES",
|
||||
"FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FLUSH_SPAN", "FOV", "FOV_PATCH", "FPS60", "FPS_LIMIT", "FRAME_QUEUE",
|
||||
"FREEZE_IDLE", "FREE_CORES",
|
||||
"FULLSCREEN", "FXAA", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HDR", "HDR_GAME_NITS", "HDR_HUE",
|
||||
"HDR_PEAK_NITS", "HDR_UI_NITS", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD",
|
||||
"LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "LSTICK_DEADZONE", "MEMORY", "MENU_LANG", "MENU_TEST",
|
||||
"MENU_CURSOR", "MENU_CURSOR_LOG", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MODS_DIR", "MODS_DISABLED", "MODS_ORDER", "MODS_REBUILD", "MOTION", "MOUSE_MODE", "MOUSE_DIRECT_PATCH", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE",
|
||||
"MENU_CURSOR", "MENU_CURSOR_LOG", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MODS_DIR", "MODS_DISABLED", "MODS_ORDER", "MODS_REBUILD", "MOTION", "MOUSE_AIM_SCALE", "MOUSE_MODE", "MOUSE_DIRECT_PATCH", "MOUSE_SENS", "MOVIE_ASPECT", "MOVIE_HOST", "MOVIE_PACE",
|
||||
"MVOBJ_ALL", "MVOBJ_BANKS", "MVOBJ_EQUAL", "MVOBJ_EXACT", "MVOBJ_EXEC", "MVOBJ_NOC4", "MVOBJ_ONLY", "MVOBJ_TIMES", "MVPREV_CHECK", "MVPREV_GROW", "MVPREV_SKIP", "MVPREV_TRUST", "MV_CHECK",
|
||||
"MV_SURVEY",
|
||||
"ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT",
|
||||
"PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES",
|
||||
"PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_BENCH", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES",
|
||||
"PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_END", "REEXEC",
|
||||
"RENDER_SCALE", "REPLAY_ASYNC",
|
||||
"REPLAY_CHECK", "RESOLVE_CHECK", "RESTART_WAIT", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES",
|
||||
@@ -58,18 +60,18 @@ static const char *const known[] = {
|
||||
"SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "STICK_DEADZONE", "STICK_SENS",
|
||||
"SWKBD_ANSWER",
|
||||
"SWKBD_TEST", "TEST_PAD", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_MEMO", "TEX_VRAM_PRESSURE", "TIMER_1MS", "TRACE", "TXD_TRANSPOSE", "UBO_SNAPSHOT", "UB_OVERLAY", "UPSCALER", "VK_DYN_A2C", "VK_DYN_VERTEX", "VK_NO_FLOAT64",
|
||||
"VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS",
|
||||
"VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VRAM_LIMIT_MIB", "VS_OUTS",
|
||||
"WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS",
|
||||
"ZSTD_CHECK", "ZSTD_NATIVE",
|
||||
};
|
||||
|
||||
// The totk.ini section a key cfg_set may write goes to when the file lacks it (totk.ini.example's sections).
|
||||
static const struct { const char *key, *section; } sections[] = {
|
||||
{"FPS_LIMIT", "frame rate"}, {"FPS60", "frame rate"},
|
||||
{"FPS_LIMIT", "frame rate"}, {"FPS60", "frame rate"}, {"FRAME_QUEUE", "frame rate"},
|
||||
{"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"},
|
||||
{"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"},
|
||||
{"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"},
|
||||
{"SHARPNESS", "display"}, {"ASPECT", "display"}, {"FOV", "display"}, {"ANISO", "display"},
|
||||
{"SHARPNESS", "display"}, {"ASPECT", "display"}, {"MOVIE_ASPECT", "display"}, {"FOV", "display"}, {"ANISO", "display"},
|
||||
{"COLOR_PRESET", "display"},
|
||||
{"COLOR_BRIGHTNESS", "display"}, {"COLOR_CONTRAST", "display"}, {"COLOR_SATURATION", "display"},
|
||||
{"COLOR_GAMMA", "display"}, {"HDR", "display"}, {"HDR_PEAK_NITS", "display"}, {"HDR_GAME_NITS", "display"},
|
||||
@@ -85,7 +87,7 @@ static const struct { const char *key, *section; } sections[] = {
|
||||
{"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"},
|
||||
{"PAD_LAYOUT", "input"}, {"PROMPTS", "input"}, {"STICK_DEADZONE", "input"}, {"LSTICK_DEADZONE", "input"}, {"RSTICK_DEADZONE", "input"},
|
||||
{"STICK_SENS", "input"},
|
||||
{"MENU_CURSOR", "input"}, {"MOUSE_MODE", "input"}, {"MOUSE_SENS", "input"}, {"WALK_KEY", "input"}, {"WALK_SCALE", "input"}, {"INPUT_RECORD", "input"},
|
||||
{"MENU_CURSOR", "input"}, {"MOUSE_MODE", "input"}, {"MOUSE_SENS", "input"}, {"MOUSE_AIM_SCALE", "input"}, {"WALK_KEY", "input"}, {"WALK_SCALE", "input"}, {"INPUT_RECORD", "input"},
|
||||
{"BIND_A", "input"}, {"BIND_B", "input"}, {"BIND_X", "input"}, {"BIND_Y", "input"}, {"BIND_LCLICK", "input"},
|
||||
{"BIND_RCLICK", "input"}, {"BIND_L", "input"}, {"BIND_R", "input"}, {"BIND_ZL", "input"}, {"BIND_ZR", "input"},
|
||||
{"BIND_PLUS", "input"}, {"BIND_MINUS", "input"}, {"BIND_LEFT", "input"}, {"BIND_UP", "input"},
|
||||
@@ -120,7 +122,7 @@ static const CfgMeta metas[] = {
|
||||
{"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance|ultra_performance", LIVE},
|
||||
{"DLSS_PRESET", "default", "default|k|j", LIVE},
|
||||
{"DLSS_CHAR_MASK", "65", "0|35|65|100", LIVE}, {"FXAA", "1", "0|1", LIVE},
|
||||
{"ASPECT", "fit", "fit|stretch", LIVE}, {"FOV", "100", "70..140", LIVE},
|
||||
{"ASPECT", "fit", "fit|stretch", LIVE}, {"MOVIE_ASPECT", "keep", "keep|stretch", LIVE}, {"FOV", "100", "70..140", LIVE},
|
||||
{"ANISO", "game", "game|2|4|8|16", RESTART}, // vk_texture.c sampler_features
|
||||
// colour adjustment (vk_color.c); the preset is the menu's, the four values are what the present uses
|
||||
{"COLOR_PRESET", "default", "default|vivid|clarity|custom", LIVE}, {"COLOR_BRIGHTNESS", "0", "-30..30", LIVE},
|
||||
@@ -135,7 +137,7 @@ static const CfgMeta metas[] = {
|
||||
{"SHADOW_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART},
|
||||
{"PCSS", "0", "0..200", RESTART},
|
||||
// Game
|
||||
{"FPS_LIMIT", "60", "30|40|45|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE},
|
||||
{"FPS_LIMIT", "60", "30|40|45|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"FRAME_QUEUE", "0", "0|1", LIVE},
|
||||
{"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART},
|
||||
{"MODS_REBUILD", "auto", "auto|off", RESTART},
|
||||
{"HIGHFPS_FIX", "1", "0|1", RESTART},
|
||||
@@ -150,7 +152,7 @@ static const CfgMeta metas[] = {
|
||||
{"STICK_DEADZONE", "8", "0..50", LIVE}, {"STICK_SENS", "1", "0.1..3", RESTART},
|
||||
{"LSTICK_DEADZONE", "", "0..50", LIVE}, {"RSTICK_DEADZONE", "", "0..50", LIVE},
|
||||
{"MOUSE_MODE", "direct", "stick|direct", LIVE},
|
||||
{"MOUSE_SENS", "1", "0..10", LIVE}, {"MENU_CURSOR", "1", "0|1", LIVE},
|
||||
{"MOUSE_SENS", "1", "0..10", LIVE}, {"MOUSE_AIM_SCALE", "1", "0.1..3", LIVE}, {"MENU_CURSOR", "1", "0|1", LIVE},
|
||||
{"WALK_KEY", "none", NULL, LIVE}, {"WALK_SCALE", "0.51", "0.2..0.9", LIVE},
|
||||
{"MENU_LANG", "", "en|ru|pt-BR|zh-Hans", LIVE},
|
||||
{"AMIIBO_DIR", "", NULL, LIVE},
|
||||
@@ -328,9 +330,51 @@ static const char *raw_get(const char *name) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// ---- the screen's shape (desktop): a primary display of another shape than 16:9 gives output_res a default of that
|
||||
// shape while neither the environment nor totk.ini sets it, so the first start fills the screen instead of a 16:9
|
||||
// picture between black bars. The sizes are the ones the installer lays the HUD out for (installer/steps.py
|
||||
// ASPECT_SIZES, ui/menu.cpp row_output_res): of the display's shape within 1%, the smallest at least 1080 high that fits
|
||||
// the display, else the largest that fits. A 16:9 display, an unknown one or one of another shape keeps 1920x1080.
|
||||
// Xbox or keyboard prompts keep 1920x1080 too: the setup builds their folders for 16:9 only (romfs.c overlay_init), so
|
||||
// a default of another shape would trade the prompts the player chose for the Switch ones.
|
||||
static const unsigned SHAPED[][2] = {
|
||||
{2560, 1080}, {3440, 1440}, {3840, 1600}, {5120, 2160}, // 21:9
|
||||
{3840, 1080}, {5120, 1440}, // 32:9
|
||||
{1280, 800}, {1680, 1050}, {1920, 1200}, {2560, 1600}, // 16:10
|
||||
{1920, 1280}, {2160, 1440}, {2256, 1504}, {2880, 1920}, {3000, 2000}, // 3:2
|
||||
};
|
||||
static char screen_res[16]; // set once by cfg_init, "" for none
|
||||
|
||||
static int switch_prompts(void) {
|
||||
const char *p = raw_get(PREFIX "PROMPTS"), *l = raw_get(PREFIX "PAD_LAYOUT");
|
||||
return (!p || !strcasecmp(p, "nintendo")) && !(l && !strcasecmp(l, "xbox_prompts"));
|
||||
}
|
||||
|
||||
static void screen_default(void) {
|
||||
int sw, sh;
|
||||
if (!plat_screen_size(&sw, &sh)) return;
|
||||
double r = (double)sw / sh;
|
||||
if (fabs(r / (16.0 / 9.0) - 1) <= 0.01) return;
|
||||
int best = -1, fit = -1;
|
||||
for (int i = 0; i < (int)(sizeof SHAPED / sizeof *SHAPED); i++) {
|
||||
unsigned w = SHAPED[i][0], h = SHAPED[i][1];
|
||||
if (fabs((double)w / h / r - 1) > 0.01 || w > (unsigned)sw || h > (unsigned)sh) continue;
|
||||
if (fit < 0 || w > SHAPED[fit][0]) fit = i; // the largest that fits
|
||||
if (h >= 1080 && (best < 0 || w < SHAPED[best][0])) best = i;
|
||||
}
|
||||
if (best < 0) best = fit;
|
||||
if (best < 0) return;
|
||||
snprintf(screen_res, sizeof screen_res, "%ux%u", SHAPED[best][0], SHAPED[best][1]);
|
||||
if (!raw_get(PREFIX "OUTPUT_RES") && switch_prompts())
|
||||
rt_log("cfg: the display is %dx%d: output_res defaults to %s, its shape (totk.ini output_res sets another)", sw,
|
||||
sh, screen_res);
|
||||
}
|
||||
|
||||
const char *cfg_get(const char *name) {
|
||||
const char *v = raw_get(name);
|
||||
if (v || strncmp(name, PREFIX, PREFIX_LEN) || !profile_of()) return v;
|
||||
if (v || strncmp(name, PREFIX, PREFIX_LEN)) return v;
|
||||
if (!profile_of())
|
||||
return screen_res[0] && !strcasecmp(name + PREFIX_LEN, "OUTPUT_RES") && switch_prompts() ? screen_res : NULL;
|
||||
for (size_t i = 0; i < sizeof DECK / sizeof *DECK; i++)
|
||||
if (!strcasecmp(DECK[i].key, name + PREFIX_LEN)) return DECK[i].value;
|
||||
return NULL;
|
||||
@@ -705,6 +749,7 @@ static void load_ini(void) {
|
||||
|
||||
void cfg_init(void) {
|
||||
load_ini();
|
||||
if (!profile_of()) screen_default();
|
||||
if (profile_of())
|
||||
rt_log("cfg: device profile Steam Deck: defaults for the keys totk.ini does not set (TOTK_DEVICE_PROFILE=desktop "
|
||||
"turns it off)");
|
||||
|
||||
@@ -72,6 +72,7 @@ void gfx_window_closed(void) {
|
||||
rt_log("gfx: window closed; %s", restart ? "restarting" : "exiting");
|
||||
fs_save_flush();
|
||||
vk_pipeline_save();
|
||||
playtime_save();
|
||||
prof_write(); // plat_exit runs no atexit handlers
|
||||
if (restart) {
|
||||
plat_setenv("TOTK_REEXEC", NULL); // the new process counts its own address-space retries (memory.c)
|
||||
|
||||
@@ -167,6 +167,9 @@ void mem_thaw(uint64_t a, uint64_t n); // makes the frozen r
|
||||
void mem_freeze_stats(uint64_t *frozen, uint64_t *freezes, uint64_t *fault_thaws, uint64_t *other_thaws);
|
||||
// regions frozen now; freezes and thaws since the last call
|
||||
void mem_kernel_free(void *p, uint64_t size); // TLR/TLS reuse after thread exit
|
||||
int mem_guest_readable(uint64_t a, uint64_t n); // [a, a+n) can be read without a fault: inside a loaded
|
||||
// module or the committed heap answered from the layout,
|
||||
// anything else by plat_mem_readable (an OS query)
|
||||
|
||||
// ---- modules (loader.c)
|
||||
typedef struct {
|
||||
@@ -313,6 +316,10 @@ int probe_cfg(void); // cfg_probe.c
|
||||
int probe_dpi(void); // dpi_probe_win.c (Windows only)
|
||||
int probe_mods(void); // mods_probe.c
|
||||
void discord_init(void); // discord_rpc.c: the Rich Presence thread, game runs only
|
||||
void playtime_init(void); // playtime.c: the play time thread, game runs only
|
||||
void playtime_save(void); // playtime.c: writes <profile>/playtime.txt; at exit
|
||||
int playtime_get(uint64_t *total_s, uint64_t *session_s); // playtime.c: all runs and this one; 0 without a profile
|
||||
int probe_playtime(void); // playtime.c: the file, the ticks and the save
|
||||
int probe_discord(void); // discord_rpc.c
|
||||
int probe_loader(void), probe_kernel(void), probe_ipc(void), probe_services(void), probe_fs(void);
|
||||
int probe_gfx_abi(void); // gfx_abi_probe.c
|
||||
|
||||
+47
-1
@@ -541,6 +541,35 @@ static int32_t shake_stick(int held) {
|
||||
return (now - from) / SHAKE_SIDE_NS % 2 ? STICK_MAX : -STICK_MAX;
|
||||
}
|
||||
|
||||
// The scroll wheel on the Purah Pad's map, which zooms with the right stick's y (up: in): each notch is a full-tilt
|
||||
// pulse of MAP_ZOOM_PULSE_NS on that stick with MAP_ZOOM_GAP_NS of neutral after it, so a step of the zoom and a
|
||||
// held zoom both see one notch as one push. A fast scroll's notches wait their turn (at most MAP_ZOOM_QUEUE), a turn the
|
||||
// other way drops them. Returns the stick y for this poll, 0 between pulses and off the map. Under lock.
|
||||
#define MAP_ZOOM_PULSE_NS 100000000ull
|
||||
#define MAP_ZOOM_GAP_NS 50000000ull
|
||||
#define MAP_ZOOM_QUEUE 4
|
||||
static int32_t map_zoom_stick(int32_t notches, int on_map) {
|
||||
static int32_t queued, dir;
|
||||
static uint64_t until; // the end of the pulse (dir != 0) or of the neutral after it
|
||||
uint64_t now = plat_now_ns();
|
||||
if (!on_map) { queued = dir = 0, until = 0; return 0; }
|
||||
if (notches) {
|
||||
if (queued && (notches > 0) != (queued > 0)) queued = 0;
|
||||
queued += notches;
|
||||
queued = queued > MAP_ZOOM_QUEUE ? MAP_ZOOM_QUEUE : queued < -MAP_ZOOM_QUEUE ? -MAP_ZOOM_QUEUE : queued;
|
||||
}
|
||||
if (dir) {
|
||||
if (now < until) return dir * STICK_MAX;
|
||||
dir = 0, until = now + MAP_ZOOM_GAP_NS;
|
||||
return 0;
|
||||
}
|
||||
if (now < until || !queued) return 0;
|
||||
dir = queued > 0 ? 1 : -1;
|
||||
queued -= dir;
|
||||
until = now + MAP_ZOOM_PULSE_NS;
|
||||
return dir * STICK_MAX;
|
||||
}
|
||||
|
||||
// Under lock, state 1: the open gamepad's inputs by position (pd[PAD_*] != 0 held); 0 without a connected gamepad.
|
||||
static int pad_physical(uint8_t pd[PAD_COUNT]) {
|
||||
if ((!pad || !SDL_GamepadConnected(pad)) && plat_now_ns() / 1000000u >= next_scan) { next_scan = plat_now_ns() / 1000000u + RESCAN_MS; scan_pads(); }
|
||||
@@ -579,6 +608,8 @@ int input_pad_stick_percent(double pct[2]) {
|
||||
return ok;
|
||||
}
|
||||
|
||||
static uint64_t g_buttons_last; // the merged buttons of the last poll (input_buttons_last)
|
||||
|
||||
static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry) {
|
||||
uint64_t b = 0;
|
||||
int32_t sl[2] = {0, 0}, sr[2] = {0, 0};
|
||||
@@ -617,10 +648,22 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx
|
||||
pick(&sr[0], &sr[1], k[0], k[1]);
|
||||
int selector = b & (1ull << B_L) ? 1 : b & (1ull << B_UP) ? 2 :
|
||||
b & (1ull << B_LEFT) ? 3 : b & (1ull << B_RIGHT) ? 4 : 0;
|
||||
// Only while the wheel or a strip is on screen (menu_cursor.c reads the focused screen): L also soothes the
|
||||
// horse and turns menu tabs, the D-pad does other things too, and then the mouse stays on the camera.
|
||||
// Before the screens were read (the menu cursor off) the buttons alone decide, as before.
|
||||
if (selector && menu_cursor_shortcut() == 0) selector = 0;
|
||||
mouse_camera(k, selector);
|
||||
pick(&sr[0], &sr[1], k[0], k[1]);
|
||||
// On the map the left stick moves the cursor and the right one zooms: the mouse moves the cursor there,
|
||||
// the scroll wheel zooms (map_zoom_stick). Elsewhere the wheel is unbound; its notches are dropped.
|
||||
int map = menu_cursor_map();
|
||||
if (map) pick(&sl[0], &sl[1], k[0], k[1]);
|
||||
else pick(&sr[0], &sr[1], k[0], k[1]);
|
||||
int32_t zoom = map_zoom_stick(ikb_wheel_take(), map);
|
||||
if (zoom) pick(&sr[0], &sr[1], 0, zoom);
|
||||
int32_t shake = shake_stick(input_map_held(down, B_SHAKE));
|
||||
if (shake) sr[0] = shake, sr[1] = 0;
|
||||
// A mouse shake (mouse_direct.c) moves the stick with the mouse, side by side, and lets go when it rests
|
||||
else if (input_direct_mouse_shake()) sr[0] = input_direct_mouse_shake() * STICK_MAX, sr[1] = 0;
|
||||
static uint32_t travel_seen;
|
||||
uint32_t travel = ikb_mouse_travel();
|
||||
if (travel - travel_seen >= MOUSE_USED) kbm_used = 1;
|
||||
@@ -644,9 +687,12 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx
|
||||
if (overlay) menu_perf_cycle();
|
||||
stick_bits(&b, sl[0], sl[1], B_SL_LEFT);
|
||||
stick_bits(&b, sr[0], sr[1], B_SR_LEFT);
|
||||
__atomic_store_n(&g_buttons_last, b, __ATOMIC_RELAXED);
|
||||
*buttons = b; *lx = sl[0]; *ly = sl[1]; *rx = sr[0]; *ry = sr[1];
|
||||
}
|
||||
|
||||
uint64_t input_buttons_last(void) { return __atomic_load_n(&g_buttons_last, __ATOMIC_RELAXED); }
|
||||
|
||||
// Text entry (swkbd_*.c): while it is open the game reads no input, as behind the keyboard applet; after it closes
|
||||
// the game reads none until every button and stick direction is released, so the press that closed it stays there.
|
||||
// g_block: 0 off, 1 text entry open, 2 closed, waiting for the release. The cursor is released while it is open.
|
||||
|
||||
@@ -23,10 +23,18 @@ int input_direct_mouse_selector_active(void);
|
||||
// Consume direct mouse counts, including one-shot MOUSE events from an input script. enabled=0 discards scripted
|
||||
// counts while leaving the real mouse for menu input. Live counts require cursor capture and foreground focus.
|
||||
void input_direct_mouse_sample(int enabled, int32_t *dx, int32_t *dy);
|
||||
// The buttons (B_* bits) of the last poll, keys and gamepad merged; any thread (mouse_direct.c: ZR for the bow's scale)
|
||||
uint64_t input_buttons_last(void);
|
||||
// mouse_direct.c: the right stick's side a mouse shake gives while Ultrahand holds an object (-1 / +1), 0 while the
|
||||
// mouse does not shake; input.c puts it on the stick
|
||||
int input_direct_mouse_shake(void);
|
||||
// menu_cursor.c: the L ability wheel or a D-pad strip has the focus: 1 / 0, -1 with the menu cursor off (not read)
|
||||
int menu_cursor_shortcut(void);
|
||||
// menu_cursor.c: the pointer in the game's menus (1.4.3). poll: once per pad read, adds a click's A or B; pointer: a
|
||||
// menu has the pointer, so the mouse camera's capture is released
|
||||
void menu_cursor_poll(uint64_t *buttons);
|
||||
int menu_cursor_pointer(void);
|
||||
int menu_cursor_map(void); // the Purah Pad's map is open: the mouse's stick is the left one (its cursor)
|
||||
// The same for host UI (the text entry): never blocked. input_block(1) while a text entry is open: input_poll then
|
||||
// reports nothing; input_block(0) when it closes: nothing until all buttons and stick directions are released.
|
||||
void input_poll_ui(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry);
|
||||
|
||||
+113
-7
@@ -1,11 +1,13 @@
|
||||
// The SDL3 back end of the keyboard and the mouse (input_wsys.h; input.c merges them with the gamepad): SDL scancodes to
|
||||
// the key ids of input_map.h, the mouse camera's relative motion and the cursor capture (SDL's relative mouse mode).
|
||||
// Key and button state comes from the window's events (window thread) and is read by any thread. Keys and their map:
|
||||
// docs/controls.md.
|
||||
// the key ids of input_map.h, the mouse camera's relative motion, the cursor capture (SDL's relative mouse mode), the
|
||||
// pointer's place in the window (the game's menus, menu_cursor.c) and the mouse travel (the last-device switch,
|
||||
// input_kbm_last). Key and button state comes from the window's events (window thread) and is read by any thread. Keys
|
||||
// and their map: docs/controls.md.
|
||||
//
|
||||
// The capture follows the Win32 back end's rules (input_win.c): captured while the window has the focus, the mouse
|
||||
// camera is on and no text entry or menu is open; Esc releases it until a click in the window (and closing the menu
|
||||
// opened by that Esc gives it back); losing the focus releases it until the window has the focus again.
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <SDL3/SDL.h>
|
||||
@@ -21,8 +23,18 @@ static SDL_Window *win;
|
||||
static volatile uint8_t key_held[KEY_COUNT];
|
||||
static volatile int32_t esc_held, f8_held, focused;
|
||||
static volatile int32_t mouse_dx, mouse_dy; // relative motion since the last ikb_mouse_take, whole counts
|
||||
static volatile int32_t mouse_wheel; // wheel turned while captured, in 1/120 notches (ikb_wheel_take)
|
||||
static float rem_x, rem_y; // window thread: the fractions SDL reported beyond them
|
||||
static volatile int32_t mouse_travel; // raw counts moved in total, captured or not (ikb_mouse_travel)
|
||||
static float travel_rem; // window thread: the fraction of a count beyond mouse_travel
|
||||
static volatile int32_t captured; // relative mouse mode is on
|
||||
// The pointer's place in the window, as fractions of its size packed 32.32 fixed point (x in the high word), written
|
||||
// by the window thread from the mouse events and read by the game thread (menu_cursor.c through ikb_pointer).
|
||||
// ptr_have is 0 whenever the pointer is not over the window, as the Win32 back end's client-rect test.
|
||||
static volatile uint64_t ptr_pos;
|
||||
static volatile int32_t ptr_have;
|
||||
static volatile int32_t warp_pending; // ikb_pointer_set asked the window thread to move the pointer
|
||||
static float warp_nx, warp_ny; // its target, read by the window thread once warp_pending is seen
|
||||
enum { CUR_REL = 1, CUR_ESC = 2 }; // as input_win.c: released by Esc or a click elsewhere; by Esc
|
||||
static volatile int32_t cur_rel, cur_suspend, cur_pending;
|
||||
static uint32_t wake_event; // SDL_RegisterEvents: wakes the window thread for a cursor change
|
||||
@@ -133,6 +145,39 @@ static void cursor_apply(void) {
|
||||
plat_xchg32(&captured, want);
|
||||
}
|
||||
|
||||
// The pointer's place in the window (the window thread): x and y are SDL window units, the same space the mouse
|
||||
// events report, so dividing by the window's size makes fractions of it whatever the pixel density is. At and past
|
||||
// the edges the fraction is clamped to 0..1, where a letterboxed picture covers no item anyway.
|
||||
static void pointer_store(float x, float y) {
|
||||
if (!win) return;
|
||||
int w = 0, h = 0;
|
||||
SDL_GetWindowSize(win, &w, &h);
|
||||
if (w < 1 || h < 1) return;
|
||||
double fx = x / w, fy = y / h;
|
||||
if (!(fx >= 0)) fx = 0; // also NaN
|
||||
else if (fx > 1) fx = 1;
|
||||
if (!(fy >= 0)) fy = 0;
|
||||
else if (fy > 1) fy = 1;
|
||||
__atomic_store_n(&ptr_pos, (uint64_t)(uint32_t)(fx * 4294967295.0) << 32 | (uint32_t)(fy * 4294967295.0),
|
||||
__ATOMIC_RELEASE);
|
||||
__atomic_store_n(&ptr_have, 1, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
// A warp asked for by ikb_pointer_set, done here as every window call: on the window thread, and after the cursor
|
||||
// change of the same menu opening has been applied. SDL's warp makes a motion event where it works (X11); where it
|
||||
// does not (some Wayland compositors) the stored place stands, so the item under the pointer is the place asked for
|
||||
// even if the visible cursor stayed behind.
|
||||
static void pointer_apply(void) {
|
||||
if (!plat_xchg32(&warp_pending, 0)) return;
|
||||
if (!win || !focused) return;
|
||||
int w = 0, h = 0;
|
||||
SDL_GetWindowSize(win, &w, &h);
|
||||
if (w < 1 || h < 1) return;
|
||||
float x = warp_nx * w, y = warp_ny * h;
|
||||
SDL_WarpMouseInWindow(win, x, y);
|
||||
pointer_store(x, y);
|
||||
}
|
||||
|
||||
// Any thread: the window thread applies the change at its next event.
|
||||
void ikb_cursor_update(void) {
|
||||
plat_xchg32(&cur_pending, 1);
|
||||
@@ -158,11 +203,13 @@ void input_sdl_window(SDL_Window *w) {
|
||||
win = w;
|
||||
wake_event = SDL_RegisterEvents(1);
|
||||
plat_xchg32(&focused, (SDL_GetWindowFlags(w) & SDL_WINDOW_INPUT_FOCUS) != 0);
|
||||
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE); // the pointer's place is unknown until it enters or moves
|
||||
cursor_apply();
|
||||
}
|
||||
|
||||
void input_sdl_idle(void) {
|
||||
if (cur_pending) cursor_apply();
|
||||
pointer_apply();
|
||||
}
|
||||
|
||||
void input_sdl_event(const SDL_Event *e) {
|
||||
@@ -186,9 +233,19 @@ void input_sdl_event(const SDL_Event *e) {
|
||||
int k = mouse_key(e->button.button);
|
||||
if (k) key_held[k] = (uint8_t)down;
|
||||
if (down && (cur_rel & CUR_REL)) plat_xchg32(&cur_rel, 0); // a click in the window captures again
|
||||
if (!captured) pointer_store(e->button.x, e->button.y); // a click can come without a motion first
|
||||
break;
|
||||
}
|
||||
case SDL_EVENT_MOUSE_MOTION:
|
||||
case SDL_EVENT_MOUSE_MOTION: {
|
||||
// The travel counts any motion, captured or not, as the Win32 back end's raw input does: it is what makes a
|
||||
// moved mouse the device used last, so the menu pointer appears without a click or a key.
|
||||
travel_rem += fabsf(e->motion.xrel) + fabsf(e->motion.yrel);
|
||||
int32_t t = (int32_t)travel_rem;
|
||||
if (t) {
|
||||
travel_rem -= t;
|
||||
plat_add32(&mouse_travel, t);
|
||||
}
|
||||
if (!captured) pointer_store(e->motion.x, e->motion.y); // in relative mode x and y are not the pointer's
|
||||
if (captured) {
|
||||
rem_x += e->motion.xrel;
|
||||
rem_y += e->motion.yrel;
|
||||
@@ -198,6 +255,22 @@ void input_sdl_event(const SDL_Event *e) {
|
||||
if (dy) plat_add32(&mouse_dy, dy);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SDL_EVENT_WINDOW_MOUSE_ENTER: { // entering without moving yet: the place is where the enter found the pointer
|
||||
float x, y;
|
||||
SDL_GetMouseState(&x, &y); // the window with mouse focus is this one during its own enter event
|
||||
pointer_store(x, y);
|
||||
break;
|
||||
}
|
||||
case SDL_EVENT_WINDOW_MOUSE_LEAVE:
|
||||
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE);
|
||||
break;
|
||||
case SDL_EVENT_MOUSE_WHEEL: // notches, + away from the player (a flipped wheel reports the other sign)
|
||||
if (captured) {
|
||||
float y = e->wheel.direction == SDL_MOUSEWHEEL_FLIPPED ? -e->wheel.y : e->wheel.y;
|
||||
plat_add32(&mouse_wheel, (int32_t)(y * 120));
|
||||
}
|
||||
break;
|
||||
case SDL_EVENT_WINDOW_FOCUS_GAINED:
|
||||
plat_xchg32(&focused, 1);
|
||||
break;
|
||||
@@ -207,9 +280,11 @@ void input_sdl_event(const SDL_Event *e) {
|
||||
memset((void *)key_held, 0, sizeof key_held); // the key-ups go elsewhere
|
||||
plat_xchg32(&esc_held, 0);
|
||||
plat_xchg32(&f8_held, 0);
|
||||
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE); // the pointer left with the focus, leave or not
|
||||
break;
|
||||
}
|
||||
cursor_apply();
|
||||
pointer_apply(); // after cursor_apply: a menu opening uncaptures first, then the pointer moves to its middle
|
||||
}
|
||||
|
||||
// ---- input_wsys.h
|
||||
@@ -217,11 +292,42 @@ int ikb_foreground(void) { return focused != 0; }
|
||||
int ikb_down(int key) { return key > 0 && key < KEY_COUNT && key_held[key]; }
|
||||
int ikb_escape(void) { return esc_held != 0; }
|
||||
int ikb_captured(void) { return captured != 0; }
|
||||
int ikb_pointer(float *nx, float *ny) { (void)nx, (void)ny; return 0; } // (menu_cursor.c: Windows only for now)
|
||||
void ikb_pointer_set(float nx, float ny) { (void)nx, (void)ny; }
|
||||
uint32_t ikb_mouse_travel(void) { return 0; } // (the last-device switch: keys and buttons only for now)
|
||||
|
||||
// The pointer's place in the window as fractions of its size (menu_cursor.c maps them onto the picture the present
|
||||
// drew). 0 whenever the pointer is not over this window or the window has not the focus, as the Win32 back end's
|
||||
// GetCursorPos test.
|
||||
int ikb_pointer(float *nx, float *ny) {
|
||||
if (!focused || !__atomic_load_n(&ptr_have, __ATOMIC_ACQUIRE)) return 0;
|
||||
uint64_t p = __atomic_load_n(&ptr_pos, __ATOMIC_ACQUIRE);
|
||||
*nx = (float)(uint32_t)(p >> 32) / 4294967295.0f;
|
||||
*ny = (float)(uint32_t)p / 4294967295.0f;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Moves the pointer there (menu_cursor.c: to the middle when a menu opens). The window thread warps at its next
|
||||
// event, as SDL asks for its video thread; until then the warp target stands as the pointer's place.
|
||||
void ikb_pointer_set(float nx, float ny) {
|
||||
if (!(nx >= 0 && nx <= 1) || !(ny >= 0 && ny <= 1)) return;
|
||||
warp_nx = nx, warp_ny = ny;
|
||||
__atomic_store_n(&warp_pending, 1, __ATOMIC_RELEASE);
|
||||
if (wake_event) {
|
||||
SDL_Event e = {.user = {.type = wake_event}};
|
||||
SDL_PushEvent(&e);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ikb_mouse_travel(void) { return (uint32_t)__atomic_load_n(&mouse_travel, __ATOMIC_RELAXED); }
|
||||
|
||||
void ikb_mouse_take(int32_t *dx, int32_t *dy) {
|
||||
*dx = plat_xchg32(&mouse_dx, 0);
|
||||
*dy = plat_xchg32(&mouse_dy, 0);
|
||||
}
|
||||
|
||||
int32_t ikb_wheel_take(void) {
|
||||
int32_t o, n;
|
||||
do {
|
||||
o = mouse_wheel;
|
||||
n = o % 120; // the part of a notch stays for the next call
|
||||
} while (!__atomic_compare_exchange_n(&mouse_wheel, &o, n, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST));
|
||||
return o / 120;
|
||||
}
|
||||
@@ -84,6 +84,7 @@ uint32_t input_key_char(int key) {
|
||||
// ---- mouse camera: raw motion accumulated by the window thread, one stick sample per presented frame
|
||||
static volatile LONG mouse_dx, mouse_dy; // raw counts since the last frame sample
|
||||
static volatile LONG mouse_travel; // raw counts moved in total, captured or not (ikb_mouse_travel)
|
||||
static volatile LONG mouse_wheel; // wheel turned while captured, in WHEEL_DELTA units (ikb_wheel_take)
|
||||
static volatile LONG cur_captured; // cursor hidden and confined to the client area
|
||||
static volatile LONG cur_active; // WM_ACTIVATEAPP: the window's application is active
|
||||
// Bits: CUR_REL, Esc or activation by a click on the title bar or border: until a client click; CUR_ESC, set with CUR_REL
|
||||
@@ -147,6 +148,9 @@ int input_window_msg(HWND h, UINT m, WPARAM w, LPARAM l, LRESULT *res) {
|
||||
InterlockedAdd(&mouse_dy, y);
|
||||
}
|
||||
}
|
||||
// The wheel comes in the same message (usButtonData, signed, + away from the player)
|
||||
if (cur_captured && ri.header.dwType == RIM_TYPEMOUSE && (ri.data.mouse.usButtonFlags & RI_MOUSE_WHEEL))
|
||||
InterlockedAdd(&mouse_wheel, (SHORT)ri.data.mouse.usButtonData);
|
||||
break; // DefWindowProc must see WM_INPUT for cleanup
|
||||
}
|
||||
case WM_SETCURSOR:
|
||||
@@ -234,6 +238,15 @@ void ikb_mouse_take(int32_t *dx, int32_t *dy) {
|
||||
*dy = InterlockedExchange(&mouse_dy, 0);
|
||||
}
|
||||
|
||||
int32_t ikb_wheel_take(void) {
|
||||
LONG o, n;
|
||||
do {
|
||||
o = mouse_wheel;
|
||||
n = o % WHEEL_DELTA; // the part of a notch stays for the next call
|
||||
} while (InterlockedCompareExchange(&mouse_wheel, n, o) != o);
|
||||
return (int32_t)(o / WHEEL_DELTA);
|
||||
}
|
||||
|
||||
void ikb_cursor_update(void) { cursor_update(gfx_window_handle()); }
|
||||
|
||||
void ikb_menu_closed(void) { cur_rel_update(rel_menu_closed); }
|
||||
@@ -13,6 +13,8 @@ void ikb_pointer_set(float nx, float ny); // moves the pointer there (the wind
|
||||
int ikb_captured(void); // the cursor is captured for the mouse camera
|
||||
void ikb_mouse_take(int32_t *dx, int32_t *dy); // raw mouse motion since the last call, in counts
|
||||
uint32_t ikb_mouse_travel(void); // raw counts the mouse moved in total (|dx| + |dy|), captured or not
|
||||
int32_t ikb_wheel_take(void); // whole wheel notches turned while captured since the last call (+ away
|
||||
// from the player); a high-resolution wheel's part of a notch is kept
|
||||
void ikb_cursor_update(void); // what input_cursor_allowed says may have changed
|
||||
void ikb_menu_closed(void); // the menu closed: a capture that Esc gave up comes back
|
||||
|
||||
|
||||
+6
-2
@@ -2,10 +2,12 @@
|
||||
//
|
||||
// totk.exe [--exefs DIR] [--romfs DIR] [--profile DIR] <mode>
|
||||
// --selftest layout, dispatch table and host-function registry; needs no game files
|
||||
// --probe-mods the mods folder scan, order and switches (mods.c); needs no game files
|
||||
// --probe-mods the mods folder scan, order and switches (mods.c), the size table entries of the members of
|
||||
// mods' packs (restbl_probe.c); needs no game files
|
||||
// --probe-loader load and relocate the modules, check them against the measured 1.2.1 values
|
||||
// --probe-kernel, --probe-ipc, --probe-services, --probe-fs host probes
|
||||
// --probe-discord the Rich Presence IPC exchange; skips without a Discord client; no game files
|
||||
// --probe-playtime the play time file, its ticks and saves (playtime.c); needs no game files
|
||||
// --probe-dpi the process DPI awareness (per-monitor v2) and the primary monitor's size; no game files
|
||||
// --probe-gfx-abi NVN object layouts against nvn.h's reserved sizes; needs no game files
|
||||
// --probe-nvn, --probe-nvn-tex, --probe-window, --probe-shader, --probe-vkmem, --probe-vkexec graphics probes
|
||||
@@ -462,7 +464,7 @@ static int probe_crash(int null) {
|
||||
|
||||
static int usage(const char *argv0) {
|
||||
fprintf(stderr, "usage: %s [--exefs DIR] [--romfs DIR] [--profile DIR] [--selftest | --probe-loader | "
|
||||
"--probe-cfg | --probe-dpi | --probe-mods | --probe-kernel | --probe-ipc | --probe-services | --probe-fs | --probe-gfx-abi | "
|
||||
"--probe-cfg | --probe-dpi | --probe-mods | --probe-playtime | --probe-kernel | --probe-ipc | --probe-services | --probe-fs | --probe-gfx-abi | "
|
||||
"--probe-nvn | --probe-nvn-tex | --probe-window | --probe-shader | --probe-vkmem | "
|
||||
"--probe-vkexec | --probe-astc | --probe-movie | --probe-crash-call | --probe-crash-null | --probe-discord | "
|
||||
"--prepare-shaders | --warm-shaders | --boot |--seconds S [--shot PNG]]\n", argv0);
|
||||
@@ -552,6 +554,7 @@ int main(int argc, char **argv) {
|
||||
if (!mode) {
|
||||
cfg.boot = cfg.seconds > 0; // --seconds starts the game like --boot, with its checkpoints
|
||||
discord_init(); // the Rich Presence thread (discord_rpc.c); it reads totk.ini itself and idles while off
|
||||
playtime_init(); // the play time thread (playtime.c): the Game tab's play time across runs
|
||||
rt_boot();
|
||||
return 0;
|
||||
}
|
||||
@@ -565,6 +568,7 @@ int main(int argc, char **argv) {
|
||||
#endif
|
||||
if (!strcmp(mode, "--probe-mods")) return probe_mods();
|
||||
if (!strcmp(mode, "--probe-discord")) return probe_discord();
|
||||
if (!strcmp(mode, "--probe-playtime")) return probe_playtime();
|
||||
if (!strcmp(mode, "--probe-kernel")) return probe_kernel();
|
||||
if (!strcmp(mode, "--probe-ipc")) return probe_ipc();
|
||||
if (!strcmp(mode, "--probe-services")) return probe_services();
|
||||
|
||||
@@ -288,6 +288,35 @@ uint32_t mem_set_heap_size(uint64_t size, uint64_t *addr) {
|
||||
return R_OK;
|
||||
}
|
||||
|
||||
// The runtime's readers of game objects (menu_cursor.c, mouse_direct.c) check every pointer before they follow it. An
|
||||
// OS query (plat_mem_readable: VirtualQuery) costs tens of microseconds in this process, and a reader that checks a
|
||||
// few dozen pointers at a time stalls the game thread for milliseconds. The game's objects live in the committed heap
|
||||
// and its globals in the modules' images, which are readable for as long as they are mapped: those answer from the
|
||||
// layout. Any other range asks the OS. The heap only shrinks when the game asks for it (mem_set_heap_size), not while
|
||||
// it runs.
|
||||
int mem_guest_readable(uint64_t a, uint64_t n) {
|
||||
static uint64_t fast, slow;
|
||||
if (a + n < a) return 0;
|
||||
uint64_t hs = __atomic_load_n(&heap_size, __ATOMIC_ACQUIRE);
|
||||
int ok = a >= L.heap.base && a + n <= L.heap.base + hs;
|
||||
for (int i = 0; !ok && i < ldr_count(); i++) {
|
||||
const RtLoaded *m = ldr_module(i);
|
||||
ok = a >= m->base && a + n <= m->base + m->size;
|
||||
}
|
||||
if (ok) {
|
||||
if (__atomic_add_fetch(&fast, 1, __ATOMIC_RELAXED) == 100000)
|
||||
rt_log("memory: 100000 guest reads checked by the layout, %llu by the OS",
|
||||
(unsigned long long)__atomic_load_n(&slow, __ATOMIC_RELAXED));
|
||||
} else {
|
||||
ok = plat_mem_readable(a, n);
|
||||
uint64_t s = __atomic_add_fetch(&slow, 1, __ATOMIC_RELAXED);
|
||||
if (!(s & (s - 1)) && s >= 1024) // 1024, 2048, 4096...: how often the layout could not answer
|
||||
rt_log("memory: guest reads checked by the layout %llu, by the OS %llu",
|
||||
(unsigned long long)__atomic_load_n(&fast, __ATOMIC_RELAXED), (unsigned long long)s);
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
// ---- module data permissions (0x02, 0x03) and module pages for QueryMemory
|
||||
static int module_index(uint64_t a) {
|
||||
for (int i = 0; i < ldr_count(); i++) {
|
||||
|
||||
+64
-6
@@ -53,7 +53,7 @@ enum { PANE_PARENT = 0x18, PANE_SIZE = 0x50, PANE_FLAG = 0x58, PANE_ALPHA = 0x59
|
||||
static uint64_t main_lo, main_hi;
|
||||
|
||||
static int ok_at(uint64_t p, uint64_t n) {
|
||||
return p >= 0x10000 && p < (1ull << 47) && (p & 7) == 0 && plat_mem_readable(p, n);
|
||||
return p >= 0x10000 && p < (1ull << 47) && (p & 7) == 0 && mem_guest_readable(p, n);
|
||||
}
|
||||
static uint64_t rd64(uint64_t a) { uint64_t v; memcpy(&v, (const void *)(uintptr_t)a, 8); return v; }
|
||||
static uint32_t rd32(uint64_t a) { uint32_t v; memcpy(&v, (const void *)(uintptr_t)a, 4); return v; }
|
||||
@@ -157,11 +157,45 @@ static Focus focus_now(void) {
|
||||
static void layout_name(uint64_t scr, char *out, size_t n) {
|
||||
snprintf(out, n, "?");
|
||||
uint64_t lyt = rd64(scr + SCR_LAYOUT), name = ok_at(lyt, LYT_NAME + 8) ? rd64(lyt + LYT_NAME) : 0;
|
||||
if (name < 0x10000 || name >= (1ull << 47) || !plat_mem_readable(name, n)) return;
|
||||
if (name < 0x10000 || name >= (1ull << 47) || !mem_guest_readable(name, n)) return;
|
||||
memcpy(out, (const void *)(uintptr_t)name, n - 1);
|
||||
out[n - 1] = 0;
|
||||
for (char *q = out; *q; q++) if (*q < 0x20 || *q > 0x7e) { *q = 0; break; }
|
||||
}
|
||||
// The open screens: eui::ScreenMgr's screen array, count at +0x8 and its pointers at +0x10 (1.0.0's layout, which the
|
||||
// 1.4.3 constructor keeps). The map has no focus box, so it is found here: the Purah Pad's frame (AppMenuOverlay_00)
|
||||
// with AppMap_00 and the menu's background AppMenuBG_00 open. The Scope opens the frame over AppMap_00 without that
|
||||
// background (Weeping of the Empire's engine/runtime/totk_menu_cursor.cpp census tells them apart the same way).
|
||||
// TOTK_MENU_CURSOR_LOG=1 logs the open screens whenever the set changes.
|
||||
enum { SM_COUNT = 0x8, SM_SCREENS = 0x10 };
|
||||
static int map_open(void) {
|
||||
uint64_t sm = screen_mgr();
|
||||
if (!sm) return 0;
|
||||
int32_t n = (int32_t)rd32(sm + SM_COUNT);
|
||||
uint64_t arr = rd64(sm + SM_SCREENS);
|
||||
if (n <= 0 || n > 1024 || !ok_at(arr, 8ull * (uint64_t)n)) return 0;
|
||||
const char *e = cfg_get("TOTK_MENU_CURSOR_LOG");
|
||||
int verbose = e && !strcmp(e, "1"), pad = 0, map = 0, bg = 0;
|
||||
char list[1024];
|
||||
size_t len = 0;
|
||||
uint64_t h = 1469598103934665603ull;
|
||||
for (int32_t i = 0; i < n; i++) {
|
||||
uint64_t scr = rd64(arr + 8ull * (uint64_t)i);
|
||||
if (!game_object(scr, SCR_REQUEST + 1) || rd8(scr + SCR_STATE) != SCR_OPENED) continue;
|
||||
char nm[48];
|
||||
layout_name(scr, nm, sizeof nm);
|
||||
pad |= !strcmp(nm, "AppMenuOverlay_00");
|
||||
map |= !strcmp(nm, "AppMap_00");
|
||||
bg |= !strcmp(nm, "AppMenuBG_00");
|
||||
if (!verbose) continue;
|
||||
for (const char *c = nm; *c; c++) h = (h ^ (uint8_t)*c) * 1099511628211ull;
|
||||
if (len < sizeof list - 64) len += (size_t)snprintf(list + len, sizeof list - len, "%s%s", len ? " " : "", nm);
|
||||
}
|
||||
static uint64_t last;
|
||||
static int lines;
|
||||
if (verbose && h != last && lines < 200) last = h, lines++, rt_log("menu_cursor: open screens: %s", list);
|
||||
return pad && map && bg;
|
||||
}
|
||||
static void layout_size(uint64_t scr, float *lw, float *lh) {
|
||||
*lw = 1920, *lh = 1080;
|
||||
uint64_t lyt = rd64(scr + SCR_LAYOUT);
|
||||
@@ -245,8 +279,10 @@ static int gameplay_screen(const char *nm) {
|
||||
}
|
||||
|
||||
static volatile int32_t g_pointer; // a menu has the pointer: input_cursor_allowed releases the capture
|
||||
static volatile int32_t g_map; // the Purah Pad's map is open (not the Scope): the mouse moves its cursor
|
||||
|
||||
int menu_cursor_pointer(void) { return __atomic_load_n(&g_pointer, __ATOMIC_RELAXED); }
|
||||
int menu_cursor_map(void) { return __atomic_load_n(&g_map, __ATOMIC_RELAXED); }
|
||||
|
||||
static int enabled(void) {
|
||||
if (!RT_V143) return 0;
|
||||
@@ -282,29 +318,40 @@ static void log_screen(const Focus *f, const char *nm, int n, float lw, float lh
|
||||
// Once per pad read on the game thread: the pointer's hover and clicks, as pad buttons (A, B) for this read
|
||||
void menu_cursor_poll(uint64_t *buttons) {
|
||||
static int inited, pending_a, held_l, held_r;
|
||||
static uint64_t pending_node, pending_until, hold_until, hold_bit;
|
||||
static uint64_t pending_node, pending_until, hold_until, hold_bit, menu_seen;
|
||||
static float last_px = -1, last_py = -1;
|
||||
if (!inited) {
|
||||
inited = 1;
|
||||
main_lo = MOD_MAIN_BASE, main_hi = MOD_MAIN_BASE + MAIN_SIZE;
|
||||
if (RT_V143) rt_log("menu_cursor: on for 1.4.3 (TOTK_MENU_CURSOR=0 turns it off)");
|
||||
}
|
||||
if (!enabled()) { set_pointer(0); return; }
|
||||
if (!enabled()) { set_pointer(0); __atomic_store_n(&g_map, 0, __ATOMIC_RELAXED); return; }
|
||||
Focus f = focus_now();
|
||||
char nm[48] = "";
|
||||
if (f.screen) layout_name(f.screen, nm, sizeof nm);
|
||||
// The open screens are scanned every 100 ms, not at every pad read: each screen costs memory queries
|
||||
uint64_t now = plat_now_ms();
|
||||
static uint64_t map_at;
|
||||
static int map, map_logged;
|
||||
if (!map_at || now - map_at >= 100) map_at = now, map = map_open();
|
||||
if (map && !map_logged) map_logged = 1, rt_log("menu_cursor: the map is open: the mouse moves its cursor");
|
||||
__atomic_store_n(&g_map, map, __ATOMIC_RELAXED);
|
||||
// With the gamepad as the last device the menus stay as they are on the console: no pointer, the capture kept.
|
||||
// Moving the mouse (or a key) makes keyboard and mouse the last device and the pointer comes.
|
||||
int menu = f.screen && !gameplay_screen(nm) && ikb_foreground() && input_kbm_last();
|
||||
set_pointer(menu);
|
||||
if (menu) menu_seen = now;
|
||||
// A menu's focus gap (a tab switch, a popup opening: no focus box for a frame or two) keeps the pointer where it
|
||||
// is, for up to 300 ms: releasing it there captured it again and centred it when the next tab took the focus
|
||||
int gap = !menu && !f.screen && menu_seen && now - menu_seen < 300 && ikb_foreground() && input_kbm_last();
|
||||
set_pointer(menu || gap);
|
||||
int l = ikb_down(KEY_MOUSE_L), r = ikb_down(KEY_MOUSE_R);
|
||||
int click_l = l && !held_l, click_r = r && !held_r;
|
||||
held_l = l, held_r = r;
|
||||
uint64_t now = plat_now_ms();
|
||||
if (now < hold_until) { // a click's button, held for 60 ms so the game sees one press whatever its read rate
|
||||
*buttons |= hold_bit;
|
||||
return;
|
||||
}
|
||||
if (gap) return; // a click's focus request waits for the next screen
|
||||
if (!menu) { pending_a = 0; last_px = last_py = -1; return; }
|
||||
if (pending_a) { // the focus asked for by a click: A once it is there
|
||||
if (rd64(f.control + CTL_ACTIVE) == pending_node) {
|
||||
@@ -338,3 +385,14 @@ void menu_cursor_poll(uint64_t *buttons) {
|
||||
else pending_a = 1, pending_node = at, pending_until = now + 300;
|
||||
}
|
||||
}
|
||||
|
||||
// The L ability wheel or a D-pad strip (materials, weapons, shields, bows) has the focus: 1 / 0, -1 with the menu
|
||||
// cursor off (the screens are not read). input.c asks while L or the D-pad is held, before it gives the mouse to their
|
||||
// selectors: L also soothes the horse and turns menu tabs, the D-pad does other things too.
|
||||
int menu_cursor_shortcut(void) {
|
||||
if (!enabled()) return -1;
|
||||
Focus f = focus_now();
|
||||
char nm[48] = "";
|
||||
if (f.screen) layout_name(f.screen, nm, sizeof nm);
|
||||
return f.screen && (!strcmp(nm, "ShortCutMainItem_00") || !strcmp(nm, "ShortCut_00"));
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
// --probe-mods: the mods folder scan, its order and switches (mods.c). Builds a mods folder of its own next to totk.exe,
|
||||
// scans it and removes it. Needs no game files.
|
||||
// scans it and removes it. Also the resource size table's entries of the members of the mods' packs (restbl_probe.c).
|
||||
// Needs no game files.
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -7,6 +8,7 @@
|
||||
#include "host.h"
|
||||
#include "mods.h"
|
||||
#include "platform/platform.h"
|
||||
#include "restbl.h"
|
||||
|
||||
static int fails;
|
||||
#define CHECK(c, what) do { if (!(c)) { fails++; fprintf(stderr, "FAIL mods: %s\n", what); } } while (0)
|
||||
@@ -126,5 +128,6 @@ int probe_mods(void) {
|
||||
}
|
||||
remove_tree(root);
|
||||
printf("mods: %s\n", fails ? "FAIL" : "ok");
|
||||
return fails ? 1 : 0;
|
||||
int table = restbl_probe();
|
||||
return fails || table ? 1 : 0;
|
||||
}
|
||||
+766
-37
@@ -1,12 +1,16 @@
|
||||
// Direct mouse input for TotK 1.4.3. The camera controller's input update (main+0x874c1c) turns HID stick floats
|
||||
// into a radial dead zone, clamps the radius to one and applies StickExponent. The mouse enters after all three,
|
||||
// at main+0x874cb4, before the game's X/Y inversion and input-activity flags. It never becomes a HID stick value.
|
||||
// Direct mouse input for TotK 1.4.3 and 1.2.1. The camera controller's input update (1.4.3 main+0x874c1c, 1.2.1
|
||||
// main+0xd18088) turns HID stick floats into a radial dead zone, clamps the radius to one and applies StickExponent.
|
||||
// The mouse enters after all three, at the store of x (1.4.3 main+0x874cb4), before the game's X/Y inversion and
|
||||
// input-activity flags. It never becomes a HID stick value. Where each version keeps the values the hooks read is in
|
||||
// its MouseLayout (layout_143, layout_121), chosen by the running game version.
|
||||
// Free orbit removes that sample again before the camera's additional vertical square/velocity filters and adds
|
||||
// raw-count angular deltas at its spherical-angle output instead. Ultrahand has a separate post-curve hook.
|
||||
// raw-count angular deltas at its spherical-angle output instead. The aiming, scope, ability, horse and Purah Pad
|
||||
// cameras do the same at the angle each integrates from (camera_load). Ultrahand has a separate post-curve hook.
|
||||
// The other camera modes still take the mouse as stick, linear on both axes (mouse_stick_add).
|
||||
// The ordinary stick's result stays, so a controller still uses the game's own response.
|
||||
//
|
||||
// This is deliberately not a render-camera override: the game remains responsible for aiming, camera collision,
|
||||
// lock-on and scripted cameras. Which of its other modes consume this camera input needs in-game verification.
|
||||
// lock-on and scripted cameras.
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
@@ -15,13 +19,37 @@
|
||||
#include "cfg.h"
|
||||
#include "host.h"
|
||||
#include "input.h"
|
||||
#include "input_map.h"
|
||||
#include "input_wsys.h"
|
||||
#include "layout.h"
|
||||
#include "platform/platform.h"
|
||||
|
||||
#if __has_include("patches.h")
|
||||
#include "patches.h"
|
||||
#endif
|
||||
|
||||
// One turn rate for every camera, as a PC game has: degrees per raw count at sensitivity 1. It is the free camera's rate
|
||||
// since the direct mode came (0.08, about 14.3 cm a turn at 800 DPI), so a mouse_sens set for it keeps its meaning. The
|
||||
// stick rates and the ability camera's scales below are those Weeping of the Empire's engine/runtime/pc_mouse.cpp
|
||||
// works with.
|
||||
#define DEG_PER_COUNT 0.08f
|
||||
// The stick turns yaw 70 x / 30 degrees per step at the 30 Hz frame ratio: a processed stick value of STICK_PER_COUNT a
|
||||
// count turns yaw DEG_PER_COUNT in the cameras that still take the mouse as stick (mouse_stick_add).
|
||||
#define STICK_PER_COUNT (DEG_PER_COUNT * 30.0f / 70.0f)
|
||||
// Pitch turns 51 degrees a second a unit of y against yaw's 70 a unit of x (linearly in every camera but the free
|
||||
// orbit, which squares y and takes degrees instead): the mouse's y is PITCH_GAIN times its x a count.
|
||||
#define PITCH_GAIN (70.0f / 51.0f)
|
||||
// The ability camera (ExecutePlayerCameraSpecialPower) turns the stored stick its own way: yaw x * 0.8 of on foot's
|
||||
// rate and pitch y * 1.5 * 51, linear (no signed square). The mouse's part is scaled back to on foot's degrees a count:
|
||||
// x / 0.8, and pitch linear at 70 / (1.5 * 51).
|
||||
#define ABILITY_GAIN_X (1.0f / 0.8f)
|
||||
#define ABILITY_GAIN_Y (70.0f / (1.5f * 51.0f))
|
||||
// Ultrahand's held object moves by its post-curve input times its speed at a full tilt: the mouse's part is
|
||||
// HAND_PER_COUNT a count over the frame ratio, the rate the direct mode has had since it came, at most HAND_MAX full
|
||||
// tilts a step
|
||||
#define HAND_PER_COUNT 0.01f
|
||||
#define HAND_MAX 3.0f
|
||||
|
||||
static int direct_mode(void) {
|
||||
// cfg_value: unset is the settings table's default (direct), as the menu shows it
|
||||
return !strcmp(cfg_value("TOTK_MOUSE_MODE"), "direct") && rt_patch_enabled(rt_patch_set("mouse_direct"));
|
||||
@@ -44,6 +72,11 @@ int input_direct_mouse_active(void) {
|
||||
|
||||
int input_direct_mouse_enabled(void) { return direct_mode(); }
|
||||
|
||||
// A shake of the mouse while Ultrahand holds an object (camera_input, mouse_shake_step): the right stick's side that
|
||||
// follows it, -1 / +1, 0 while the mouse does not shake (input.c puts it on the right stick's x)
|
||||
static volatile int32_t shake_side;
|
||||
int input_direct_mouse_shake(void) { return __atomic_load_n(&shake_side, __ATOMIC_RELAXED); }
|
||||
|
||||
void input_direct_mouse_radial(int32_t dx, int32_t dy, float sensitivity, float cursor[2], int32_t out[2]) {
|
||||
if (!(sensitivity > 0)) { cursor[0] = cursor[1] = 0; out[0] = out[1] = 0; return; }
|
||||
cursor[0] += dx * (double)sensitivity / 200;
|
||||
@@ -88,18 +121,49 @@ void input_direct_mouse_row(int32_t dx, float sensitivity, uint64_t now, InputMo
|
||||
#define HOST_MOUSE_HAND (RT_PATCH_PAGE + 0xf90)
|
||||
static _Thread_local uint64_t mouse_input_object;
|
||||
|
||||
// Where a game version keeps what the hooks read and write (recomp/patches-v143.txt, patches-v121.txt). The camera
|
||||
// input update keeps its flags in w21, its input object in x20 and y in s10 in both; the free orbit's object is x0 at
|
||||
// its begin and x20 at its angles; Ultrahand's object is x19 and its y s15.
|
||||
struct LoadSite;
|
||||
typedef struct {
|
||||
uint8_t input_x; // camera_input: the s register with x, which the displaced store puts at +0x420
|
||||
uint8_t activity_sp; // camera_activity: the displaced ldp d9, d8, [sp, #activity_sp]
|
||||
uint8_t orbit_pitch, orbit_yaw; // orbit_angles: the final pitch and yaw on the stack, sp + these
|
||||
uint8_t orbit_reg; // and the displaced ldr s<orbit_reg>, [sp, #orbit_pitch]
|
||||
uint8_t hand_x_sp, hand_x_reg; // hand_input: x at sp + hand_x_sp, or in s<hand_x_reg> when that is 0
|
||||
uint8_t hand_store_reg, hand_store_sp; // the displaced str w<hand_store_reg>, [sp, #hand_store_sp]
|
||||
uint64_t player_root_slot, main_size; // player_state: 0 when not known for this version
|
||||
const struct LoadSite *loads; // camera_load's sites
|
||||
size_t load_count;
|
||||
} MouseLayout;
|
||||
static const MouseLayout *mouse_layout(void);
|
||||
|
||||
typedef struct {
|
||||
uint64_t object, generation, when;
|
||||
float pad[2], motion[2], angle[2]; // post-inversion controller input, mouse input, mouse yaw/pitch in degrees
|
||||
int camera_enabled;
|
||||
int swing; // a mouse shake swings the right stick in this step or did in the last (pad[0] is 0 then)
|
||||
uint32_t player; // player_state_logged's flags for this step (0 without mouse motion)
|
||||
} MouseSample;
|
||||
static MouseSample sample;
|
||||
static PlatMutex sample_lock = PLAT_MUTEX_INIT;
|
||||
// The generation of the last sample a direct hook turned a camera by (orbit_angles, load_stick); sample_lock. A sample
|
||||
// with mouse motion that none took went to its camera as stick input only (mouse_stick_add): camera_input logs that.
|
||||
static uint64_t sample_taken;
|
||||
// The last sample with mouse motion a watched camera mode loaded as stick (ROLE_WATCH): its generation and mode
|
||||
static uint64_t sample_watched;
|
||||
static int sample_watched_mode = -1;
|
||||
static const char *mode_name(int mode); // the load sites' camera modes, below
|
||||
static void sample_mark_taken(uint64_t generation) {
|
||||
plat_mutex_lock(&sample_lock);
|
||||
sample_taken = generation;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
}
|
||||
static _Thread_local struct { uint64_t object; MouseSample mouse; } orbit;
|
||||
typedef struct {
|
||||
uint64_t object, generation, input;
|
||||
uint64_t object, generation, input, seen;
|
||||
float pitch, original_target;
|
||||
int hold_pitch, target_saved;
|
||||
int hold_pitch, target_saved, resume;
|
||||
} OrbitTrack;
|
||||
static OrbitTrack orbit_seen[16];
|
||||
|
||||
@@ -134,6 +198,76 @@ static MouseSample sample_read(void) {
|
||||
}
|
||||
static float wrap_degrees(float a) { return remainderf(a, 360.0f); }
|
||||
|
||||
// ---- the player's state: using an ability, the bow in hand. The player's action verbs, read as Weeping of the
|
||||
// Empire's engine/runtime/totk_player_state.cpp reads them, with its 1.4.3 placement (games/totk/patches/
|
||||
// pins_v143.json, fields_v143.json): the player root's GOT slot main+0x3969918 (1.0.0 +0x4562308), its link +0x20
|
||||
// (id +0x10, unit +8; the unit's id +0x48 and proc +0x40, the proc's state +0x24 not 7..11 while it is deleted), the
|
||||
// actor's component array +0x228 (1.0.0 +0x220), its AS component +0x158, whose 5 slots (+0x1f0) hold the verb at +0x28
|
||||
// (+0x4c when +0x28 is Invalid). Every pointer is checked before it is followed; any miss reads as "nothing".
|
||||
// 1.2.1's slot, component offset and verb numbers are not known (MouseLayout.player_root_slot 0): there the player
|
||||
// always reads as not found, so the ability camera's stick fallback keeps on-foot gains and mouse_aim_scale stays off.
|
||||
enum { VERB_USE_BOW = 59, VERB_USE_SPECIAL_POWER = 61, VERB_DRAWN_BOW = 205, VERB_INVALID = 284 };
|
||||
enum { PLAYER_FOUND = 1, PLAYER_ABILITY = 2, PLAYER_BOW = 4 };
|
||||
|
||||
static int readable(uint64_t p, uint64_t n) {
|
||||
return p >= 0x10000 && p < (1ull << 47) && !(p & 7) && mem_guest_readable(p, n);
|
||||
}
|
||||
static int32_t guest_s32(uint64_t at) { int32_t v; memcpy(&v, (void *)(uintptr_t)at, sizeof v); return v; }
|
||||
static int game_object(uint64_t p, uint64_t n) { // readable, its vtable in main's image
|
||||
if (!readable(p, n)) return 0;
|
||||
uint64_t vt = guest_pointer(p);
|
||||
return vt >= MOD_MAIN_BASE && vt < MOD_MAIN_BASE + mouse_layout()->main_size;
|
||||
}
|
||||
|
||||
static uint32_t player_state(void) {
|
||||
if (!mouse_layout()->player_root_slot) return 0;
|
||||
uint64_t slot = MOD_MAIN_BASE + mouse_layout()->player_root_slot;
|
||||
if (!readable(slot, 8)) return 0;
|
||||
uint64_t var = guest_pointer(slot);
|
||||
if (!readable(var, 8)) return 0;
|
||||
uint64_t root = guest_pointer(var);
|
||||
if (!readable(root, 0x38)) return 0;
|
||||
uint64_t link = root + 0x20, unit = guest_pointer(link + 8);
|
||||
int32_t id = guest_s32(link + 0x10);
|
||||
if (id == -1 || !readable(unit, 0x50) || guest_s32(unit + 0x48) != id) return 0;
|
||||
uint64_t proc = guest_pointer(unit + 0x40);
|
||||
if (!game_object(proc, 0x230) || (uint32_t)(guest_s32(proc + 0x24) - 7) < 5) return 0;
|
||||
uint64_t comps = guest_pointer(proc + 0x228);
|
||||
if (!readable(comps, 0x160)) return 0;
|
||||
uint64_t as = guest_pointer(comps + 0x158);
|
||||
if (!game_object(as, 0x1f0 + 5 * 8)) return 0;
|
||||
uint32_t f = PLAYER_FOUND;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
uint64_t s = guest_pointer(as + 0x1f0 + 8ull * i);
|
||||
if (!readable(s, 0x50)) continue;
|
||||
int32_t v = guest_s32(s + 0x28);
|
||||
if (v == VERB_INVALID) v = guest_s32(s + 0x4c);
|
||||
if (v == VERB_USE_SPECIAL_POWER) f |= PLAYER_ABILITY;
|
||||
if (v == VERB_USE_BOW || v == VERB_DRAWN_BOW) f |= PLAYER_BOW;
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
// The player's state for this camera step, read again every 50 ms (each read costs memory queries), and its changes in
|
||||
// the log (the first reads, then each change, 40 lines)
|
||||
static uint32_t player_state_logged(void) {
|
||||
static uint32_t last = ~0u, f;
|
||||
static uint64_t at;
|
||||
static int lines;
|
||||
uint64_t now = plat_now_ns();
|
||||
if (at && now - at < 50000000ull) return f;
|
||||
at = now;
|
||||
f = player_state();
|
||||
if (f != last && lines < 40) {
|
||||
lines++;
|
||||
rt_log("mouse: player %s%s%s", f & PLAYER_FOUND ? "found" : "not found",
|
||||
f & PLAYER_ABILITY ? ", using an ability (ability camera gains)" : "",
|
||||
f & PLAYER_BOW ? ", bow in hand" : "");
|
||||
}
|
||||
last = f;
|
||||
return f;
|
||||
}
|
||||
|
||||
// main+0x191d78 builds the pitch target from +0x15c and +0x11c; the orbit update filters +0x108 toward it and adds
|
||||
// (1 - +0x88) * +0x10c at output. Updating only +0x108 makes the camera spring back to the unchanged target.
|
||||
static float orbit_pitch_offset(uint64_t object) {
|
||||
@@ -146,19 +280,94 @@ static void orbit_pitch_target(uint64_t object, float pitch) {
|
||||
|
||||
static void orbit_pitch_release(OrbitTrack *track) {
|
||||
if (track->target_saved) guest_float_store(track->object + 0x15c, track->original_target);
|
||||
track->hold_pitch = track->target_saved = 0;
|
||||
track->hold_pitch = track->target_saved = track->resume = 0;
|
||||
}
|
||||
|
||||
// The pitch the camera has now (the filtered pitch plus its vertical offset), as orbit_angles leaves it
|
||||
static float orbit_pitch_now(uint64_t object) {
|
||||
return wrap_degrees(guest_float(object + 0x108) + orbit_pitch_offset(object));
|
||||
}
|
||||
|
||||
// The camera stays where it is now: the mouse holds the pitch the camera has (orbit_begin writes its target), so
|
||||
// neither the game's default target nor the mouse's target from before an aim or a lock-on pulls it back.
|
||||
static void orbit_pitch_settle(OrbitTrack *track) {
|
||||
track->pitch = orbit_pitch_now(track->object);
|
||||
track->hold_pitch = 1, track->resume = 0;
|
||||
}
|
||||
|
||||
// The mouse's part of the processed stick for dx / dy counts at k stick units a count. Only the free orbit turns its
|
||||
// pitch by the signed square of y, and it never takes this value (orbit_begin removes it, orbit_angles adds degrees).
|
||||
// The other cameras that read the stick turn both axes linearly, yaw at the orbit's rate and pitch at 51 / 70 of it
|
||||
// (Horse, ClimbObj, WaterfallClimb: PlayerCamera +0xc9c for pitch against +0xc9c times the yaw factor for yaw), so y
|
||||
// is linear with PITCH_GAIN. The cameras with load sites below take degrees instead; this is the fallback for the
|
||||
// rest. The ability camera's linear scales are undone in its offset mode, which the load sites leave to the stick.
|
||||
static void mouse_stick_add(int32_t dx, int32_t dy, float k, int ability, float *x, float *y) {
|
||||
float v = -dy * k;
|
||||
if (ability) {
|
||||
*x += dx * k * ABILITY_GAIN_X;
|
||||
*y += v * ABILITY_GAIN_Y;
|
||||
} else {
|
||||
*x += dx * k;
|
||||
*y += v * PITCH_GAIN;
|
||||
}
|
||||
}
|
||||
|
||||
// The game detaches a fused part when the right stick swings left and right a few times; in direct mode the mouse
|
||||
// never reaches that stick. Once the mouse shakes (horizontal swings of at least SHAKE_SWING_DEG of camera turn each,
|
||||
// changing direction SHAKE_FOLLOW_TURNS times within SHAKE_WINDOW_NS of the first change), the right stick follows
|
||||
// it: full tilt the way the mouse moves, each side held at least SHAKE_SIDE_NS (two frames at the game's 30 fps) so
|
||||
// every side is read, neutral as soon as the mouse rests. Only the player's own swings reach the stick, nothing plays
|
||||
// on after them; SHAKE_IDLE_NS without motion ends the shake. Turning a held object back and forth at an ordinary pace
|
||||
// takes longer than the window, and a reversal after a shorter swing starts the count again.
|
||||
#define SHAKE_SWING_DEG 10.0f
|
||||
#define SHAKE_FOLLOW_TURNS 2
|
||||
#define SHAKE_WINDOW_NS 350000000ull
|
||||
#define SHAKE_SIDE_NS 66666667ull
|
||||
#define SHAKE_IDLE_NS 150000000ull
|
||||
typedef struct { int dir, turns, side; float swing; uint64_t first, side_from, moved; } MouseShake;
|
||||
// deg: this step's horizontal motion in degrees of camera turn. Returns the right stick's side for this step: -1 / +1
|
||||
// while it follows the mouse's shake, 0 otherwise.
|
||||
static int mouse_shake_step(MouseShake *s, float deg, uint64_t now) {
|
||||
int following = s->turns >= SHAKE_FOLLOW_TURNS;
|
||||
if (!following && s->turns && now - s->first > SHAKE_WINDOW_NS) s->turns = 0;
|
||||
if (deg != 0) {
|
||||
int d = deg > 0 ? 1 : -1;
|
||||
s->moved = now;
|
||||
if (d == s->dir) {
|
||||
s->swing += fabsf(deg);
|
||||
} else {
|
||||
if (following || (s->dir && s->swing >= SHAKE_SWING_DEG)) {
|
||||
if (!s->turns) s->first = now;
|
||||
s->turns++;
|
||||
} else {
|
||||
s->turns = 0;
|
||||
}
|
||||
s->dir = d, s->swing = fabsf(deg);
|
||||
}
|
||||
following = s->turns >= SHAKE_FOLLOW_TURNS;
|
||||
} else if (following && now - s->moved >= SHAKE_IDLE_NS) { // the shake is over
|
||||
*s = (MouseShake){0};
|
||||
return 0;
|
||||
}
|
||||
if (!following) return 0;
|
||||
if (s->side && now - s->side_from < SHAKE_SIDE_NS) return s->side; // a side is read before the next
|
||||
int want = deg != 0 ? s->dir : 0; // neutral while the mouse rests
|
||||
if (want != s->side) s->side = want, s->side_from = now;
|
||||
return s->side;
|
||||
}
|
||||
|
||||
// A host call at an instruction site, not an AAPCS64 function replacement. Preserve every guest register except
|
||||
// s9/s10, which carry the processed camera input, and perform the displaced store of s9 at [x20 + 0x420].
|
||||
// x and s10, which carry the processed camera input (x is s9 in 1.4.3, s11 in 1.2.1: MouseLayout.input_x), and
|
||||
// perform the displaced store of x at [x20 + 0x420].
|
||||
static void camera_input(Cpu *c) {
|
||||
const unsigned rx = mouse_layout()->input_x;
|
||||
mouse_input_object = 0;
|
||||
uint32_t flags = (uint32_t)c->x[21];
|
||||
int accept = !(flags & 1) && !input_direct_mouse_selector_active();
|
||||
__atomic_store_n(&accepts_mouse, accept, __ATOMIC_RELAXED);
|
||||
__atomic_store_n(&last_update, plat_now_ns(), __ATOMIC_RELEASE);
|
||||
MouseSample next = {.object = c->x[20], .when = plat_now_ns(), .camera_enabled = accept};
|
||||
memcpy(&next.pad[0], &c->v[9], sizeof(float));
|
||||
memcpy(&next.pad[0], &c->v[rx], sizeof(float));
|
||||
memcpy(&next.pad[1], &c->v[10], sizeof(float));
|
||||
if (flags & 2) next.pad[0] = -next.pad[0];
|
||||
if (flags & 4) next.pad[1] = -next.pad[1];
|
||||
@@ -167,6 +376,28 @@ static void camera_input(Cpu *c) {
|
||||
input_direct_mouse_sample(!input_direct_mouse_selector_active() && (accept || hand_active(plat_now_ns())), &dx, &dy);
|
||||
float sensitivity = (float)cfg_double("TOTK_MOUSE_SENS");
|
||||
sensitivity = fminf(10, fmaxf(0, sensitivity));
|
||||
uint32_t player = (dx || dy) ? player_state_logged() : 0;
|
||||
next.player = player;
|
||||
int ability = (player & PLAYER_ABILITY) != 0;
|
||||
// The bow drawn (in hand with ZR held): mouse_aim_scale times the mouse's motion on every path
|
||||
if ((player & PLAYER_BOW) && (input_buttons_last() & (1ull << B_ZR)))
|
||||
sensitivity *= (float)fminf(3, fmaxf(0.1, cfg_double("TOTK_MOUSE_AIM_SCALE")));
|
||||
// Ultrahand holding an object: a shake of the mouse swings the right stick with it (mouse_shake_step)
|
||||
static MouseShake shake;
|
||||
static int last_side;
|
||||
uint64_t step_now = plat_now_ns();
|
||||
int side = 0;
|
||||
if (hand_active(step_now)) side = mouse_shake_step(&shake, dx * DEG_PER_COUNT * sensitivity, step_now);
|
||||
else shake = (MouseShake){0};
|
||||
__atomic_store_n(&shake_side, side, __ATOMIC_RELAXED);
|
||||
if (side) {
|
||||
static int logged;
|
||||
if (!logged) logged = 1, rt_log("mouse: a shake while Ultrahand holds an object swings the right stick with it");
|
||||
}
|
||||
// That swing is the mouse's own motion, which turns the camera in degrees already: the camera hooks take the
|
||||
// right stick's x as 0 while it swings (the stick read of this step may still carry the last step's side)
|
||||
if (side || last_side) next.pad[0] = 0, next.swing = 1;
|
||||
last_side = side;
|
||||
// The game multiplies camera input by its 30 Hz frame ratio later. Divide by that exact ratio, rather
|
||||
// than wall-clock time: an equal distance of mouse motion then gives equal input at every frame rate.
|
||||
float ratio = 1;
|
||||
@@ -178,18 +409,20 @@ static void camera_input(Cpu *c) {
|
||||
if (isfinite(ratio) && ratio > 0 && sensitivity > 0 && (dx || dy)) {
|
||||
if (accept) mouse_input_object = c->x[20];
|
||||
float x, y;
|
||||
memcpy(&x, &c->v[9], sizeof x);
|
||||
memcpy(&x, &c->v[rx], sizeof x);
|
||||
memcpy(&y, &c->v[10], sizeof y);
|
||||
float scale = 0.01f * sensitivity / ratio;
|
||||
next.motion[0] = dx * scale * (flags & 2 ? -1 : 1);
|
||||
next.motion[1] = -dy * scale * (flags & 4 ? -1 : 1);
|
||||
next.angle[0] = -dx * 0.08f * sensitivity * (flags & 2 ? -1 : 1);
|
||||
next.angle[1] = dy * 0.08f * sensitivity * (flags & 4 ? -1 : 1);
|
||||
if (accept) { x += dx * scale; y -= dy * scale; }
|
||||
float hand = HAND_PER_COUNT * sensitivity / ratio;
|
||||
next.motion[0] = fminf(HAND_MAX, fmaxf(-HAND_MAX, dx * hand * (flags & 2 ? -1 : 1)));
|
||||
next.motion[1] = fminf(HAND_MAX, fmaxf(-HAND_MAX, -dy * hand * (flags & 4 ? -1 : 1)));
|
||||
next.angle[0] = -dx * DEG_PER_COUNT * sensitivity * (flags & 2 ? -1 : 1);
|
||||
next.angle[1] = dy * DEG_PER_COUNT * sensitivity * (flags & 4 ? -1 : 1);
|
||||
// stick_sens multiplies the game's stick turn rates (camera_speed.c): the mouse divides it out
|
||||
if (accept) mouse_stick_add(dx, dy, STICK_PER_COUNT * sensitivity / (ratio * cam_speed_applied()), ability,
|
||||
&x, &y);
|
||||
uint32_t xb, yb;
|
||||
memcpy(&xb, &x, sizeof xb);
|
||||
memcpy(&yb, &y, sizeof yb);
|
||||
c->v[9] = xb;
|
||||
c->v[rx] = xb;
|
||||
c->v[10] = yb;
|
||||
static int logged;
|
||||
if (!logged) {
|
||||
@@ -199,10 +432,23 @@ static void camera_input(Cpu *c) {
|
||||
}
|
||||
}
|
||||
plat_mutex_lock(&sample_lock);
|
||||
MouseSample last = sample;
|
||||
int untaken = last.camera_enabled && (last.angle[0] || last.angle[1]) && sample_taken != last.generation;
|
||||
int watched = sample_watched == last.generation ? sample_watched_mode : -1;
|
||||
next.generation = sample.generation + 1;
|
||||
sample = next;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
uint32_t original = (uint32_t)c->v[9];
|
||||
// The camera modes still on stick input, as play reaches them: the first 30 steps, then one in 600
|
||||
static unsigned untaken_count;
|
||||
if (untaken && (++untaken_count <= 30 || untaken_count % 600 == 0)) {
|
||||
uint32_t state = 0;
|
||||
if (readable(last.object, 0x160)) memcpy(&state, (void *)(uintptr_t)(last.object + 0x15c), sizeof state);
|
||||
rt_log("mouse: step %u with mouse motion took the stick path (no direct camera hook): camera %s, player "
|
||||
"%s%s%s, input +0x15c %#x", untaken_count, watched >= 0 ? mode_name(watched) : "not a watched one",
|
||||
last.player & PLAYER_FOUND ? "found" : "not found", last.player & PLAYER_ABILITY ? ", using an ability" : "",
|
||||
last.player & PLAYER_BOW ? ", bow in hand" : "", state);
|
||||
}
|
||||
uint32_t original = (uint32_t)c->v[rx];
|
||||
memcpy((void *)(uintptr_t)(c->x[20] + 0x420), &original, sizeof original);
|
||||
}
|
||||
|
||||
@@ -225,8 +471,17 @@ static void orbit_begin(Cpu *c) {
|
||||
memcpy(&override, (void *)(uintptr_t)(input + 0x15c), 1);
|
||||
plat_mutex_lock(&sample_lock);
|
||||
OrbitTrack *track = orbit_track(object);
|
||||
if (track->input != input) track->hold_pitch = track->target_saved = 0;
|
||||
if (m.pad[1] != 0 || (held & 0x20) || (override & 0x40)) orbit_pitch_release(track);
|
||||
if (track->input != input) track->hold_pitch = track->target_saved = track->resume = 0;
|
||||
uint64_t now = plat_now_ns();
|
||||
// A gamepad's vertical input gives the pitch back to the game's own target. The game's lock-on or override
|
||||
// (aiming) drives the camera itself: the mouse lets go without restoring the target it had before, and
|
||||
// once that ends (or after this camera went 100 ms without a step) settles on the pitch the camera has
|
||||
if (m.pad[1] != 0) orbit_pitch_release(track);
|
||||
else if ((held & 0x20) || (override & 0x40)) {
|
||||
if (track->hold_pitch) track->hold_pitch = 0, track->resume = 1;
|
||||
} else if (track->resume || (track->hold_pitch && now - track->seen > 100000000ull))
|
||||
orbit_pitch_settle(track);
|
||||
track->seen = now;
|
||||
take = moved || track->hold_pitch;
|
||||
if (take) track->input = input;
|
||||
if (track->hold_pitch) orbit_pitch_target(object, track->pitch);
|
||||
@@ -245,17 +500,21 @@ static void orbit_begin(Cpu *c) {
|
||||
c->x[8] = guest_pointer(object + 8); // displaced ldr x8, [x0, #8]
|
||||
}
|
||||
|
||||
// The final pitch and yaw are on the stack (1.4.3 sp + 0x44 / 0x48, 1.2.1 sp + 0x3c / 0x40)
|
||||
static void orbit_angles(Cpu *c) {
|
||||
const MouseLayout *ml = mouse_layout();
|
||||
const uint64_t pitch_at = c->sp + ml->orbit_pitch, yaw_at = c->sp + ml->orbit_yaw;
|
||||
uint64_t object = c->x[20];
|
||||
if (orbit.object == object) {
|
||||
float yaw_delta = orbit.mouse.angle[0], pitch_delta = orbit.mouse.angle[1];
|
||||
int fresh = plat_now_ns() - orbit.mouse.when < 150000000ull &&
|
||||
orbit_sample_once(object, orbit.mouse.generation);
|
||||
if (!fresh) yaw_delta = pitch_delta = 0;
|
||||
if (yaw_delta || pitch_delta) sample_mark_taken(orbit.mouse.generation);
|
||||
plat_mutex_lock(&sample_lock);
|
||||
OrbitTrack *track = orbit_track(object);
|
||||
if (track->hold_pitch || yaw_delta || pitch_delta) {
|
||||
float pitch = guest_float(c->sp + 0x44), yaw = guest_float(c->sp + 0x48);
|
||||
float pitch = guest_float(pitch_at), yaw = guest_float(yaw_at);
|
||||
float low = guest_float(object + 0xf8), high = guest_float(object + 0xfc);
|
||||
if (!isfinite(low) || !isfinite(high) || low >= high) low = -89.9f, high = 89.9f;
|
||||
low = fmaxf(-89.9f, low); high = fminf(89.9f, high);
|
||||
@@ -263,8 +522,8 @@ static void orbit_angles(Cpu *c) {
|
||||
// Integrate from our last requested angle, then correct the final output even on stationary frames.
|
||||
float base = track->hold_pitch ? track->pitch : pitch;
|
||||
float new_pitch = fminf(high, fmaxf(low, base + pitch_delta));
|
||||
guest_float_store(c->sp + 0x44, new_pitch);
|
||||
guest_float_store(c->sp + 0x48, wrap_degrees(yaw + yaw_delta));
|
||||
guest_float_store(pitch_at, new_pitch);
|
||||
guest_float_store(yaw_at, wrap_degrees(yaw + yaw_delta));
|
||||
guest_float_store(object + 0x108, wrap_degrees(new_pitch - orbit_pitch_offset(object)));
|
||||
guest_float_store(object + 0x120, wrap_degrees(guest_float(object + 0x120) + yaw_delta));
|
||||
if (!track->target_saved) track->original_target = guest_float(object + 0x15c), track->target_saved = 1;
|
||||
@@ -273,31 +532,37 @@ static void orbit_angles(Cpu *c) {
|
||||
static int logged;
|
||||
if (!logged) {
|
||||
logged = 1;
|
||||
rt_log("mouse: free-camera angles directly, 0.08 degrees per count at sensitivity 1, equal X/Y");
|
||||
rt_log("mouse: free-camera angles directly, %.4f degrees per count at sensitivity 1, equal X/Y",
|
||||
DEG_PER_COUNT);
|
||||
}
|
||||
}
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
orbit.object = 0;
|
||||
}
|
||||
uint32_t bits;
|
||||
memcpy(&bits, (const void *)(uintptr_t)(c->sp + 0x44), sizeof bits);
|
||||
c->v[12] = bits; // displaced ldr s12, [sp, #0x44]
|
||||
memcpy(&bits, (const void *)(uintptr_t)pitch_at, sizeof bits);
|
||||
c->v[ml->orbit_reg] = bits; // displaced ldr s12, [sp, #0x44] (1.2.1 ldr s13, [sp, #0x3c])
|
||||
}
|
||||
|
||||
// Ultrahand reads the player's manipulation input rather than the camera's processed stick. Insert the mouse
|
||||
// after that controller's per-axis power curves (main+0x1d59460), preserving the keyboard/controller contribution.
|
||||
// after that controller's per-axis power curves (1.4.3 main+0x1d59460, 1.2.1 main+0x176949c), preserving the
|
||||
// keyboard/controller contribution. x is at [sp + 0x60] in 1.4.3 and in s9 in 1.2.1, y in s15 in both.
|
||||
static void hand_input(Cpu *c) {
|
||||
const MouseLayout *ml = mouse_layout();
|
||||
__atomic_store_n(&hand_update, plat_now_ns(), __ATOMIC_RELEASE);
|
||||
static _Thread_local uint64_t object, generation;
|
||||
if (direct_mode()) {
|
||||
MouseSample m = sample_read();
|
||||
if (m.generation != generation || object != c->x[19]) {
|
||||
float x = guest_float(c->sp + 0x60), y;
|
||||
float x, y;
|
||||
if (ml->hand_x_sp) x = guest_float(c->sp + ml->hand_x_sp);
|
||||
else memcpy(&x, &c->v[ml->hand_x_reg], sizeof x);
|
||||
memcpy(&y, &c->v[15], sizeof y);
|
||||
x += m.motion[0];
|
||||
y += m.motion[1];
|
||||
guest_float_store(c->sp + 0x60, x);
|
||||
uint32_t bits;
|
||||
if (ml->hand_x_sp) guest_float_store(c->sp + ml->hand_x_sp, x);
|
||||
else memcpy(&bits, &x, sizeof bits), c->v[ml->hand_x_reg] = bits;
|
||||
memcpy(&bits, &y, sizeof bits);
|
||||
c->v[15] = bits;
|
||||
object = c->x[19]; generation = m.generation;
|
||||
@@ -308,15 +573,478 @@ static void hand_input(Cpu *c) {
|
||||
}
|
||||
}
|
||||
}
|
||||
uint32_t original = (uint32_t)c->x[8];
|
||||
memcpy((void *)(uintptr_t)(c->sp + 0x48), &original, sizeof original);
|
||||
uint32_t original = (uint32_t)c->x[ml->hand_store_reg]; // displaced str w8, [sp, #0x48] (1.2.1 w9, #0x18)
|
||||
memcpy((void *)(uintptr_t)(c->sp + ml->hand_store_sp), &original, sizeof original);
|
||||
}
|
||||
|
||||
// ---- The other player cameras that turn by the stick: degrees at the angle they integrate from.
|
||||
// Each of these camera modes (vtable slot 36 of its ExecutePlayerCamera* class, the per-step update) turns by the
|
||||
// processed stick at input +0x420 (x) / +0x424 (y) times its own speeds and the frame time, and adds that to a base
|
||||
// angle in degrees. Two loads per axis are replaced by a host call (the `mouse_direct` load sites of
|
||||
// recomp/patches-v143.txt and patches-v121.txt, all at page +0xf80; the return address tells them apart; the main
|
||||
// addresses below are 1.4.3's, load_sites_121 has 1.2.1's):
|
||||
// stick: the load the turn is computed from gets the gamepad's part only (the sample's pad, post-inversion as the
|
||||
// game stored it), so the mode's speeds, time step and slow motion never touch the mouse;
|
||||
// base: the load of the angle the turn is added to gets the mouse's degrees added, DEG_PER_COUNT a count as the
|
||||
// free orbit, once per sample. The game's clamps, collision and blends run on the result as usual.
|
||||
// The stick loads that only test whether there is input (before the gyro branch) keep the mouse, so a mouse move
|
||||
// still counts as stick input there. The stick load always runs before its base load; it leaves the degrees for that
|
||||
// base (pending), so the two never disagree about a step.
|
||||
// Aiming (bow, throwing; main+0x23be978): yaw = input +0x414 + turn ([x29-0x48]), pitch target = +0x15c + turn, the
|
||||
// pitch follows its target at once (main+0x191970 with rate 1).
|
||||
// AimingTelescope (the scope; main+0x23c08ac) and SpecialPower (abilities; main+0x23d2d40): yaw as
|
||||
// Aiming ([sp+0x58], [x29-0x50]); pitch is +0x160 in degrees, taken to a position along an eased curve
|
||||
// (main+0x23c11d8 / 0x23d38e0), moved by the stick and taken back (main+0x23c14dc / 0x23d3be4). Degrees added to
|
||||
// +0x160 before that come back unchanged, so the curve no longer shapes the mouse. Beyond the pitch limits
|
||||
// (+0x1ac / +0x1b0) the stick moves a second camera parameter instead; the mouse's part past the limit stays in
|
||||
// the stick for that (LIMIT_160). That parameter is the camera's distance (the first of the (distance, pitch, yaw)
|
||||
// main+0x2e2468 takes from the camera's look vector), not a turn.
|
||||
// SpecialPower's offset mode (input +0x15c bit 8; SKIP_OFFSET on the sites above, ONLY_OFFSET below) is Recall's
|
||||
// cursor: the camera keeps a direction (+0x54 yaw) and the stick moves the cursor, +0x1d8 += x *
|
||||
// ReverseRecorderCursorSpeed * frame ratio and +0x1dc likewise, clamped to ReverseRecorderCursorRange; the camera
|
||||
// follows it, yaw = +0x54 - +0x1d8 * P.x and pitch = ... - +0x1dc * P.y with P = ReverseRecorderCameraRange (the
|
||||
// getters main+0x18a82a0, 0x18a824c, 0x18a8348; the step publishes the cursor at input +0x6c0). The cursor's base
|
||||
// loads get the change that moves the aim, the camera's turn plus the cursor's angle from the screen's centre
|
||||
// (o * P + atan(o * tan(half view angle)), the offset taken as the screen's half width / height), by the mouse's
|
||||
// degrees: the world under the cursor moves DEG_PER_COUNT a count, as the camera turns elsewhere (recall_offset).
|
||||
// P is read where the step loads P.y (ROLE_SCALE, both floats); until it was read once the mouse stays in the stick.
|
||||
// CameraFinder (the Purah Pad camera; main+0x23c26c8): pitch = +0x50 - PlayerCamera +0xc9c * y * frame ratio,
|
||||
// clamped; yaw = input +0x414 ([sp+0x48]) - the same with x.
|
||||
// LockOn / Target (lock-on; main+0x23d7140): the game points the camera at the target and the stick adds an offset,
|
||||
// yaw +0xbc and pitch +0xa4 += the step's turn ([sp+0x20], -PlayerCamera +0xc9c * stick * frame time), which the
|
||||
// update then limits and lets return; the step's turn is read twice (ROLE_BASE_KEEP, then ROLE_BASE) and also
|
||||
// decides that return, so it is the turn that gets the mouse's degrees. Where the camera points stays the game's.
|
||||
// LockOnAimingAt (the bow drawn while locked on, BowLockOn / BowLockOn_Horse; its stick step main+0x23cec74):
|
||||
// pitch offset +0x198 and yaw offset +0x19c += -PlayerCamera +0xc9c * stick * frame time, then clamped. The
|
||||
// other bow cameras (Bow, Bow_Crouch, Bow_Zoom, Bow_Horse, Bow_Zoom_Horse) are Aiming.
|
||||
// Tail (wall climbing, parameter set Climb; main+0x23d4950): the stick as angle and length; in its manual state
|
||||
// (+0x16c == 4) yaw +0xc0 and pitch +0xb4 -= x / y * speed * frame ratio. ClimbObj (main+0x23c3a98): pitch +0x88
|
||||
// (through x22, set by a patched mov) and yaw +0x90 likewise. WaterfallClimb (main+0x23dce00): yaw = the camera's
|
||||
// yaw - x * speed * frame ratio, kept at [x29-0x34] and loaded into w8 (the base); its vertical axis moves the
|
||||
// camera's height (ManualHeightMin..Max), not an angle, and stays stick input (watched).
|
||||
// EventMultiTalk (main+0x23c531c) and EventTalkManual (main+0x23c8ffc): pitch / yaw fields -= stick * speed *
|
||||
// frame ratio; MultiTalk's x load is also its input test (EPSILON).
|
||||
// ShieldSurfing (main+0x23d0088) and Wakeboard (main+0x23da61c), one template: the stick as angle and length; yaw
|
||||
// in the steering state = the camera's yaw ([sp+0x3c]) - x * speed * frame time; pitch = +0xdc / +0xd8 taken to an
|
||||
// eased curve's position, moved by K * -y|y| ([sp+0x10] / [sp+0x14]) and taken back, and the same turn moves a
|
||||
// second parameter. Stick y keeps the mouse (KEEP_STICK), the pitch base gets the degrees, the pitch's turn is cut
|
||||
// to the pad's share (ROLE_SHARE); stick x is EPSILON, its length also choosing the steering state.
|
||||
// HorseLockOnEmpty (ZL on a horse with no target) maps the stick's position to an offset that returns with it: no
|
||||
// degrees a count to give, so it stays stick input (watched).
|
||||
// Horse (main+0x23ca518, its helpers main+0x23cb1d4 and 0x23cb398): yaw = input +0x414 + turn (+0x68), pitch =
|
||||
// input +0x410 + turn (+0x64), clamped to +0x5c..+0x60.
|
||||
// Every one of them turns by -K x and -K y for a stick (x, y) and a positive K, as the free orbit does: the sample's
|
||||
// angle[] (-x and -y in counts, times DEG_PER_COUNT) is added as it is.
|
||||
#define HOST_MOUSE_LOAD (RT_PATCH_PAGE + 0xf80)
|
||||
// ROLE_BASE_KEEP: a base load another base load follows. ROLE_SHARE: a turn the game computed from a stick load with
|
||||
// KEEP_STICK, cut to the gamepad's share of it. ROLE_BASE_STORE: a store (str s<t>, [x<n>, #imm]) of base + turn that a
|
||||
// shared helper computed, where the base load itself is in the helper: the stored value and s<t> get the degrees.
|
||||
enum { ROLE_STICK, ROLE_BASE, ROLE_SCALE, ROLE_WATCH, ROLE_BASE_KEEP, ROLE_SHARE, ROLE_BASE_STORE };
|
||||
// Stick flags. EPSILON: the load is also the game's test for input, so with the gamepad's axis at rest and the mouse
|
||||
// moving it gives +-1e-12 in the mouse's direction (input, no turn) instead of 0. KEEP_STICK: the value stays the
|
||||
// game's, mouse and all (other parameters follow it); the turn it makes is cut to the pad's share at ROLE_SHARE.
|
||||
// REPEAT: another read of the axis for the same turn before its stick load (1.2.1 reads the stick once for its length
|
||||
// and again for its angle): the same value, and it leaves the degrees to that stick load.
|
||||
enum { LIMIT_160 = 1, SKIP_OFFSET = 2, ONLY_OFFSET = 4, EPSILON = 8, KEEP_STICK = 16, REPEAT = 32 };
|
||||
enum {
|
||||
MODE_AIM, MODE_SCOPE, MODE_ABILITY, MODE_HORSE, MODE_ABILITY_OFFSET, MODE_FINDER,
|
||||
MODE_CLIMB, MODE_WAKEBOARD, MODE_WATERFALL, MODE_TAIL, MODE_LOCKON, MODE_LOCKON_AIM, MODE_HORSE_LOCKON, MODE_TALK,
|
||||
MODE_TALK_MANUAL, MODE_SHIELD,
|
||||
MODE_COUNT
|
||||
};
|
||||
static const char *const mode_names[MODE_COUNT] = {
|
||||
"aiming (bow, throw)", "scope", "ability", "horse", "Recall cursor (ability offset mode)", "Purah Pad camera",
|
||||
"climbing an object (ClimbObj)", "Wakeboard", "waterfall climbing (WaterfallClimb)", "climbing (Tail)",
|
||||
"LockOn / Target", "bow lock-on (LockOnAimingAt)", "HorseLockOnEmpty", "dialogue (EventMultiTalk)",
|
||||
"dialogue (EventTalkManual)", "shield surfing"};
|
||||
static const char *mode_name(int mode) { return mode >= 0 && mode < MODE_COUNT ? mode_names[mode] : "?"; }
|
||||
typedef struct LoadSite {
|
||||
uint32_t offset, insn; // main offset, the original load (ldr / ldur s<t> or w<t>, [x<n>, #imm]) or store
|
||||
uint8_t mode, axis, role, input_reg, flags;
|
||||
} LoadSite;
|
||||
#define PAIR(m, a) ((m) * 2 + (a))
|
||||
static const LoadSite load_sites_143[] = {
|
||||
{0x23beb94, 0xbd4426c1, MODE_AIM, 1, ROLE_STICK, 22, 0}, // ldr s1, [x22, #0x424]
|
||||
{0x23bebc8, 0xbd415e61, MODE_AIM, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x15c]
|
||||
{0x23bee2c, 0xbd4422c1, MODE_AIM, 0, ROLE_STICK, 22, 0}, // ldr s1, [x22, #0x420]
|
||||
{0x23beeec, 0xbc5b83a1, MODE_AIM, 0, ROLE_BASE, 0, 0}, // ldur s1, [x29, #-0x48]
|
||||
{0x23c0a10, 0xbd4422e0, MODE_SCOPE, 0, ROLE_STICK, 23, 0}, // ldr s0, [x23, #0x420]
|
||||
{0x23c0a1c, 0xbd4426eb, MODE_SCOPE, 1, ROLE_STICK, 23, LIMIT_160}, // ldr s11, [x23, #0x424]
|
||||
{0x23c0b00, 0xbd416260, MODE_SCOPE, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0x160]
|
||||
{0x23c0e80, 0xbd405be1, MODE_SCOPE, 0, ROLE_BASE, 0, 0}, // ldr s1, [sp, #0x58]
|
||||
{0x23d2eec, 0xbd4422e8, MODE_ABILITY, 0, ROLE_STICK, 23, SKIP_OFFSET}, // ldr s8, [x23, #0x420]
|
||||
{0x23d2ef4, 0xbd4426ee, MODE_ABILITY, 1, ROLE_STICK, 23, SKIP_OFFSET | LIMIT_160}, // ldr s14, [x23, #0x424]
|
||||
{0x23d3158, 0xbd416260, MODE_ABILITY, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0x160]
|
||||
{0x23d34cc, 0xbc5b03a1, MODE_ABILITY, 0, ROLE_BASE, 0, 0}, // ldur s1, [x29, #-0x50]
|
||||
{0x23cb274, 0xbd442288, MODE_HORSE, 0, ROLE_STICK, 20, 0}, // ldr s8, [x20, #0x420]
|
||||
{0x23cb2a0, 0xbd406a61, MODE_HORSE, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x68]
|
||||
{0x23cb3f8, 0xbd4426a8, MODE_HORSE, 1, ROLE_STICK, 21, 0}, // ldr s8, [x21, #0x424]
|
||||
{0x23cb424, 0xbd406661, MODE_HORSE, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x64]
|
||||
{0x23d2f30, 0xbd4422e8, MODE_ABILITY_OFFSET, 0, ROLE_STICK, 23, ONLY_OFFSET}, // ldr s8, [x23, #0x420]
|
||||
{0x23d2f5c, 0xbd41da62, MODE_ABILITY_OFFSET, 0, ROLE_BASE, 0, 0}, // ldr s2, [x19, #0x1d8]
|
||||
{0x23d2f6c, 0xbd4426e8, MODE_ABILITY_OFFSET, 1, ROLE_STICK, 23, ONLY_OFFSET}, // ldr s8, [x23, #0x424]
|
||||
{0x23d2f98, 0xbd41de62, MODE_ABILITY_OFFSET, 1, ROLE_BASE, 0, 0}, // ldr s2, [x19, #0x1dc]
|
||||
{0x23d3210, 0xbd400400, MODE_ABILITY_OFFSET, 1, ROLE_SCALE, 0, 0}, // ldr s0, [x0, #0x4] (P.y)
|
||||
{0x23c2890, 0xbd4426ad, MODE_FINDER, 1, ROLE_STICK, 21, 0}, // ldr s13, [x21, #0x424]
|
||||
{0x23c28b4, 0xbd405261, MODE_FINDER, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x50]
|
||||
{0x23c2934, 0xbd4422ad, MODE_FINDER, 0, ROLE_STICK, 21, 0}, // ldr s13, [x21, #0x420]
|
||||
{0x23c2964, 0xbd404be1, MODE_FINDER, 0, ROLE_BASE, 0, 0}, // ldr s1, [sp, #0x48]
|
||||
{0x23c3dd0, 0xbd442301, MODE_CLIMB, 0, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x420]
|
||||
{0x23c3dd8, 0xbd409261, MODE_CLIMB, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x90] (yaw)
|
||||
{0x23c3d64, 0xbd442701, MODE_CLIMB, 1, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x424]
|
||||
// The game's pitch load is ldr s1, [x22, #0x88]! (bc488ec1). recomp/patches-v143.txt makes the mov before it
|
||||
// set x22 = x19 + 0x88, so the hook performs it as the plain load below and writes no register but s1.
|
||||
{0x23c3d70, 0xbd4002c1, MODE_CLIMB, 1, ROLE_BASE, 0, 0}, // ldr s1, [x22] (pitch +0x88)
|
||||
{0x23da694, 0xbd4422c1, MODE_WAKEBOARD, 0, ROLE_STICK, 22, EPSILON}, // ldr s1, [x22, #0x420]
|
||||
{0x23da698, 0xbd4426c0, MODE_WAKEBOARD, 1, ROLE_STICK, 22, KEEP_STICK}, // ldr s0, [x22, #0x424]
|
||||
{0x23da840, 0xbd40da60, MODE_WAKEBOARD, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xd8] (pitch)
|
||||
{0x23da894, 0xbd4017e0, MODE_WAKEBOARD, 1, ROLE_SHARE, 0, 0}, // ldr s0, [sp, #0x14] (pitch turn)
|
||||
{0x23daed8, 0xbd403fe9, MODE_WAKEBOARD, 0, ROLE_BASE, 0, 0}, // ldr s9, [sp, #0x3c] (yaw)
|
||||
{0x23d0100, 0xbd4422c1, MODE_SHIELD, 0, ROLE_STICK, 22, EPSILON}, // ldr s1, [x22, #0x420]
|
||||
{0x23d0104, 0xbd4426c0, MODE_SHIELD, 1, ROLE_STICK, 22, KEEP_STICK}, // ldr s0, [x22, #0x424]
|
||||
{0x23d02ac, 0xbd40de60, MODE_SHIELD, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xdc] (pitch)
|
||||
{0x23d0a34, 0xbd4013e0, MODE_SHIELD, 1, ROLE_SHARE, 0, 0}, // ldr s0, [sp, #0x10] (pitch turn)
|
||||
{0x23d087c, 0xbd403fe9, MODE_SHIELD, 0, ROLE_BASE, 0, 0}, // ldr s9, [sp, #0x3c] (yaw)
|
||||
{0x23dced8, 0xbd4422cd, MODE_WATERFALL, 0, ROLE_STICK, 22, 0}, // ldr s13, [x22, #0x420]
|
||||
{0x23dd070, 0xb85cc3a8, MODE_WATERFALL, 0, ROLE_BASE, 0, 0}, // ldur w8, [x29, #-0x34] (yaw, as bits)
|
||||
{0x23dd008, 0xbd4426c9, MODE_WATERFALL, 1, ROLE_WATCH, 22, 0}, // ldr s9, [x22, #0x424] (height, stick)
|
||||
{0x23d4b14, 0xbd44228c, MODE_TAIL, 0, ROLE_STICK, 20, 0}, // ldr s12, [x20, #0x420]
|
||||
{0x23d4b1c, 0xbd44268d, MODE_TAIL, 1, ROLE_STICK, 20, 0}, // ldr s13, [x20, #0x424]
|
||||
{0x23d4f34, 0xbd40c260, MODE_TAIL, 0, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xc0] (yaw)
|
||||
{0x23d5028, 0xbd40b661, MODE_TAIL, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0xb4] (pitch)
|
||||
{0x23d756c, 0xbd442300, MODE_LOCKON, 0, ROLE_WATCH, 24, 0}, // ldr s0, [x24, #0x420] (the input test)
|
||||
{0x23d7594, 0xbd442301, MODE_LOCKON, 0, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x420]
|
||||
{0x23d75b4, 0xbd4023e0, MODE_LOCKON, 0, ROLE_BASE_KEEP, 0, 0}, // ldr s0, [sp, #0x20] (the yaw turn)
|
||||
{0x23d75c4, 0xbd4023e9, MODE_LOCKON, 0, ROLE_BASE, 0, 0}, // ldr s9, [sp, #0x20]
|
||||
{0x23d7998, 0xbd442701, MODE_LOCKON, 1, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x424]
|
||||
{0x23d79b8, 0xbd4023e0, MODE_LOCKON, 1, ROLE_BASE_KEEP, 0, 0}, // ldr s0, [sp, #0x20] (the pitch turn)
|
||||
{0x23d79c8, 0xbd4023ea, MODE_LOCKON, 1, ROLE_BASE, 0, 0}, // ldr s10, [sp, #0x20]
|
||||
{0x23cecb4, 0xbd4426a9, MODE_LOCKON_AIM, 1, ROLE_STICK, 21, 0}, // ldr s9, [x21, #0x424]
|
||||
{0x23cecf8, 0xbd419a61, MODE_LOCKON_AIM, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x198] (pitch offset)
|
||||
{0x23ced0c, 0xbd4422a9, MODE_LOCKON_AIM, 0, ROLE_STICK, 21, 0}, // ldr s9, [x21, #0x420]
|
||||
{0x23ced4c, 0xbd419e61, MODE_LOCKON_AIM, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x19c] (yaw offset)
|
||||
{0x23cc4b4, 0xbd44232b, MODE_HORSE_LOCKON, 0, ROLE_WATCH, 25, 0}, // ldr s11, [x25, #0x420]
|
||||
{0x23c542c, 0xbd4426eb, MODE_TALK, 1, ROLE_STICK, 23, 0}, // ldr s11, [x23, #0x424]
|
||||
{0x23c546c, 0xbd405e61, MODE_TALK, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x5c] (pitch)
|
||||
{0x23c54d4, 0xbd4422eb, MODE_TALK, 0, ROLE_STICK, 23, EPSILON}, // ldr s11, [x23, #0x420] (also the test)
|
||||
{0x23c5554, 0xbd406661, MODE_TALK, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x64] (yaw)
|
||||
{0x23c90ac, 0xbd442709, MODE_TALK_MANUAL, 1, ROLE_STICK, 24, 0}, // ldr s9, [x24, #0x424]
|
||||
{0x23c90d8, 0xbd407661, MODE_TALK_MANUAL, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x74] (pitch)
|
||||
{0x23c9140, 0xbd442309, MODE_TALK_MANUAL, 0, ROLE_STICK, 24, 0}, // ldr s9, [x24, #0x420]
|
||||
{0x23c9170, 0xbd407e61, MODE_TALK_MANUAL, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x7c] (yaw)
|
||||
};
|
||||
// The same camera modes in 1.2.1 (recomp/patches-v121.txt), each site matched to its 1.4.3 one by enclosing function.
|
||||
// The base (the angle a turn is added to) differs where 1.2.1 adds the turn in a shared helper (*p = wrap(*p + s0)):
|
||||
// Aiming's pitch target takes the degrees at the store of the helper's result, Horse's yaw at the turn the helper is
|
||||
// given. Wakeboard, ShieldSurfing and Tail read each stick axis twice (REPEAT on the first read).
|
||||
static const LoadSite load_sites_121[] = {
|
||||
{0x1d34338, 0xbd4426c1, MODE_AIM, 1, ROLE_STICK, 22, 0}, // ldr s1, [x22, #0x424]
|
||||
{0x1d34374, 0xbd015660, MODE_AIM, 1, ROLE_BASE_STORE, 0, 0}, // str s0, [x19, #0x154] (+0x15c + turn)
|
||||
{0x1d34584, 0xbd4422c1, MODE_AIM, 0, ROLE_STICK, 22, 0}, // ldr s1, [x22, #0x420]
|
||||
{0x1d345d0, 0xbc5b83a1, MODE_AIM, 0, ROLE_BASE, 0, 0}, // ldur s1, [x29, #-0x48]
|
||||
{0x1d35fd4, 0xbd4422e0, MODE_SCOPE, 0, ROLE_STICK, 23, 0}, // ldr s0, [x23, #0x420]
|
||||
{0x1d35fe0, 0xbd4426e9, MODE_SCOPE, 1, ROLE_STICK, 23, LIMIT_160}, // ldr s9, [x23, #0x424]
|
||||
{0x1d36280, 0xbd416260, MODE_SCOPE, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0x160]
|
||||
{0x1d36224, 0xbd405be1, MODE_SCOPE, 0, ROLE_BASE, 0, 0}, // ldr s1, [sp, #0x58]
|
||||
{0x1d48478, 0xbd4422cf, MODE_ABILITY, 0, ROLE_STICK, 22, SKIP_OFFSET}, // ldr s15, [x22, #0x420]
|
||||
{0x1d48480, 0xbd4426cc, MODE_ABILITY, 1, ROLE_STICK, 22, SKIP_OFFSET | LIMIT_160}, // ldr s12, [x22, #0x424]
|
||||
{0x1d48bb4, 0xbd416262, MODE_ABILITY, 1, ROLE_BASE, 0, 0}, // ldr s2, [x19, #0x160]
|
||||
{0x1d48b38, 0xbc5a83a1, MODE_ABILITY, 0, ROLE_BASE, 0, 0}, // ldur s1, [x29, #-0x58]
|
||||
// Horse's x19 is the yaw's address (+0x68) here, after a pre-indexed store: a key for the pair, as an object is
|
||||
{0x1d4070c, 0xbd442288, MODE_HORSE, 0, ROLE_STICK, 20, 0}, // ldr s8, [x20, #0x420]
|
||||
{0x1d40740, 0xbd401be0, MODE_HORSE, 0, ROLE_BASE, 0, 0}, // ldr s0, [sp, #0x18] (the yaw turn)
|
||||
{0x1d408f8, 0xbd4426a8, MODE_HORSE, 1, ROLE_STICK, 21, 0}, // ldr s8, [x21, #0x424]
|
||||
{0x1d409ac, 0xbd406661, MODE_HORSE, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x64]
|
||||
{0x1d48ccc, 0xbd4422c9, MODE_ABILITY_OFFSET, 0, ROLE_STICK, 22, ONLY_OFFSET}, // ldr s9, [x22, #0x420]
|
||||
{0x1d48cf0, 0xbd41da61, MODE_ABILITY_OFFSET, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x1d8]
|
||||
{0x1d48cfc, 0xbd4426c9, MODE_ABILITY_OFFSET, 1, ROLE_STICK, 22, ONLY_OFFSET}, // ldr s9, [x22, #0x424]
|
||||
{0x1d48d18, 0xbd41de61, MODE_ABILITY_OFFSET, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x1dc]
|
||||
{0x1d485f8, 0xbd400400, MODE_ABILITY_OFFSET, 1, ROLE_SCALE, 0, 0}, // ldr s0, [x0, #0x4] (P.y)
|
||||
{0x1d37b44, 0xbd4426ad, MODE_FINDER, 1, ROLE_STICK, 21, 0}, // ldr s13, [x21, #0x424]
|
||||
{0x1d37b68, 0xbd405261, MODE_FINDER, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x50]
|
||||
{0x1d37bcc, 0xbd4422ad, MODE_FINDER, 0, ROLE_STICK, 21, 0}, // ldr s13, [x21, #0x420]
|
||||
{0x1d37bf4, 0xbd405be1, MODE_FINDER, 0, ROLE_BASE, 0, 0}, // ldr s1, [sp, #0x58]
|
||||
{0x1d38e08, 0xbd442301, MODE_CLIMB, 0, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x420]
|
||||
{0x1d38e10, 0xbd409261, MODE_CLIMB, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x90] (yaw)
|
||||
{0x1d38dac, 0xbd442701, MODE_CLIMB, 1, ROLE_STICK, 24, 0}, // ldr s1, [x24, #0x424]
|
||||
{0x1d38db8, 0xbd4002c1, MODE_CLIMB, 1, ROLE_BASE, 0, 0}, // ldr s1, [x22] (pitch +0x88, as 1.4.3)
|
||||
{0x1d50738, 0xbd4422c0, MODE_WAKEBOARD, 0, ROLE_STICK, 22, EPSILON | REPEAT}, // ldr s0, [x22, #0x420]
|
||||
{0x1d50740, 0xbd4426c1, MODE_WAKEBOARD, 1, ROLE_STICK, 22, KEEP_STICK | REPEAT}, // ldr s1, [x22, #0x424]
|
||||
{0x1d50768, 0xbd4426c0, MODE_WAKEBOARD, 1, ROLE_STICK, 22, KEEP_STICK}, // ldr s0, [x22, #0x424]
|
||||
{0x1d5076c, 0xbd4422c1, MODE_WAKEBOARD, 0, ROLE_STICK, 22, EPSILON}, // ldr s1, [x22, #0x420]
|
||||
{0x1d50e5c, 0xbd40da60, MODE_WAKEBOARD, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xd8] (pitch)
|
||||
{0x1d508bc, 0xbd401fa0, MODE_WAKEBOARD, 1, ROLE_SHARE, 0, 0}, // ldr s0, [x29, #0x1c] (pitch turn)
|
||||
{0x1d50f20, 0xbd403bec, MODE_WAKEBOARD, 0, ROLE_BASE, 0, 0}, // ldr s12, [sp, #0x38] (yaw)
|
||||
{0x1d46108, 0xbd4422e0, MODE_SHIELD, 0, ROLE_STICK, 23, EPSILON | REPEAT}, // ldr s0, [x23, #0x420]
|
||||
{0x1d46110, 0xbd4426e1, MODE_SHIELD, 1, ROLE_STICK, 23, KEEP_STICK | REPEAT}, // ldr s1, [x23, #0x424]
|
||||
{0x1d46138, 0xbd4426e0, MODE_SHIELD, 1, ROLE_STICK, 23, KEEP_STICK}, // ldr s0, [x23, #0x424]
|
||||
{0x1d4613c, 0xbd4422e1, MODE_SHIELD, 0, ROLE_STICK, 23, EPSILON}, // ldr s1, [x23, #0x420]
|
||||
{0x1d46788, 0xbd40de60, MODE_SHIELD, 1, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xdc] (pitch)
|
||||
{0x1d46910, 0xbd401fa0, MODE_SHIELD, 1, ROLE_SHARE, 0, 0}, // ldr s0, [x29, #0x1c] (pitch turn)
|
||||
{0x1d467b4, 0xbd403bec, MODE_SHIELD, 0, ROLE_BASE, 0, 0}, // ldr s12, [sp, #0x38] (yaw)
|
||||
{0x1d51e10, 0xbd4422cd, MODE_WATERFALL, 0, ROLE_STICK, 22, 0}, // ldr s13, [x22, #0x420]
|
||||
{0x1d51fb8, 0xb9403be8, MODE_WATERFALL, 0, ROLE_BASE, 0, 0}, // ldr w8, [sp, #0x38] (yaw, as bits)
|
||||
{0x1d51f48, 0xbd4426c9, MODE_WATERFALL, 1, ROLE_WATCH, 22, 0}, // ldr s9, [x22, #0x424] (height, stick)
|
||||
{0x1d4a11c, 0xbd442280, MODE_TAIL, 0, ROLE_STICK, 20, REPEAT}, // ldr s0, [x20, #0x420]
|
||||
{0x1d4a124, 0xbd442681, MODE_TAIL, 1, ROLE_STICK, 20, REPEAT}, // ldr s1, [x20, #0x424]
|
||||
{0x1d4a14c, 0xbd442680, MODE_TAIL, 1, ROLE_STICK, 20, 0}, // ldr s0, [x20, #0x424]
|
||||
{0x1d4a150, 0xbd442281, MODE_TAIL, 0, ROLE_STICK, 20, 0}, // ldr s1, [x20, #0x420]
|
||||
{0x1d4a4a0, 0xbd40c260, MODE_TAIL, 0, ROLE_BASE, 0, 0}, // ldr s0, [x19, #0xc0] (yaw)
|
||||
{0x1d4a514, 0xbd40b661, MODE_TAIL, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0xb4] (pitch)
|
||||
{0x1d4c930, 0xbd442320, MODE_LOCKON, 0, ROLE_WATCH, 25, 0}, // ldr s0, [x25, #0x420] (the input test)
|
||||
{0x1d4c958, 0xbd442321, MODE_LOCKON, 0, ROLE_STICK, 25, 0}, // ldr s1, [x25, #0x420]
|
||||
{0x1d4c97c, 0xbd402be0, MODE_LOCKON, 0, ROLE_BASE_KEEP, 0, 0}, // ldr s0, [sp, #0x28] (the yaw turn)
|
||||
{0x1d4c98c, 0xbd402be9, MODE_LOCKON, 0, ROLE_BASE, 0, 0}, // ldr s9, [sp, #0x28]
|
||||
{0x1d4cd5c, 0xbd442721, MODE_LOCKON, 1, ROLE_STICK, 25, 0}, // ldr s1, [x25, #0x424]
|
||||
{0x1d4cd80, 0xbd402be0, MODE_LOCKON, 1, ROLE_BASE_KEEP, 0, 0}, // ldr s0, [sp, #0x28] (the pitch turn)
|
||||
{0x1d4cd90, 0xbd402beb, MODE_LOCKON, 1, ROLE_BASE, 0, 0}, // ldr s11, [sp, #0x28]
|
||||
{0x1d443e8, 0xbd4426a9, MODE_LOCKON_AIM, 1, ROLE_STICK, 21, 0}, // ldr s9, [x21, #0x424]
|
||||
{0x1d44430, 0xbd419a61, MODE_LOCKON_AIM, 1, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x198] (pitch offset)
|
||||
{0x1d44444, 0xbd4422a9, MODE_LOCKON_AIM, 0, ROLE_STICK, 21, 0}, // ldr s9, [x21, #0x420]
|
||||
{0x1d44490, 0xbd419e61, MODE_LOCKON_AIM, 0, ROLE_BASE, 0, 0}, // ldr s1, [x19, #0x19c] (yaw offset)
|
||||
{0x1d418dc, 0xbd44234b, MODE_HORSE_LOCKON, 0, ROLE_WATCH, 26, 0}, // ldr s11, [x26, #0x420]
|
||||
// EventMultiTalk and EventTalkManual: pre-indexed angle loads, made plain loads by the patched mov before each
|
||||
{0x1d3a3f8, 0xbd44270b, MODE_TALK, 1, ROLE_STICK, 24, 0}, // ldr s11, [x24, #0x424]
|
||||
{0x1d3a420, 0xbd4002e1, MODE_TALK, 1, ROLE_BASE, 0, 0}, // ldr s1, [x23] (pitch +0x5c)
|
||||
{0x1d3a484, 0xbd44230b, MODE_TALK, 0, ROLE_STICK, 24, EPSILON}, // ldr s11, [x24, #0x420] (also the test)
|
||||
{0x1d3a4e4, 0xbd4002c1, MODE_TALK, 0, ROLE_BASE, 0, 0}, // ldr s1, [x22] (yaw +0x64)
|
||||
{0x1d3e2b0, 0xbd442729, MODE_TALK_MANUAL, 1, ROLE_STICK, 25, 0}, // ldr s9, [x25, #0x424]
|
||||
{0x1d3e2d8, 0xbd400301, MODE_TALK_MANUAL, 1, ROLE_BASE, 0, 0}, // ldr s1, [x24] (pitch +0x74)
|
||||
{0x1d3e33c, 0xbd442329, MODE_TALK_MANUAL, 0, ROLE_STICK, 25, 0}, // ldr s9, [x25, #0x420]
|
||||
{0x1d3e364, 0xbd4002c1, MODE_TALK_MANUAL, 0, ROLE_BASE, 0, 0}, // ldr s1, [x22] (yaw +0x7c)
|
||||
};
|
||||
|
||||
static const MouseLayout layout_143 = {
|
||||
.input_x = 9, .activity_sp = 8, .orbit_pitch = 0x44, .orbit_yaw = 0x48, .orbit_reg = 12,
|
||||
.hand_x_sp = 0x60, .hand_store_reg = 8, .hand_store_sp = 0x48,
|
||||
.player_root_slot = 0x3969918, .main_size = 0x3adf000,
|
||||
.loads = load_sites_143, .load_count = sizeof load_sites_143 / sizeof load_sites_143[0]};
|
||||
static const MouseLayout layout_121 = {
|
||||
.input_x = 11, .activity_sp = 0x10, .orbit_pitch = 0x3c, .orbit_yaw = 0x40, .orbit_reg = 13,
|
||||
.hand_x_reg = 9, .hand_store_reg = 9, .hand_store_sp = 0x18,
|
||||
.player_root_slot = 0, .main_size = 0x472b000,
|
||||
.loads = load_sites_121, .load_count = sizeof load_sites_121 / sizeof load_sites_121[0]};
|
||||
// Only 1.4.3 and 1.2.1 have the mouse_direct set (1.1.0's table has none, so direct_mode() is off and no hook runs)
|
||||
static const MouseLayout *mouse_layout(void) { return RT_V143 ? &layout_143 : &layout_121; }
|
||||
|
||||
// The original single-register 32-bit loads: LDR S / W (unsigned offset), LDUR S and LDUR W (a float's bits in a
|
||||
// general register), and for ROLE_BASE_STORE the store STR S (unsigned offset). Never a load with write-back: the hook
|
||||
// is a call, and the lifted caller keeps X19-X29 in locals that a call does not reload (recomp/regs.py), so a base
|
||||
// register written here would be lost. Their address:
|
||||
static uint64_t load_address(const Cpu *c, uint32_t insn) {
|
||||
unsigned n = (insn >> 5) & 31;
|
||||
uint64_t base = n == 31 ? c->sp : c->x[n];
|
||||
if ((insn & 0xfb800000u) == 0xb9000000u) return base + (((insn >> 10) & 0xfff) << 2); // LDR / STR, S or W
|
||||
int32_t imm9 = (int32_t)((insn >> 12) & 0x1ff);
|
||||
if (imm9 & 0x100) imm9 -= 0x200;
|
||||
return base + (int64_t)imm9;
|
||||
}
|
||||
static int load_to_general(uint32_t insn) {
|
||||
return (insn & 0xffe00c00u) == 0xb8400000u || (insn & 0xffc00000u) == 0xb9400000u; // LDUR W, LDR W
|
||||
}
|
||||
|
||||
// Degrees a stick load left for its base load, on this thread: per mode and axis, for one camera object
|
||||
static _Thread_local struct { uint64_t object, generation; float degrees; } load_pending[MODE_COUNT * 2];
|
||||
// A KEEP_STICK load's gamepad part and total, for its ROLE_SHARE load
|
||||
static _Thread_local struct { uint64_t object; float pad, total; } load_share[MODE_COUNT * 2];
|
||||
// The sample each camera object and axis took its degrees from: a sample turns a camera once
|
||||
static struct { uint64_t object, generation[2]; } load_taken[16];
|
||||
static int load_take_once(uint64_t object, int axis, uint64_t generation) {
|
||||
plat_mutex_lock(&sample_lock);
|
||||
int slot = 0;
|
||||
for (int i = 0; i < 16; i++) {
|
||||
if (load_taken[i].object == object) { slot = i; goto found; }
|
||||
if (load_taken[i].generation[0] + load_taken[i].generation[1] <
|
||||
load_taken[slot].generation[0] + load_taken[slot].generation[1]) slot = i;
|
||||
}
|
||||
load_taken[slot].object = object;
|
||||
load_taken[slot].generation[0] = load_taken[slot].generation[1] = 0;
|
||||
found:;
|
||||
int fresh = load_taken[slot].generation[axis] != generation;
|
||||
load_taken[slot].generation[axis] = generation;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
return fresh;
|
||||
}
|
||||
|
||||
// The ability camera's offset scale P (degrees of turn per unit of offset, x and y), as its last step read it
|
||||
static struct { uint64_t object; float scale[2]; } offset_scale;
|
||||
|
||||
// Recall's view: SpecialPower's Fovy (50 degrees, vertical; PlayerCameraAIParam SpecialPower) times the field-of-view
|
||||
// factor and the camera's aspect ratio when those patch sets are on (resolution.c: page +60, +56), else 16:9. The tangent
|
||||
// of the half view angle along an axis (0 across, 1 up).
|
||||
#define RECALL_FOVY 50.0f
|
||||
#define RECALL_PI 3.14159265f
|
||||
static float recall_tan_half(int axis) {
|
||||
static int fov_set = -2, aspect_set = -2;
|
||||
if (fov_set == -2) fov_set = rt_patch_set("fov"), aspect_set = rt_patch_set("aspect");
|
||||
float fovy = RECALL_FOVY, aspect = 16.0f / 9.0f, v;
|
||||
const uint8_t *page = rt_patch_page();
|
||||
if (page && fov_set >= 0 && rt_patch_enabled(fov_set)) {
|
||||
memcpy(&v, page + 60, sizeof v);
|
||||
if (v > 0.5f && v < 2) fovy *= v;
|
||||
}
|
||||
if (page && aspect_set >= 0 && rt_patch_enabled(aspect_set)) {
|
||||
memcpy(&v, page + 56, sizeof v);
|
||||
if (v > 0.5f && v < 5) aspect = v;
|
||||
}
|
||||
float t = tanf(fovy * 0.5f * RECALL_PI / 180);
|
||||
return axis ? t : t * aspect;
|
||||
}
|
||||
|
||||
// The change of Recall's cursor offset o that moves its aim by `degrees`. The aim is the camera's follow, o * range
|
||||
// degrees, plus the cursor's angle from the centre, atan(o * t); it grows with o, so Newton's method converges from o.
|
||||
static float recall_offset(float o, float range, float t, float degrees) {
|
||||
const float k = 180 / RECALL_PI;
|
||||
float target = o * range + atanf(o * t) * k + degrees, n = o;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
float d = range + k * t / (1 + n * n * t * t);
|
||||
n -= (n * range + atanf(n * t) * k - target) / d;
|
||||
}
|
||||
return isfinite(n) ? n - o : 0;
|
||||
}
|
||||
|
||||
// The stick load: the gamepad's part of the axis, and the degrees for the base load. f is what the game stored.
|
||||
static float load_stick(const LoadSite *s, Cpu *c, float f) {
|
||||
uint64_t object = c->x[19], input = c->x[s->input_reg];
|
||||
int pair = PAIR(s->mode, s->axis);
|
||||
if (!(s->flags & REPEAT)) load_pending[pair].object = 0;
|
||||
MouseSample m = sample_read();
|
||||
if (m.object != input || !m.camera_enabled || plat_now_ns() - m.when >= 150000000ull) return f;
|
||||
// A step without the mouse in it keeps the game's value as it is: the gamepad's stick and anything else the game
|
||||
// put there after the input update (the sample's pad is only the stick the update stored)
|
||||
if (!m.angle[0] && !m.angle[1] && !m.swing) return f;
|
||||
float scale = 1;
|
||||
if (s->flags & (SKIP_OFFSET | ONLY_OFFSET)) {
|
||||
uint32_t state;
|
||||
memcpy(&state, (void *)(uintptr_t)(input + 0x15c), sizeof state);
|
||||
int offset = (state & 0x100) != 0;
|
||||
if ((s->flags & SKIP_OFFSET) && offset) return f;
|
||||
if (s->flags & ONLY_OFFSET) {
|
||||
if (!offset) return f;
|
||||
plat_mutex_lock(&sample_lock);
|
||||
scale = offset_scale.object == object ? offset_scale.scale[s->axis] : 0;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
if (!isfinite(scale) || fabsf(scale) < 1e-4f) { // not read yet: the stick, as the game turns it
|
||||
static int logged;
|
||||
if (!logged) logged = 1, rt_log("mouse: ability offset mode before its scale was read, stick input");
|
||||
return f;
|
||||
}
|
||||
}
|
||||
}
|
||||
float mouse = f - m.pad[s->axis], degrees = m.angle[s->axis];
|
||||
float out = m.pad[s->axis];
|
||||
if (s->flags & KEEP_STICK) {
|
||||
out = f;
|
||||
load_share[pair].object = object, load_share[pair].pad = m.pad[s->axis], load_share[pair].total = f;
|
||||
} else if ((s->flags & EPSILON) && out == 0 && mouse != 0) {
|
||||
out = copysignf(1e-12f, mouse);
|
||||
}
|
||||
if (s->flags & REPEAT) return out;
|
||||
if (!degrees || !load_take_once(object, s->axis, m.generation)) degrees = 0;
|
||||
// The offset turns the camera by -offset * P: an aim that turns as the sample's angle is -degrees of o's growth
|
||||
if (s->flags & ONLY_OFFSET && degrees)
|
||||
degrees = recall_offset(guest_float(object + (s->axis ? 0x1dc : 0x1d8)), scale, recall_tan_half(s->axis),
|
||||
-degrees);
|
||||
if ((s->flags & LIMIT_160) && degrees) {
|
||||
float pitch = guest_float(object + 0x160), lo = guest_float(object + 0x1ac), hi = guest_float(object + 0x1b0);
|
||||
if (isfinite(pitch) && isfinite(lo) && isfinite(hi)) {
|
||||
if (lo > hi) { float t = lo; lo = hi; hi = t; }
|
||||
float want = pitch + degrees, kept = fminf(hi, fmaxf(lo, want));
|
||||
if (kept != want) { // past the limit: that share of the mouse's stick moves the camera's other parameter
|
||||
out += mouse * ((want - kept) / degrees);
|
||||
degrees = kept - pitch;
|
||||
}
|
||||
}
|
||||
}
|
||||
load_pending[pair].object = object;
|
||||
load_pending[pair].generation = m.generation;
|
||||
load_pending[pair].degrees = degrees;
|
||||
return out;
|
||||
}
|
||||
|
||||
// The base load: the angle plus the degrees its stick load left (ROLE_BASE_KEEP leaves them for the next base load)
|
||||
static float load_base(const LoadSite *s, Cpu *c, float f) {
|
||||
uint64_t object = c->x[19];
|
||||
int pair = PAIR(s->mode, s->axis);
|
||||
if (load_pending[pair].object != object) return f;
|
||||
if (s->role != ROLE_BASE_KEEP) load_pending[pair].object = 0;
|
||||
float degrees = load_pending[pair].degrees;
|
||||
if (degrees) {
|
||||
sample_mark_taken(load_pending[pair].generation);
|
||||
static int logged[MODE_COUNT];
|
||||
if (!logged[s->mode]) {
|
||||
logged[s->mode] = 1;
|
||||
rt_log("mouse: %s camera angles directly, %.4f degrees per count at sensitivity 1",
|
||||
mode_names[s->mode], DEG_PER_COUNT);
|
||||
}
|
||||
}
|
||||
return degrees ? f + degrees : f; // f + 0 would turn a -0 the game loads into +0
|
||||
}
|
||||
|
||||
// A turn the game made from a KEEP_STICK load's total t, as K * -t|t| (shield surfing, wakeboard: their pitch squares
|
||||
// the stick), cut to the gamepad's p: K * -p|p|, the mouse's part being degrees at the base load
|
||||
static float load_share_cut(const LoadSite *s, Cpu *c, float f) {
|
||||
int pair = PAIR(s->mode, s->axis);
|
||||
if (load_share[pair].object != c->x[19]) return f;
|
||||
load_share[pair].object = 0;
|
||||
float p = load_share[pair].pad, t = load_share[pair].total;
|
||||
return t != 0 && isfinite(f) ? f * (p * fabsf(p)) / (t * fabsf(t)) : f;
|
||||
}
|
||||
|
||||
// A host call in place of one float load (MouseLayout.loads): performs the load, then gives the register the value
|
||||
static void camera_load(Cpu *c) {
|
||||
uint64_t offset = c->x[30] - 4 - MOD_MAIN_BASE;
|
||||
const MouseLayout *ml = mouse_layout();
|
||||
const LoadSite *s = NULL;
|
||||
for (size_t i = 0; i < ml->load_count; i++)
|
||||
if (ml->loads[i].offset == offset) { s = &ml->loads[i]; break; }
|
||||
if (!s) {
|
||||
rt_log("mouse: load hook called from main+%#llx, no such site", (unsigned long long)offset);
|
||||
abort();
|
||||
}
|
||||
uint64_t at = load_address(c, s->insn);
|
||||
if (s->role == ROLE_BASE_STORE) { // performs the store, of the value plus the degrees when there are any
|
||||
uint32_t bits = (uint32_t)c->v[s->insn & 31];
|
||||
float f, g;
|
||||
memcpy(&f, &bits, sizeof f);
|
||||
if (direct_mode() && (g = load_base(s, c, f)) != f) {
|
||||
f = wrap_degrees(g);
|
||||
memcpy(&bits, &f, sizeof bits);
|
||||
c->v[s->insn & 31] = bits; // the code after the store goes on with the value in the register
|
||||
}
|
||||
memcpy((void *)(uintptr_t)at, &bits, sizeof bits);
|
||||
return;
|
||||
}
|
||||
float f = guest_float(at);
|
||||
if (s->role == ROLE_SCALE) { // the ability camera's offset scale: P.y is this load, P.x the float before it
|
||||
plat_mutex_lock(&sample_lock);
|
||||
offset_scale.object = c->x[19];
|
||||
offset_scale.scale[0] = guest_float(at - 4);
|
||||
offset_scale.scale[1] = f;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
} else if (s->role == ROLE_WATCH) { // the value stays the game's; a load with the mouse in it names its mode
|
||||
if (direct_mode()) {
|
||||
plat_mutex_lock(&sample_lock);
|
||||
if (sample.object == c->x[(s->insn >> 5) & 31] && sample.camera_enabled &&
|
||||
(sample.angle[0] || sample.angle[1]))
|
||||
sample_watched = sample.generation, sample_watched_mode = s->mode;
|
||||
plat_mutex_unlock(&sample_lock);
|
||||
}
|
||||
} else if (direct_mode()) {
|
||||
f = s->role == ROLE_STICK ? load_stick(s, c, f) : s->role == ROLE_SHARE ? load_share_cut(s, c, f)
|
||||
: load_base(s, c, f);
|
||||
}
|
||||
uint32_t bits;
|
||||
memcpy(&bits, &f, sizeof bits);
|
||||
if (load_to_general(s->insn)) c->x[s->insn & 31] = bits; // a W load clears the upper half
|
||||
else c->v[s->insn & 31] = bits; // a 32-bit load clears the rest of the vector register
|
||||
}
|
||||
|
||||
// The game also uses a 10% activity threshold after processing the stick. A one-count mouse movement must count
|
||||
// as active, even when its displacement is smaller than that threshold. The site is the displaced ldp d9, d8, [sp, #8]
|
||||
// just before the update's last `str w8, [x20, #0x418]`: w8 holds the flags then (bit 0 raw input, bit 4 any input,
|
||||
// bits 3 and 5 processed input below the threshold), so they are changed in w8; a write to +0x418 would be overwritten
|
||||
// by that store. No flag is changed for controller-only input.
|
||||
// (1.2.1 [sp, #0x10]) just before the update's last `str w8, [x20, #0x418]`: w8 holds the flags then (bit 0 raw
|
||||
// input, bit 4 any input, bits 3 and 5 processed input below the threshold), so they are changed in w8; a write to
|
||||
// +0x418 would be overwritten by that store. No flag is changed for controller-only input.
|
||||
static void camera_activity(Cpu *c) {
|
||||
if (mouse_input_object && mouse_input_object == c->x[20]) {
|
||||
uint32_t flags = (uint32_t)c->x[8];
|
||||
@@ -324,8 +1052,8 @@ static void camera_activity(Cpu *c) {
|
||||
mouse_input_object = 0;
|
||||
}
|
||||
uint64_t d9, d8;
|
||||
memcpy(&d9, (const void *)(uintptr_t)(c->sp + 8), sizeof d9);
|
||||
memcpy(&d8, (const void *)(uintptr_t)(c->sp + 16), sizeof d8);
|
||||
memcpy(&d9, (const void *)(uintptr_t)(c->sp + mouse_layout()->activity_sp), sizeof d9);
|
||||
memcpy(&d8, (const void *)(uintptr_t)(c->sp + mouse_layout()->activity_sp + 8), sizeof d8);
|
||||
c->v[9] = d9;
|
||||
c->v[8] = d8;
|
||||
}
|
||||
@@ -336,5 +1064,6 @@ __attribute__((constructor)) static void mouse_direct_register(void) {
|
||||
rt_register_host(HOST_MOUSE_ORBIT_BEGIN, orbit_begin);
|
||||
rt_register_host(HOST_MOUSE_ORBIT_ANGLES, orbit_angles);
|
||||
rt_register_host(HOST_MOUSE_HAND, hand_input);
|
||||
rt_register_host(HOST_MOUSE_LOAD, camera_load);
|
||||
}
|
||||
#endif
|
||||
+9
-1
@@ -29,10 +29,18 @@ typedef struct {
|
||||
enum { MOVIE_EV_INPUT, MOVIE_EV_OUTPUT, MOVIE_EV_FORMAT, MOVIE_EV_ERROR }; // DecoderEvents: EventType * per event
|
||||
enum { MOVIE_TYPE_VP9 = 3, MOVIE_MODE_BUFFER = 1, MOVIE_FORMAT_NV12 = 4, MOVIE_FLAG_EOS = 4 };
|
||||
|
||||
typedef struct { uint64_t frames, decode_ns, max_ns, errors, dropped, handed; } MovieStats;
|
||||
typedef struct { uint64_t frames, decode_ns, max_ns, errors, dropped, handed, fit_ns; } MovieStats;
|
||||
// fit_ns: the part of decode_ns spent writing the NV12 frame
|
||||
|
||||
void movie_set_guest(const MovieGuest *g); // probe: stand-ins instead of the modules
|
||||
void movie_set_clock(uint64_t (*clock)(void)); // probe: a fake clock (ns) for the pacing; NULL = real
|
||||
void movie_set_pace(int on); // probe: 0 hands every decoded frame over at the next tick
|
||||
int movie_stats(uint64_t obj, MovieStats *out); // counters of the decoder at guest object obj; 0 if none
|
||||
int movie_quiet(uint64_t obj); // 1 when its worker is idle and cannot take more input now
|
||||
|
||||
// Keeping a movie's shape on an output of another shape (ov_movie.c): the picture is shrunk inside the frame, with
|
||||
// black (Y 16, U = V 128) around it. movie_fit_new returns NULL when the shapes agree within 1%: copy the frame.
|
||||
typedef struct MovieFit MovieFit;
|
||||
MovieFit *movie_fit_new(int w, int h, unsigned out_w, unsigned out_h);
|
||||
void movie_fit_apply(const MovieFit *f, const uint8_t *const plane[3], const int stride[3], uint8_t *dst);
|
||||
void movie_fit_free(MovieFit *f);
|
||||
@@ -9,6 +9,7 @@
|
||||
// Without the RomFS (no game data) it prints why and exits 0. TOTK_PROBE_MOVIE_SHOT=<file.ppm> saves the middle frame.
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -267,7 +268,104 @@ static int paced(uint64_t obj, const uint8_t *data, const Track *t, int limit, u
|
||||
return 0;
|
||||
}
|
||||
|
||||
// The shape-keeping resampler (ov_movie.c movie_fit_new / movie_fit_apply) on a synthetic 1920x1080 I420 picture, which
|
||||
// needs no game data. The planes are gradients, which a box filter keeps linear, so every output sample has an expected
|
||||
// value: luma rises left to right and top to bottom, U rises left to right, V falls top to bottom. A 16:9 output must give
|
||||
// no plan; the others must give bars (Y 16, U = V 128) that are symmetric, a picture of the movie's shape once the game
|
||||
// stretches the frame, and samples of the picture where the gradients say. TOTK_PROBE_MOVIE_BENCH=1 also times the frame.
|
||||
#define FIT_CHECK(cond, ...) \
|
||||
do { \
|
||||
if (!(cond)) { \
|
||||
printf("probe-movie: FAILED: "); \
|
||||
printf(__VA_ARGS__); \
|
||||
printf("\n"); \
|
||||
rc = 1; \
|
||||
goto done; \
|
||||
} \
|
||||
} while (0)
|
||||
static int check_fit(void) {
|
||||
enum { W = 1920, H = 1080, CW = W / 2, CH = H / 2 };
|
||||
int rc = 0;
|
||||
MovieFit *f = NULL;
|
||||
uint8_t *y = malloc((size_t)W * H), *u = malloc((size_t)CW * CH), *v = malloc((size_t)CW * CH);
|
||||
uint8_t *out = malloc((size_t)W * H * 3 / 2);
|
||||
FIT_CHECK(y && u && v && out, "fit test buffers");
|
||||
for (int j = 0; j < H; j++)
|
||||
for (int i = 0; i < W; i++) y[j * W + i] = (uint8_t)(32 + 150.0 * (i + 0.5) / W + 60.0 * (j + 0.5) / H + 0.5);
|
||||
for (int j = 0; j < CH; j++)
|
||||
for (int i = 0; i < CW; i++) {
|
||||
u[j * CW + i] = (uint8_t)(40 + 150.0 * (i + 0.5) / CW + 0.5);
|
||||
v[j * CW + i] = (uint8_t)(220 - 150.0 * (j + 0.5) / CH + 0.5);
|
||||
}
|
||||
const uint8_t *plane[3] = {y, u, v};
|
||||
const int stride[3] = {W, CW, CW};
|
||||
FIT_CHECK(!movie_fit_new(W, H, 1920, 1080) && !movie_fit_new(W, H, 2560, 1440), "16:9 outputs need no plan");
|
||||
static const unsigned outs[][2] = {{5120, 1440}, {3440, 1440}, {1280, 800}, {1920, 1200}};
|
||||
for (int k = 0; k < 4; k++) {
|
||||
unsigned ow = outs[k][0], oh = outs[k][1];
|
||||
f = movie_fit_new(W, H, ow, oh);
|
||||
FIT_CHECK(f, "%ux%u: no plan", ow, oh);
|
||||
memset(out, 0xAA, (size_t)W * H * 3 / 2); // a byte nothing else produces: every pixel must be written
|
||||
movie_fit_apply(f, plane, stride, out);
|
||||
const uint8_t *uv = out + (size_t)W * H;
|
||||
int l = 0, r = W - 1, t = 0, b = H - 1; // the picture's extent: where luma leaves 16, on the middle row and column
|
||||
while (l < W && out[(H / 2) * W + l] == 16) l++;
|
||||
while (r >= 0 && out[(H / 2) * W + r] == 16) r--;
|
||||
while (t < H && out[t * W + W / 2] == 16) t++;
|
||||
while (b >= 0 && out[b * W + W / 2] == 16) b--;
|
||||
int pw = r - l + 1, ph = b - t + 1;
|
||||
FIT_CHECK(pw > 2 && ph > 2, "%ux%u: no picture found", ow, oh);
|
||||
FIT_CHECK(abs(l - (W - 1 - r)) <= 2 && abs(t - (H - 1 - b)) <= 2,
|
||||
"%ux%u: bars not symmetric: left %d right %d, top %d bottom %d", ow, oh, l, W - 1 - r, t, H - 1 - b);
|
||||
// On screen the picture covers pw/W of the width and ph/H of the height of an ow x oh canvas; 1 = the movie's shape.
|
||||
double shape = ((double)pw / W * ow) / ((double)ph / H * oh) / ((double)W / H);
|
||||
FIT_CHECK(fabs(shape - 1) < 0.01, "%ux%u: picture %dx%d shows at %.3f of the movie's shape", ow, oh, pw, ph, shape);
|
||||
FIT_CHECK(l == 0 || ph == H, "%ux%u: sideways bars with a squeezed height", ow, oh);
|
||||
for (int j = 0; j < H; j++) // everything outside the picture is black in luma and chroma, left and right alike
|
||||
for (int i = 0; i < W; i++)
|
||||
if (j < t || j > b || i < l || i > r)
|
||||
FIT_CHECK(out[j * W + i] == 16, "%ux%u: luma (%d,%d) is %d, not black", ow, oh, i, j, out[j * W + i]);
|
||||
for (int j = 0; j < CH; j++)
|
||||
for (int i = 0; i < CW; i++) {
|
||||
int outside = 2 * j + 1 < t || 2 * j > b || 2 * i + 1 < l || 2 * i > r;
|
||||
const uint8_t *c = uv + (size_t)j * W + 2 * i;
|
||||
if (outside) FIT_CHECK(c[0] == 128 && c[1] == 128, "%ux%u: chroma (%d,%d) is %d/%d, not black", ow, oh, i, j,
|
||||
c[0], c[1]);
|
||||
}
|
||||
static const double fr[] = {0.1, 0.35, 0.5, 0.8, 0.95}; // samples of the picture, as fractions of it
|
||||
for (int a = 0; a < 5; a++)
|
||||
for (int c = 0; c < 5; c++) {
|
||||
int px = (int)(pw * fr[a]), py = (int)(ph * fr[c]); // picture pixel
|
||||
double sx = (px + 0.5) * W / pw, sy = (py + 0.5) * H / ph; // where it comes from in the source
|
||||
double ey = 32 + 150.0 * sx / W + 60.0 * sy / H;
|
||||
int got = out[(t + py) * W + l + px];
|
||||
FIT_CHECK(fabs(got - ey) <= 2, "%ux%u: luma at picture (%d,%d) is %d, want %.1f", ow, oh, px, py, got, ey);
|
||||
int cx = px / 2, cy = py / 2, cpw = pw / 2, cph = ph / 2;
|
||||
double sux = (cx + 0.5) * CW / cpw, svy = (cy + 0.5) * CH / cph;
|
||||
const uint8_t *q = uv + (size_t)(t / 2 + cy) * W + 2 * (l / 2 + cx);
|
||||
double eu = 40 + 150.0 * sux / CW, ev = 220 - 150.0 * svy / CH;
|
||||
FIT_CHECK(fabs(q[0] - eu) <= 3 && fabs(q[1] - ev) <= 3,
|
||||
"%ux%u: chroma at picture (%d,%d) is U %d V %d, want U %.1f V %.1f", ow, oh, cx, cy, q[0], q[1], eu,
|
||||
ev);
|
||||
}
|
||||
if (cfg_get("TOTK_PROBE_MOVIE_BENCH")) {
|
||||
uint64_t t0 = plat_now_ns();
|
||||
for (int i = 0; i < 100; i++) movie_fit_apply(f, plane, stride, out);
|
||||
printf("probe-movie: fit %ux%u: %.2f ms per frame\n", ow, oh, (plat_now_ns() - t0) / 1e8);
|
||||
}
|
||||
printf("probe-movie: fit %ux%u: picture %dx%d at (%d,%d) of the frame, bars Y 16 / UV 128, gradients as expected\n",
|
||||
ow, oh, pw, ph, l, t);
|
||||
movie_fit_free(f);
|
||||
f = NULL;
|
||||
}
|
||||
done:
|
||||
movie_fit_free(f);
|
||||
free(y), free(u), free(v), free(out);
|
||||
return rc;
|
||||
}
|
||||
|
||||
int probe_movie(void) {
|
||||
if (check_fit()) return 1;
|
||||
const char *dir = rt_config()->romfs;
|
||||
char image[PLAT_PATH_MAX];
|
||||
snprintf(image, sizeof image, "%s/romfs.bin", dir);
|
||||
|
||||
+11
-5
@@ -11,6 +11,7 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "cfg.h"
|
||||
#include "gfx.h"
|
||||
#include "host.h"
|
||||
#include "nvn_api.h"
|
||||
@@ -667,8 +668,12 @@ static void sleep_until(uint64_t deadline) {
|
||||
}
|
||||
|
||||
// NVNwindowAcquireTextureResult nvnWindowAcquireTexture(NVNwindow *w, NVNsync *s, int *index): blocks here, not in the
|
||||
// present, until the image's previous present plus one period has passed (the game often presents with a lock held).
|
||||
// That is the time the next frame goes to the display, so the image is free as soon as that time is reached.
|
||||
// present, until the image is free (the game often presents with a lock held). Without the frame queue that is the
|
||||
// image's previous present plus one period, when the next frame goes to the display, so a frame gets exactly one period
|
||||
// from acquire to present. Its present is a copy already on the queue by its display time, so with the frame queue
|
||||
// (TOTK_FRAME_QUEUE=1) the image is free from that time on: the game draws the next frame while the previous one waits
|
||||
// for its turn, and a frame that takes up to one more period still makes its slot, for up to one frame more latency.
|
||||
// Town at 4K with DLAA at 60 on an RTX 5070: frames over 17.5 ms 1-8 per 30 s with the queue against 25-33 without.
|
||||
NVN_API(nvnWindowAcquireTexture) {
|
||||
win_t *o = arg_p(c, 0);
|
||||
sync_t *s = arg_p(c, 1);
|
||||
@@ -693,8 +698,9 @@ NVN_API(nvnWindowAcquireTexture) {
|
||||
|
||||
// void nvnQueuePresentTexture(NVNqueue *q, NVNwindow *w, int index): queues the copy and returns at once. The display
|
||||
// time comes from the pacer: the back end's present thread holds the host present until then (back-edge pacing, as the
|
||||
// Switch's display flips at vblank), so the present cadence does not follow the replay time; one period later the
|
||||
// image is free for the next acquire. Added latency: the slack of the frame (period minus its work), as on the Switch.
|
||||
// Switch's display flips at vblank), so the present cadence does not follow the replay time; one period later (at that
|
||||
// time with the frame queue) the image is free for the next acquire. Added latency: the slack of the frame (period minus
|
||||
// its work), as on the Switch, plus up to a period with the frame queue.
|
||||
NVN_API(nvnQueuePresentTexture) {
|
||||
win_t *o = arg_p(c, 1);
|
||||
int idx = (int)arg_x(c, 2);
|
||||
@@ -709,7 +715,7 @@ NVN_API(nvnQueuePresentTexture) {
|
||||
uint64_t slot = now + pace(&o->pace, now, period);
|
||||
gfx_backend()->present(t, o->crop, slot);
|
||||
o->ticket[idx] = o->presents;
|
||||
o->avail[idx] = slot + period;
|
||||
o->avail[idx] = cfg_bool("TOTK_FRAME_QUEUE") ? slot : slot + period;
|
||||
frame_step_present(slot, o->interval); // frame_rate.c: the real-time step follows the display times
|
||||
rt_frame_presented(t, o->presents);
|
||||
}
|
||||
+196
-4
@@ -73,6 +73,7 @@ typedef struct {
|
||||
unsigned owed; // events to signal on the next guest thread (bit per MOVIE_EV_*)
|
||||
uint64_t t0; // host time of the first frame handed over (pacing)
|
||||
int64_t pts0; // its presentation time (us)
|
||||
MovieFit *fit; // picture shrunk inside the frame; NULL = the shapes agree, copy
|
||||
MovieStats st;
|
||||
PlatMutex mu;
|
||||
PlatCond work, idle;
|
||||
@@ -207,6 +208,173 @@ static void to_nv12(const vpx_image_t *img, uint8_t *dst, int w, int h) {
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Keeping the movie's shape. The game draws a decoded frame over the whole canvas, so on an output that is not 16:9
|
||||
// (output_res in totk.ini) the 1920x1080 movies would be stretched. The frame keeps its size; the picture is shrunk
|
||||
// inside it and the rest is black, so that after the game's stretch the picture has the movie's own shape again: a wider
|
||||
// output gets a squeezed picture with black at the left and right, a taller one (16:10) black above and below.
|
||||
// The shrink is a box filter (each output pixel averages the source pixels it covers, weights in 1/4096), separable, with
|
||||
// the per-column and per-row source spans and weights built once per movie (movie_fit_new), so the frame loop only
|
||||
// multiplies and adds.
|
||||
enum { FIT_ONE = 4096, FIT_Y_BLACK = 16, FIT_UV_BLACK = 128 }; // black of limited-range video: Y 16, U = V 128
|
||||
typedef struct { int n, taps; int *start; uint16_t *wt; } FitAxis; // output i: taps weights from source start[i]
|
||||
struct MovieFit {
|
||||
int w, h, x0, y0, pw, ph; // frame, and the picture's corner and size in it (all even)
|
||||
FitAxis lx, ly, cx, cy; // luma, chroma; columns, rows; n = 0 where the axis is kept
|
||||
uint8_t *tmp; // horizontally shrunk rows, before the vertical pass
|
||||
uint32_t *acc; // one row of the vertical sum
|
||||
};
|
||||
|
||||
// Box filter from src_n to dst_n (dst_n < src_n): output i covers [i, i + 1) * src_n / dst_n of the source.
|
||||
static int axis_build(FitAxis *a, int src_n, int dst_n) {
|
||||
double s = (double)src_n / dst_n;
|
||||
a->n = dst_n;
|
||||
a->taps = (int)s + 2 > src_n ? src_n : (int)s + 2;
|
||||
a->start = malloc((size_t)dst_n * sizeof *a->start);
|
||||
a->wt = malloc((size_t)dst_n * (size_t)a->taps * sizeof *a->wt);
|
||||
if (!a->start || !a->wt) return 0;
|
||||
for (int i = 0; i < dst_n; i++) {
|
||||
double lo = i * s, hi = (i + 1) * s;
|
||||
int st = (int)lo;
|
||||
if (st > src_n - a->taps) st = src_n - a->taps;
|
||||
a->start[i] = st;
|
||||
int sum = 0, big = 0;
|
||||
uint16_t *w = a->wt + (size_t)i * a->taps;
|
||||
for (int t = 0; t < a->taps; t++) {
|
||||
double ov = (st + t + 1 < hi ? st + t + 1 : hi) - (st + t > lo ? st + t : lo);
|
||||
w[t] = ov > 0 ? (uint16_t)(ov / s * FIT_ONE + 0.5) : 0;
|
||||
sum += w[t];
|
||||
if (w[t] > w[big]) big = t;
|
||||
}
|
||||
w[big] = (uint16_t)(w[big] + FIT_ONE - sum); // the weights add up to exactly 1
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
static void axis_free(FitAxis *a) {
|
||||
free(a->start);
|
||||
free(a->wt);
|
||||
}
|
||||
|
||||
void movie_fit_free(MovieFit *f) {
|
||||
if (!f) return;
|
||||
axis_free(&f->lx), axis_free(&f->ly), axis_free(&f->cx), axis_free(&f->cy);
|
||||
free(f->tmp);
|
||||
free(f->acc);
|
||||
free(f);
|
||||
}
|
||||
|
||||
// The plan for a w x h movie shown on an ow x oh output; NULL when the shapes agree within 1% (the frame is copied).
|
||||
MovieFit *movie_fit_new(int w, int h, unsigned ow, unsigned oh) {
|
||||
if (w < 16 || h < 16 || (w | h) & 1 || !ow || !oh) return NULL;
|
||||
double movie = (double)w / h, out = (double)ow / oh, r = out / movie;
|
||||
if (r > 0.99 && r < 1.01) return NULL;
|
||||
MovieFit *f = calloc(1, sizeof *f);
|
||||
if (!f) {
|
||||
rt_log("movie: out of memory for the picture-shape tables; this movie is stretched");
|
||||
return NULL;
|
||||
}
|
||||
f->w = w, f->h = h, f->pw = w, f->ph = h;
|
||||
if (r > 1) f->pw = (int)(w / r / 2 + 0.5) * 2; // wider output: squeeze sideways
|
||||
else f->ph = (int)(h * r / 2 + 0.5) * 2; // taller output: squeeze vertically
|
||||
if (f->pw < 2) f->pw = 2;
|
||||
if (f->ph < 2) f->ph = 2;
|
||||
f->x0 = (w - f->pw) / 2 & ~1;
|
||||
f->y0 = (h - f->ph) / 2 & ~1;
|
||||
int ok = 1;
|
||||
if (f->pw < w) ok = axis_build(&f->lx, w, f->pw) && axis_build(&f->cx, w / 2, f->pw / 2);
|
||||
if (f->ph < h) ok = ok && axis_build(&f->ly, h, f->ph) && axis_build(&f->cy, h / 2, f->ph / 2);
|
||||
f->tmp = malloc((size_t)f->pw * h);
|
||||
f->acc = malloc((size_t)f->pw * sizeof *f->acc);
|
||||
if (!ok || !f->tmp || !f->acc) {
|
||||
rt_log("movie: out of memory for the picture-shape tables; this movie is stretched");
|
||||
movie_fit_free(f);
|
||||
return NULL;
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
// One output row of the horizontal pass: dst gets the shrunk src row (dstep 2 writes every other byte, for U and V).
|
||||
// The tap count is a constant in the 3 and 4 tap copies (what 2x and below squeezes need), so the compiler unrolls the sum.
|
||||
static inline __attribute__((always_inline)) void fit_row_taps(const FitAxis *a, const uint8_t *src, uint8_t *dst,
|
||||
int dstep, int taps) {
|
||||
for (int i = 0; i < a->n; i++) {
|
||||
const uint8_t *p = src + a->start[i];
|
||||
const uint16_t *w = a->wt + (size_t)i * taps;
|
||||
uint32_t v = FIT_ONE / 2;
|
||||
for (int t = 0; t < taps; t++) v += w[t] * p[t];
|
||||
dst[(size_t)i * dstep] = (uint8_t)(v / FIT_ONE);
|
||||
}
|
||||
}
|
||||
static void fit_row_h(const FitAxis *a, const uint8_t *src, uint8_t *dst, int dstep) {
|
||||
if (a->taps == 3) fit_row_taps(a, src, dst, dstep, 3);
|
||||
else if (a->taps == 4) fit_row_taps(a, src, dst, dstep, 4);
|
||||
else fit_row_taps(a, src, dst, dstep, a->taps);
|
||||
}
|
||||
|
||||
// One plane (sw x sh) shrunk into the pw x ph picture whose corner (ox, oy) is in dst; ax/ay NULL = that axis is kept.
|
||||
static void fit_plane(const MovieFit *f, const uint8_t *src, int ss, int sw, int sh, uint8_t *dst, int ds, int dstep,
|
||||
int ox, int oy, const FitAxis *ax, const FitAxis *ay, int pw, int ph) {
|
||||
uint8_t *base = dst + (size_t)oy * ds + (size_t)ox * dstep;
|
||||
if (!ay) { // sideways only: straight into the frame
|
||||
for (int y = 0; y < sh; y++) {
|
||||
const uint8_t *row = src + (size_t)y * ss;
|
||||
uint8_t *o = base + (size_t)y * ds;
|
||||
if (ax) fit_row_h(ax, row, o, dstep);
|
||||
else if (dstep == 1) memcpy(o, row, (size_t)sw);
|
||||
else for (int x = 0; x < sw; x++) o[(size_t)x * dstep] = row[x];
|
||||
}
|
||||
return;
|
||||
}
|
||||
const uint8_t *in = src;
|
||||
int is = ss;
|
||||
if (ax) {
|
||||
for (int y = 0; y < sh; y++) fit_row_h(ax, src + (size_t)y * ss, f->tmp + (size_t)y * pw, 1);
|
||||
in = f->tmp, is = pw;
|
||||
}
|
||||
for (int y = 0; y < ph; y++) {
|
||||
const uint16_t *w = ay->wt + (size_t)y * ay->taps;
|
||||
const uint8_t *r0 = in + (size_t)ay->start[y] * is;
|
||||
uint8_t *o = base + (size_t)y * ds;
|
||||
if (ay->taps == 3) { // the common case, summed in registers
|
||||
const uint8_t *r1 = r0 + is, *r2 = r1 + is;
|
||||
for (int x = 0; x < pw; x++)
|
||||
o[(size_t)x * dstep] = (uint8_t)((FIT_ONE / 2 + w[0] * r0[x] + w[1] * r1[x] + w[2] * r2[x]) / FIT_ONE);
|
||||
continue;
|
||||
}
|
||||
memset(f->acc, 0, (size_t)pw * sizeof *f->acc);
|
||||
for (int t = 0; t < ay->taps; t++) {
|
||||
const uint8_t *row = r0 + (size_t)t * is;
|
||||
uint32_t k = w[t];
|
||||
for (int x = 0; x < pw; x++) f->acc[x] += k * row[x];
|
||||
}
|
||||
for (int x = 0; x < pw; x++) o[(size_t)x * dstep] = (uint8_t)((f->acc[x] + FIT_ONE / 2) / FIT_ONE);
|
||||
}
|
||||
}
|
||||
|
||||
// I420 planes -> packed NV12 with the picture shrunk inside black bars: w x h of Y, then w x h/2 of interleaved U, V.
|
||||
void movie_fit_apply(const MovieFit *f, const uint8_t *const plane[3], const int stride[3], uint8_t *dst) {
|
||||
int w = f->w, h = f->h, cw = w / 2, ch = h / 2;
|
||||
uint8_t *uv = dst + (size_t)w * h;
|
||||
// Black only where the picture does not go: whole rows above and below it, the strips left and right of it.
|
||||
int rx = f->x0 + f->pw, ry = f->y0 + f->ph;
|
||||
memset(dst, FIT_Y_BLACK, (size_t)f->y0 * w);
|
||||
memset(dst + (size_t)ry * w, FIT_Y_BLACK, (size_t)(h - ry) * w);
|
||||
memset(uv, FIT_UV_BLACK, (size_t)(f->y0 / 2) * w);
|
||||
memset(uv + (size_t)(ry / 2) * w, FIT_UV_BLACK, (size_t)(ch - ry / 2) * w);
|
||||
for (int y = f->y0; y < ry; y++) {
|
||||
memset(dst + (size_t)y * w, FIT_Y_BLACK, (size_t)f->x0);
|
||||
memset(dst + (size_t)y * w + rx, FIT_Y_BLACK, (size_t)(w - rx));
|
||||
}
|
||||
for (int y = f->y0 / 2; y < ry / 2; y++) {
|
||||
memset(uv + (size_t)y * w, FIT_UV_BLACK, (size_t)f->x0);
|
||||
memset(uv + (size_t)y * w + rx, FIT_UV_BLACK, (size_t)(w - rx));
|
||||
}
|
||||
fit_plane(f, plane[0], stride[0], w, h, dst, w, 1, f->x0, f->y0, f->lx.n ? &f->lx : NULL, f->ly.n ? &f->ly : NULL,
|
||||
f->pw, f->ph);
|
||||
for (int c = 0; c < 2; c++)
|
||||
fit_plane(f, plane[1 + c], stride[1 + c], cw, ch, uv + c, w, 2, f->x0 / 2, f->y0 / 2,
|
||||
f->cx.n ? &f->cx : NULL, f->cy.n ? &f->cy : NULL, f->pw / 2, f->ph / 2);
|
||||
}
|
||||
|
||||
static int free_out(const Movie *m) {
|
||||
for (int i = 0; i < OUT_BUFS; i++)
|
||||
if (!m->out_held[i]) return i;
|
||||
@@ -250,7 +418,9 @@ static void worker(void *arg) {
|
||||
slot = free_out(m);
|
||||
m->out_held[slot] = 1; // reserved: in no queue, so the game cannot release it
|
||||
}
|
||||
uint64_t gen = m->gen, dt = 0;
|
||||
uint64_t gen = m->gen, dt = 0, fit_ns = 0;
|
||||
// A plan made for another frame size (a start that found the worker busy) is not used: it would overrun dst.
|
||||
const MovieFit *fit = m->fit && m->fit->w == m->w && m->fit->h == m->h ? m->fit : NULL;
|
||||
int got = 0, w = m->w, h = m->h;
|
||||
uint8_t *dst = slot >= 0 ? m->out[slot] : NULL;
|
||||
vpx_codec_err_t e = VPX_CODEC_OK;
|
||||
@@ -265,7 +435,12 @@ static void worker(void *arg) {
|
||||
const vpx_image_t *img;
|
||||
while ((img = vpx_codec_get_frame(&m->vpx, &it)) != NULL) {
|
||||
if (img->fmt != VPX_IMG_FMT_I420 || (int)img->d_w != w || (int)img->d_h != h) bad = "layout";
|
||||
else if (!got) to_nv12(img, dst, w, h);
|
||||
else if (!got) {
|
||||
uint64_t t1 = kern_now_ns();
|
||||
if (fit) movie_fit_apply(fit, (const uint8_t *const *)img->planes, img->stride, dst);
|
||||
else to_nv12(img, dst, w, h);
|
||||
fit_ns = kern_now_ns() - t1;
|
||||
}
|
||||
got++;
|
||||
}
|
||||
}
|
||||
@@ -279,6 +454,7 @@ static void worker(void *arg) {
|
||||
m->owed |= 1u << MOVIE_EV_INPUT;
|
||||
if (p.size > 0) {
|
||||
m->st.decode_ns += dt;
|
||||
m->st.fit_ns += fit_ns;
|
||||
if (dt > m->st.max_ns) m->st.max_ns = dt;
|
||||
if (bad) rt_fatal("movie: VP9 frame layout differs from the configured %dx%d I420", w, h);
|
||||
if (e != VPX_CODEC_OK || !got) {
|
||||
@@ -302,8 +478,10 @@ static void worker(void *arg) {
|
||||
push_decoded(m, slot, 0, p.time, frame_bytes(m));
|
||||
m->st.frames++;
|
||||
if (m->st.frames % 600 == 0)
|
||||
rt_log("movie: %llu frames, decode %.2f ms per frame (max %.2f)", (unsigned long long)m->st.frames,
|
||||
m->st.decode_ns / 1e6 / (double)m->st.frames, m->st.max_ns / 1e6);
|
||||
rt_log("movie: %llu frames, decode %.2f ms per frame (max %.2f), of it %.2f ms %s",
|
||||
(unsigned long long)m->st.frames, m->st.decode_ns / 1e6 / (double)m->st.frames,
|
||||
m->st.max_ns / 1e6, m->st.fit_ns / 1e6 / (double)m->st.frames,
|
||||
m->fit ? "fitting the picture" : "converting");
|
||||
}
|
||||
}
|
||||
if (p.flags & MOVIE_FLAG_EOS && !m->eos_in) {
|
||||
@@ -355,6 +533,8 @@ static void release_codec(Movie *m) { // m->mu held, worker quiesced
|
||||
free(m->out[i]);
|
||||
m->out[i] = NULL;
|
||||
}
|
||||
movie_fit_free(m->fit);
|
||||
m->fit = NULL;
|
||||
m->configured = m->started = 0;
|
||||
reset_queues(m);
|
||||
}
|
||||
@@ -597,6 +777,18 @@ static void ov_start(Cpu *c) {
|
||||
plat_mutex_lock(&m->mu);
|
||||
int st = ST_NOT_CONFIGURED;
|
||||
if (m->configured) {
|
||||
if (!m->started && !m->busy) { // the worker is idle: it reads m->fit only when it takes an input
|
||||
movie_fit_free(m->fit);
|
||||
m->fit = NULL;
|
||||
unsigned out[2];
|
||||
res_wanted(out);
|
||||
if (strcmp(cfg_value("TOTK_MOVIE_ASPECT"), "stretch")) {
|
||||
m->fit = movie_fit_new(m->w, m->h, out[0], out[1]);
|
||||
if (m->fit)
|
||||
rt_log("movie: %dx%d picture kept in shape on the %ux%u output (%dx%d inside the frame)", m->w,
|
||||
m->h, out[0], out[1], m->fit->pw, m->fit->ph);
|
||||
}
|
||||
}
|
||||
m->started = 1;
|
||||
m->owed |= 1u << MOVIE_EV_INPUT;
|
||||
plat_cond_signal(&m->work);
|
||||
|
||||
@@ -270,7 +270,8 @@ int plat_intr_resume(PlatIntr *t, uint64_t to) {
|
||||
// ---- fibers: a stack switch of our own. glibc's swapcontext saves and restores the signal mask with a system call
|
||||
// on every switch, and the game switches fibers often. fiber_swap saves the callee-saved registers, the MXCSR and the
|
||||
// x87 control word on the current stack, stores the stack pointer in *save and loads the other one. A new fiber's
|
||||
// stack is laid out as fiber_swap leaves one, returning into fiber_entry, which calls fn(arg) (r12 and r13).
|
||||
// stack is laid out as fiber_swap leaves one, returning into fiber_entry, which realigns the stack and calls fn(arg)
|
||||
// (r12 and r13).
|
||||
struct PlatFiber {
|
||||
void *sp;
|
||||
void *stack; // mapped stack (NULL for a thread's own context)
|
||||
@@ -312,6 +313,11 @@ __asm__(".text\n"
|
||||
".type plat_fiber_entry, @function\n"
|
||||
".p2align 4\n"
|
||||
"plat_fiber_entry:\n"
|
||||
// fiber_swap's ret lands here with rsp = top - 8, as at the entry of a called function. The call below must
|
||||
// be made with rsp 16-byte aligned so that fn starts with rsp = 8 mod 16, as the System V ABI demands; without
|
||||
// the realignment every 16-byte local of fn is off by 8, which the VEX instructions of a v3 build tolerate
|
||||
// but the SSE ones of a v2 or k10 build (movdqa, pcmpeqb with a memory operand) fault on.
|
||||
" andq $-16, %rsp\n"
|
||||
" movq %r13, %rdi\n"
|
||||
" callq *%r12\n"
|
||||
" ud2\n"
|
||||
@@ -993,6 +999,12 @@ int plat_mem_read(uint64_t addr, void *out, size_t n) {
|
||||
return process_vm_readv(getpid(), &local, 1, &remote, 1, 0) == (ssize_t)n;
|
||||
}
|
||||
|
||||
// Not known before the SDL window exists; the Steam Deck has its own profile (cfg.c)
|
||||
int plat_screen_size(int *w, int *h) {
|
||||
(void)w, (void)h;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int plat_mem_readable(uint64_t addr, uint64_t n) {
|
||||
uint8_t b;
|
||||
uint64_t end = addr + (n ? n : 1);
|
||||
|
||||
@@ -240,6 +240,7 @@ typedef struct {
|
||||
} PlatCrash;
|
||||
void plat_crash_hook(void (*fn)(const PlatCrash *c));
|
||||
int plat_mem_read(uint64_t addr, void *out, size_t n); // copies n bytes, 0 instead of faulting on unmapped memory
|
||||
int plat_screen_size(int *w, int *h); // the primary display's current mode in pixels; 0 unknown
|
||||
int plat_mem_readable(uint64_t addr, uint64_t n); // every page of [addr, addr + n) can be read; no fault
|
||||
void *plat_aligned_alloc(size_t size, size_t align); // free with plat_aligned_free; NULL on failure
|
||||
void plat_aligned_free(void *p);
|
||||
|
||||
@@ -775,6 +775,14 @@ int plat_mem_read(uint64_t addr, void *out, size_t n) {
|
||||
return ReadProcessMemory(GetCurrentProcess(), (const void *)(uintptr_t)addr, out, n, &got) && got == n;
|
||||
}
|
||||
|
||||
// The display mode's own size: physical pixels whatever the process's DPI awareness and the display scale
|
||||
int plat_screen_size(int *w, int *h) {
|
||||
DEVMODEW dm = {.dmSize = sizeof dm};
|
||||
if (!EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &dm) || !dm.dmPelsWidth || !dm.dmPelsHeight) return 0;
|
||||
*w = (int)dm.dmPelsWidth, *h = (int)dm.dmPelsHeight;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int plat_mem_readable(uint64_t addr, uint64_t n) {
|
||||
for (uint64_t a = addr, end = addr + n; a < end || a == addr;) {
|
||||
MEMORY_BASIC_INFORMATION mbi;
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
// Play time: how long the player has spent in the game, across runs, shown on the Game tab of the settings menu
|
||||
// (ui/menu.cpp tab_game). The game itself keeps no play time a player can see, and the Switch's own play log is not
|
||||
// there to read, so the port counts it.
|
||||
//
|
||||
// One host thread (it never holds a virtual core, as discord_rpc.c's) wakes every second and adds the time since its
|
||||
// last wake when the window has the focus (gfx_window_focused) and the game presented at least one frame meanwhile
|
||||
// (gfx_stats). So the shader prewarm before the first frame, a window left in the background and a hung game do not
|
||||
// count; loading screens and the game's own menus do, as they present frames. One wake adds at most TICK_CAP_MS, so a
|
||||
// machine that slept with the game open adds two seconds, not the night.
|
||||
//
|
||||
// The total lives in <profile>/playtime.txt, next to account.uid and the saves, so it stays with them when the
|
||||
// install is updated or moved. It is plain text, "total_seconds <n>", written atomically (plat_file_write_atomic)
|
||||
// every SAVE_EVERY_MS while it grows and once more when the game exits (playtime_save from boot.c, svc.c and
|
||||
// gfx_present.c, next to prof_write); a crash loses at most SAVE_EVERY_MS. A file that does not read as that is kept
|
||||
// as playtime.txt.bad and the count starts again from zero. A scripted run (--seconds) reads the total and adds nothing.
|
||||
#include <inttypes.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "gfx.h"
|
||||
#include "host.h"
|
||||
#include "platform/platform.h"
|
||||
|
||||
#define TICK_MS 1000
|
||||
#define TICK_CAP_MS 2000
|
||||
#define SAVE_EVERY_MS 30000
|
||||
#define TOTAL_CAP_S (100ull * 365 * 24 * 3600) // a hundred years: anything larger is a damaged file
|
||||
|
||||
static PlatMutex lock = PLAT_MUTEX_INIT; // the totals and the file
|
||||
static uint64_t total_ms, session_ms, saved_ms;
|
||||
static int loaded; // 1 once the file was read (or found missing), -1 when there is no profile
|
||||
static char path[1100];
|
||||
|
||||
// The seconds of a playtime.txt: "total_seconds <n>", a line end or nothing after it, a UTF-8 byte order mark before it
|
||||
// (an editor may add one). 1 when the file reads so and n is at most TOTAL_CAP_S.
|
||||
static int parse(const uint8_t *b, uint64_t n, uint64_t *seconds) {
|
||||
if (n >= 3 && !memcmp(b, "\xEF\xBB\xBF", 3)) b += 3, n -= 3;
|
||||
char text[64] = {0};
|
||||
memcpy(text, b, n < sizeof text - 1 ? n : sizeof text - 1);
|
||||
unsigned long long s = 0;
|
||||
char tail = 0;
|
||||
if (sscanf(text, "total_seconds %llu%c", &s, &tail) < 1 || (tail && tail != '\n' && tail != '\r') ||
|
||||
s > TOTAL_CAP_S)
|
||||
return 0;
|
||||
*seconds = s;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Holding lock. dir: the profile directory.
|
||||
static void load(const char *dir) {
|
||||
if (loaded) return;
|
||||
if (!dir || !*dir || snprintf(path, sizeof path, "%s/playtime.txt", dir) >= (int)sizeof path) {
|
||||
loaded = -1;
|
||||
rt_log("playtime: no profile directory; play time is not counted");
|
||||
return;
|
||||
}
|
||||
loaded = 1;
|
||||
uint64_t n = 0, s = 0;
|
||||
uint8_t *b = plat_file_read(path, &n);
|
||||
if (!b) {
|
||||
rt_log("playtime: no %s yet; counting from zero", path);
|
||||
return;
|
||||
}
|
||||
if (parse(b, n, &s)) {
|
||||
free(b);
|
||||
total_ms = saved_ms = s * 1000;
|
||||
rt_log("playtime: %llu h %02llu min played before this run (%s)", (unsigned long long)(s / 3600),
|
||||
(unsigned long long)(s / 60 % 60), path);
|
||||
return;
|
||||
}
|
||||
char bad[1110];
|
||||
snprintf(bad, sizeof bad, "%s.bad", path);
|
||||
int kept = plat_file_write_atomic(bad, b, (size_t)n); // the whole file, for the player to recover the number
|
||||
free(b);
|
||||
rt_log("playtime: %s does not read as \"total_seconds <n>\"; %s, counting from zero", path,
|
||||
kept ? "kept as playtime.txt.bad" : "could not keep a copy");
|
||||
}
|
||||
|
||||
// Holding lock.
|
||||
static void save_locked(void) {
|
||||
if (loaded != 1 || total_ms / 1000 == saved_ms / 1000) return;
|
||||
char text[48];
|
||||
int n = snprintf(text, sizeof text, "total_seconds %" PRIu64 "\n", total_ms / 1000);
|
||||
if (plat_file_write_atomic(path, text, (size_t)n)) saved_ms = total_ms;
|
||||
else rt_log("playtime: cannot write %s", path);
|
||||
}
|
||||
|
||||
void playtime_save(void) {
|
||||
plat_mutex_lock(&lock);
|
||||
save_locked();
|
||||
plat_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
int playtime_get(uint64_t *total_s, uint64_t *session_s) {
|
||||
plat_mutex_lock(&lock);
|
||||
int ok = loaded == 1;
|
||||
*total_s = total_ms / 1000;
|
||||
*session_s = session_ms / 1000;
|
||||
plat_mutex_unlock(&lock);
|
||||
return ok;
|
||||
}
|
||||
|
||||
// Holding lock: the time since the last tick, d ms, when the game was played meanwhile; the file every SAVE_EVERY_MS.
|
||||
static void tick_locked(uint64_t now, uint64_t d, int playing, uint64_t *last_save) {
|
||||
if (d > TICK_CAP_MS) d = TICK_CAP_MS;
|
||||
if (playing) total_ms += d, session_ms += d;
|
||||
if (now - *last_save >= SAVE_EVERY_MS) save_locked(), *last_save = now;
|
||||
}
|
||||
|
||||
static void playtime_main(void *arg) {
|
||||
(void)arg;
|
||||
plat_thread_priority(PLAT_PRIO_BELOW_NORMAL);
|
||||
uint64_t last = plat_now_ms(), last_save = last, frames = gfx_stats().frames;
|
||||
for (;;) {
|
||||
plat_sleep_ms(TICK_MS);
|
||||
uint64_t now = plat_now_ms(), f = gfx_stats().frames;
|
||||
int playing = f != frames && gfx_window_focused();
|
||||
plat_mutex_lock(&lock);
|
||||
tick_locked(now, now - last, playing, &last_save);
|
||||
plat_mutex_unlock(&lock);
|
||||
last = now, frames = f;
|
||||
}
|
||||
}
|
||||
|
||||
// The file is read at once, so the Game tab shows the total from the first frame. A scripted run (--seconds: benches,
|
||||
// menu shots, input scripts) shows it but adds nothing: those runs are not play.
|
||||
void playtime_init(void) {
|
||||
static int32_t started;
|
||||
if (plat_xchg32(&started, 1)) return;
|
||||
plat_mutex_lock(&lock);
|
||||
load(rt_config()->profile);
|
||||
int on = loaded == 1;
|
||||
plat_mutex_unlock(&lock);
|
||||
if (!on) return;
|
||||
if (rt_config()->seconds > 0) {
|
||||
rt_log("playtime: a scripted run (--seconds); play time is shown, not counted");
|
||||
return;
|
||||
}
|
||||
if (!plat_thread_spawn(playtime_main, NULL, "playtime", 0))
|
||||
rt_log("playtime: cannot start its thread; play time is not counted");
|
||||
}
|
||||
|
||||
// --probe-playtime: the file's parsing, a missing, a valid and a damaged file, the periodic save and the tick's cap, in
|
||||
// a directory next to totk.exe. Needs no game files.
|
||||
static int fails;
|
||||
#define CHECK(c, what) do { if (!(c)) { fails++; fprintf(stderr, "FAIL playtime: %s\n", what); } } while (0)
|
||||
|
||||
static void reset(void) { total_ms = session_ms = saved_ms = 0, loaded = 0, path[0] = 0; }
|
||||
|
||||
static int file_is(const char *p, const char *want) {
|
||||
uint64_t n = 0;
|
||||
uint8_t *b = plat_file_read(p, &n);
|
||||
int ok = b && n == strlen(want) && !memcmp(b, want, n);
|
||||
free(b);
|
||||
return ok;
|
||||
}
|
||||
|
||||
int probe_playtime(void) {
|
||||
uint64_t s = 0;
|
||||
CHECK(parse((const uint8_t *)"total_seconds 42\n", 17, &s) && s == 42, "a line with LF");
|
||||
CHECK(parse((const uint8_t *)"total_seconds 42\r\n", 18, &s) && s == 42, "a line with CRLF");
|
||||
CHECK(parse((const uint8_t *)"total_seconds 42", 16, &s) && s == 42, "no line end");
|
||||
CHECK(parse((const uint8_t *)"\xEF\xBB\xBFtotal_seconds 7\n", 19, &s) && s == 7, "a byte order mark");
|
||||
CHECK(!parse((const uint8_t *)"total_seconds 42x", 17, &s), "a character after the number");
|
||||
CHECK(!parse((const uint8_t *)"total_seconds -1\n", 17, &s), "a negative number");
|
||||
CHECK(!parse((const uint8_t *)"total_seconds 3153600001\n", 25, &s), "over a hundred years");
|
||||
CHECK(!parse((const uint8_t *)"seconds 42\n", 11, &s), "another key");
|
||||
CHECK(!parse((const uint8_t *)"", 0, &s), "an empty file");
|
||||
|
||||
char dir[1024];
|
||||
if (!plat_exe_path(dir, sizeof dir)) return 1;
|
||||
char *cut = plat_last_sep(dir);
|
||||
if (!cut) return 1;
|
||||
strcpy(cut + 1, "playtime-probe");
|
||||
plat_file_mkdir_p(dir);
|
||||
char file[1100], bad[1110];
|
||||
snprintf(file, sizeof file, "%s/playtime.txt", dir);
|
||||
snprintf(bad, sizeof bad, "%s.bad", file);
|
||||
plat_file_delete(file);
|
||||
plat_file_delete(bad);
|
||||
|
||||
uint64_t total, session, last_save = 0;
|
||||
reset();
|
||||
load(dir);
|
||||
CHECK(playtime_get(&total, &session) && total == 0, "a missing file counts from zero");
|
||||
tick_locked(1000, 1000, 1, &last_save);
|
||||
tick_locked(2000, 1000, 0, &last_save);
|
||||
CHECK(plat_file_size(file) < 0, "nothing is written before SAVE_EVERY_MS");
|
||||
tick_locked(2000 + 3600000, 3600000, 1, &last_save); // a machine that slept: one tick adds TICK_CAP_MS, and saves
|
||||
playtime_get(&total, &session);
|
||||
CHECK(total == 3 && session == 3, "played ticks count, an idle one does not, a long one is capped");
|
||||
CHECK(file_is(file, "total_seconds 3\n"), "the save after SAVE_EVERY_MS writes the total");
|
||||
|
||||
reset();
|
||||
load(dir);
|
||||
playtime_get(&total, &session);
|
||||
CHECK(total == 3 && session == 0, "the next run reads the total back");
|
||||
|
||||
static const char damaged[] = "total_seconds twelve\n";
|
||||
plat_file_write_atomic(file, damaged, sizeof damaged - 1);
|
||||
reset();
|
||||
load(dir);
|
||||
playtime_get(&total, &session);
|
||||
CHECK(total == 0, "a damaged file counts from zero");
|
||||
CHECK(file_is(bad, damaged), "a damaged file is kept whole as playtime.txt.bad");
|
||||
|
||||
plat_file_delete(file);
|
||||
plat_file_delete(bad);
|
||||
reset();
|
||||
fprintf(stderr, "playtime: %s (%d failures)\n", fails ? "FAILED" : "ok", fails);
|
||||
return fails ? 1 : 0;
|
||||
}
|
||||
@@ -234,3 +234,102 @@ uint32_t restbl_grow(const char *key, uint32_t entry, uint64_t old, uint64_t new
|
||||
uint64_t e = entry + ((new_size - old) * f + 999) / 1000;
|
||||
return clamp32((e + 31) & ~(uint64_t)31);
|
||||
}
|
||||
|
||||
// ---- packs
|
||||
// SARC: "SARC", u16 header size, u16 byte order mark 0xfeff, u32 archive size, u32 data offset, u16 version, u16 pad;
|
||||
// SFAT: "SFAT", u16 header size, u16 node count, u32 hash key, then per node {u32 name hash, u32 attributes (bit 24: it
|
||||
// has a name, bits 0-23: the name's offset in SFNT / 4), u32 data start, u32 data end} with the data offsets relative
|
||||
// to the archive's data offset; SFNT: "SFNT", u16 header size, u16 pad, then the NUL-terminated names.
|
||||
static uint32_t rd16(const uint8_t *p) { return p[0] | p[1] << 8; }
|
||||
|
||||
int restbl_sarc_each(const uint8_t *p, size_t n, RestblMember *each, void *ctx) {
|
||||
if (n < 0x14 || memcmp(p, "SARC", 4) || rd16(p + 6) != 0xfeff) return 0;
|
||||
size_t head = rd16(p + 4), data = rd32(p + 12);
|
||||
if (head + 12 > n || memcmp(p + head, "SFAT", 4) || data > n) return 0;
|
||||
size_t count = rd16(p + head + 6), nodes = head + rd16(p + head + 4), names = nodes + count * 16;
|
||||
if (names + 8 > n || memcmp(p + names, "SFNT", 4) || rd16(p + names + 4) < 8) return 0;
|
||||
names += rd16(p + names + 4);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
const uint8_t *e = p + nodes + i * 16;
|
||||
uint32_t attr = rd32(e + 4), lo = rd32(e + 8), hi = rd32(e + 12);
|
||||
if (!(attr >> 24)) continue; // without a name: nothing the game looks up by path
|
||||
size_t s = names + (size_t)(attr & 0xffffff) * 4;
|
||||
if (s >= n || !memchr(p + s, 0, n - s) || lo > hi || hi > n - data) return 0;
|
||||
each((const char *)p + s, p + data + lo, hi - lo, ctx);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
// The decompressed size a zstd frame p[0..n) records (Frame_Content_Size), or 4 times n when it records none, as
|
||||
// romfs.c content_size takes a loose file's.
|
||||
static uint64_t frame_content_size(const uint8_t *p, size_t n) {
|
||||
static const uint8_t did_bytes[4] = {0, 1, 2, 4};
|
||||
if (n < 6 || rd32(p) != 0xFD2FB528u) return n;
|
||||
uint8_t fhd = p[4];
|
||||
int single = fhd >> 5 & 1, fcs = fhd >> 6;
|
||||
size_t at = 5 + !single + did_bytes[fhd & 3], len = fcs ? 1u << fcs : single;
|
||||
if (!len || at + len > n) return (uint64_t)n * 4;
|
||||
uint64_t v = 0;
|
||||
for (size_t i = 0; i < len; i++) v |= (uint64_t)p[at + i] << 8 * i;
|
||||
return len == 2 ? v + 256 : v;
|
||||
}
|
||||
|
||||
typedef struct { const char *name; uint64_t size; } Member;
|
||||
typedef struct { Member *m; size_t n, cap; int full; } Members;
|
||||
|
||||
static int ends_with(const char *s, const char *tail) {
|
||||
size_t n = strlen(s), k = strlen(tail);
|
||||
return n >= k && !strcmp(s + n - k, tail);
|
||||
}
|
||||
|
||||
// A member's size as the game unpacks it: a .zs member's content size, else its bytes (a .mc member's compressed ones).
|
||||
static void member_add(const char *name, const uint8_t *data, size_t size, void *ctx) {
|
||||
Members *ms = ctx;
|
||||
if (ms->n == ms->cap) {
|
||||
size_t cap = ms->cap ? ms->cap * 2 : 64;
|
||||
Member *grown = realloc(ms->m, cap * sizeof *grown);
|
||||
if (!grown) {
|
||||
ms->full = 1;
|
||||
return;
|
||||
}
|
||||
ms->m = grown, ms->cap = cap;
|
||||
}
|
||||
ms->m[ms->n++] = (Member){name, ends_with(name, ".zs") ? frame_content_size(data, size) : size};
|
||||
}
|
||||
|
||||
static int by_name(const void *a, const void *b) {
|
||||
return strcmp(((const Member *)a)->name, ((const Member *)b)->name);
|
||||
}
|
||||
|
||||
int restbl_pack_raise(Restbl *t, const Restbl *base, const uint8_t *mod, size_t mod_n, const uint8_t *orig,
|
||||
size_t orig_n, RestblNote *note, void *ctx) {
|
||||
Members m = {0}, o = {0};
|
||||
int raised = -1;
|
||||
if (!restbl_sarc_each(mod, mod_n, member_add, &m) || m.full ||
|
||||
(orig && (!restbl_sarc_each(orig, orig_n, member_add, &o) || o.full)))
|
||||
goto done;
|
||||
if (o.n) qsort(o.m, o.n, sizeof *o.m, by_name);
|
||||
raised = 0;
|
||||
for (size_t i = 0; i < m.n; i++) {
|
||||
char key[1024];
|
||||
uint32_t entry, before = 0, want;
|
||||
restbl_key(m.m[i].name, key, sizeof key);
|
||||
int mc = ends_with(m.m[i].name, ".mc");
|
||||
const Member *was = o.n ? bsearch(&m.m[i], o.m, o.n, sizeof *o.m, by_name) : NULL;
|
||||
if (was) {
|
||||
if (!restbl_get(base, key, &entry)) continue; // the game sizes it without the table (streamed)
|
||||
want = restbl_grow(key, entry, was->size, m.m[i].size, mc);
|
||||
} else { // new to this pack: no copy of the game's to grow from
|
||||
want = restbl_estimate(key, mc ? m.m[i].size * 8 : m.m[i].size);
|
||||
}
|
||||
restbl_get(t, key, &before);
|
||||
if (want && restbl_raise(t, key, want)) {
|
||||
raised++;
|
||||
if (note) note(key, before, want, ctx);
|
||||
}
|
||||
}
|
||||
done:
|
||||
free(m.m);
|
||||
free(o.m);
|
||||
return raised;
|
||||
}
|
||||
@@ -31,3 +31,20 @@ uint32_t restbl_estimate(const char *key, uint64_t size);
|
||||
// times the type's factor, never lowered. scaled: the sizes are compressed ones (a mesh codec .mc file), whose entry
|
||||
// grows in proportion.
|
||||
uint32_t restbl_grow(const char *key, uint32_t entry, uint64_t old, uint64_t new_size, int scaled);
|
||||
|
||||
// The members of the SARC archive p[0..n): each(name, data, size, ctx) for every named member, in the archive's order.
|
||||
// 0 when p is not a SARC archive or a member lies outside it.
|
||||
typedef void RestblMember(const char *name, const uint8_t *data, size_t size, void *ctx);
|
||||
int restbl_sarc_each(const uint8_t *p, size_t n, RestblMember *each, void *ctx);
|
||||
|
||||
// A pack (Pack/**/*.pack.zs, decompressed: a SARC archive) whose members the game loads as resources of their own, each
|
||||
// sized by its own entry. The entries of a mod's pack `mod` raised in t against the game's table `base` and the game's
|
||||
// copy of the pack `orig` (NULL for a pack the game lacks): a member that grew by restbl_grow, a member the game's copy
|
||||
// lacks by restbl_estimate, the others left as they are. note(key, entry before, entry after, ctx) for each raised
|
||||
// entry. The number raised; -1 when either pack is not a SARC archive.
|
||||
typedef void RestblNote(const char *key, uint32_t was, uint32_t now, void *ctx);
|
||||
int restbl_pack_raise(Restbl *t, const Restbl *base, const uint8_t *mod, size_t mod_n, const uint8_t *orig,
|
||||
size_t orig_n, RestblNote *note, void *ctx);
|
||||
|
||||
// restbl_probe.c, part of --probe-mods: the number of failed checks.
|
||||
int restbl_probe(void);
|
||||
@@ -0,0 +1,133 @@
|
||||
// The entries of the members of the mods' packs (restbl.c restbl_pack_raise), on archives and tables of its own; part
|
||||
// of --probe-mods (mods_probe.c). Needs no game files.
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "restbl.h"
|
||||
|
||||
static int fails;
|
||||
#define CHECK(c, what) do { if (!(c)) { fails++; fprintf(stderr, "FAIL restbl: %s\n", what); } } while (0)
|
||||
|
||||
// A member of a probe archive: its name and size; a .zs member is a zstd frame header recording `content` bytes:
|
||||
// fcs 4, a frame with a window descriptor and a 4-byte field; 2, a single-segment frame with a 2-byte field holding
|
||||
// content - 256.
|
||||
typedef struct { const char *name; size_t size, content; int fcs; } Member;
|
||||
|
||||
static void wr16(uint8_t *p, unsigned v) { p[0] = (uint8_t)v, p[1] = (uint8_t)(v >> 8); }
|
||||
static void wr32(uint8_t *p, uint32_t v) { wr16(p, v & 0xffff), wr16(p + 2, v >> 16); }
|
||||
|
||||
// A SARC archive of the members m[0..n); unnamed: the index of a member without a name, -1 for none. malloc'd.
|
||||
static uint8_t *sarc(const Member *m, int n, int unnamed, size_t *out_n) {
|
||||
size_t names = 0, data = 0;
|
||||
for (int i = 0; i < n; i++) names += (strlen(m[i].name) + 4) & ~(size_t)3, data += (m[i].size + 7) & ~(size_t)7;
|
||||
size_t sfat = 0x14, sfnt = sfat + 12 + 16 * (size_t)n, start = (sfnt + 8 + names + 15) & ~(size_t)15;
|
||||
size_t total = start + data;
|
||||
uint8_t *p = calloc(1, total);
|
||||
if (!p) return NULL;
|
||||
memcpy(p, "SARC", 4), wr16(p + 4, 0x14), wr16(p + 6, 0xfeff);
|
||||
wr32(p + 8, (uint32_t)total), wr32(p + 12, (uint32_t)start);
|
||||
memcpy(p + sfat, "SFAT", 4), wr16(p + sfat + 4, 12), wr16(p + sfat + 6, (unsigned)n), wr32(p + sfat + 8, 0x65);
|
||||
memcpy(p + sfnt, "SFNT", 4), wr16(p + sfnt + 4, 8);
|
||||
size_t name_at = 0, data_at = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
uint8_t *node = p + sfat + 12 + 16 * (size_t)i, *d = p + start + data_at;
|
||||
wr32(node + 4, i == unnamed ? 0 : 0x01000000u | (uint32_t)(name_at / 4));
|
||||
wr32(node + 8, (uint32_t)data_at), wr32(node + 12, (uint32_t)(data_at + m[i].size));
|
||||
memcpy(p + sfnt + 8 + name_at, m[i].name, strlen(m[i].name));
|
||||
memset(d, 0x5a, m[i].size);
|
||||
if (m[i].fcs == 4) wr32(d, 0xFD2FB528u), d[4] = 0x80, d[5] = 0x58, wr32(d + 6, (uint32_t)m[i].content);
|
||||
if (m[i].fcs == 2) wr32(d, 0xFD2FB528u), d[4] = 0x60, wr16(d + 5, (unsigned)(m[i].content - 256));
|
||||
name_at += (strlen(m[i].name) + 4) & ~(size_t)3;
|
||||
data_at += (m[i].size + 7) & ~(size_t)7;
|
||||
}
|
||||
*out_n = total;
|
||||
return p;
|
||||
}
|
||||
|
||||
// An empty table with the entries keys[i] = sizes[i].
|
||||
static Restbl *table(const char *const *keys, const uint32_t *sizes, int n) {
|
||||
uint8_t head[22] = "RESTBL";
|
||||
wr32(head + 6, 1), wr32(head + 10, 160), wr32(head + 14, 0), wr32(head + 18, 0);
|
||||
Restbl *t = restbl_parse(head, sizeof head);
|
||||
for (int i = 0; t && i < n; i++) restbl_raise(t, keys[i], sizes[i]);
|
||||
return t;
|
||||
}
|
||||
|
||||
static uint32_t get(const Restbl *t, const char *key) {
|
||||
uint32_t v = 0;
|
||||
return restbl_get(t, key, &v) ? v : 0;
|
||||
}
|
||||
|
||||
static int visited;
|
||||
static void count(const char *name, const uint8_t *data, size_t size, void *ctx) {
|
||||
(void)name, (void)data, (void)size, (void)ctx;
|
||||
visited++;
|
||||
}
|
||||
|
||||
static int notes;
|
||||
static void note(const char *key, uint32_t was, uint32_t now, void *ctx) {
|
||||
(void)key, (void)ctx;
|
||||
notes += now > was;
|
||||
}
|
||||
|
||||
int restbl_probe(void) {
|
||||
fails = 0;
|
||||
static const char *const keys[] = {"AI/Grow.root.ainb", "AI/Same.root.ainb", "AI/Shrink.root.ainb",
|
||||
"Component/Shared.bgyml", "Model/Mesh.bfres", "AI/Zs.ainb", "AI/Zs2.ainb"};
|
||||
static const uint32_t sizes[] = {13512, 5000, 6000, 9000, 30000, 4400, 3500};
|
||||
// The game's copy: an .ainb member a mod grows (by 288 bytes, past its entry's slack), one it keeps, one it
|
||||
// shrinks, one the table does not size, a mesh codec member and two compressed ones.
|
||||
static const Member orig[] = {{"AI/Grow.root.ainb", 13088, 0, 0}, {"AI/Same.root.ainb", 4600, 0, 0},
|
||||
{"AI/Shrink.root.ainb", 5600, 0, 0}, {"AI/NotSized.ainb", 100, 0, 0},
|
||||
{"Model/Mesh.bfres.mc", 1000, 0, 0}, {"AI/Zs.ainb.zs", 64, 4000, 4},
|
||||
{"AI/Zs2.ainb.zs", 64, 3900, 2}};
|
||||
// The mod's copy: those, plus members new to the pack (one the game sizes elsewhere, one it lacks, a streamed one).
|
||||
static const Member mod[] = {{"AI/Grow.root.ainb", 13376, 0, 0}, {"AI/Same.root.ainb", 4600, 0, 0},
|
||||
{"AI/Shrink.root.ainb", 5000, 0, 0}, {"AI/NotSized.ainb", 300, 0, 0},
|
||||
{"Component/New/X.bgyml", 1000, 0, 0}, {"Component/Shared.bgyml", 2000, 0, 0},
|
||||
{"Sound/Stream.bwav", 500, 0, 0}, {"Model/Mesh.bfres.mc", 1500, 0, 0},
|
||||
{"AI/Zs.ainb.zs", 64, 4500, 4}, {"AI/Zs2.ainb.zs", 64, 4200, 2}};
|
||||
size_t on = 0, mn = 0;
|
||||
uint8_t *op = sarc(orig, 7, -1, &on), *mp = sarc(mod, 10, 4, &mn); // the mod's New/X has no name: left alone
|
||||
Restbl *base = table(keys, sizes, 7), *t = table(keys, sizes, 7);
|
||||
CHECK(op && mp && base && t, "probe archives and tables");
|
||||
if (op && mp && base && t) {
|
||||
visited = 0;
|
||||
CHECK(restbl_sarc_each(mp, mn, count, NULL) && visited == 9, "SARC members: every named one");
|
||||
int r = restbl_pack_raise(t, base, mp, mn, op, on, note, NULL);
|
||||
CHECK(r == 5 && notes == 5, "five entries raised, each noted");
|
||||
CHECK(get(t, "AI/Grow.root.ainb") == 13824, "a member that grew: its entry plus the growth, 32-byte steps");
|
||||
CHECK(get(t, "AI/Same.root.ainb") == 5000 && get(t, "AI/Shrink.root.ainb") == 6000,
|
||||
"members that kept or lost bytes keep their entries");
|
||||
CHECK(!get(t, "AI/NotSized.ainb"), "a member the game sizes without the table gets no entry");
|
||||
CHECK(!get(t, "Component/New/X.bgyml"), "a member without a name is not looked up");
|
||||
CHECK(get(t, "Component/Shared.bgyml") == 16384, "a member new to the pack: the estimate of its type");
|
||||
CHECK(!get(t, "Sound/Stream.bwav"), "a streamed member new to the pack gets no entry");
|
||||
CHECK(get(t, "Model/Mesh.bfres") == 45000, "a mesh codec member's entry grows in proportion");
|
||||
CHECK(get(t, "AI/Zs.ainb") == 4928 && get(t, "AI/Zs2.ainb") == 3808,
|
||||
"a compressed member: the growth of the size its frame records (4- and 2-byte fields)");
|
||||
notes = 0;
|
||||
CHECK(restbl_pack_raise(t, base, mp, mn, op, on, note, NULL) == 0 && !notes, "a second pass raises nothing");
|
||||
Restbl *shipped = table(keys, (const uint32_t[]){20000, 5000, 6000, 9000, 30000, 4400, 3500}, 7);
|
||||
CHECK(shipped && restbl_pack_raise(shipped, base, mp, mn, op, on, NULL, NULL) == 4 &&
|
||||
get(shipped, "AI/Grow.root.ainb") == 20000,
|
||||
"an entry a mod's own table raised further stays");
|
||||
restbl_free(shipped);
|
||||
Restbl *added = table(keys, sizes, 7);
|
||||
CHECK(added && restbl_pack_raise(added, base, mp, mn, NULL, 0, NULL, NULL) == 7 &&
|
||||
get(added, "AI/Grow.root.ainb") == 24576 && get(added, "AI/NotSized.ainb") == 12288 &&
|
||||
get(added, "AI/Zs2.ainb") == 16384 && get(added, "Model/Mesh.bfres") == 30000,
|
||||
"a pack the game lacks: every member gets the estimate of its type, an entry above it stays");
|
||||
restbl_free(added);
|
||||
CHECK(restbl_pack_raise(t, base, (const uint8_t *)"SARC", 4, NULL, 0, NULL, NULL) == -1 &&
|
||||
restbl_pack_raise(t, base, mp, mn, mp, 0x20, NULL, NULL) == -1,
|
||||
"an archive that is not one, or whose game copy is cut short, raises nothing");
|
||||
}
|
||||
free(op);
|
||||
free(mp);
|
||||
restbl_free(base);
|
||||
restbl_free(t);
|
||||
printf("restbl: %s\n", fails ? "FAIL" : "ok");
|
||||
return fails;
|
||||
}
|
||||
+120
-5
@@ -24,8 +24,8 @@
|
||||
// matches a RomFS path only without case is served under the RomFS spelling.
|
||||
//
|
||||
// The resource size table: with a player mod enabled, the game's table is rebuilt at start with the tables the mods
|
||||
// ship merged in and the entries of the mods' files raised to what they need (restbl_overlay), and served from
|
||||
// <profile>/mods/ in place of the game's or a mod's table.
|
||||
// ship merged in and the entries of the mods' files raised to what they need (restbl_overlay), the members of their
|
||||
// packs too (restbl_packs), and served from <profile>/mods/ in place of the game's or a mod's table.
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -621,10 +621,122 @@ static Restbl *restbl_unpack(const void *z, size_t n) {
|
||||
return t;
|
||||
}
|
||||
|
||||
// ---- the members of the mods' packs (restbl_pack_raise). The game loads each member of a pack (Pack/**/*.pack.zs, a
|
||||
// SARC archive compressed with a dictionary of Pack/ZsDic.pack.zs) as a resource of its own, in a heap sized by the
|
||||
// member's own entry, so a mod that changes a member and ships no table for it (or an older one) leaves the game's
|
||||
// entry. A member that outgrew its entry's slack loads, then its heap runs out: TotK 1.4.3 writes through a null
|
||||
// pointer at main+0x21794c when the 0x68-byte object an .ainb member builds after its file no longer fits.
|
||||
#define PACK_MAX (256u << 20) // the largest pack taken, decompressed (AI.Global.Product.140.pack: 24 MiB)
|
||||
typedef struct { ZSTD_DDict *dict[4]; unsigned id[4]; int n; ZSTD_DCtx *dctx; } Packs;
|
||||
|
||||
// The bytes of zstd frame z[0..n), with the dictionary of ps its header names; malloc'd. NULL when it is not such a
|
||||
// frame with a recorded size of at most PACK_MAX.
|
||||
static uint8_t *pack_unpack(Packs *ps, const void *z, size_t n, size_t *out_n) {
|
||||
unsigned long long raw = ZSTD_getFrameContentSize(z, n);
|
||||
unsigned id = ZSTD_getDictID_fromFrame(z, n);
|
||||
ZSTD_DDict *dd = NULL;
|
||||
for (int i = 0; i < ps->n; i++)
|
||||
if (ps->id[i] == id) dd = ps->dict[i];
|
||||
if (raw == ZSTD_CONTENTSIZE_UNKNOWN || raw == ZSTD_CONTENTSIZE_ERROR || raw > PACK_MAX || (id && !dd) || !ps->dctx)
|
||||
return NULL;
|
||||
uint8_t *d = malloc(raw ? (size_t)raw : 1);
|
||||
size_t got = !d ? 0 : dd ? ZSTD_decompress_usingDDict(ps->dctx, d, (size_t)raw, z, n, dd)
|
||||
: ZSTD_decompressDCtx(ps->dctx, d, (size_t)raw, z, n);
|
||||
if (!d || ZSTD_isError(got) || got != raw) {
|
||||
free(d);
|
||||
return NULL;
|
||||
}
|
||||
*out_n = (size_t)raw;
|
||||
return d;
|
||||
}
|
||||
|
||||
static void pack_dict_add(const char *name, const uint8_t *data, size_t size, void *ctx) {
|
||||
Packs *ps = ctx;
|
||||
ZSTD_DDict *dd = ps->n < 4 && ends_with(name, ".zsdic") ? ZSTD_createDDict(data, size) : NULL; // a copy
|
||||
if (!dd) return;
|
||||
ps->dict[ps->n] = dd;
|
||||
ps->id[ps->n++] = ZSTD_getDictID_fromDDict(dd);
|
||||
}
|
||||
|
||||
// The dictionaries of Pack/ZsDic.pack.zs as served (zs.zsdic, pack.zsdic, bcett.byml.zsdic): a SARC compressed
|
||||
// without one. 0 when it holds none.
|
||||
static int packs_open(Packs *ps) {
|
||||
Overlay *base;
|
||||
size_t n = 0, rn = 0;
|
||||
ps->dctx = ZSTD_createDCtx();
|
||||
void *z = read_served("Pack/ZsDic.pack.zs", &base, &n, "the members of the mods' packs keep their entries");
|
||||
uint8_t *raw = z ? pack_unpack(ps, z, n, &rn) : NULL;
|
||||
int ok = raw && restbl_sarc_each(raw, rn, pack_dict_add, ps) && ps->n;
|
||||
free(z);
|
||||
free(raw);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static void packs_close(Packs *ps) {
|
||||
for (int i = 0; i < ps->n; i++) ZSTD_freeDDict(ps->dict[i]);
|
||||
ZSTD_freeDCtx(ps->dctx);
|
||||
}
|
||||
|
||||
// Overlay o (a pack) and the game's copy of it, decompressed; NULL when o cannot be read or unpacked. *orig stays NULL
|
||||
// for a pack the game lacks or whose copy cannot be read.
|
||||
static uint8_t *pack_pair(Packs *ps, const Overlay *o, size_t *n, uint8_t **orig, size_t *orig_n) {
|
||||
uint64_t zn = 0;
|
||||
void *z = plat_file_read(o->path, &zn);
|
||||
uint8_t *mod = z ? pack_unpack(ps, z, (size_t)zn, n) : NULL;
|
||||
free(z);
|
||||
*orig = NULL;
|
||||
if (!mod || o->index == ADDED) return mod;
|
||||
Entry e = entry(o->index);
|
||||
void *g = e.size < READ_CHUNK ? malloc(e.size ? (size_t)e.size : 1) : NULL;
|
||||
if (g && read_at(image, g, (uint32_t)e.size, e.offset) == (int64_t)e.size)
|
||||
*orig = pack_unpack(ps, g, (size_t)e.size, orig_n);
|
||||
free(g);
|
||||
return mod;
|
||||
}
|
||||
|
||||
typedef struct { const char *pack, *mod; int lines; } PackNote;
|
||||
|
||||
static void pack_note(const char *key, uint32_t was, uint32_t now, void *ctx) {
|
||||
PackNote *pn = ctx;
|
||||
if (pn->lines++ < 16)
|
||||
rt_log("RomFS: resource size table: %s in %s (%s): entry %u -> %u", key, pn->pack, pn->mod, was, now);
|
||||
}
|
||||
|
||||
// The entries of the members of every pack a mod serves, raised in out against the game's table base; the number
|
||||
// raised, *packs the number of packs with one.
|
||||
static int restbl_packs(Restbl *out, const Restbl *base, int *packs, int *lines) {
|
||||
Packs ps = {0};
|
||||
int raised = 0, opened = 0, bad = 0;
|
||||
*packs = 0;
|
||||
for (size_t k = 0; k < noverlay; k++) {
|
||||
const Overlay *o = &overlays[k];
|
||||
if ((!o->mod && o->prio != 1) || !ends_with(o->name, ".pack.zs")) continue;
|
||||
if (!opened++ && !packs_open(&ps)) {
|
||||
rt_log("RomFS: no zstd dictionary in Pack/ZsDic.pack.zs; the members of mods' packs keep their entries");
|
||||
break;
|
||||
}
|
||||
// A pack whose game copy cannot be read counts as new: each member gets an estimate, which only raises entries.
|
||||
size_t n = 0, orig_n = 0;
|
||||
uint8_t *orig, *mod = pack_pair(&ps, o, &n, &orig, &orig_n);
|
||||
PackNote pn = {o->name, owner_name(o), *lines};
|
||||
int r = mod ? restbl_pack_raise(out, base, mod, n, orig, orig_n, pack_note, &pn) : -1;
|
||||
if (r < 0 && bad++ < 4) rt_log("RomFS: %s (%s) is not a pack this build reads; its members keep their entries",
|
||||
o->name, owner_name(o));
|
||||
*lines = pn.lines;
|
||||
raised += r > 0 ? r : 0;
|
||||
*packs += r > 0;
|
||||
free(mod);
|
||||
free(orig);
|
||||
}
|
||||
packs_close(&ps);
|
||||
return raised;
|
||||
}
|
||||
|
||||
// With a player mod (or the TOTK_ROMFS_MODS manifest) serving files: the game's table with every shipped table of this
|
||||
// version merged in (an entry larger than the game's wins), the entries a mod's table for another version gives for
|
||||
// that mod's files, and each served mod file's entry raised to what its size needs (restbl_grow for a file the game
|
||||
// has, restbl_estimate for an added one). Never lowers the game's entries.
|
||||
// has, restbl_estimate for an added one), the members of the packs mods serve too (restbl_packs). Never lowers the
|
||||
// game's entries.
|
||||
static void restbl_overlay(void) {
|
||||
int player = 0;
|
||||
for (size_t k = 0; k < noverlay; k++) player |= overlays[k].mod || overlays[k].prio == 1;
|
||||
@@ -691,8 +803,10 @@ static void restbl_overlay(void) {
|
||||
}
|
||||
raised += want && restbl_raise(out, key, want);
|
||||
}
|
||||
int packs = 0, lines = 0, members = restbl_packs(out, base, &packs, &lines);
|
||||
if (lines > 16) rt_log("RomFS: resource size table: %d more entries of pack members raised", lines - 16);
|
||||
restbl_free(base);
|
||||
if (!merged && !raised && !served) {
|
||||
if (!merged && !raised && !members && !served) {
|
||||
restbl_free(out);
|
||||
rt_log("RomFS: resource size table: the mods' files fit the game's entries (%.0f ms)", (now_s() - t0) * 1000);
|
||||
return;
|
||||
@@ -711,7 +825,8 @@ static void restbl_overlay(void) {
|
||||
}
|
||||
if (serve_generated(restbl_rel, served, z, zn, "mods", "merged resource sizes", keeps))
|
||||
rt_log("RomFS: resource size table: %d tables merged (%d entries), %d entries raised for mod files (%d "
|
||||
"added files estimated), %.0f ms", tables, merged, raised, estimated, (now_s() - t0) * 1000);
|
||||
"added files estimated), %d for members of %d mod packs, %.0f ms", tables, merged, raised, estimated,
|
||||
members, packs, (now_s() - t0) * 1000);
|
||||
}
|
||||
|
||||
// The HeapDef table a bigger game resolution needs (resolution.c): its texture heap and that heap's parent grow. The
|
||||
|
||||
@@ -216,6 +216,7 @@ static void svc_body(Cpu *c, uint32_t imm, uint64_t pc) {
|
||||
rt_log("guest ExitProcess at %s; exiting", ldr_describe(pc, at, sizeof at));
|
||||
fs_save_flush();
|
||||
vk_pipeline_save();
|
||||
playtime_save();
|
||||
prof_write();
|
||||
fflush(NULL);
|
||||
if (svc_test_exit_hook) return svc_test_exit_hook(0);
|
||||
|
||||
@@ -57,6 +57,7 @@ extern const int rt_game_version;
|
||||
extern const char rt_port_version[];
|
||||
void cheats_frame(uint64_t frame); // cheats.c
|
||||
bool tab_cheats(float scale); // ui/cheats_tab.cpp; true: restart into the rebuild
|
||||
int playtime_get(uint64_t *total_s, uint64_t *session_s); // playtime.c
|
||||
}
|
||||
|
||||
// Roboto Medium (Apache-2.0, ui/fonts/LICENSE-Roboto.txt) with Latin and Cyrillic glyphs.
|
||||
@@ -668,6 +669,8 @@ static void tab_screen(float scale) {
|
||||
opt_slider("TOTK_SHARPNESS", UI_MENU_SHARPNESS, 0, 100, UI_MENU_SHARPNESS_DESC, 5, "%.0f %%");
|
||||
static const UiTextId aspect[] = {UI_MENU_ASPECT_FIT, UI_MENU_ASPECT_STRETCH};
|
||||
opt_choice("TOTK_ASPECT", UI_MENU_ASPECT, aspect, 2, UI_MENU_ASPECT_DESC);
|
||||
static const UiTextId movie_aspect[] = {UI_MENU_MOVIE_ASPECT_KEEP, UI_MENU_MOVIE_ASPECT_STRETCH};
|
||||
opt_choice("TOTK_MOVIE_ASPECT", UI_MENU_MOVIE_ASPECT, movie_aspect, 2, UI_MENU_MOVIE_ASPECT_DESC);
|
||||
opt_slider("TOTK_FOV", UI_MENU_FOV, 70, 140, UI_MENU_FOV_DESC, 5, "%.0f %%");
|
||||
static const char *const aniso[] = {"game", "2", "4", "8", "16"};
|
||||
const char *aniso_names[] = {menu_text(UI_MENU_ANISO_GAME), "2x", "4x", "8x", "16x"};
|
||||
@@ -696,13 +699,28 @@ static void tab_screen(float scale) {
|
||||
opt_end();
|
||||
}
|
||||
|
||||
// Play time across runs (playtime.c), read only. Hidden while it is not counted (no profile directory).
|
||||
static void row_play_time(void) {
|
||||
uint64_t total, session;
|
||||
if (!playtime_get(&total, &session)) return;
|
||||
char value[64], run[64], note[96];
|
||||
snprintf(value, sizeof value, menu_text(UI_MENU_PLAY_TIME_HM), (unsigned long long)(total / 3600),
|
||||
(unsigned)(total / 60 % 60));
|
||||
snprintf(run, sizeof run, menu_text(UI_MENU_PLAY_TIME_HM), (unsigned long long)(session / 3600),
|
||||
(unsigned)(session / 60 % 60));
|
||||
snprintf(note, sizeof note, menu_text(UI_MENU_PLAY_TIME_SESSION), run);
|
||||
opt_text_row("##play_time", menu_text(UI_MENU_PLAY_TIME), value, note, menu_text(UI_MENU_PLAY_TIME_DESC), false);
|
||||
}
|
||||
|
||||
static void tab_game(float scale) {
|
||||
opt_begin("##game", scale);
|
||||
row_fps_limit();
|
||||
opt_toggle("TOTK_FRAME_QUEUE", UI_MENU_FRAME_QUEUE, UI_MENU_FRAME_QUEUE_DESC);
|
||||
row_game_lang();
|
||||
static const UiTextId mode[] = {UI_MENU_MODE_DOCKED, UI_MENU_MODE_HANDHELD};
|
||||
opt_choice("TOTK_OPERATION_MODE", UI_MENU_OPERATION_MODE, mode, 2, UI_MENU_OPERATION_MODE_DESC);
|
||||
opt_toggle("TOTK_ASSUME_FOCUS", UI_MENU_ASSUME_FOCUS, UI_MENU_ASSUME_FOCUS_DESC);
|
||||
row_play_time();
|
||||
opt_end();
|
||||
}
|
||||
|
||||
|
||||
+48
-4
@@ -79,6 +79,10 @@ static const char *const text_en[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_ASPECT_DESC] = "When the window's shape differs from the game resolution's (a 16:9 picture on a 21:9 "
|
||||
"screen): keep the picture's shape with black bars, or stretch it over the window.",
|
||||
[UI_MENU_ASPECT_FIT] = "Black bars", [UI_MENU_ASPECT_STRETCH] = "Stretch",
|
||||
[UI_MENU_MOVIE_ASPECT] = "Movie shape",
|
||||
[UI_MENU_MOVIE_ASPECT_DESC] = "When the game resolution is not 16:9, keep the cutscene movies' own shape with black "
|
||||
"bars, or stretch them over the whole picture. Applies from the next movie.",
|
||||
[UI_MENU_MOVIE_ASPECT_KEEP] = "Black bars", [UI_MENU_MOVIE_ASPECT_STRETCH] = "Stretch",
|
||||
[UI_MENU_FOV] = "Field of view",
|
||||
[UI_MENU_FOV_DESC] = "How much of the world the camera shows, in percent of the game's own. Game version 1.4.3 only.",
|
||||
[UI_MENU_SHADOW_RES] = "Shadow map size",
|
||||
@@ -168,6 +172,9 @@ static const char *const text_en[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_90] = "90 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS",
|
||||
// the monitor's refresh rate; printf format with the rate in Hz when it is known
|
||||
[UI_MENU_FPS_DISPLAY] = "Monitor rate", [UI_MENU_FPS_DISPLAY_HZ] = "Monitor rate (%.0f Hz)",
|
||||
[UI_MENU_FRAME_QUEUE] = "Frame queue",
|
||||
[UI_MENU_FRAME_QUEUE_DESC] = "The game starts a frame while the previous one waits for its turn on screen: far fewer "
|
||||
"dropped frames at the limit, up to one frame more input delay. Applies at once.",
|
||||
[UI_MENU_REALTIME] = "Game speed follows the clock",
|
||||
[UI_MENU_REALTIME_DESC] = "Steps the game by real time, so a slow frame does not slow the game down.",
|
||||
[UI_MENU_CLOTH_REALTIME] = "Cloth on the clock",
|
||||
@@ -185,6 +192,10 @@ static const char *const text_en[UI_TEXT_COUNT] = {
|
||||
"window loses focus, as on the Switch when Home is pressed; a load interrupted that "
|
||||
"way can stop for good.",
|
||||
|
||||
[UI_MENU_PLAY_TIME] = "Play time",
|
||||
[UI_MENU_PLAY_TIME_DESC] = "Time in the game over all runs, counted while the game window has the focus and the game "
|
||||
"draws frames. Kept in playtime.txt in the profile folder, next to the saves.",
|
||||
[UI_MENU_PLAY_TIME_HM] = "%llu h %02u min", [UI_MENU_PLAY_TIME_SESSION] = "this run: %s",
|
||||
[UI_MENU_MODS_BUILTIN] = "Built into the port", [UI_MENU_MODS_INSTALLED] = "Installed mods",
|
||||
[UI_MENU_MODS_NONE] = "No mods yet. Unpack a mod into the mods folder, one folder per mod with its romfs folder "
|
||||
"inside, and restart the game. TKMM can export its merged mods into a folder there too.",
|
||||
@@ -263,7 +274,7 @@ static const char *const text_en[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_STICK_DEADZONE_DESC] = "How far a gamepad stick moves before the game sees it. Raise it if the character or the camera moves on its own: let go of the stick, read \"stick now\" and set the dead zone a few percent above it.",
|
||||
[UI_MENU_STICK_DEADZONE_NOW] = "stick now: %.0f %%",
|
||||
[UI_MENU_MOUSE_MODE] = "Mouse camera",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Direct: the camera turns by how far the mouse moves, as in a PC game, with no stick dead zone or curve (game 1.4.3; other versions use stick emulation). Stick emulation: the mouse acts as the right stick.",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Direct: the camera turns by how far the mouse moves, as in a PC game, with no stick dead zone or curve (games 1.4.3 and 1.2.1; 1.1.0 uses stick emulation). Stick emulation: the mouse acts as the right stick.",
|
||||
[UI_MENU_MOUSE_STICK] = "Stick emulation",
|
||||
[UI_MENU_MOUSE_DIRECT] = "Direct",
|
||||
[UI_MENU_MENU_CURSOR] = "Mouse in the game's menus",
|
||||
@@ -542,6 +553,10 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_ASPECT_DESC] = "Когда форма окна отличается от разрешения игры (картинка 16:9 на экране 21:9): сохранить "
|
||||
"форму картинки с чёрными полосами или растянуть её на всё окно.",
|
||||
[UI_MENU_ASPECT_FIT] = "Чёрные полосы", [UI_MENU_ASPECT_STRETCH] = "Растянуть",
|
||||
[UI_MENU_MOVIE_ASPECT] = "Форма видеороликов",
|
||||
[UI_MENU_MOVIE_ASPECT_DESC] = "Когда разрешение игры не 16:9: сохранить форму роликов с чёрными полосами или "
|
||||
"растянуть их на всю картинку. Действует со следующего ролика.",
|
||||
[UI_MENU_MOVIE_ASPECT_KEEP] = "Чёрные полосы", [UI_MENU_MOVIE_ASPECT_STRETCH] = "Растянуть",
|
||||
[UI_MENU_FOV] = "Поле зрения",
|
||||
[UI_MENU_FOV_DESC] = "Сколько мира показывает камера, в процентах от игрового. Только для версии игры 1.4.3.",
|
||||
[UI_MENU_SHADOW_RES] = "Размер карты теней",
|
||||
@@ -631,6 +646,9 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_FPS_30] = "30 FPS", [UI_MENU_FPS_40] = "40 FPS", [UI_MENU_FPS_45] = "45 FPS",
|
||||
[UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_90] = "90 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS",
|
||||
[UI_MENU_FPS_DISPLAY] = "Как у монитора", [UI_MENU_FPS_DISPLAY_HZ] = "Как у монитора (%.0f Гц)",
|
||||
[UI_MENU_FRAME_QUEUE] = "Очередь кадров",
|
||||
[UI_MENU_FRAME_QUEUE_DESC] = "Игра начинает кадр, пока предыдущий ждёт показа: намного меньше пропущенных кадров на "
|
||||
"лимите, задержка ввода больше не более чем на кадр. Применяется сразу.",
|
||||
[UI_MENU_REALTIME] = "Скорость игры по часам",
|
||||
[UI_MENU_REALTIME_DESC] = "Игра идёт по реальному времени, медленный кадр её не замедляет.",
|
||||
[UI_MENU_CLOTH_REALTIME] = "Ткань по часам",
|
||||
@@ -648,6 +666,10 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
|
||||
"когда окно теряет фокус, как на Switch при нажатии Home; прерванная так загрузка "
|
||||
"может остановиться насовсем.",
|
||||
|
||||
[UI_MENU_PLAY_TIME] = "Время в игре",
|
||||
[UI_MENU_PLAY_TIME_DESC] = "Время в игре за все запуски. Считается, пока окно игры в фокусе и игра рисует кадры. "
|
||||
"Хранится в playtime.txt в папке профиля, рядом с сохранениями.",
|
||||
[UI_MENU_PLAY_TIME_HM] = "%llu ч %02u мин", [UI_MENU_PLAY_TIME_SESSION] = "в этом запуске: %s",
|
||||
[UI_MENU_MODS_BUILTIN] = "Встроенные в порт", [UI_MENU_MODS_INSTALLED] = "Установленные моды",
|
||||
[UI_MENU_MODS_NONE] = "Модов пока нет. Распакуйте мод в папку mods, каждый мод в свою папку с папкой romfs внутри, и "
|
||||
"перезапустите игру. TKMM тоже может выгрузить туда объединённые моды отдельной папкой.",
|
||||
@@ -724,7 +746,7 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_STICK_DEADZONE_DESC] = "Насколько нужно отклонить стик геймпада, чтобы игра это заметила. Увеличьте, если персонаж или камера двигаются сами: отпустите стик, посмотрите «стик сейчас» и поставьте мёртвую зону на несколько процентов выше.",
|
||||
[UI_MENU_STICK_DEADZONE_NOW] = "стик сейчас: %.0f %%",
|
||||
[UI_MENU_MOUSE_MODE] = "Управление мышью",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Прямое: камера поворачивается на столько, на сколько сдвинута мышь, как в играх для ПК, без мёртвой зоны и кривой стика (версия игры 1.4.3; на других версиях эмуляция стика). Эмуляция стика: мышь работает как правый стик.",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Прямое: камера поворачивается на столько, на сколько сдвинута мышь, как в играх для ПК, без мёртвой зоны и кривой стика (версии игры 1.4.3 и 1.2.1; на 1.1.0 эмуляция стика). Эмуляция стика: мышь работает как правый стик.",
|
||||
[UI_MENU_MOUSE_STICK] = "Эмуляция стика",
|
||||
[UI_MENU_MOUSE_DIRECT] = "Прямое",
|
||||
[UI_MENU_MENU_CURSOR] = "Мышь в меню игры",
|
||||
@@ -969,6 +991,10 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_TAB_SCREEN] = "Tela", [UI_MENU_TAB_GAME] = "Jogo", [UI_MENU_TAB_SOUND] = "Som",
|
||||
[UI_MENU_TAB_CONTROLS] = "Controles", [UI_MENU_TAB_AMIIBO] = "Amiibo", [UI_MENU_TAB_MENU] = "Menu", [UI_MENU_TAB_ADVANCED] = "Avançado",
|
||||
[UI_MENU_TAB_MODS] = "Mods",
|
||||
[UI_MENU_PLAY_TIME] = "Tempo de jogo",
|
||||
[UI_MENU_PLAY_TIME_DESC] = "Tempo no jogo somando todas as sessões, contado enquanto a janela do jogo está em foco e o "
|
||||
"jogo desenha quadros. Fica em playtime.txt na pasta do perfil, junto dos saves.",
|
||||
[UI_MENU_PLAY_TIME_HM] = "%llu h %02u min", [UI_MENU_PLAY_TIME_SESSION] = "nesta sessão: %s",
|
||||
[UI_MENU_MODS_BUILTIN] = "Embutidos no port", [UI_MENU_MODS_INSTALLED] = "Mods instalados",
|
||||
[UI_MENU_MODS_NONE] = "Nenhum mod ainda. Descompacte um mod na pasta mods, uma pasta por mod com a pasta romfs dentro, "
|
||||
"e reinicie o jogo. O TKMM também pode exportar os mods mesclados para uma pasta ali.",
|
||||
@@ -1040,6 +1066,10 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_ASPECT_DESC] = "Quando o formato da janela difere do da resolução do jogo (uma imagem 16:9 numa tela "
|
||||
"21:9): manter o formato da imagem com barras pretas ou esticá-la sobre a janela.",
|
||||
[UI_MENU_ASPECT_FIT] = "Barras pretas", [UI_MENU_ASPECT_STRETCH] = "Esticar",
|
||||
[UI_MENU_MOVIE_ASPECT] = "Formato dos vídeos",
|
||||
[UI_MENU_MOVIE_ASPECT_DESC] = "Quando a resolução do jogo não é 16:9: manter o formato dos vídeos das cenas com "
|
||||
"barras pretas ou esticá-los sobre a imagem toda. Vale a partir do próximo vídeo.",
|
||||
[UI_MENU_MOVIE_ASPECT_KEEP] = "Barras pretas", [UI_MENU_MOVIE_ASPECT_STRETCH] = "Esticar",
|
||||
[UI_MENU_SHARPNESS] = "Nitidez do FSR",
|
||||
[UI_MENU_SHARPNESS_DESC] = "Aumento de nitidez após a ampliação do FSR; 0 desliga.",
|
||||
|
||||
@@ -1054,6 +1084,9 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
|
||||
"a janela perde o foco, como no Switch ao apertar Home; um carregamento interrompido "
|
||||
"assim pode parar de vez.",
|
||||
[UI_MENU_FPS_DISPLAY] = "Taxa do monitor", [UI_MENU_FPS_DISPLAY_HZ] = "Taxa do monitor (%.0f Hz)",
|
||||
[UI_MENU_FRAME_QUEUE] = "Fila de quadros",
|
||||
[UI_MENU_FRAME_QUEUE_DESC] = "O jogo começa um quadro enquanto o anterior espera a vez de aparecer: muito menos quadros "
|
||||
"perdidos no limite, com até um quadro a mais de atraso na entrada. Vale na hora.",
|
||||
[UI_MENU_REALTIME] = "Velocidade do jogo pelo relógio",
|
||||
[UI_MENU_REALTIME_DESC] = "Avança o jogo pelo tempo real, para que um quadro lento não deixe o jogo mais lento.",
|
||||
[UI_MENU_CLOTH_REALTIME] = "Tecidos pelo relógio",
|
||||
@@ -1349,7 +1382,7 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_PROMPTS_XBOX] = "Xbox",
|
||||
[UI_MENU_PROMPTS_PC] = "PC",
|
||||
[UI_MENU_MOUSE_MODE] = "Câmera com o mouse",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Direta: a câmera gira o quanto o mouse se move, como num jogo de PC, sem zona morta nem curva do analógico (jogo 1.4.3; as outras versões usam a emulação do analógico). Emulação do analógico: o mouse age como o analógico direito.",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "Direta: a câmera gira o quanto o mouse se move, como num jogo de PC, sem zona morta nem curva do analógico (jogos 1.4.3 e 1.2.1; o 1.1.0 usa a emulação do analógico). Emulação do analógico: o mouse age como o analógico direito.",
|
||||
[UI_MENU_MOUSE_STICK] = "Emulação do analógico",
|
||||
[UI_MENU_MOUSE_DIRECT] = "Direta",
|
||||
[UI_MENU_MENU_CURSOR] = "Mouse nos menus do jogo",
|
||||
@@ -1471,6 +1504,10 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_TAB_MENU] = "菜单",
|
||||
[UI_MENU_TAB_ADVANCED] = "高级",
|
||||
[UI_MENU_TAB_MODS] = "模组",
|
||||
[UI_MENU_PLAY_TIME] = "游戏时间",
|
||||
[UI_MENU_PLAY_TIME_DESC] = "所有运行累计的游戏时间,仅在游戏窗口处于焦点且游戏正在绘制画面时计时。"
|
||||
"保存在配置文件夹的 playtime.txt 中,与存档放在一起。",
|
||||
[UI_MENU_PLAY_TIME_HM] = "%llu 小时 %02u 分钟", [UI_MENU_PLAY_TIME_SESSION] = "本次运行:%s",
|
||||
[UI_MENU_MODS_BUILTIN] = "移植版内置", [UI_MENU_MODS_INSTALLED] = "已安装的模组",
|
||||
[UI_MENU_MODS_NONE] = "还没有模组。把模组解压到 mods 文件夹,每个模组一个文件夹,里面放 romfs 文件夹,然后重启游戏。"
|
||||
"TKMM 也可以把合并后的模组导出到那里的一个文件夹。",
|
||||
@@ -1549,6 +1586,11 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
|
||||
"用黑边保持画面比例,或拉伸铺满窗口。",
|
||||
[UI_MENU_ASPECT_FIT] = "黑边",
|
||||
[UI_MENU_ASPECT_STRETCH] = "拉伸",
|
||||
[UI_MENU_MOVIE_ASPECT] = "视频画面比例",
|
||||
[UI_MENU_MOVIE_ASPECT_DESC] = "当游戏分辨率不是 16:9 时:用黑边保持过场视频的原有比例,或拉伸铺满整个画面。"
|
||||
"从下一段视频起生效。",
|
||||
[UI_MENU_MOVIE_ASPECT_KEEP] = "黑边",
|
||||
[UI_MENU_MOVIE_ASPECT_STRETCH] = "拉伸",
|
||||
[UI_MENU_FOV] = "视野",
|
||||
[UI_MENU_FOV_DESC] = "镜头能看到多大范围,以游戏自身视野的百分比表示。"
|
||||
"仅限游戏版本 1.4.3。",
|
||||
@@ -1582,6 +1624,8 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_FPS_144] = "144 FPS",
|
||||
[UI_MENU_FPS_DISPLAY] = "显示器刷新率",
|
||||
[UI_MENU_FPS_DISPLAY_HZ] = "显示器刷新率(%.0f Hz)",
|
||||
[UI_MENU_FRAME_QUEUE] = "帧队列",
|
||||
[UI_MENU_FRAME_QUEUE_DESC] = "前一帧等待显示时游戏就开始绘制下一帧:在帧率上限下掉帧大幅减少,输入延迟最多增加一帧。立即生效。",
|
||||
[UI_MENU_REALTIME] = "游戏速度跟随时钟",
|
||||
[UI_MENU_REALTIME_DESC] = "按真实时间推进游戏,帧率低时游戏速度也不会变慢。",
|
||||
[UI_MENU_CLOTH_REALTIME] = "布料跟随时钟",
|
||||
@@ -1955,7 +1999,7 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
|
||||
[UI_MENU_PROMPTS_XBOX] = "Xbox",
|
||||
[UI_MENU_PROMPTS_PC] = "PC",
|
||||
[UI_MENU_MOUSE_MODE] = "鼠标视角",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "直接:镜头按鼠标移动的距离转动,与电脑游戏相同,没有摇杆死区和响应曲线(游戏 1.4.3;其他版本使用摇杆模拟)。摇杆模拟:鼠标相当于右摇杆。",
|
||||
[UI_MENU_MOUSE_MODE_DESC] = "直接:镜头按鼠标移动的距离转动,与电脑游戏相同,没有摇杆死区和响应曲线(游戏 1.4.3 和 1.2.1;1.1.0 使用摇杆模拟)。摇杆模拟:鼠标相当于右摇杆。",
|
||||
[UI_MENU_MOUSE_STICK] = "摇杆模拟",
|
||||
[UI_MENU_MOUSE_DIRECT] = "直接",
|
||||
[UI_MENU_MENU_CURSOR] = "在游戏菜单中使用鼠标",
|
||||
|
||||
@@ -37,6 +37,7 @@ typedef enum {
|
||||
UI_MENU_RENDER_SCALE, UI_MENU_RENDER_SCALE_DESC, UI_MENU_RENDER_SCALE_GAME,
|
||||
UI_MENU_UPSCALER, UI_MENU_UPSCALER_DESC, UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR,
|
||||
UI_MENU_ASPECT, UI_MENU_ASPECT_DESC, UI_MENU_ASPECT_FIT, UI_MENU_ASPECT_STRETCH,
|
||||
UI_MENU_MOVIE_ASPECT, UI_MENU_MOVIE_ASPECT_DESC, UI_MENU_MOVIE_ASPECT_KEEP, UI_MENU_MOVIE_ASPECT_STRETCH,
|
||||
UI_MENU_FOV, UI_MENU_FOV_DESC,
|
||||
UI_MENU_SHADOW_RES, UI_MENU_SHADOW_RES_DESC, UI_MENU_SHADOW_RES_GAME,
|
||||
UI_MENU_ANISO, UI_MENU_ANISO_DESC, UI_MENU_ANISO_GAME,
|
||||
@@ -62,12 +63,16 @@ typedef enum {
|
||||
UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_40, UI_MENU_FPS_45, UI_MENU_FPS_60, UI_MENU_FPS_90,
|
||||
UI_MENU_FPS_120, UI_MENU_FPS_144,
|
||||
UI_MENU_FPS_DISPLAY, UI_MENU_FPS_DISPLAY_HZ,
|
||||
UI_MENU_FRAME_QUEUE, UI_MENU_FRAME_QUEUE_DESC,
|
||||
UI_MENU_REALTIME, UI_MENU_REALTIME_DESC,
|
||||
UI_MENU_CLOTH_REALTIME, UI_MENU_CLOTH_REALTIME_DESC,
|
||||
UI_MENU_HIGHFPS_FIX, UI_MENU_HIGHFPS_FIX_DESC,
|
||||
UI_MENU_GAME_LANG, UI_MENU_GAME_LANG_DESC, UI_MENU_GAME_LANG_AUTO,
|
||||
UI_MENU_OPERATION_MODE, UI_MENU_OPERATION_MODE_DESC, UI_MENU_MODE_DOCKED, UI_MENU_MODE_HANDHELD,
|
||||
UI_MENU_ASSUME_FOCUS, UI_MENU_ASSUME_FOCUS_DESC,
|
||||
UI_MENU_PLAY_TIME, UI_MENU_PLAY_TIME_DESC,
|
||||
UI_MENU_PLAY_TIME_HM, // hours and minutes: "%llu h %02u min" (unsigned long long hours, unsigned minutes)
|
||||
UI_MENU_PLAY_TIME_SESSION, // note under the total: "this run: %s" (the hours and minutes above)
|
||||
|
||||
// Mods: the port's own patches and the player's mods folder (mods.c)
|
||||
UI_MENU_MODS_BUILTIN, UI_MENU_MODS_INSTALLED,
|
||||
|
||||
@@ -428,6 +428,7 @@ void vk_texture_stats(uint64_t *images, uint64_t *uploads, uint64_t *reuploads);
|
||||
// (images not bound into pool memory).
|
||||
typedef struct { uint64_t live, released, own_live, own_released, bytes_live, bytes_released; } VkTexCensus;
|
||||
void vk_texture_census(VkTexCensus *s);
|
||||
void vk_texture_released_log(uint64_t frame); // mem: released lines of vram_log
|
||||
void vk_texture_shutdown(void); // vk_mem_shutdown calls it
|
||||
void vk_texture_new_submit(void); // a queue submit starts: draw bindings check storage again
|
||||
uint32_t vk_texture_epoch(void); // the write-watch snapshot epoch vk_texture_new_submit started
|
||||
|
||||
@@ -565,10 +565,23 @@ void vk_mem_census(uint64_t frame) {
|
||||
window_start = frame;
|
||||
}
|
||||
|
||||
// TOTK_VRAM_LIMIT_MIB: pretend the device-local budget is at most this many MiB, so the paths that react to the budget
|
||||
// can be driven on a card larger than the one a report came from. The driver knows nothing of it.
|
||||
static uint64_t vram_limit(void) {
|
||||
static int64_t limit = -1;
|
||||
if (limit < 0) {
|
||||
const char *s = cfg_get("TOTK_VRAM_LIMIT_MIB");
|
||||
limit = s && *s ? (int64_t)strtoull(s, NULL, 10) << 20 : 0;
|
||||
if (limit) rt_log("mem: device-local budget limited to %lld MiB (TOTK_VRAM_LIMIT_MIB)", (long long)(limit >> 20));
|
||||
}
|
||||
return (uint64_t)limit;
|
||||
}
|
||||
|
||||
int vk_mem_vram(uint64_t *used, uint64_t *budget, int *exact) {
|
||||
VkCtx *c = vk_ctx();
|
||||
*used = *budget = 0, *exact = 0;
|
||||
if (!c) return 0;
|
||||
uint64_t limit = vram_limit();
|
||||
const VkPhysicalDeviceMemoryProperties *mp = &c->mem_props;
|
||||
if (c->has_memory_budget) {
|
||||
VkPhysicalDeviceMemoryBudgetPropertiesEXT b = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT};
|
||||
@@ -578,6 +591,7 @@ int vk_mem_vram(uint64_t *used, uint64_t *budget, int *exact) {
|
||||
if (p2.memoryProperties.memoryHeaps[h].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
|
||||
*used += b.heapUsage[h], *budget += b.heapBudget[h];
|
||||
*exact = 1;
|
||||
if (limit && *budget > limit) *budget = limit;
|
||||
return *budget != 0;
|
||||
}
|
||||
VmaBudget vb[VK_MAX_MEMORY_HEAPS];
|
||||
@@ -585,6 +599,7 @@ int vk_mem_vram(uint64_t *used, uint64_t *budget, int *exact) {
|
||||
for (uint32_t h = 0; h < mp->memoryHeapCount && h < VK_MAX_MEMORY_HEAPS; h++)
|
||||
if (mp->memoryHeaps[h].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
|
||||
*used += vb[h].statistics.blockBytes, *budget += mp->memoryHeaps[h].size;
|
||||
if (limit && *budget > limit) *budget = limit;
|
||||
return *budget != 0;
|
||||
}
|
||||
|
||||
@@ -633,6 +648,17 @@ static uint32_t reg_tried[RT_ADDRESS_LIMIT >> REG_SHIFT]; // gen_lock: ww_ep o
|
||||
static uint32_t *fcand; // gen_lock: regions to try at the next freeze pass
|
||||
static int nfcand, cfcand;
|
||||
static uint64_t n_frz_refused; // gen_lock: candidates mem_freeze refused
|
||||
// Regions the GPU writes. Storage-buffer stores, buffer copies and fills land in imported guest memory, directly (import
|
||||
// mode) or through a pool's mirror that vk_mem_mirror_end copies or merges into the imported buffer. They are not CPU
|
||||
// writes: no fault thaws the region and no write-watch bit is set, so a region only the GPU writes looked idle, was
|
||||
// frozen, and the GPU went on writing pages the CPU side had made read-only. LAS Recomp never changes the protection of
|
||||
// imported memory: on NVIDIA, VirtualProtect on pages imported with VK_EXT_external_memory_host left the GPU reading
|
||||
// wrong data (runtime/nvn/vulkan/exec.c, the comment on its write watch); a GPU write there is the likely cause of the
|
||||
// device faults "write invalid" at a page of guest memory on NVIDIA (#788, #802). reg_gpu holds the timeline value of
|
||||
// the newest submission that writes into the region (gpu_writes): freeze_pass leaves the region alone until the GPU is
|
||||
// past that value, and a frozen region is thawed when a write into it is recorded.
|
||||
static uint64_t reg_gpu[RT_ADDRESS_LIMIT >> REG_SHIFT]; // replay thread
|
||||
static volatile int64_t n_frz_gpu, n_thaw_gpu; // freeze candidates kept for a GPU write; thaws for one (mirror_log)
|
||||
|
||||
static uint32_t *gen_slot(uint64_t page_addr, int create) {
|
||||
uint64_t ci = page_addr >> GEN_CHUNK_SHIFT;
|
||||
@@ -1693,8 +1719,26 @@ static void snap_free(void *arg) { // completion thread: the submission is don
|
||||
free(f);
|
||||
}
|
||||
|
||||
// Record time: the submission being recorded writes [off, off+size) of r's guest range, directly into the imported
|
||||
// buffer or into the mirror whose bytes go back at its end. Keeps the regions unfrozen until the GPU is past it
|
||||
// (reg_gpu). Shadow storage needs nothing: the GPU writes the shadow and the CPU copies it back, thawing as it goes.
|
||||
static void gpu_writes(const PoolRec *r, uint64_t off, uint64_t size) {
|
||||
if (!freeze_idle || r->smap) return;
|
||||
uint64_t a = r->import_lo + off, b = a + size;
|
||||
if (b <= a || b > RT_ADDRESS_LIMIT) return;
|
||||
uint64_t f = vk_exec_recording_fence();
|
||||
if (!f) f = vk_sync_issued() + 1;
|
||||
int frozen = 0;
|
||||
for (uint64_t j = a >> REG_SHIFT; j <= (b - 1) >> REG_SHIFT; j++) {
|
||||
if (__atomic_load_n(®_gpu[j], __ATOMIC_RELAXED) < f) __atomic_store_n(®_gpu[j], f, __ATOMIC_RELAXED);
|
||||
frozen |= mem_frozen(j << REG_SHIFT);
|
||||
}
|
||||
if (frozen) mem_thaw(a, b - a), plat_inc64(&n_thaw_gpu);
|
||||
}
|
||||
|
||||
static void gpu_wrote(const VkMemSpan *sp, uint64_t size, int shader) {
|
||||
PoolRec *r = sp->pool;
|
||||
if (r && size) gpu_writes(r, sp->offset, size);
|
||||
if (!r || r->mstate != MS_ON || sp->buffer != r->mbuf || !size) return;
|
||||
// A binding to the end of its pool (no size) can span hundreds of MiB: those stay copies.
|
||||
if (shader && !(sp->offset & 3) && !(size & 3) && size <= MERGE_MAX && merging() && snap_add(r, sp->offset, size))
|
||||
@@ -1778,9 +1822,11 @@ void nvn_pool_flushed(const pool_t *p, uint64_t off, uint64_t size) {
|
||||
// gen_lock exclusive: freezes up to FREEZE_PER_SUB candidate regions still idle. The query after the
|
||||
// protection collects the writes made before it took effect.
|
||||
static void freeze_pass(void) {
|
||||
uint64_t gpu_done = vk_sync_fence_done();
|
||||
for (int done = 0; nfcand && done < FREEZE_PER_SUB;) {
|
||||
uint64_t j = fcand[--nfcand], a = j << REG_SHIFT;
|
||||
if (ww_ep - reg_last[j] < (uint32_t)freeze_idle || mem_frozen(a)) continue;
|
||||
if (__atomic_load_n(®_gpu[j], __ATOMIC_RELAXED) > gpu_done) { plat_inc64(&n_frz_gpu); continue; } // gpu_writes
|
||||
done++;
|
||||
if (!mem_freeze(a)) { n_frz_refused++; continue; }
|
||||
query_stamp(a, a + (1ull << REG_SHIFT), ++gen_now);
|
||||
@@ -1998,6 +2044,10 @@ static void mirror_log(uint64_t frame) {
|
||||
"or mapping change %llu, refused %llu",
|
||||
(unsigned long long)frame, wc / wf, wb / wf / 1048576.0, qpc_ms(wt) / wf, dc / wf, wp / wf, qpc_ms(dt) / wf,
|
||||
fz * 2.0, (unsigned long long)ff, (unsigned long long)ft, (unsigned long long)fo, (unsigned long long)nr);
|
||||
int64_t kg = plat_xchg64(&n_frz_gpu, 0), tg = plat_xchg64(&n_thaw_gpu, 0);
|
||||
if (kg || tg) // gpu_writes: before this, every count here was a region frozen under a GPU write
|
||||
rt_log("mem: frame %llu: regions the GPU writes, since the last line: %lld kept from freezing, %lld frozen ones "
|
||||
"thawed", (unsigned long long)frame, (long long)kg, (long long)tg);
|
||||
if (!vk_mirror_on) return;
|
||||
plat_mutex_lock(&mirror_stat_lock);
|
||||
MirrorAcc a = macc;
|
||||
@@ -2050,6 +2100,7 @@ static void vram_log(uint64_t frame) {
|
||||
alloc_bytes / M, (unsigned long long)t.live, (unsigned long long)t.own_live, t.bytes_live / M,
|
||||
(unsigned long long)t.released, (unsigned long long)t.own_released, t.bytes_released / M, (long long)m_live_n,
|
||||
m_live_bytes / M, dead_pending());
|
||||
vk_texture_released_log(frame);
|
||||
}
|
||||
|
||||
// Device class: INTEGRATED -> uma; a discrete GPU with a DEVICE_LOCAL heap of 1 GiB or more beside a
|
||||
|
||||
+99
-21
@@ -3,7 +3,8 @@
|
||||
// call's arguments; its pointers point into the packet itself, so the recorder passes the payload to the driver as
|
||||
// it is. A packet never wraps: one that does not fit before the end is preceded by a pad. The producer publishes head
|
||||
// after each packet; the recorder makes the calls and advances tail, which the producer waits on when the ring is
|
||||
// full and in rec_drain. While a part is recorded the recorder spins on head; idle, it sleeps on an event.
|
||||
// full and in rec_drain. While a part is recorded the recorder spins on head; idle, it sleeps on an event. Packets also
|
||||
// begin, end and submit the parts (rec_begin, rec_end_cb, rec_submit), so each part stays on the recorder throughout.
|
||||
// Design: Savage Wind Recomp #189 and LAS Recomp runtime/nvn/vulkan/record.c (https://github.com/peiikai/LASRecomp
|
||||
// @ a4b53a3, MIT, Copyright (c) 2026 Peiikai); the code is ours.
|
||||
#define VK_REC_IMPL
|
||||
@@ -22,8 +23,12 @@ static volatile uint64_t head, tail; // words published by the producer / cons
|
||||
static volatile int32_t sleeping; // the recorder waits for wake_ev
|
||||
static PlatEvent wake_ev; // auto-reset
|
||||
static uint64_t put_h; // producer: words written (published up to head)
|
||||
static VkCommandBuffer rec_cb; // the part being recorded (set while the recorder is idle)
|
||||
static VkCommandBuffer rec_cb; // producer: the part being recorded, whose vkCmd* become packets
|
||||
static VkCommandBuffer r_cb; // recorder: the command buffer its packets go into (set by a BeginCb packet)
|
||||
static int rec_live; // producer: rec_begin started the recorder for rec_cb
|
||||
static int end_mode = -1; // TOTK_REC_END (rec_own)
|
||||
static int sub_pending; // producer: the recorder ended a part that rec_submit has not handed over yet
|
||||
static volatile VkResult r_sub_res; // recorder: the result of its last vkQueueSubmit2, read after the drain
|
||||
static PlatThread *rec_thread;
|
||||
static int rec_prio; // the submitting thread's priority, which the recorder takes
|
||||
static int rec_chk; // TOTK_REC_CHECK (rec_check_handle)
|
||||
@@ -32,7 +37,7 @@ static volatile uint64_t part_h0; // put_h at rec_begin: where the packets
|
||||
static volatile uint64_t part_fence; // the value of the part being recorded (rec_begin)
|
||||
|
||||
// Producer statistics, logged by rec_stats_log.
|
||||
static struct { uint64_t packets, words, drains, fallbacks, drain_ns, full_waits, parts, parts_on; } RS_;
|
||||
static struct { uint64_t packets, words, drains, fallbacks, drain_ns, full_waits, parts, parts_on, submits; } RS_;
|
||||
|
||||
enum {
|
||||
R_PAD, R_BeginQuery, R_BeginRendering, R_BindDescriptorSets, R_BindIndexBuffer, R_BindPipeline, R_BindVertexBuffers2,
|
||||
@@ -44,7 +49,7 @@ enum {
|
||||
R_SetRasterizerDiscardEnable, R_SetScissorWithCount, R_SetStencilCompareMask, R_SetStencilOp, R_SetStencilReference,
|
||||
R_SetStencilTestEnable, R_SetStencilWriteMask, R_SetViewportWithCount, R_WriteTimestamp, R_WriteTimestamp2,
|
||||
R_PushTpl, R_Push, R_VertexInput, R_Bool, R_PolygonMode, R_BlendEnable, R_BlendEquation, R_WriteMask, R_EndCb,
|
||||
R_PassMark,
|
||||
R_PassMark, R_BeginCb, R_Submit,
|
||||
};
|
||||
|
||||
static uint64_t now_ns(void) { return plat_now_ns(); }
|
||||
@@ -135,7 +140,23 @@ void rec_drain(void) {
|
||||
RS_.drains++, RS_.drain_ns += now_ns() - t0;
|
||||
}
|
||||
|
||||
void rec_begin(VkCommandBuffer cb, uint64_t fence) {
|
||||
static int rec_own(void) {
|
||||
if (end_mode < 0) end_mode = rt_knob("REC_END", "1");
|
||||
return end_mode;
|
||||
}
|
||||
|
||||
// vkBeginCommandBuffer (one submission) and the breadcrumb, on the thread that records cb.
|
||||
static void begin_now(VkCommandBuffer cb, int crumb, uint64_t n) {
|
||||
VkCommandBufferBeginInfo bi = {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
||||
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
|
||||
vkBeginCommandBuffer(cb, &bi);
|
||||
if (crumb) vk_crumb(cb, crumb, n);
|
||||
}
|
||||
|
||||
// The command buffer the following packets go into; begin: the recorder begins it (TOTK_REC_END=1).
|
||||
typedef struct { VkCommandBuffer cb; int begin, crumb; uint64_t n; } A_BeginCb;
|
||||
|
||||
void rec_begin(VkCommandBuffer cb, uint64_t fence, int crumb, uint64_t n) {
|
||||
static int mode = -1;
|
||||
if (mode < 0) {
|
||||
// Default off on AMD GPUs. With the recorder those drivers lost the device or hung the GPU at startup on
|
||||
@@ -168,11 +189,21 @@ void rec_begin(VkCommandBuffer cb, uint64_t fence) {
|
||||
}
|
||||
}
|
||||
RS_.parts++;
|
||||
if (!RT_KNOB_ON(mode)) return;
|
||||
int on = RT_KNOB_ON(mode), own = on && rec_own();
|
||||
if (!own) {
|
||||
// The submitting thread begins cb. The part pool is the recorder's while it has packets (an A/B switch
|
||||
// between parts): it finishes them first.
|
||||
rec_drain();
|
||||
begin_now(cb, crumb, n);
|
||||
if (!on) return;
|
||||
}
|
||||
RS_.parts_on++;
|
||||
rec_cb = cb; // the recorder is idle: rec_end drained it
|
||||
__atomic_store_n(&part_h0, put_h, __ATOMIC_RELEASE);
|
||||
__atomic_store_n(&part_fence, fence, __ATOMIC_RELEASE);
|
||||
A_BeginCb *a = put(R_BeginCb, sizeof *a);
|
||||
*a = (A_BeginCb){cb, own, crumb, n};
|
||||
pub();
|
||||
rec_cb = cb;
|
||||
rec_live = 1;
|
||||
}
|
||||
|
||||
@@ -182,23 +213,28 @@ void rec_end(void) {
|
||||
rec_live = 0;
|
||||
}
|
||||
|
||||
// TOTK_REC_END (default 1): the thread that recorded the part also ends it, after the breadcrumb crumb (kind 0: none)
|
||||
// that vk_sync.c writes at the end of a submission. On an RX 6700 XT (driver 26.10.1, issue #5) parts the recorder
|
||||
// recorded and the submitting thread ended broke when a submission was split (vk_sync.c vk_sync_split): the GPU hung
|
||||
// or the scene turned green, then white. The handoff in rec_drain orders the two threads, so Vulkan allows the old
|
||||
// split; the driver did not cope with it. TOTK_REC_END=0 brings the old split back.
|
||||
// TOTK_REC_END (default 1): a part the recorder records is the recorder's from its begin to its submission: it begins
|
||||
// it, makes every command, ends it after the breadcrumb crumb (kind 0: none) that vk_sync.c writes at the end of a
|
||||
// submission, and submits it. The submitting thread touches the part pool only while the recorder is idle. That is
|
||||
// LAS Recomp's and Savage Wind Recomp's model (runtime/nvn/vulkan/record.h: command buffers allocated once, then only
|
||||
// the recorder begins, records, ends and submits them). Before, the submitting thread began and submitted parts the
|
||||
// recorder recorded and, before that, also ended them. The handoff in rec_drain orders the two threads, so Vulkan
|
||||
// allows that split, but on an RX 6700 XT (driver 26.10.1, issue #5) parts ended by the other thread broke when a
|
||||
// submission was split (vk_sync.c vk_sync_split): the GPU hung or the scene turned green, then white. Moving the end
|
||||
// fixed that; begin and submit followed. TOTK_REC_END=0 brings the old split back: the submitting thread begins,
|
||||
// ends and submits every part.
|
||||
// The line is written only when a part was recorded by the recorder: with the recorder off (the default on AMD) the
|
||||
// switch changes nothing, and reports read an unconditional line as proof that the recorder was running (#315).
|
||||
typedef struct { int kind; uint64_t n; } A_EndCb;
|
||||
int rec_end_cb(VkCommandBuffer cb, int crumb, uint64_t n) {
|
||||
static int mode = -1, said;
|
||||
if (mode < 0) mode = rt_knob("REC_END", "1");
|
||||
static int said;
|
||||
int own = rec_own();
|
||||
if (rec_live && cb == rec_cb && !said) {
|
||||
said = 1;
|
||||
rt_log("vk_rec: a part the recorder records is ended by %s (TOTK_REC_END=%d)",
|
||||
mode ? "the recorder" : "the submitting thread", mode);
|
||||
rt_log("vk_rec: a part the recorder records is begun, ended and submitted by %s (TOTK_REC_END=%d)",
|
||||
own ? "the recorder" : "the submitting thread", own);
|
||||
}
|
||||
if (!rec_live || cb != rec_cb || !mode) {
|
||||
if (!rec_live || cb != rec_cb || !own) {
|
||||
rec_end();
|
||||
if (crumb) vk_crumb(cb, crumb, n);
|
||||
return 0;
|
||||
@@ -206,18 +242,53 @@ int rec_end_cb(VkCommandBuffer cb, int crumb, uint64_t n) {
|
||||
A_EndCb *a = put(R_EndCb, sizeof *a);
|
||||
*a = (A_EndCb){crumb, n};
|
||||
pub();
|
||||
rec_drain();
|
||||
rec_live = 0;
|
||||
sub_pending = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// At most two command buffers and one signal: the shape vk_sync.c submits.
|
||||
typedef struct { uint32_t ncb, nsig; VkCommandBufferSubmitInfo cbi[2]; VkSemaphoreSubmitInfo sig; } A_Submit;
|
||||
VkResult rec_submit(const VkSubmitInfo2 *si) {
|
||||
if (!sub_pending) {
|
||||
vk_queue_lock();
|
||||
VkResult r = vkQueueSubmit2(vk_ctx()->gfx_queue, 1, si, VK_NULL_HANDLE);
|
||||
vk_queue_unlock();
|
||||
return r;
|
||||
}
|
||||
sub_pending = 0;
|
||||
if (si->commandBufferInfoCount > 2 || si->signalSemaphoreInfoCount > 1 || si->waitSemaphoreInfoCount || si->pNext)
|
||||
rt_fatal("vk_rec: a submission of %u command buffers, %u waits and %u signals the recorder cannot carry",
|
||||
si->commandBufferInfoCount, si->waitSemaphoreInfoCount, si->signalSemaphoreInfoCount);
|
||||
A_Submit *a = put(R_Submit, sizeof *a);
|
||||
memset(a, 0, sizeof *a);
|
||||
a->ncb = si->commandBufferInfoCount, a->nsig = si->signalSemaphoreInfoCount;
|
||||
for (uint32_t i = 0; i < a->ncb; i++) a->cbi[i] = si->pCommandBufferInfos[i];
|
||||
if (a->nsig) a->sig = si->pSignalSemaphoreInfos[0];
|
||||
pub();
|
||||
// Waited for here, so the queue holds every earlier submission when the caller goes on, as with the recorder off:
|
||||
// the present, uploads, readbacks and device waits on other threads rely on that order.
|
||||
rec_drain();
|
||||
RS_.submits++;
|
||||
return r_sub_res;
|
||||
}
|
||||
|
||||
static void submit_run(const A_Submit *a) {
|
||||
VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .commandBufferInfoCount = a->ncb,
|
||||
.pCommandBufferInfos = a->cbi, .signalSemaphoreInfoCount = a->nsig,
|
||||
.pSignalSemaphoreInfos = a->nsig ? &a->sig : NULL};
|
||||
vk_queue_lock();
|
||||
r_sub_res = vkQueueSubmit2(vk_ctx()->gfx_queue, 1, &si, VK_NULL_HANDLE);
|
||||
vk_queue_unlock();
|
||||
}
|
||||
|
||||
void rec_stats_log(void) {
|
||||
if (!(rt_trace & RT_TRACE_PERF) || !RS_.parts) return;
|
||||
rt_log("vk_rec: %llu of %llu parts recorded by the recorder: %llu packets (%.1f MiB), %llu drains (%llu for a call "
|
||||
"without a packet) waited %.2f ms in all, ring full %llu times",
|
||||
"without a packet) waited %.2f ms in all, ring full %llu times, %llu submissions made by the recorder",
|
||||
(unsigned long long)RS_.parts_on, (unsigned long long)RS_.parts, (unsigned long long)RS_.packets,
|
||||
RS_.words * 8 / 1048576.0, (unsigned long long)RS_.drains, (unsigned long long)RS_.fallbacks,
|
||||
RS_.drain_ns / 1e6, (unsigned long long)RS_.full_waits);
|
||||
RS_.drain_ns / 1e6, (unsigned long long)RS_.full_waits, (unsigned long long)RS_.submits);
|
||||
memset(&RS_, 0, sizeof RS_);
|
||||
}
|
||||
|
||||
@@ -642,7 +713,14 @@ TARGET_CMD(rec_write_mask, R_WriteMask, PFN_vkCmdSetColorWriteMaskEXT, VkColorCo
|
||||
// ---- the recorder's side
|
||||
|
||||
static void exec_packet(uint32_t op, void *p) {
|
||||
VkCommandBuffer cb = rec_cb;
|
||||
if (op == R_BeginCb) {
|
||||
A_BeginCb *a = p;
|
||||
r_cb = a->cb;
|
||||
if (a->begin) begin_now(r_cb, a->crumb, a->n);
|
||||
return;
|
||||
}
|
||||
if (op == R_Submit) { submit_run(p); return; }
|
||||
VkCommandBuffer cb = r_cb;
|
||||
switch (op) {
|
||||
#define F(name, ...) case R_##name: { A_##name *a = p; vkCmd##name(cb, __VA_ARGS__); break; }
|
||||
F(BeginQuery, a->p, a->q, a->f)
|
||||
|
||||
+17
-11
@@ -1,11 +1,12 @@
|
||||
// The recorder thread (vk_rec.c): the Vulkan calls the replay makes into its command buffer are made by a thread of
|
||||
// their own. vk_sync.c brackets each part of a submission with rec_begin (after vkBeginCommandBuffer) and rec_end
|
||||
// (before vkEndCommandBuffer). In between, every vkCmd* on that command buffer copies its arguments into a packet of a
|
||||
// ring, in call order, and the recorder makes the real call in that order; calls into any other command buffer (uploads,
|
||||
// the window, probes) are made at once. A call the ring has no packet for (a structure with a pNext chain) waits for
|
||||
// the recorder to empty the ring and is then made at once on the calling thread. rec_end returns once the recorder made
|
||||
// every call. vk_sync.c ends a part through rec_end_cb: the recorder makes the last calls into a part it recorded,
|
||||
// vkEndCommandBuffer included; submitting and the command pool stay on the submitting thread.
|
||||
// The recorder thread (vk_rec.c): the Vulkan calls the replay makes into its command buffers are made by a thread of
|
||||
// their own. vk_sync.c begins each part of a submission (and the mirror prologue) with rec_begin, ends it with
|
||||
// rec_end_cb and submits it with rec_submit. In between, every vkCmd* on that command buffer copies its arguments
|
||||
// into a packet of a ring, in call order, and the recorder makes the real call in that order; calls into any other
|
||||
// command buffer (uploads, the window, probes) are made at once. A call the ring has no packet for (a structure with a
|
||||
// pNext chain) waits for the recorder to empty the ring and is then made at once on the calling thread. With
|
||||
// TOTK_REC_END=1 (default) the recorder also begins, ends and submits the parts it records, so a part's command buffer
|
||||
// never changes threads; rec_submit returns once the recorder submitted it. The submitting thread allocates from the
|
||||
// part pool only while the recorder is idle (vk_sync.c claim_slot).
|
||||
//
|
||||
// Every vkCmd* the runtime calls through vk.h goes through the rc_* wrappers below (the macros at the end); the
|
||||
// extension commands called through function pointers have rec_* wrappers of their own. TOTK_VK_RECORDER=0 makes every
|
||||
@@ -15,11 +16,16 @@
|
||||
// MIT, Copyright (c) 2026 Peiikai): the driver's work behind the commands depends on nothing the replay decides next.
|
||||
#pragma once
|
||||
|
||||
void rec_begin(VkCommandBuffer cb, uint64_t fence); // the submitting thread, sub_lock held; fence: the part's value
|
||||
// The submitting thread, sub_lock held: vkBeginCommandBuffer (one submission) on cb and the breadcrumb crumb (0: none,
|
||||
// vk_crumbs.c) with number n, made by the recorder when it records the part, else at once; fence: the part's value.
|
||||
void rec_begin(VkCommandBuffer cb, uint64_t fence, int crumb, uint64_t n);
|
||||
void rec_end(void); // waits for the recorder; no-op when rec_begin did not start it
|
||||
// The end of part cb: the breadcrumb crumb (0: none, vk_crumbs.c), then vkEndCommandBuffer, both made by the recorder
|
||||
// when it records cb, and the wait for it (1); otherwise rec_end and the breadcrumb, and the caller ends cb (0).
|
||||
// The end of part cb: the breadcrumb crumb, then vkEndCommandBuffer, both queued for the recorder when it records cb
|
||||
// (1: rec_submit hands the part over); otherwise rec_end and the breadcrumb, and the caller ends cb (0).
|
||||
int rec_end_cb(VkCommandBuffer cb, int crumb, uint64_t n);
|
||||
// vkQueueSubmit2 of si (at most two command buffers, one signal, no wait, no fence) under vk_queue_lock: by the
|
||||
// recorder after a part it ended, waited for, else at once.
|
||||
VkResult rec_submit(const VkSubmitInfo2 *si);
|
||||
void rec_drain(void); // waits until the recorder made every call queued so far
|
||||
void rec_stats_log(void); // TOTK_TRACE=perf: packets, bytes, drains and waits since the last call
|
||||
// TOTK_REC_CHECK=1 (debug, recorder on): vk_memory.c reports each object it defers (destroy 0, stamped tl) or destroys
|
||||
|
||||
+7
-20
@@ -328,6 +328,7 @@ static int claim_slot(VkCtx *c, uint64_t fence) {
|
||||
slots[i].fence = fence;
|
||||
return i;
|
||||
}
|
||||
rec_drain(); // the part pool is the recorder's while it has packets (vk_rec.h): it is idle for the allocation
|
||||
CmdSlot *n = realloc(slots, sizeof *n * (size_t)(nslots + 1));
|
||||
if (!n) rt_fatal("vk: out of memory (command buffers)");
|
||||
slots = n;
|
||||
@@ -353,13 +354,11 @@ static VkCommandBuffer prologue(VkCtx *c, uint64_t fence) {
|
||||
if (!vk_mem_mirror_pending()) return VK_NULL_HANDLE;
|
||||
int i = claim_slot(c, fence); // before reading slots: the claim may move it
|
||||
VkCommandBuffer cb = slots[i].cb;
|
||||
VkCommandBufferBeginInfo bi = {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
||||
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
|
||||
vkBeginCommandBuffer(cb, &bi);
|
||||
rec_begin(cb, fence, 0, 0); // a command buffer of the part pool: the recorder's like the parts
|
||||
int pair = ts_open(cb);
|
||||
vk_mem_mirror_prologue(cb);
|
||||
ts_close(cb, pair, fence);
|
||||
vkEndCommandBuffer(cb);
|
||||
if (!rec_end_cb(cb, 0, 0)) vkEndCommandBuffer(cb);
|
||||
return cb;
|
||||
}
|
||||
|
||||
@@ -375,21 +374,15 @@ VkCommandBuffer vk_sync_split(void) {
|
||||
VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .commandBufferInfoCount = pro ? 2 : 1,
|
||||
.pCommandBufferInfos = pro ? cbi : cbi + 1};
|
||||
ts_submitted();
|
||||
vk_queue_lock();
|
||||
VkResult r = vkQueueSubmit2(c->gfx_queue, 1, &si, VK_NULL_HANDLE);
|
||||
vk_queue_unlock();
|
||||
VkResult r = rec_submit(&si); // by the recorder when it recorded the part
|
||||
if (r != VK_SUCCESS) {
|
||||
vk_device_fault_report(r);
|
||||
rt_fatal("vk: vkQueueSubmit2 of a part of value %llu failed (%d)", (unsigned long long)cur_fence, (int)r);
|
||||
}
|
||||
vk_mem_note_submit(cur_fence); // objects destroyed from here on may be in use by the part just submitted
|
||||
CmdSlot *s = take_slot(c, cur_fence); // the submitted part keeps its slot until the value is reached
|
||||
VkCommandBufferBeginInfo bi = {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
||||
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
|
||||
vkBeginCommandBuffer(s->cb, &bi);
|
||||
vk_crumb(s->cb, VK_CRUMB_SUBMIT, cur_fence);
|
||||
rec_begin(s->cb, cur_fence, VK_CRUMB_SUBMIT, cur_fence);
|
||||
ts_begin(s->cb);
|
||||
rec_begin(s->cb, cur_fence);
|
||||
return s->cb;
|
||||
}
|
||||
|
||||
@@ -412,13 +405,9 @@ uint64_t vk_sync_submit(const uint64_t *handles, int n) {
|
||||
uint64_t fence = __atomic_load_n(&issued, __ATOMIC_ACQUIRE) + 1;
|
||||
cur_fence = fence;
|
||||
CmdSlot *s = take_slot(c, fence);
|
||||
VkCommandBufferBeginInfo bi = {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
||||
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
|
||||
uint64_t t0 = perf_begin();
|
||||
vkBeginCommandBuffer(s->cb, &bi);
|
||||
vk_crumb(s->cb, VK_CRUMB_SUBMIT, fence);
|
||||
rec_begin(s->cb, fence, VK_CRUMB_SUBMIT, fence); // begun by the recorder when it records the part
|
||||
ts_begin(s->cb);
|
||||
rec_begin(s->cb, fence);
|
||||
int recorded = vk_exec_record(s->cb, handles, n, fence);
|
||||
s = &slots[cur_slot]; // the last part (vk_sync_split)
|
||||
if (recorded) ts_end(s->cb, fence);
|
||||
@@ -439,9 +428,7 @@ uint64_t vk_sync_submit(const uint64_t *handles, int n) {
|
||||
.pCommandBufferInfos = pro ? cbi : cbi + 1, .signalSemaphoreInfoCount = 1,
|
||||
.pSignalSemaphoreInfos = &sig};
|
||||
ts_submitted();
|
||||
vk_queue_lock();
|
||||
VkResult r = vkQueueSubmit2(c->gfx_queue, 1, &si, VK_NULL_HANDLE);
|
||||
vk_queue_unlock();
|
||||
VkResult r = rec_submit(&si); // by the recorder when it recorded the part
|
||||
if (r != VK_SUCCESS) {
|
||||
vk_device_fault_report(r);
|
||||
rt_fatal("vk: vkQueueSubmit2 of value %llu failed (%d)", (unsigned long long)fence, (int)r);
|
||||
|
||||
+254
-13
@@ -61,6 +61,10 @@ typedef struct Tex {
|
||||
uint8_t *snap; // a texture that fills no page: its storage bytes when the GPU write was recorded
|
||||
uint32_t wt_n; // WriteTexels into the storage since the last upload
|
||||
struct Tex *rel_prev, *rel_next; // while released: the list of released entries, oldest first
|
||||
uint64_t rel_ms; // while released: when (coarse_ms)
|
||||
uint64_t use_seq; // order of the last creation or take-back among all entries
|
||||
uint64_t rel_seq; // while released: use_seq of the newest entry placed before this release; an entry
|
||||
// with a later use_seq on overlapping storage replaced this one's bytes
|
||||
} Tex;
|
||||
|
||||
// A slot keeps what vk_texture_by_id resolved for it, so a draw binding skips the key lookup and the address chain: the
|
||||
@@ -157,6 +161,17 @@ static void make_key(const tex_t *t, TexKey *k) {
|
||||
}
|
||||
|
||||
// Keys equal apart from the descriptor's swizzle selectors: the same storage, format and geometry.
|
||||
// The colour format without its sRGB decode: a target and its sRGB view share one texel layout (slot_resolve).
|
||||
static int linear_format(int f) {
|
||||
switch (f) {
|
||||
case NVN_FORMAT_RGBA8_SRGB: return NVN_FORMAT_RGBA8;
|
||||
case NVN_FORMAT_RGBX8_SRGB: return NVN_FORMAT_RGBX8;
|
||||
case NVN_FORMAT_BGRA8_SRGB: return NVN_FORMAT_BGRA8;
|
||||
case NVN_FORMAT_BGRX8_SRGB: return NVN_FORMAT_BGRX8;
|
||||
default: return f;
|
||||
}
|
||||
}
|
||||
|
||||
static int same_but_swizzle(const TexKey *a, const TexKey *b) {
|
||||
TexKey x = *a, y = *b;
|
||||
x.d.swizzle_r = x.d.swizzle_g = x.d.swizzle_b = x.d.swizzle_a = 0;
|
||||
@@ -529,6 +544,46 @@ static void rel_unlink(Tex *e) {
|
||||
e->rel_prev = e->rel_next = NULL;
|
||||
}
|
||||
|
||||
// A clock read per submit, for stamps on paths that run many times a frame.
|
||||
static uint64_t coarse_ms;
|
||||
static uint64_t use_counter;
|
||||
|
||||
// How long released entries wait until the game takes them back, split into those holding GPU-written content and the
|
||||
// others (TOTK_TRACE=perf, vk_texture_released_log): where transient textures end and the tail that can go begins.
|
||||
enum { AGE_1S, AGE_5S, AGE_30S, AGE_120S, AGE_LONG, AGE_N };
|
||||
static const char *const age_name[AGE_N] = {"<1s", "<5s", "<30s", "<120s", ">=120s"};
|
||||
static uint64_t takeback_n[2][AGE_N];
|
||||
static int age_bucket(uint64_t ms) {
|
||||
return ms < 1000 ? AGE_1S : ms < 5000 ? AGE_5S : ms < 30000 ? AGE_30S : ms < 120000 ? AGE_120S : AGE_LONG;
|
||||
}
|
||||
|
||||
// Keys of entries the pressure path dropped, to count the ones the game asks for again soon after: a drop that buys
|
||||
// nothing and, for GPU-written content, loses it. Direct-mapped, a lost record only undercounts.
|
||||
#define DROPPED_SLOTS 4096u
|
||||
static struct { uint64_t hash, ms; } dropped[DROPPED_SLOTS];
|
||||
static uint64_t n_recreated[2], n_recreated_written[2]; // index: within 10 s, later
|
||||
static uint64_t key_hash(const TexKey *k) {
|
||||
uint64_t h = 0xcbf29ce484222325ull;
|
||||
const uint8_t *b = (const uint8_t *)k;
|
||||
for (size_t i = 0; i < sizeof *k; i++) h = (h ^ b[i]) * 0x100000001b3ull;
|
||||
return h | 1;
|
||||
}
|
||||
static void dropped_note(const Tex *e) {
|
||||
uint64_t h = key_hash(&e->key);
|
||||
dropped[h >> 3 & (DROPPED_SLOTS - 1)].hash = h ^ (uint64_t)(e->pub.gpu_owned != 0) << 1;
|
||||
dropped[h >> 3 & (DROPPED_SLOTS - 1)].ms = coarse_ms;
|
||||
}
|
||||
static void dropped_check(const TexKey *k) {
|
||||
uint64_t h = key_hash(k);
|
||||
unsigned i = h >> 3 & (DROPPED_SLOTS - 1);
|
||||
uint64_t was = dropped[i].hash;
|
||||
if (!was || (was & ~2ull) != (h & ~2ull)) return;
|
||||
int later = coarse_ms - dropped[i].ms >= 10000;
|
||||
n_recreated[later]++;
|
||||
if (was != h) n_recreated_written[later]++;
|
||||
dropped[i].hash = 0;
|
||||
}
|
||||
|
||||
static void destroy_tex(Tex *e) {
|
||||
own_remove(e);
|
||||
tex_gen_bump(e->key.addr);
|
||||
@@ -558,15 +613,112 @@ static void sweep_released(void) {
|
||||
while (nreleased > RELEASED_MAX && rel_head) destroy_tex(rel_head);
|
||||
}
|
||||
|
||||
// TOTK_TEX_VRAM_PRESSURE (percent of the device-local budget, default 90; 0 = off): above it, each submit drops up to
|
||||
// PRESSURE_STEP of the oldest released entries, so a 4 GiB card does not keep RELEASED_MAX released images (each ASTC
|
||||
// one decoded to RGBA8) while the heap spills into system memory. A few per submit, for the reason above. Only entries
|
||||
// that come back intact are dropped: mirrored ones the GPU never wrote, re-uploaded from their storage. A render target
|
||||
// lives only in its image; dropping it brought the texture back empty (black flashes in a Depths boss fight, ~170
|
||||
// TOTK_TEX_VRAM_PRESSURE (percent of the device-local budget, default 90; 0 = off): above it, each budget query drops up
|
||||
// to PRESSURE_STEP released entries, oldest first, until the use is back under the line; a few at a time, for the reason
|
||||
// above. Two kinds come back without loss:
|
||||
//
|
||||
// Overwritten: the game placed another texture on the entry's storage after releasing it, so on the Switch its bytes are
|
||||
// gone too, and it has waited DEAD_AGE_MS. Transient render targets are taken back within a second or two (a stand-still
|
||||
// field window: about 19000 take-backs under 1 s, 2 later than that, none after 30 s), while their leftovers at
|
||||
// addresses the game's allocator moved on from stay released for good: 1.9 GiB of 2.0 GiB, nearly all of it render targets
|
||||
// no storage can refill. Not bound through a finalized slot for DEAD_QUIET_SUBMITS either: such a slot still samples the
|
||||
// entry (slot_resolve).
|
||||
//
|
||||
// Clean: mirrored ones the GPU never wrote, re-uploaded from their storage, at the cost of the upload, so after
|
||||
// CLEAN_AGE_MS: without the wait a fight re-created about 500 of them per 10 s. Any other render target lives only in its
|
||||
// image: dropping one that was merely old brought the texture back empty (black flashes in a Depths boss fight, ~170
|
||||
// "left uninitialised" aliases a minute).
|
||||
#define PRESSURE_STEP 32
|
||||
#define CLEAN_AGE_MS 5000u
|
||||
#define DEAD_AGE_MS 30000u
|
||||
#define DEAD_QUIET_SUBMITS 600u
|
||||
#define DEAD_RETRY_QUERIES 8 // budget queries to skip after a search that found nothing
|
||||
static int vram_pressure = -1;
|
||||
static uint64_t n_pressure_drops;
|
||||
static uint64_t n_pressure_drops, n_pressure_overwritten;
|
||||
|
||||
static int tex_by_addr(const void *a, const void *b) {
|
||||
const Tex *x = *(Tex *const *)a, *y = *(Tex *const *)b;
|
||||
return x->pub.addr < y->pub.addr ? -1 : x->pub.addr > y->pub.addr;
|
||||
}
|
||||
|
||||
// All entries sorted by storage address, with the highest storage end up to each one: the input of storage_taken.
|
||||
typedef struct { Tex **e; uint64_t *end; int n; } AddrIndex;
|
||||
|
||||
static int addr_index(AddrIndex *x) {
|
||||
x->n = 0;
|
||||
x->e = malloc(sizeof *x->e * (size_t)(by_key.n + 1));
|
||||
x->end = malloc(sizeof *x->end * (size_t)(by_key.n + 1));
|
||||
if (!x->e || !x->end) { free(x->e), free(x->end); return 0; }
|
||||
for (uint32_t i = 0; i < by_key.cap; i++)
|
||||
if (by_key.vals[i]) x->e[x->n++] = by_key.vals[i];
|
||||
qsort(x->e, (size_t)x->n, sizeof *x->e, tex_by_addr);
|
||||
uint64_t top = 0;
|
||||
for (int i = 0; i < x->n; i++) {
|
||||
uint64_t end = x->e[i]->pub.addr + x->e[i]->t.L.size;
|
||||
x->end[i] = top = end > top ? end : top;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void addr_index_free(AddrIndex *x) { free(x->e), free(x->end); }
|
||||
|
||||
// A texture placed after the release of x->e[i] overlaps its storage.
|
||||
static int storage_taken(const AddrIndex *x, int i) {
|
||||
const Tex *e = x->e[i];
|
||||
for (int j = i; --j >= 0 && x->end[j] > e->pub.addr;)
|
||||
if (x->e[j]->pub.addr + x->e[j]->t.L.size > e->pub.addr && x->e[j]->use_seq > e->rel_seq) return 1;
|
||||
for (int j = i; ++j < x->n && x->e[j]->pub.addr < e->pub.addr + e->t.L.size;)
|
||||
if (x->e[j]->use_seq > e->rel_seq) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint64_t own_bytes(const Tex *e) {
|
||||
VkCtx *c = vk_ctx();
|
||||
if (!e->alloc || !c) return 0;
|
||||
VmaAllocationInfo ai;
|
||||
vmaGetAllocationInfo(c->vma, e->alloc, &ai);
|
||||
return ai.size;
|
||||
}
|
||||
|
||||
static int dead_candidate(const Tex *e) {
|
||||
return e->alloc && (!e->checked || submit_epoch - e->checked >= DEAD_QUIET_SUBMITS);
|
||||
}
|
||||
|
||||
// Drops overwritten entries until `need` bytes are free or the step is used up. The sort runs only under pressure, while
|
||||
// an old enough entry exists, and rests for a while when it finds nothing to drop. Returns the bytes freed.
|
||||
static uint64_t pressure_search_ns; // longest search since the last mem: released line
|
||||
static uint64_t drop_overwritten(uint64_t need, int *dropped) {
|
||||
static int rest;
|
||||
if (rest > 0) { rest--; return 0; }
|
||||
if (!rel_head || coarse_ms - rel_head->rel_ms < DEAD_AGE_MS) return 0;
|
||||
uint64_t t0 = plat_now_ns(), freed = 0;
|
||||
AddrIndex x;
|
||||
if (!addr_index(&x)) return 0;
|
||||
Tex *cand[PRESSURE_STEP];
|
||||
int nc = 0;
|
||||
for (Tex *e = rel_head; e && nc < PRESSURE_STEP && coarse_ms - e->rel_ms >= DEAD_AGE_MS; e = e->rel_next) {
|
||||
if (!dead_candidate(e)) continue;
|
||||
int lo = 0, hi = x.n; // the first entry at e's address, then e among those
|
||||
while (lo < hi) {
|
||||
int m = (lo + hi) / 2;
|
||||
if (x.e[m]->pub.addr < e->pub.addr) lo = m + 1;
|
||||
else hi = m;
|
||||
}
|
||||
while (lo < x.n && x.e[lo] != e) lo++;
|
||||
if (lo < x.n && storage_taken(&x, lo)) cand[nc++] = e;
|
||||
}
|
||||
addr_index_free(&x);
|
||||
for (int i = 0; i < nc && freed < need; i++) {
|
||||
freed += own_bytes(cand[i]);
|
||||
dropped_note(cand[i]);
|
||||
destroy_tex(cand[i]);
|
||||
(*dropped)++, n_pressure_drops++, n_pressure_overwritten++;
|
||||
}
|
||||
if (!nc) rest = DEAD_RETRY_QUERIES;
|
||||
uint64_t ns = plat_now_ns() - t0;
|
||||
if (ns > pressure_search_ns) pressure_search_ns = ns;
|
||||
return freed;
|
||||
}
|
||||
|
||||
static void sweep_pressure(void) { // tex_lock held
|
||||
if (vram_pressure < 0) {
|
||||
@@ -578,11 +730,16 @@ static void sweep_pressure(void) { // tex_lock held
|
||||
if (!vram_pressure || !rel_head || submit_epoch & 7) return; // the budget query every 8 submits
|
||||
uint64_t used, budget;
|
||||
int exact;
|
||||
if (!vk_mem_vram(&used, &budget, &exact) || used <= budget / 100 * (uint64_t)vram_pressure) return;
|
||||
if (!vk_mem_vram(&used, &budget, &exact)) return;
|
||||
uint64_t line = budget / 100 * (uint64_t)vram_pressure;
|
||||
if (used <= line) return;
|
||||
int dropped = 0;
|
||||
for (Tex *e = rel_head, *next; e && dropped < PRESSURE_STEP; e = next) {
|
||||
uint64_t need = used - line, freed = drop_overwritten(need, &dropped);
|
||||
for (Tex *e = rel_head, *next; e && freed < need && dropped < PRESSURE_STEP && coarse_ms - e->rel_ms >= CLEAN_AGE_MS; e = next) {
|
||||
next = e->rel_next;
|
||||
if (!e->pub.mirrored || e->pub.gpu_owned || e->gpu_dirty) continue;
|
||||
freed += own_bytes(e);
|
||||
dropped_note(e);
|
||||
destroy_tex(e);
|
||||
dropped++, n_pressure_drops++;
|
||||
}
|
||||
@@ -936,6 +1093,8 @@ static Tex *entry_of(const tex_t *t) {
|
||||
}
|
||||
if (!(e = create_tex(t, &k, tex_alias))) return NULL;
|
||||
perf_count(PERF_CNT_TEX_NEW);
|
||||
dropped_check(&k);
|
||||
e->use_seq = ++use_counter;
|
||||
// released entries of another descriptor at this address are replaced by the new one; a live one holding
|
||||
// GPU-written content is the alias source, preferring the one that differs only in swizzle (same_but_swizzle)
|
||||
int alias = 0;
|
||||
@@ -971,7 +1130,11 @@ static Tex *entry_of(const tex_t *t) {
|
||||
nvn_hm_put(&by_key, &k, e);
|
||||
tex_gen_bump(k.addr);
|
||||
}
|
||||
if (e->released) e->released = 0, nreleased--, rel_unlink(e), tex_gen_bump(k.addr);
|
||||
if (e->released) {
|
||||
takeback_n[e->pub.gpu_owned != 0][age_bucket(coarse_ms - e->rel_ms)]++;
|
||||
e->use_seq = ++use_counter;
|
||||
e->released = 0, nreleased--, rel_unlink(e), tex_gen_bump(k.addr);
|
||||
}
|
||||
e->t = *t;
|
||||
return e;
|
||||
}
|
||||
@@ -1062,6 +1225,8 @@ void vk_texture_release(const tex_t *t) {
|
||||
Tex *e = nvn_hm_get(&by_key, &k);
|
||||
if (e && !e->released) {
|
||||
e->released = 1;
|
||||
e->rel_ms = coarse_ms;
|
||||
e->rel_seq = use_counter;
|
||||
nreleased++;
|
||||
rel_append(e);
|
||||
tex_gen_bump(k.addr);
|
||||
@@ -1125,10 +1290,16 @@ static Tex *slot_resolve(TexSlot *s, view_t *view, int *has_view) {
|
||||
// Prefer the live entry that differs from the slot descriptor only in its swizzle: transient render targets
|
||||
// share storage, and the newest one at the address is usually another size. The map screen samples its
|
||||
// 2250x1080 map target through an (R,G,B,1) descriptor and followed a 960x60 target at the same address.
|
||||
// Only an entry of the slot's texel format follows (sRGB aside): Maxwell reads the storage through the slot
|
||||
// descriptor's format, and an entry of another format holds another texture's texels. The quick menu samples
|
||||
// its 768x432 RGB10A2 scene capture through a slot whose entry was released; after a fuse the Autobuild
|
||||
// thumbnail of the fused object, RGBA8 at the same storage, was the live entry, and the menu drew it behind
|
||||
// the wheel (the object's silhouette, or garbled colours). Without such an entry the released one keeps the
|
||||
// slot: its image holds what was last written through that descriptor.
|
||||
Tex *own = e, *any = NULL;
|
||||
e = NULL;
|
||||
for (Tex *p = nvn_hm_get(&by_addr, &k.addr); p; p = p->next_at) {
|
||||
if (p->released) continue;
|
||||
if (p->released || linear_format(p->key.d.format) != linear_format(k.d.format)) continue;
|
||||
if (!any) any = p;
|
||||
if (same_but_swizzle(&p->key, &k)) { e = p; break; }
|
||||
}
|
||||
@@ -1219,6 +1390,7 @@ uint32_t vk_texture_epoch(void) { return __atomic_load_n(&submit_epoch, __ATOMIC
|
||||
void vk_texture_new_submit(void) {
|
||||
lock();
|
||||
if (!++submit_epoch) submit_epoch = 1;
|
||||
coarse_ms = plat_now_ms();
|
||||
sweep_pressure();
|
||||
static uint64_t log_at;
|
||||
uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED) / 60;
|
||||
@@ -1238,9 +1410,10 @@ void vk_texture_new_submit(void) {
|
||||
(unsigned long long)f * 60, (unsigned long long)ck, (unsigned long long)n_checks, (unsigned long long)calls,
|
||||
(unsigned long long)untr);
|
||||
n_checks = 0;
|
||||
rt_log("perf: frame %llu: released textures kept %d, dropped under VRAM pressure %llu", (unsigned long long)f * 60,
|
||||
nreleased, (unsigned long long)n_pressure_drops);
|
||||
n_pressure_drops = 0;
|
||||
rt_log("perf: frame %llu: released textures kept %d, dropped under VRAM pressure %llu (%llu overwritten)",
|
||||
(unsigned long long)f * 60, nreleased, (unsigned long long)n_pressure_drops,
|
||||
(unsigned long long)n_pressure_overwritten);
|
||||
n_pressure_drops = n_pressure_overwritten = 0;
|
||||
}
|
||||
unlock();
|
||||
}
|
||||
@@ -1946,6 +2119,74 @@ void vk_texture_census(VkTexCensus *s) {
|
||||
unlock();
|
||||
}
|
||||
|
||||
// TOTK_TRACE=perf, with mem: vram: what the released entries in own memory hold and how long they waited.
|
||||
void vk_texture_released_log(uint64_t frame) {
|
||||
VkCtx *c = vk_ctx();
|
||||
if (!c) return;
|
||||
enum { CL_CLEAN, CL_BACKED, CL_DIRTY, CL_POOLS, CL_N };
|
||||
uint64_t cl_n[CL_N] = {0}, cl_b[CL_N] = {0}, age_b[AGE_N] = {0}, dead_n = 0, dead_b = 0, dead_dirty_b = 0;
|
||||
uint64_t bound_n = 0, bound_b = 0, ded_n = 0, ded_b = 0;
|
||||
typedef struct { uint32_t w, h, fmt, n; uint64_t b; } Group;
|
||||
Group gr[256];
|
||||
int ng = 0;
|
||||
lock();
|
||||
AddrIndex x = {0};
|
||||
int indexed = addr_index(&x);
|
||||
for (int i = 0; indexed && i < x.n; i++) {
|
||||
Tex *e = x.e[i];
|
||||
if (!e->released || !e->alloc) continue;
|
||||
VmaAllocationInfo2 ai2;
|
||||
vmaGetAllocationInfo2(c->vma, e->alloc, &ai2);
|
||||
const VmaAllocationInfo ai = ai2.allocationInfo;
|
||||
if (ai2.dedicatedMemory) ded_n++, ded_b += ai.size;
|
||||
int cl = !e->pub.mirrored ? CL_POOLS : e->gpu_dirty ? CL_DIRTY : e->pub.gpu_owned ? CL_BACKED : CL_CLEAN;
|
||||
cl_n[cl]++, cl_b[cl] += ai.size;
|
||||
if (cl != CL_CLEAN) age_b[age_bucket(coarse_ms - e->rel_ms)] += ai.size;
|
||||
if (e->checked && submit_epoch - e->checked < 600) bound_n++, bound_b += ai.size;
|
||||
if (storage_taken(&x, i)) dead_n++, dead_b += ai.size, dead_dirty_b += cl != CL_CLEAN ? ai.size : 0;
|
||||
int g = 0;
|
||||
while (g < ng && (gr[g].w != e->t.d.width || gr[g].h != e->t.d.height || gr[g].fmt != (uint32_t)e->t.d.format)) g++;
|
||||
if (g == ng && ng < 256) gr[ng++] = (Group){e->t.d.width, e->t.d.height, (uint32_t)e->t.d.format, 0, 0};
|
||||
if (g < ng) gr[g].n++, gr[g].b += ai.size;
|
||||
}
|
||||
if (indexed) addr_index_free(&x);
|
||||
const double M = 1048576.0;
|
||||
rt_log("mem: released frame %llu: own memory: clean %llu %.0f MiB, GPU-written with storage current %llu %.0f MiB, "
|
||||
"GPU-written image only %llu %.0f MiB, not mirrored %llu %.0f MiB; all but clean by age <1s %.0f <5s %.0f <30s %.0f "
|
||||
"<120s %.0f older %.0f MiB; storage taken by a later texture %llu %.0f MiB (%.0f not clean); bound through a slot "
|
||||
"in the last 600 submits %llu %.0f MiB; in dedicated memory, returned to the driver when dropped, %llu %.0f MiB; "
|
||||
"longest search %.2f ms",
|
||||
(unsigned long long)frame, (unsigned long long)cl_n[CL_CLEAN], cl_b[CL_CLEAN] / M, (unsigned long long)cl_n[CL_BACKED],
|
||||
cl_b[CL_BACKED] / M, (unsigned long long)cl_n[CL_DIRTY], cl_b[CL_DIRTY] / M, (unsigned long long)cl_n[CL_POOLS],
|
||||
cl_b[CL_POOLS] / M, age_b[AGE_1S] / M, age_b[AGE_5S] / M, age_b[AGE_30S] / M, age_b[AGE_120S] / M,
|
||||
age_b[AGE_LONG] / M, (unsigned long long)dead_n, dead_b / M, dead_dirty_b / M, (unsigned long long)bound_n,
|
||||
bound_b / M, (unsigned long long)ded_n, ded_b / M, pressure_search_ns / 1e6);
|
||||
pressure_search_ns = 0;
|
||||
for (int k = 0; k < 2; k++) {
|
||||
char line[256];
|
||||
size_t o = 0;
|
||||
for (int a = 0; a < AGE_N; a++) {
|
||||
o += (size_t)snprintf(line + o, sizeof line - o, " %s %llu", age_name[a], (unsigned long long)takeback_n[k][a]);
|
||||
takeback_n[k][a] = 0;
|
||||
}
|
||||
rt_log("mem: released frame %llu: taken back after,%s:%s", (unsigned long long)frame, k ? " GPU-written" : " others", line);
|
||||
}
|
||||
rt_log("mem: released frame %llu: dropped under pressure and created again: within 10 s %llu (%llu GPU-written), later %llu (%llu)",
|
||||
(unsigned long long)frame, (unsigned long long)n_recreated[0], (unsigned long long)n_recreated_written[0],
|
||||
(unsigned long long)n_recreated[1], (unsigned long long)n_recreated_written[1]);
|
||||
n_recreated[0] = n_recreated[1] = n_recreated_written[0] = n_recreated_written[1] = 0;
|
||||
for (int top = 0; top < 4; top++) {
|
||||
int best = -1;
|
||||
for (int g = 0; g < ng; g++)
|
||||
if (gr[g].n && (best < 0 || gr[g].b > gr[best].b)) best = g;
|
||||
if (best < 0) break;
|
||||
rt_log("mem: released frame %llu: largest %d: %ux%u fmt %#x: %u entries %.0f MiB", (unsigned long long)frame, top + 1,
|
||||
gr[best].w, gr[best].h, gr[best].fmt, gr[best].n, gr[best].b / M);
|
||||
gr[best].n = 0;
|
||||
}
|
||||
unlock();
|
||||
}
|
||||
|
||||
void vk_texture_shutdown(void) {
|
||||
VkCtx *c = vk_ctx();
|
||||
lock();
|
||||
|
||||
Reference in new issue
Block a user