mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
What was merged from NX2navi (DLSS frame generation, AMD FSR 4 in Setup builds, texture detail by video memory, sprint, volume, frame caps, safer saves, the above-60 fixes), the ultrawide HUD at the screen edges, camera speed, movies without the AV1 Video Extension, the 5120x2880 + RenoDX HDR start fix, the renderer work of 11-14 and the first float changes of the lift.
849 lines
51 KiB
Python
849 lines
51 KiB
Python
"""Changes to the lifted C for Ocarina of Time, applied by lift.py after it writes the code (and by hand: python -I nx2/oot_patches.py).
|
|
|
|
Each is a runtime switch where it can be, so the game's own path stays reachable.
|
|
|
|
- Dynamic resolution (Lichii's built-in "Max Resolution" patch, main+0x805BD0): the engine's config flag at +0x94 picks the path that
|
|
follows the GPU-time controller; with hos_fixed_resolution set it takes the other path, the 3D at full scale. The controller made
|
|
a new set of render targets at each size, ~11 images a frame at times, and held the GPU near its budget.
|
|
- Text speed (the Insert menu's "Text speed"): f_80b1e140 (main+0xafe140) steps a text pane's letter animation, the
|
|
LetterAnimControl of the panes with "LetterAnimOn" user data (dialogue, Navi, signs). Its time argument (s0) moves the
|
|
letters' clock (+0x60 += rate +0x4c * time, the rate from the message's speed tag) and the pauses' timer (+0x58 -= time);
|
|
hos_text_scale multiplies it, 1.0 as shipped. The auto-advance timer (+0x5c, before) keeps the game's time. A huge
|
|
scale shows a page at once (one frame per pause), as the game's own skip on A (+0x72 = 2, f_80794b00) without its flags.
|
|
- The fixed path's scale (hos_fixed_scale_bits: the Insert menu's Resolution) reaching the 3D, in the caller f_831f3200
|
|
(main+0x31d3200). It recomputes the 3D's scale (+0xe5c = scale * +0xe58 / +0xe50) only while +0xe2c bit 3 is set. The dynamic
|
|
path sets it on a level change; the fixed path's flag 1 calls f_831f41d0, whose bit 3 the apply block clears in the same frame,
|
|
before any recompute. So the fixed path kept the dynamic path's last scale (0.75 docked: 1536x864 at every setting). Flag 1 now
|
|
also asks for the recompute, and on the fixed path the flags +0xe20 bits 3/4 (a hardcoded 0.75 / 0.5 in place of the scale)
|
|
are not looked at.
|
|
"""
|
|
import glob
|
|
import os
|
|
import sys
|
|
import whole_write # (rewrites written beside and moved over: issue 1197)
|
|
|
|
DECL = "extern volatile int hos_fixed_resolution;\nextern volatile int hos_dynres_runs;\nextern volatile uint32_t hos_fixed_scale_bits;\n"
|
|
OLD = "if (!((c->x[8] >> 0) & 1)) { goto L_8082640c; }"
|
|
NEW = "if (hos_fixed_resolution || !((c->x[8] >> 0) & 1)) { goto L_8082640c; }\n hos_dynres_runs++;"
|
|
LABEL = "L_8082640c:;"
|
|
SCALE_OLD = "c->x[9] = 0x3f800000ULL;"
|
|
SCALE_NEW = "c->x[9] = hos_fixed_scale_bits;" # (the fixed path's scale, 1.0 as shipped)
|
|
DECL2 = "extern volatile int hos_fixed_resolution;\nextern volatile uint64_t hos_res_module;\nextern volatile uint32_t hos_fixed_scale_bits;\n"
|
|
APPLY_OLD = "L_831f3efc:;\n c->x[9]=recomp_load32(c,c->x[20] + 3628);"
|
|
APPLY_NEW = "L_831f3efc:;\n if (hos_fixed_resolution) { /* (only while +0xe5c is not the chosen scale: a recompute every frame remade the targets) */\n union { uint32_t u; float f; } now = {(uint32_t)recomp_load32(c,c->x[20] + 3676)}, want = {hos_fixed_scale_bits},\n e50 = {(uint32_t)recomp_load32(c,c->x[20] + 3664)}, e58 = {(uint32_t)recomp_load32(c,c->x[20] + 3672)};\n const float d = now.f - (e50.f != 0 ? want.f * e58.f / e50.f : want.f);\n if (d > 1e-4f || d < -1e-4f) c->x[8] |= 8;\n }\n c->x[9]=recomp_load32(c,c->x[20] + 3628);"
|
|
FLAGS_OLD = "L_831f3f08:;\n c->x[8]=recomp_load64(c,c->x[20] + 3616);\n"
|
|
FLAGS_NEW = FLAGS_OLD + " hos_res_module = c->x[20];\n if (hos_fixed_resolution) c->x[8] &= ~0x18ULL;\n"
|
|
|
|
|
|
def fixed_scale(t):
|
|
"""The fixed path's scale reaching the 3D (the Resolution row). (t, 1) when applied here"""
|
|
if APPLY_OLD not in t or FLAGS_OLD not in t:
|
|
return t, 0
|
|
t = t.replace(APPLY_OLD, APPLY_NEW, 1).replace(FLAGS_OLD, FLAGS_NEW, 1)
|
|
return t.replace('#include "a64.h"\n', '#include "a64.h"\n' + DECL2, 1), 1
|
|
|
|
TEXT_DECL = "extern volatile float hos_text_scale;\n"
|
|
LIFE_BUILD_ID = "e0f3ccfaf50065ae4ea01eb5aeb13b1a45da3348"
|
|
LIFE_HEAD = "void f_804bd8c0(Ctx *__restrict A64_NOESC c) {\n"
|
|
MOVE_HEAD = "void f_82c415e0(Ctx *__restrict A64_NOESC c) {\n"
|
|
MOVE_ANCHOR = ("if (((c->x[8] >> 1) & 1)) { goto L_82c41748; }\n")
|
|
MOVE_MATRIX = "L_82c41778:;\n"
|
|
WARP_HEAD = "void f_806d2530(Ctx *__restrict A64_NOESC c) {\n"
|
|
WARP_ANCHOR = "{ uint64_t _t = c->x[8]; c->x[30] = 0x806d25c8ULL; A64_ICALL(c, _t); }\n"
|
|
VIEW_HEAD = "void f_804e48c0(Ctx *__restrict A64_NOESC c) {\n"
|
|
# (the head of the view's loop: a bare label, since nx2/poll.py puts the interrupt poll before each backward goto; with the
|
|
# poll after the label in C lifted before that)
|
|
VIEW_ANCHORS = ("L_804e5068:;\n", "L_804e5068:; A64_POLL(c);\n")
|
|
LIFE_CAS = ("{ uint64_t _a = c->x[13]; uint32_t _e = (uint32_t)c->x[11]; "
|
|
"__atomic_compare_exchange_n((uint32_t *)A64_PTR(_a), &_e, (uint32_t)c->x[12], "
|
|
"0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); A64_MARK(_a, 4); c->x[11] = (uint64_t)_e; }")
|
|
|
|
|
|
def patch_life(source):
|
|
start = source.find(LIFE_HEAD)
|
|
if start < 0:
|
|
return None
|
|
end = source.find("\n}", start)
|
|
if end < 0 or source[start:end].count(LIFE_CAS) != 2:
|
|
return None
|
|
# x19 is the actor. Confirm its type and life pointer before protecting this write.
|
|
guard = (" if ((uint32_t)c->x[12] < (uint32_t)c->x[11] && hos_oot_hearts_enabled() &&\n"
|
|
" hos_oot_is_player(c, c->x[19]) &&\n"
|
|
" c->x[13] == recomp_load64(c,c->x[19] + 7184) + 8)\n"
|
|
" c->x[12] = c->x[11];\n")
|
|
body = source[start:end].replace(LIFE_CAS, guard + LIFE_CAS)
|
|
return (source[:start] + body + source[end:]).replace(
|
|
'#include "a64.h"\n', '#include "a64.h"\nextern int hos_oot_hearts_enabled(void);\n'
|
|
'extern int hos_oot_is_player(Ctx *c, uint64_t actor);\n', 1)
|
|
|
|
|
|
def patch_movement(source):
|
|
start = source.find(MOVE_HEAD)
|
|
if start < 0:
|
|
return None
|
|
end = source.find("\n}", start)
|
|
if end < 0 or source[start:end].count(MOVE_ANCHOR) != 1 or source[start:end].count(MOVE_MATRIX) != 1:
|
|
return None
|
|
bypass = (" hos_oot_lift_player(c, c->x[19]);\n"
|
|
+ MOVE_ANCHOR)
|
|
body = source[start:end].replace(MOVE_ANCHOR, bypass, 1).replace(
|
|
MOVE_MATRIX, MOVE_MATRIX + " hos_oot_flight_pose(c, c->x[19], c->x[25]);\n", 1)
|
|
source = source[:start] + body + source[end:]
|
|
return source.replace('#include "a64.h"\n', '#include "a64.h"\n'
|
|
'extern void hos_oot_lift_player(Ctx *c, uint64_t actor);\n'
|
|
'extern void hos_oot_flight_pose(Ctx *c, uint64_t actor, uint64_t matrix);\n', 1)
|
|
|
|
|
|
def patch_flight_rotation(source):
|
|
start = source.find(WARP_HEAD)
|
|
if start < 0:
|
|
return None
|
|
end = source.find("\n}", start)
|
|
body = source[start:end]
|
|
if end < 0 or body.count(WARP_ANCHOR) != 1:
|
|
return None
|
|
body = body.replace(WARP_ANCHOR, " hos_oot_flight_rotation(c, c->x[0], c->x[1]);\n" + WARP_ANCHOR)
|
|
return (source[:start] + body + source[end:]).replace(
|
|
'#include "a64.h"\n', '#include "a64.h"\n'
|
|
'extern void hos_oot_flight_rotation(Ctx *c, uint64_t controller, uint64_t matrix);\n', 1)
|
|
|
|
|
|
def patch_view(source):
|
|
start = source.find(VIEW_HEAD)
|
|
if start < 0:
|
|
return None
|
|
end = source.find("\n}", start)
|
|
body = source[start:end]
|
|
if end < 0:
|
|
return None
|
|
for anchor in VIEW_ANCHORS:
|
|
if body.count(anchor) == 1:
|
|
break
|
|
else:
|
|
return None
|
|
body = body.replace(anchor, anchor + " hos_oot_free_view(c, c->x[20]);\n")
|
|
return (source[:start] + body + source[end:]).replace(
|
|
'#include "a64.h"\n', '#include "a64.h"\nextern void hos_oot_free_view(Ctx *c, uint64_t view);\n', 1)
|
|
|
|
# Native mouse look (host/mouse_native.c): the player camera's update, f_80644c80 (a virtual method, the camera in x0), hands
|
|
# its camera to the host before anything else, on the game's thread, once a frame; with the menu's Mouse camera on the mouse's
|
|
# motion turns the camera's yaw (+0x1a4) and pitch (+0x18c) there, before the camera reads its input.
|
|
CAM_HEAD = "void f_80644c80(Ctx *__restrict A64_NOESC c) {\n"
|
|
|
|
|
|
def patch_mouse_camera(source):
|
|
start = source.find(CAM_HEAD)
|
|
if start < 0:
|
|
return None
|
|
if "hos_mouse_camera(c->x[0]);" in source: # (made before: a lift patched again)
|
|
return source
|
|
at = start + len(CAM_HEAD)
|
|
source = source[:at] + " hos_mouse_camera(c->x[0]); /* (nx2/oot_patches.py: native mouse look) */\n" + source[at:]
|
|
return source.replace('#include "a64.h"\n', '#include "a64.h"\nextern void hos_mouse_camera(uint64_t camera);\n', 1)
|
|
|
|
|
|
MENU_FOCUS_HEAD = "void f_802ed660(Ctx *__restrict A64_NOESC c) {\n"
|
|
|
|
|
|
def patch_menu_focus(source):
|
|
"""f_802ed660, a menu screen's handler of a pane getting the focus (host/oot_menu.c), calls
|
|
hos_oot_menu_focus first, with the screen, the pane and its caller's return address"""
|
|
start = source.find(MENU_FOCUS_HEAD)
|
|
if start < 0:
|
|
return None
|
|
if "hos_oot_menu_focus(c," in source: # (made before: a lift patched again)
|
|
return source
|
|
at = start + len(MENU_FOCUS_HEAD)
|
|
hook = " hos_oot_menu_focus(c, c->x[0], c->x[1], c->x[30]); /* (nx2/oot_patches.py: the menus' focus) */\n"
|
|
return (source[:at] + hook + source[at:]).replace(
|
|
'#include "a64.h"\n', '#include "a64.h"\nextern void hos_oot_menu_focus(Ctx *c, uint64_t screen, uint64_t pane, uint64_t lr);\n', 1)
|
|
|
|
|
|
MENU_TICK_HEAD = "void f_802f1380(Ctx *__restrict A64_NOESC c) {\n"
|
|
|
|
|
|
def patch_menu_tick(source):
|
|
"""f_802f1380, a menu screen's update (each frame, before the screen's UI controller: +56, its vtable's
|
|
+16), calls hos_oot_menu_tick first with the screen: the game's menus' mouse (host/oot_menu.c)"""
|
|
start = source.find(MENU_TICK_HEAD)
|
|
if start < 0:
|
|
return None
|
|
if "hos_oot_menu_tick(c," in source: # (made before: a lift patched again)
|
|
return source
|
|
at = start + len(MENU_TICK_HEAD)
|
|
hook = " hos_oot_menu_tick(c, c->x[0]); /* (nx2/oot_patches.py: the menus' mouse) */\n"
|
|
return (source[:at] + hook + source[at:]).replace(
|
|
'#include "a64.h"\n', '#include "a64.h"\nextern void hos_oot_menu_tick(Ctx *c, uint64_t screen);\n', 1)
|
|
|
|
|
|
TEXT_HEAD = "void f_80b1e140(Ctx *__restrict A64_NOESC c) {"
|
|
# (the letters' block: past the early returns, the auto-advance timer and the hidden / no-text checks; reached once a call)
|
|
TEXT_OLD = ("L_80b1e1b4:;\n"
|
|
" c->x[9]=recomp_load16(c,c->x[19] + 110);\n"
|
|
"if ((uint32_t)c->x[9] == 0) { goto L_80b1e18c; }\n")
|
|
# (the same block in a build with interrupt polls: nx2/poll.py puts the poll before each backward goto, as a block)
|
|
TEXT_OLD_POLLED = TEXT_OLD.replace("{ goto L_80b1e18c; }", "{ { A64_POLL(c); goto L_80b1e18c; } }")
|
|
TEXT_ADD = (" if (hos_text_scale != 1.0f) { float _t; uint32_t _u; memcpy(&_t,c->vreg[0],4); _t *= hos_text_scale; "
|
|
"memcpy(&_u,&_t,4); a64_vset64(c->vreg[0],_u); } /* (nx2/oot_patches.py: text speed) */\n")
|
|
TEXT_NEW = TEXT_OLD + TEXT_ADD
|
|
|
|
|
|
def patch_dynres(s):
|
|
if OLD not in s:
|
|
return None
|
|
s = s.replace(OLD, NEW, 1)
|
|
at = s.index(LABEL)
|
|
scale = s.index(SCALE_OLD, at)
|
|
s = s[:scale] + SCALE_NEW + s[scale + len(SCALE_OLD):]
|
|
return s.replace('#include "a64.h"\n', '#include "a64.h"\n' + DECL, 1)
|
|
|
|
|
|
# The frame's real time in place of the nominal rate, for a Frame rate cap above 60 (host/nn_vi.c hos_frame_seconds_bits; 0, as
|
|
# at a cap of 60: the game's own divide, nothing changes). The engine has two places where its integer nominal rate (+0x2c8 of
|
|
# the graphics module) becomes a time step, both a float divide "base / nominal":
|
|
# - f_80706be0: the frame's step, base 60.0 (30.0 in the half-rate mode), added to the game clock (the double at
|
|
# [x19+0xd58], in 1/60 s) and handed on as the frame's seconds;
|
|
# - f_83b6ea90: the global step (60.0 / nominal, a float in .data) the rest of the engine reads.
|
|
# The engine's own rate is 60 / <whole display intervals>, never above 60, and its controller puts 60 back over a higher value
|
|
# written from outside before either divide runs: above 60 fps every frame still stepped 1/60 s and the game ran fps / 60 times
|
|
# too fast. With the host's measured frame time the step is base * seconds, whatever the rate. hos_step_probe: f_80706be0's
|
|
# x19, which tells the host the hook is in this build and gives it the game clock for its log (HOS_FPS_LOG=1).
|
|
STEP_SITES = (("void f_80706be0(Ctx *__restrict A64_NOESC c) {\n", 8, "\n hos_step_probe = c->x[19];"),
|
|
("void f_83b6ea90(Ctx *__restrict A64_NOESC c) {\n", 0, ""))
|
|
STEP_OLD = " _v=a64_fpx_div32_div32(c,_a,_b);\n a64_vset64(c->vreg[%d],_v);}"
|
|
STEP_HOOK = (" _v=a64_fpx_div32_div32(c,_a,_b);\n"
|
|
" { const uint32_t _hs = hos_frame_seconds_bits; if (_hs) { float _base, _secs; uint32_t _w; memcpy(&_base,&_a,4); "
|
|
"memcpy(&_secs,&_hs,4); _base *= _secs; memcpy(&_w,&_base,4); _v = _w; } } /* (base * the frame's seconds: nx2/oot_patches.py) */\n"
|
|
" a64_vset64(c->vreg[%d],_v);}")
|
|
STEP_MARK = "hos_frame_seconds_bits; if (_hs)" # (once per divide with the hook)
|
|
STEP_DECL = "extern volatile uint32_t hos_frame_seconds_bits;\nextern volatile uint64_t hos_step_probe;\n"
|
|
|
|
|
|
def patch_frame_seconds(s):
|
|
"""The host's frame time at the step divides of f_80706be0 and f_83b6ea90: (s, the sites patched here). A site whose
|
|
function is not in the file, is patched already, or whose code differs (another game version) is left as it is."""
|
|
done = 0
|
|
for head_text, reg, extra in STEP_SITES:
|
|
head = s.find(head_text)
|
|
if head < 0:
|
|
continue
|
|
end = s.find("\nvoid f_", head + len(head_text))
|
|
body = s[head:end if end >= 0 else len(s)]
|
|
old, new = STEP_OLD % reg, STEP_HOOK % reg + extra
|
|
if new in body or body.count(old) != 1 or body.count("a64_fpx_div32_div32") != 1:
|
|
continue
|
|
at = head + body.index(old)
|
|
s = s[:at] + new + s[at + len(old):]
|
|
done += 1
|
|
if done and STEP_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + STEP_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
def unpatch_frame_seconds(s):
|
|
"""s without the hook, as the lift wrote it: for a lift where only one of the two divides was found (apply)"""
|
|
for _, reg, extra in STEP_SITES:
|
|
s = s.replace(STEP_HOOK % reg + extra, STEP_OLD % reg)
|
|
return s if STEP_MARK in s else s.replace(STEP_DECL, "", 1) # (a hook of another shape stays, with its declarations)
|
|
|
|
|
|
# A movie's frame count above a 60 cap. The game's movie player counts its updates while a movie plays (f_83b7c710: one more
|
|
# at +760 of the player each frame), and a cutscene that shows a movie takes that count as its timeline's frame (f_83b5ec10,
|
|
# f_83b5e9a0): the narration, the rumble and the cutscene's end are placed by it. The movie itself follows the clock, so above
|
|
# 60 fps those cues ran ahead of the picture, fps / 60 times too fast (issue 1742). The count now grows by the frames' time, as
|
|
# the game's clock does (hos_movie_frames, host/nn_vi.c: 1 as before while the host gives no frame time).
|
|
MOVIE_HEAD = "void f_83b7c710(Ctx *__restrict A64_NOESC c) {\n"
|
|
# (the load and the add alone: the store after them is rewritten by the page marks' pass, which runs after these edits)
|
|
MOVIE_OLD = (" c->x[8]=recomp_load32(c,c->x[20] + 760);\n"
|
|
" { uint64_t _a=c->x[8], _b=1ULL; uint64_t _r=_a+_b; _r&=0xFFFFFFFFULL; c->x[8]=_r; }\n")
|
|
MOVIE_NEW = MOVIE_OLD.replace("_b=1ULL", "_b=hos_movie_frames(c->x[20])")
|
|
MOVIE_DECL = "uint32_t hos_movie_frames(uint64_t player);\n"
|
|
|
|
|
|
def patch_movie_frames(s):
|
|
"""The movie player's count by the frames' time; None when the file has no such function, s unchanged when the function is
|
|
there but its code differs (another game version) or has the patch already."""
|
|
head = s.find(MOVIE_HEAD)
|
|
if head < 0:
|
|
return None
|
|
end = s.find("\nvoid f_", head + len(MOVIE_HEAD))
|
|
body = s[head:end if end >= 0 else len(s)]
|
|
if body.count(MOVIE_OLD) != 1:
|
|
return s
|
|
at = head + body.index(MOVIE_OLD)
|
|
s = s[:at] + MOVIE_NEW + s[at + len(MOVIE_OLD):]
|
|
return s if MOVIE_DECL in s else s.replace('#include "a64.h"\n', '#include "a64.h"\n' + MOVIE_DECL, 1)
|
|
|
|
|
|
# Counters that add the frame step, or the step times a whole number, cut to whole frames (host/frame_whole.h). At 60 fps the step
|
|
# is 1; under a Frame rate cap above 60 it is the frame's own time, under 1 (0.42 at 144 fps), and the cut is 0 every frame:
|
|
# - f_80a87e50, the pick-up indicator above Link's head (a rupee, a Deku Stick): the count it shows (+864) moves toward the
|
|
# wallet's (+860) by (int)(step * max(distance / 50, 1)) and the indicator fades when they meet. Cut to 0, it stayed at the old
|
|
# count until a door or a talk replaced it (issue 1832).
|
|
# - f_800672e0, the water renderer: its ripple simulation runs (int)step times the water's substeps (+76 of the pass) each frame.
|
|
# Cut to 0, the rings Link and the actors make in water stood still above 60 fps. Found by atk3001 for Lichii (zortos293/
|
|
# Lichii#1152), as ported to Fritchii (Frizti/Fritchii d389685a4, 063dbb741): its remainder is kept per water object (x21).
|
|
# - f_803edf70, the time of day: each frame it adds (int)(2 * step) game seconds (+60) to the seconds of the day (+40, a day of
|
|
# 86400, then the day count +44). Cut, it added 1 a frame below 120 fps (the day slower: 83% at 100) and 0 above 120, where
|
|
# the clock stood still and the sun swung back and forth over the frozen hour.
|
|
# hos_frame_whole carries the fractions per counter while the frames' own time is the step, so each moves at the game's rate;
|
|
# otherwise it cuts as the game does. A site is added here once it is seen to misbehave in game. (A site's function, its code to
|
|
# replace, and the counter's address for its remainder.)
|
|
WHOLE_SITES = (
|
|
# (the cut alone, the function's one: the multiply before it is a64_fpx_hot_mul32_fma32 in a lift where the function is
|
|
# among A64_HOT_FUNCS)
|
|
("void f_80a87e50(Ctx *__restrict A64_NOESC c) {@",
|
|
" c->x[12]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,1,3,c->fpcr,&c->fpsr);@",
|
|
"c->x[19] + 864"),
|
|
# (the cut alone, the function's one)
|
|
("void f_800672e0(Ctx *__restrict A64_NOESC c) {@",
|
|
" c->x[9]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,1,3,c->fpcr,&c->fpsr);@",
|
|
"c->x[21]"),
|
|
# (the cut with the store after it: the function cuts into x8 the same way once more, in the branch that sets
|
|
# the time from another source)
|
|
("void f_803edf70(Ctx *__restrict A64_NOESC c) {@",
|
|
" c->x[8]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,1,3,c->fpcr,&c->fpsr);@"
|
|
" recomp_store32(c,c->x[19] + 60,c->x[8]);@",
|
|
"c->x[19] + 60"),
|
|
)
|
|
WHOLE_SITES = tuple((h.replace("@", "\n"), o.replace("@", "\n"), k) for h, o, k in WHOLE_SITES)
|
|
WHOLE_MARK = "/* (the step's whole frames: nx2/oot_patches.py) */"
|
|
WHOLE_DECL = "extern uint32_t hos_frame_whole(uint64_t at, uint32_t amount_bits);\n"
|
|
|
|
|
|
def whole_new(old, key):
|
|
"""old with its cut to whole frames (the one recomp_fp_to_int) made hos_frame_whole's for the counter at key"""
|
|
lines = old.split("\n")
|
|
for i, line in enumerate(lines):
|
|
if "recomp_fp_to_int(c->vreg[0][0]" in line:
|
|
reg = line.split("=", 1)[0]
|
|
lines[i] = "%s=hos_frame_whole(%s, (uint32_t)c->vreg[0][0]); %s" % (reg, key, WHOLE_MARK)
|
|
return "\n".join(lines)
|
|
|
|
|
|
def patch_whole_frames(s):
|
|
"""The counters of WHOLE_SITES take hos_frame_whole's whole frames: (s, the sites patched here). A file without the function,
|
|
one patched before, or one whose code differs (another game version) is left as it is."""
|
|
done = 0
|
|
for head_text, old, key in WHOLE_SITES:
|
|
head = s.find(head_text)
|
|
if head < 0:
|
|
continue
|
|
end = s.find("\n}\n", head)
|
|
body = s[head:end if end >= 0 else len(s)]
|
|
new = whole_new(old, key)
|
|
if new in body or body.count(old) != 1:
|
|
continue
|
|
at = head + body.index(old)
|
|
s = s[:at] + new + s[at + len(old):]
|
|
done += 1
|
|
if done and WHOLE_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + WHOLE_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
# Above a Frame rate cap of 60, two places that need whole 60 fps frames (host/oot_high_fps.h has why and the logic; at a cap of
|
|
# 60 the host hands back what the game computed):
|
|
# - the sound manager's job, f_80435300 (phase in w2; phase 0 loads the game step, [[slot]]+0x10, and hands it to the sound
|
|
# engine): its head asks hos_oot_sound_gate whether to run now (60 Hz above 60 fps, the other phases following phase 0), and
|
|
# the step it loads goes through hos_oot_sound_step (a whole one while the gate holds the job). After zortos293/Lichii PR #1289
|
|
# (auz466), which does the same as a code patch for the emulator.
|
|
# - the physics solver's step count, set each update from the frame step in f_838ceb80 and f_838cfc10 (the same code in both):
|
|
# hos_oot_solver_steps rounds it up instead of down, at least 1, so Link stays on moving platforms (issue 1798).
|
|
SOUND_HEAD = "void f_80435300(Ctx *__restrict A64_NOESC c) {\n"
|
|
SOUND_SLOT = "g_module_base + 0x80435000ULL + (int64_t)75927552" # (the page of the step's pointer, whose +2192 holds it)
|
|
SOUND_OLD = (" c->x[8]=" + SOUND_SLOT + ";\n"
|
|
" { uint64_t _r = ((uint64_t)0 | ((c->x[0]) << 0)); c->x[19] = _r; }\n"
|
|
" c->x[8]=recomp_load64(c,c->x[8] + 2192);\n"
|
|
" c->x[8]=recomp_load64(c,c->x[8] + 0);\n"
|
|
" { { uint64_t _v=recomp_load32(c,(c->x[8]+16ULL)); a64_vset64(c->vreg[0],_v); } }\n")
|
|
SOUND_NEW = SOUND_OLD.replace("uint64_t _v=recomp_load32(c,(c->x[8]+16ULL));",
|
|
"uint64_t _v=hos_oot_sound_step((uint32_t)recomp_load32(c,(c->x[8]+16ULL)));")
|
|
SOUND_GATE = (" if (!hos_oot_sound_gate(c, (uint32_t)c->x[2], " + SOUND_SLOT + " + 2192)) return;"
|
|
" /* (nx2/oot_patches.py: the sound job at 60 Hz above 60 fps) */\n")
|
|
SOUND_DECL = "extern int hos_oot_sound_gate(Ctx *c, uint32_t phase, uint64_t slot);\nextern uint32_t hos_oot_sound_step(uint32_t step_bits);\n"
|
|
SOLVER_HEADS = ("void f_838ceb80(Ctx *__restrict A64_NOESC c) {\n", "void f_838cfc10(Ctx *__restrict A64_NOESC c) {\n")
|
|
# (the cut of frame step * steps a frame + 0.001, then its store into the solver: vreg 0 the float cut, vreg 1 the steps a frame)
|
|
SOLVER_OLD = (" c->x[1]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,1,3,c->fpcr,&c->fpsr);\n"
|
|
" recomp_store32(c,c->x[0] + 712,c->x[1]);\n")
|
|
SOLVER_NEW = SOLVER_OLD.replace(
|
|
" recomp_store32(", " c->x[1]=hos_oot_solver_steps((uint32_t)c->x[1], (uint32_t)c->vreg[0][0], (uint32_t)c->vreg[1][0]);"
|
|
" /* (nx2/oot_patches.py: solver steps rounded up above 60 fps) */\n recomp_store32(", 1)
|
|
SOLVER_DECL = "extern uint32_t hos_oot_solver_steps(uint32_t game, uint32_t scaled_bits, uint32_t per_frame_bits);\n"
|
|
|
|
|
|
# Three more places that go wrong with a frame step under one frame (host/oot_high_fps.h has why and the logic; at a cap of 60 the
|
|
# host hands back what the game computes). Found and fixed for this build by NX2navi (its recomp/patches-v111.txt, the sets
|
|
# ofollow, owater and orecord: main+0x13d704, +0x13a064, +0x389ac20; +0x3876014, +0x38827f8, +0x632cfc; +0x32926c8, +0x3293410,
|
|
# +0x3296b08, +0x3296da4; main is at 0x80020000 here), there as code words, here as hooks in the lifted C:
|
|
# - the character controller's three follow-surface updates compare the physics' inverse step with 100.0 and keep a tenth of
|
|
# the floor's velocity above it: every update above 100 fps, so a moving platform slid out from under Link. The 100.0 comes
|
|
# from hos_oot_floor_cut (100 / the frame's 60 fps frames while that is under one).
|
|
# - the two water managers and the interactive floors (the Deku Tree's ground webs) run seconds / (1/60 s), cut to whole,
|
|
# fixed steps: none in an update shorter than 1/60 s, so the surfaces stood still above 60 fps. Before the cut the quotient
|
|
# goes through hos_oot_sim_steps (x19 the object, each function's x0): the whole steps with the object's remainder kept.
|
|
# - the ocarina recorder's clock adds (unsigned)frame step at four places: 0 above 60 fps, so a recording lost its rests.
|
|
# hos_oot_record_frames carries the fraction.
|
|
FLOOR_HEADS = ("void f_8015d490(Ctx *__restrict A64_NOESC c) {\n", "void f_80159dc0(Ctx *__restrict A64_NOESC c) {\n",
|
|
"void f_838baa40(Ctx *__restrict A64_NOESC c) {\n")
|
|
# (mov w8, #0x42c80000; fmov s1, w8: the 100.0 of the compare that follows)
|
|
FLOOR_OLD = (" c->x[8] = 0x42c80000ULL;\n c->x[8] &= 0xFFFFFFFFULL;\n"
|
|
" { a64_vset64(c->vreg[1],0); memcpy(&c->vreg[1][0],&c->x[8],4); }\n")
|
|
FLOOR_NEW = FLOOR_OLD.replace("c->x[8] = 0x42c80000ULL;",
|
|
"c->x[8] = hos_oot_floor_cut(); /* (nx2/oot_patches.py: a floor's carry above 100 fps) */", 1)
|
|
FLOOR_DECL = "extern uint32_t hos_oot_floor_cut(void);\n"
|
|
# (a function and the register its cut goes to: fdiv s0, s8, s0 then fcvtzs w<n>, s0, the function's one cut of s0 into that register)
|
|
SIM_SITES = (("void f_83895f20(Ctx *__restrict A64_NOESC c) {\n", 8), ("void f_838a2660(Ctx *__restrict A64_NOESC c) {\n", 8),
|
|
("void f_80652cb0(Ctx *__restrict A64_NOESC c) {\n", 22))
|
|
SIM_OLD = " c->x[%d]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,1,3,c->fpcr,&c->fpsr);\n"
|
|
SIM_HOOK = (" a64_vset64(c->vreg[0],hos_oot_sim_steps(c->x[19], (uint32_t)c->vreg[0][0]));"
|
|
" /* (nx2/oot_patches.py: fixed steps above 60 fps) */\n")
|
|
SIM_DECL = "extern uint32_t hos_oot_sim_steps(uint64_t object, uint32_t quotient_bits);\n"
|
|
# (a function and how many times it adds the step to the clock: fcvtzu w8, s0)
|
|
RECORD_SITES = (("void f_832b2690(Ctx *__restrict A64_NOESC c) {\n", 1), ("void f_832b32b0(Ctx *__restrict A64_NOESC c) {\n", 1),
|
|
("void f_832b6840(Ctx *__restrict A64_NOESC c) {\n", 2))
|
|
RECORD_OLD = " c->x[8]=recomp_fp_to_int(c->vreg[0][0]&UINT64_C(0xffffffff),32,32,0,3,c->fpcr,&c->fpsr);\n"
|
|
RECORD_NEW = (" c->x[8]=hos_oot_record_frames((uint32_t)c->vreg[0][0]);"
|
|
" /* (nx2/oot_patches.py: the ocarina recorder's clock above 60 fps) */\n")
|
|
RECORD_DECL = "extern uint32_t hos_oot_record_frames(uint32_t step_bits);\n"
|
|
|
|
|
|
def _function(s, head_text):
|
|
"""(start, end) of the function whose head is head_text, or None"""
|
|
head = s.find(head_text)
|
|
if head < 0:
|
|
return None
|
|
end = s.find("\nvoid f_", head + len(head_text))
|
|
return head, end if end >= 0 else len(s)
|
|
|
|
|
|
def patch_sound_job(s):
|
|
"""The sound job's gate and step: (s, 1) when the job is in s with them (made now or before), (s, 0) when it is not here or
|
|
its code differs (another game version: left as it is)"""
|
|
at = _function(s, SOUND_HEAD)
|
|
if at is None:
|
|
return s, 0
|
|
head, end = at
|
|
body = s[head:end]
|
|
if body.count(SOUND_NEW) == 1 and body.count(SOUND_GATE) == 1:
|
|
return s, 1
|
|
if body.count(SOUND_OLD) != 1 or SOUND_GATE in body:
|
|
return s, 0
|
|
body = body.replace(SOUND_OLD, SOUND_NEW, 1)
|
|
body = SOUND_HEAD + SOUND_GATE + body[len(SOUND_HEAD):]
|
|
s = s[:head] + body + s[end:]
|
|
if SOUND_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + SOUND_DECL, 1)
|
|
return s, 1
|
|
|
|
|
|
def patch_solver_steps(s):
|
|
"""The solver step count's two places: (s, how many of them are in s with the hook, made now or before)"""
|
|
done = 0
|
|
for head_text in SOLVER_HEADS:
|
|
at = _function(s, head_text)
|
|
if at is None:
|
|
continue
|
|
head, end = at
|
|
body = s[head:end]
|
|
if body.count(SOLVER_NEW) == 1:
|
|
done += 1
|
|
elif body.count(SOLVER_OLD) == 1:
|
|
s = s[:head] + body.replace(SOLVER_OLD, SOLVER_NEW, 1) + s[end:]
|
|
done += 1
|
|
if done and SOLVER_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + SOLVER_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
def patch_floor_carry(s):
|
|
"""The follow-surface updates' compare: (s, how many of the three are in s with the hook, made now or before)"""
|
|
done = 0
|
|
for head_text in FLOOR_HEADS:
|
|
at = _function(s, head_text)
|
|
if at is None:
|
|
continue
|
|
head, end = at
|
|
body = s[head:end]
|
|
if body.count(FLOOR_NEW) == 1:
|
|
done += 1
|
|
elif body.count(FLOOR_OLD) == 1:
|
|
s = s[:head] + body.replace(FLOOR_OLD, FLOOR_NEW, 1) + s[end:]
|
|
done += 1
|
|
if done and FLOOR_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + FLOOR_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
def patch_sim_steps(s):
|
|
"""The height-field surfaces' fixed steps: (s, how many of the three places are in s with the hook, made now or before)"""
|
|
done = 0
|
|
for head_text, reg in SIM_SITES:
|
|
at = _function(s, head_text)
|
|
if at is None:
|
|
continue
|
|
head, end = at
|
|
body = s[head:end]
|
|
old = SIM_OLD % reg
|
|
if body.count(SIM_HOOK + old) == 1:
|
|
done += 1
|
|
elif body.count(old) == 1 and SIM_HOOK not in body:
|
|
s = s[:head] + body.replace(old, SIM_HOOK + old, 1) + s[end:]
|
|
done += 1
|
|
if done and SIM_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + SIM_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
def patch_record_clock(s):
|
|
"""The ocarina recorder's clock: (s, how many of its four adds are in s with the hook, made now or before). A function
|
|
whose adds are not as many as RECORD_SITES says (another game version) is left as it is."""
|
|
done = 0
|
|
for head_text, count in RECORD_SITES:
|
|
at = _function(s, head_text)
|
|
if at is None:
|
|
continue
|
|
head, end = at
|
|
body = s[head:end]
|
|
if body.count(RECORD_NEW) == count and RECORD_OLD not in body:
|
|
done += count
|
|
elif body.count(RECORD_OLD) == count and RECORD_NEW not in body:
|
|
s = s[:head] + body.replace(RECORD_OLD, RECORD_NEW) + s[end:]
|
|
done += count
|
|
if done and RECORD_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + RECORD_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
# The sprint button (host/oot_sprint.h has the rules, host/oot_sprint.c the game's addresses; after NX2navi's set "sprint").
|
|
# Link sprints while his input flags hold the dash input (bit 4), which the game sets only out of a roll. Two functions load
|
|
# those flags and test the bit: his movement update f_804caa80 (to start the sprint and to keep it), and the update of his
|
|
# stance and camera f_80c225d0 (the low byte). After each load the host gets the flags and gives them back, with the bit
|
|
# while the button's sprint is on. With the Sprint button row off the call returns what it got.
|
|
SPRINT_LINK_HEAD = "void f_804caa80(Ctx *__restrict A64_NOESC c) {\n"
|
|
SPRINT_LINK_OLD = (" c->x[10]=recomp_load64(c,c->x[19] + 80);\n"
|
|
" c->x[9]=recomp_load32(c,c->x[19] + 44);\n"
|
|
" c->x[10]=recomp_load64(c,c->x[10] + 0);\n")
|
|
SPRINT_LINK_ADD = " c->x[10]=hos_oot_sprint_link(c,c->x[19],c->x[10]); /* (nx2/oot_patches.py: the sprint button) */\n"
|
|
SPRINT_STANCE_HEAD = "void f_80c225d0(Ctx *__restrict A64_NOESC c) {\n"
|
|
SPRINT_STANCE_OLD = (" c->x[8]=recomp_load64(c,c->x[19] + 80);\n"
|
|
" c->x[8]=recomp_load8(c,c->x[8] + 0);\n"
|
|
"if (((c->x[8] >> 4) & 1)) { goto L_80c27f54; }\n")
|
|
SPRINT_STANCE_NEW = (" c->x[8]=recomp_load64(c,c->x[19] + 80);\n"
|
|
" c->x[8]=recomp_load8(c,c->x[8] + 0);\n"
|
|
" c->x[8]=hos_oot_sprint_stance(c,c->x[19],c->x[8]); /* (nx2/oot_patches.py: the sprint button) */\n"
|
|
"if (((c->x[8] >> 4) & 1)) { goto L_80c27f54; }\n")
|
|
SPRINT_DECL = ("extern uint64_t hos_oot_sprint_link(Ctx *c, uint64_t link, uint64_t flags);\n"
|
|
"extern uint64_t hos_oot_sprint_stance(Ctx *c, uint64_t link, uint64_t flags);\n")
|
|
|
|
|
|
def patch_sprint(s):
|
|
"""The sprint button's two calls: (s, how many of the two are in s, made now or before). A function whose code differs
|
|
(another game version) is left as it is."""
|
|
done = 0
|
|
for head_text, old, new in ((SPRINT_LINK_HEAD, SPRINT_LINK_OLD, SPRINT_LINK_OLD + SPRINT_LINK_ADD),
|
|
(SPRINT_STANCE_HEAD, SPRINT_STANCE_OLD, SPRINT_STANCE_NEW)):
|
|
at = _function(s, head_text)
|
|
if at is None:
|
|
continue
|
|
head, end = at
|
|
body = s[head:end]
|
|
if body.count(new) == 1:
|
|
done += 1
|
|
elif body.count(old) == 1:
|
|
s = s[:head] + body.replace(old, new) + s[end:]
|
|
done += 1
|
|
if done and SPRINT_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + SPRINT_DECL, 1)
|
|
return s, done
|
|
|
|
|
|
def patch_text_speed(s):
|
|
"""The scale at the head of the letters' block of f_80b1e140; None when the file has no such function, s unchanged when the
|
|
function is there but its code differs (another game version)."""
|
|
head = s.find(TEXT_HEAD)
|
|
if head < 0:
|
|
return None
|
|
end = s.find("\nvoid f_", head + len(TEXT_HEAD))
|
|
body = s[head:end if end >= 0 else len(s)]
|
|
for old in (TEXT_OLD_POLLED, TEXT_OLD): # (with the interrupt poll before the block's backward goto, or without: --no-polls)
|
|
if old + TEXT_ADD in body: # (applied already: a second run)
|
|
return s
|
|
if body.count(old) == 1:
|
|
break
|
|
else:
|
|
return s
|
|
if body.count("goto L_80b1e1b4;") != 1:
|
|
return s
|
|
at = head + body.index(old)
|
|
s = s[:at] + old + TEXT_ADD + s[at + len(old):]
|
|
return s.replace('#include "a64.h"\n', '#include "a64.h"\n' + TEXT_DECL, 1)
|
|
|
|
|
|
# (local, RenoDX port) The scene's colour target, "agl::RenderDisplay(color)": the game picks engine format 26 (R11G11B10F) or 44
|
|
# (RGBA16F) at main+0x65234c (0x8067234c; RenoDX's addon.cpp names the place for build e0f3ccfa). RenoDX's tone mapping wants
|
|
# RGBA16F, whose values may be negative, with HDR Native: host/nn_vi.c hos_scene_rgba16f says when. The other choice of that
|
|
# csel is 44 already, so both become 44 then; the UNORM branch at main+0x6525b0 is left alone.
|
|
RGBA16F_DECL = "int hos_scene_rgba16f(void);\n"
|
|
RGBA16F_OLD = (" c->x[9] = 0x1aULL;\n c->x[9] &= 0xFFFFFFFFULL;\n"
|
|
" { uint64_t _r = (!c->z) ? c->x[10] : c->x[9]; _r &= 0xFFFFFFFFULL; c->x[9] = _r; }\nL_80672354:;")
|
|
RGBA16F_NEW = RGBA16F_OLD.replace("c->x[9] = 0x1aULL;", "c->x[9] = hos_scene_rgba16f() ? 0x2cULL : 0x1aULL;", 1)
|
|
|
|
|
|
def patch_scene_format(s):
|
|
if RGBA16F_OLD not in s:
|
|
return None
|
|
return s.replace(RGBA16F_OLD, RGBA16F_NEW, 1).replace('#include "a64.h"\n', '#include "a64.h"\n' + RGBA16F_DECL, 1)
|
|
|
|
|
|
def apply(gen, *, protect_hearts=False, required=False):
|
|
"""required: the lift of the supported build (LIFE_BUILD_ID), whole: a missing output-size edit stops it (apply_output_size).
|
|
The other patches only warn when their place is not found once."""
|
|
import oot_native_resolution # (HOS_SCENE_NATIVE=1: the scene's base scale 1.0; off by default since #849's output resolution)
|
|
oot_native_resolution.apply(gen)
|
|
done = {"dynamic resolution branch": 0, "text speed block": 0, "fixed path's scale": 0, "movie's frame count": 0}
|
|
if protect_hearts: # (the supported build's: these places are its functions)
|
|
done["menu focus hook"] = 0
|
|
done["menu tick hook"] = 0
|
|
done["player heart protection"] = 0
|
|
done["player flight"] = 0
|
|
done["player flight rotation"] = 0
|
|
done["free camera"] = 0
|
|
done["mouse camera"] = 0
|
|
done["scene colour target format"] = 0 # (local, RenoDX port)
|
|
step_sites, step_files = 0, [] # (the divides with the hook, and the files that have it)
|
|
whole_sites = 0 # (the counters of WHOLE_SITES with the whole frames: patch_whole_frames)
|
|
sound_jobs = solver_sites = 0 # (patch_sound_job, patch_solver_steps: the places found with their hooks)
|
|
floor_sites = sim_sites = record_sites = 0 # (patch_floor_carry, patch_sim_steps, patch_record_clock: the same)
|
|
sprint_sites = 0 # (patch_sprint: its two calls)
|
|
for path in sorted(glob.glob(os.path.join(glob.escape(gen), "code_*.c"))):
|
|
with open(path, encoding="utf-8", newline="") as f:
|
|
s = f.read()
|
|
out = s
|
|
d = patch_dynres(out)
|
|
if d is not None:
|
|
out = d
|
|
done["dynamic resolution branch"] += 1
|
|
print("oot_patches: dynamic resolution switch in", os.path.basename(path))
|
|
t = patch_text_speed(out)
|
|
if t is not None and t != out:
|
|
out = t
|
|
done["text speed block"] += 1
|
|
print("oot_patches: text speed scale in", os.path.basename(path))
|
|
focus = patch_menu_focus(out) if protect_hearts else None
|
|
if focus is not None:
|
|
out = focus
|
|
done["menu focus hook"] += 1
|
|
print("oot_patches: the menus' focus hook in", os.path.basename(path))
|
|
tick = patch_menu_tick(out) if protect_hearts else None
|
|
if tick is not None:
|
|
out = tick
|
|
done["menu tick hook"] += 1
|
|
print("oot_patches: the menus' update hook in", os.path.basename(path))
|
|
movie = patch_movie_frames(out)
|
|
if movie is not None:
|
|
if MOVIE_NEW in movie: # (made now, or by an earlier run over this file)
|
|
done["movie's frame count"] += 1
|
|
if movie != out:
|
|
print("oot_patches: the movie's frame count by the frames' time in", os.path.basename(path))
|
|
out = movie
|
|
out, n = fixed_scale(out)
|
|
if n:
|
|
done["fixed path's scale"] += 1
|
|
print("oot_patches: the fixed path's scale in", os.path.basename(path))
|
|
fmt = patch_scene_format(out) if protect_hearts else None
|
|
if fmt is not None:
|
|
out = fmt
|
|
done["scene colour target format"] += 1
|
|
print("oot_patches: the scene's colour target format in", os.path.basename(path))
|
|
life = patch_life(out) if protect_hearts else None
|
|
if life is not None:
|
|
out = life
|
|
done["player heart protection"] += 1
|
|
print("oot_patches: player heart protection in", os.path.basename(path))
|
|
move = patch_movement(out) if protect_hearts else None
|
|
if move is not None:
|
|
out = move
|
|
done["player flight"] += 1
|
|
print("oot_patches: player flight in", os.path.basename(path))
|
|
rotation = patch_flight_rotation(out) if protect_hearts else None
|
|
if rotation is not None:
|
|
out = rotation
|
|
done["player flight rotation"] += 1
|
|
print("oot_patches: player flight rotation in", os.path.basename(path))
|
|
mouse = patch_mouse_camera(out) if protect_hearts else None
|
|
if mouse is not None:
|
|
out = mouse
|
|
done["mouse camera"] += 1
|
|
print("oot_patches: native mouse camera in", os.path.basename(path))
|
|
view = patch_view(out) if protect_hearts else None
|
|
if view is not None:
|
|
out = view
|
|
done["free camera"] += 1
|
|
print("oot_patches: free camera in", os.path.basename(path))
|
|
out, sites = patch_frame_seconds(out)
|
|
if STEP_MARK in out: # (made now, or by an earlier run over this file)
|
|
step_sites += out.count(STEP_MARK)
|
|
step_files.append(path)
|
|
if sites:
|
|
print("oot_patches: the frame's time at %d step divide(s) in %s" % (sites, os.path.basename(path)))
|
|
out, whole = patch_whole_frames(out)
|
|
whole_sites += out.count(WHOLE_MARK) # (made now, or by an earlier run over this file)
|
|
if whole:
|
|
print("oot_patches: %d frame counter(s) with the step's whole frames in %s" % (whole, os.path.basename(path)))
|
|
sound, found = patch_sound_job(out)
|
|
sound_jobs += found
|
|
if sound != out:
|
|
print("oot_patches: the sound job at 60 Hz above 60 fps in", os.path.basename(path))
|
|
out = sound
|
|
solver, found = patch_solver_steps(out)
|
|
solver_sites += found
|
|
if solver != out:
|
|
print("oot_patches: the solver steps rounded up above 60 fps in", os.path.basename(path))
|
|
out = solver
|
|
floor, found = patch_floor_carry(out)
|
|
floor_sites += found
|
|
if floor != out:
|
|
print("oot_patches: a floor's carry above 100 fps in", os.path.basename(path))
|
|
out = floor
|
|
sim, found = patch_sim_steps(out)
|
|
sim_sites += found
|
|
if sim != out:
|
|
print("oot_patches: the water and floor surfaces' fixed steps above 60 fps in", os.path.basename(path))
|
|
out = sim
|
|
record, found = patch_record_clock(out)
|
|
record_sites += found
|
|
if record != out:
|
|
print("oot_patches: the ocarina recorder's clock above 60 fps in", os.path.basename(path))
|
|
out = record
|
|
sprinted, found = patch_sprint(out)
|
|
sprint_sites += found
|
|
if sprinted != out:
|
|
print("oot_patches: the sprint button in", os.path.basename(path))
|
|
out = sprinted
|
|
if out != s:
|
|
whole_write.write_whole(path, out, newline="")
|
|
if sound_jobs != 1: # (without it, above 60 fps sounds and then the music can stop after a few loading zones)
|
|
print("oot_patches: WARNING: the sound job was found %d times, not once" % sound_jobs)
|
|
if solver_sites != len(SOLVER_HEADS): # (without them, above 60 fps moving platforms can drop Link)
|
|
print("oot_patches: WARNING: the solver step count was found at %d of %d places" % (solver_sites, len(SOLVER_HEADS)))
|
|
if floor_sites != len(FLOOR_HEADS): # (without them, above 100 fps a moving platform carries Link at a tenth of its speed)
|
|
print("oot_patches: WARNING: a floor's carry was found at %d of %d places" % (floor_sites, len(FLOOR_HEADS)))
|
|
if sim_sites != len(SIM_SITES): # (without them, above 60 fps the water and web surfaces stand still)
|
|
print("oot_patches: WARNING: the surfaces' fixed steps were found at %d of %d places" % (sim_sites, len(SIM_SITES)))
|
|
if record_sites != sum(n for _, n in RECORD_SITES): # (without them, above 60 fps a recorded song loses its rests)
|
|
print("oot_patches: WARNING: the ocarina recorder's clock was found at %d of %d places"
|
|
% (record_sites, sum(n for _, n in RECORD_SITES)))
|
|
if sprint_sites != 2: # (without them the Sprint button row does nothing)
|
|
print("oot_patches: WARNING: the sprint button's calls were found at %d of 2 places" % sprint_sites)
|
|
for what, n in done.items():
|
|
if n != 1:
|
|
print("oot_patches: WARNING: the %s was found %d times" % (what, n))
|
|
if step_sites != len(STEP_SITES):
|
|
# (both or neither: with one divide timed and the other stepping 1/60 s the two clocks of the game would run apart. Without
|
|
# the hook the host keeps the rate up to the cap, as before: host/nn_vi.c, hos_step_probe)
|
|
for path in step_files:
|
|
with open(path, encoding="utf-8", newline="") as f:
|
|
s = f.read()
|
|
whole_write.write_whole(path, unpatch_frame_seconds(s), newline="")
|
|
print("oot_patches: WARNING: the frame's time was found at %d of %d step divides, none patched (a Frame rate cap above 60 "
|
|
"keeps the game's own step)" % (step_sites, len(STEP_SITES)))
|
|
elif whole_sites != len(WHOLE_SITES): # (the frames' own time without them: the pick-up indicator stays above 60 fps)
|
|
print("oot_patches: WARNING: %d of %d frame counters found for the step's whole frames (above 60 fps a counter can stop: "
|
|
"the pick-up indicator, the water ripples, the time of day)" % (whole_sites, len(WHOLE_SITES)))
|
|
apply_output_size(gen, required=required)
|
|
|
|
|
|
# Output size (host/nn_applet.c hos_output_size: the Insert menu's Output resolution, 2560 x 1440 as shipped):
|
|
# - nnMain (f_81222ce0) puts the display size in the framework's create arg (+20/+24, the framework's +156/+160); the window
|
|
# textures are made at it.
|
|
# - f_810a7b70 sets up the display-size object (B = [[0x84ca29c0]+216]) from a config (x1): its docked size list (+8, first
|
|
# 2560 x 1440) is the frame's base (B+244; the frame is the base times the graphics scale's factor, f_806702e0, capped by the
|
|
# scale's display class: docked 3840 x 2160 at scale 0). Its first entry asks the host when it differs.
|
|
OUT_DECL = "uint32_t hos_output_size(int height);\nuint64_t hos_rt_pool_size(uint64_t game);\n"
|
|
OUT_EDITS = [
|
|
# (the picture's 2560 x 1440 at 0x81202ee4, not f_831f3200's copy at +0xb68; nx2/oot_wide.py's widescreen size, after it,
|
|
# stays over it: host/hos_main.c makes that one at this height)
|
|
(" c->x[8] = 0xa00ULL;\n c->x[8] = (c->x[8] & ~(0xFFFFULL<<32)) | (0x5a0ULL<<32);\n"
|
|
"{ extern volatile uint64_t hos_wide_out; const uint64_t _s = hos_wide_out; if (_s) c->x[8] = _s; } /* (nx2/oot_wide.py: hos_wide_out) */\n"
|
|
" { uint64_t _b=c->x[21]; int64_t _o=20; recomp_store64(c,(_b+_o),c->x[8]); }",
|
|
" c->x[8] = hos_output_size(0) | ((uint64_t)hos_output_size(1) << 32);\n"
|
|
"{ extern volatile uint64_t hos_wide_out; const uint64_t _s = hos_wide_out; if (_s) c->x[8] = _s; } /* (nx2/oot_wide.py: hos_wide_out) */\n"
|
|
" { uint64_t _b=c->x[21]; int64_t _o=20; recomp_store64(c,(_b+_o),c->x[8]); }"),
|
|
(" { uint64_t _a=c->x[0], _b=724ULL; uint64_t _r=_a+_b; c->x[21]=_r; }\n"
|
|
" { uint64_t _r = ((uint64_t)0 | ((c->x[1]) << 0)); c->x[20] = _r; }\n",
|
|
" { uint64_t _a=c->x[0], _b=724ULL; uint64_t _r=_a+_b; c->x[21]=_r; }\n"
|
|
" { uint64_t _r = ((uint64_t)0 | ((c->x[1]) << 0)); c->x[20] = _r; }\n"
|
|
" if (hos_output_size(0) != 2560 && recomp_load32(c, c->x[20] + 8) == 2560) { recomp_store32(c, c->x[20] + 8, hos_output_size(0)); recomp_store32(c, c->x[20] + 12, hos_output_size(1)); }\n"),
|
|
# - f_80ea2f30: the 3D's largest size, ResolutionParam's BaseResolution (or 1920 x 1080 as constants), 3/4 of 2560 x 1440;
|
|
# above it the game takes a smaller upscale network (1/3: 1280 x 720 at 4K). Scaled with the output.
|
|
("c->x[30] = 0x80ea2ffcULL; f_831cca50(c);\n"
|
|
" { uint64_t _b=c->x[0]; int64_t _o=0; { uint64_t _p0,_p1; recomp_ldp32(c,(_b+_o),&_p0,&_p1); c->x[24]=_p0; c->x[25]=_p1; } }\n",
|
|
"c->x[30] = 0x80ea2ffcULL; f_831cca50(c);\n"
|
|
" { uint64_t _b=c->x[0]; int64_t _o=0; { uint64_t _p0,_p1; recomp_ldp32(c,(_b+_o),&_p0,&_p1); c->x[24]=_p0; c->x[25]=_p1; } }\n"
|
|
" if (hos_output_size(0) != 2560) { c->x[24] = (uint32_t)c->x[24] * hos_output_size(0) / 2560; c->x[25] = (uint32_t)c->x[25] * hos_output_size(1) / 1440; }\n"),
|
|
(" c->x[8] = 0x44f00000ULL;\n c->x[8] &= 0xFFFFFFFFULL;\n recomp_store32(c,c->x[19] + 3668,c->x[8]);\n"
|
|
" c->x[8] = 0x44870000ULL;\n c->x[8] &= 0xFFFFFFFFULL;\n",
|
|
" c->x[8] = hos_output_size(0) * 3 / 4;\n { float _f = (float)c->x[8]; uint32_t _u; memcpy(&_u, &_f, 4); c->x[8] = _u; }\n"
|
|
" recomp_store32(c,c->x[19] + 3668,c->x[8]);\n"
|
|
" c->x[8] = hos_output_size(1) * 3 / 4;\n { float _f = (float)c->x[8]; uint32_t _u; memcpy(&_u, &_f, 4); c->x[8] = _u; }\n"),
|
|
# - The render targets' GPU pool: 0x13100000 bytes (the graphics config's +1464, read in f_836ce9d0, which takes its storage from
|
|
# the "Graphics" heap and makes a physical pool and a virtual one over it: f_80c4a1c0 -> f_80c49070 -> f_80c49380 -> f_811c9ba0).
|
|
# Sized for 2560 x 1440: a 3840x2160 3D at the 4K output ran out of it and the next target came back null (crash in f_8005ed00,
|
|
# the pool's allocator, its +0x28 0x13100000). Scaled with the output's pixels (host/nn_applet.c
|
|
# hos_rt_pool_size: 687 MB at 3840 x 2160), at the config, so the storage and the pool agree.
|
|
("L_836cea54:;\n",
|
|
"L_836cea54:;\n"
|
|
" if (recomp_load64(c, c->x[19] + 1464) == 0x13100000ULL) recomp_store64(c, c->x[19] + 1464, hos_rt_pool_size(0x13100000ULL));\n"),
|
|
# - The "Graphics" heap holds it, made by f_83b7b340 with the other module heaps (twice: 0x34900000 bytes in f_83b7a2c0's first
|
|
# pass, then the heap kept, 0x348ffe20; it had under 16 MB to spare): grown by as much as the pool.
|
|
("c->x[30] = 0x83b7b440ULL; f_809df710(c);\n",
|
|
"if (c->x[0] == 0x34900000ULL || c->x[0] == 0x348ffe20ULL) c->x[0] += hos_rt_pool_size(0x13100000ULL) - 0x13100000ULL;\n"
|
|
"c->x[30] = 0x83b7b440ULL; f_809df710(c);\n"),
|
|
# - f_83b7b340 then takes each module heap's use (its vtable +120) off the module's budget (the configured size, a table of slots)
|
|
# and aborts below zero (f_8351c280): the Graphics heap's use counts as the shipped one.
|
|
("{ uint64_t _t = c->x[8]; c->x[30] = 0x83b7b4e0ULL; A64_ICALL(c, _t); }\n",
|
|
"{ uint64_t _t = c->x[8]; c->x[30] = 0x83b7b4e0ULL; A64_ICALL(c, _t); }\n"
|
|
"{ const uint64_t _b = recomp_load64(c, c->x[21] + (c->x[22] << 3)), _g = hos_rt_pool_size(0x13100000ULL) - 0x13100000ULL; "
|
|
"if ((_b == 0x34900000ULL || _b == 0x348ffe20ULL) && c->x[0] > _g) c->x[0] -= _g; }\n"),
|
|
# - f_80b72340 (from the graphics init f_836cf4b0) makes a heap of what the Graphics heap can still give, which took the growth as
|
|
# well (0x1b6cb48 bytes as shipped, 0x1996cb48 grown) and left too little for the pool: it keeps its shipped size.
|
|
("c->x[30] = 0x80b723acULL; f_809df700(c);\n",
|
|
"if (c->x[0] > hos_rt_pool_size(0x13100000ULL) - 0x13100000ULL) c->x[0] -= hos_rt_pool_size(0x13100000ULL) - 0x13100000ULL;\n"
|
|
"c->x[30] = 0x80b723acULL; f_809df700(c);\n"),
|
|
]
|
|
|
|
|
|
def apply_output_size(gen, required=False):
|
|
"""required (the supported build's whole lift): each edit must be made, or found made, exactly once, else SystemExit: without
|
|
one the Insert menu's Output resolution is ignored, or a 4K output runs out of the render targets' pool. Elsewhere (another
|
|
build, part of a lift, by hand) a warning"""
|
|
found = [0] * len(OUT_EDITS)
|
|
for path in sorted(glob.glob(os.path.join(glob.escape(gen), "code_*.c"))):
|
|
with open(path, encoding="utf-8", newline="") as f:
|
|
s = f.read()
|
|
hit = False
|
|
for i, (old, new) in enumerate(OUT_EDITS):
|
|
# (every place: each made one, and each old text outside a made one; a new text can hold its old one. A file with
|
|
# both is counted for both, and its old ones are left: a second made place or a stray raw one is not once)
|
|
made = s.count(new)
|
|
raw = (s.replace(new, "\0") if made else s).count(old)
|
|
found[i] += made + raw
|
|
if raw and not made:
|
|
s = s.replace(old, new)
|
|
hit = True
|
|
if hit:
|
|
if OUT_DECL not in s:
|
|
s = s.replace('#include "a64.h"\n', '#include "a64.h"\n' + OUT_DECL, 1)
|
|
whole_write.write_whole(path, s, newline="")
|
|
print("oot_patches: output size in", os.path.basename(path))
|
|
if found != [1] * len(OUT_EDITS):
|
|
if required:
|
|
raise SystemExit("oot_patches: the output size places were found %s times, not once each (OUT_EDITS %s): the "
|
|
"lifted C no longer has the text they match" % (found, [i for i, n in enumerate(found) if n != 1]))
|
|
print("oot_patches: WARNING: the output size places were found %s times" % found)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
apply(sys.argv[1] if len(sys.argv) > 1 else os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "work", "sa", "gen"))
|