Files
NX2navi/runtime/ov_gfx.c
chrg6 897ad1d0ea Step Ocarina's game by the display interval, not one 60 Hz frame per present, so it keeps its speed above 60 fps.
The time manager **[main+0x4c7e890] holds the frame's base step in 60 Hz frames (+0x1c0), from which each time category's {frames, 1/frames, seconds, 1/seconds} is made (main+0x2c84c). The game leaves it at 1.0 whatever the frame rate, so at 144 fps it ran 2.4 times too fast. Each present now writes the 5-frame average of the display interval there (1/1000 to 1/15 s); the game never writes it itself. Scripted input follows that game clock. NX2NAVI_OCARINA_STEP=0 leaves the step alone; NX2NAVI_TRACE=perf reports game seconds against wall seconds. NX2NAVI_VI_HZ and NX2NAVI_VI_VRR set the refresh rate and VRR support vi reports (60 and off as before), for diagnosis.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 09:26:51 -05:00

195 lines
9.1 KiB
C

// Contains code Copyright (c) 2026 MacNativeGames contributors (MIT; see THIRD_PARTY_NOTICES.md).
// The nvnBootstrapLoader stop is the entry to the NVN layer.
// Graphics bring-up:
// nv::* record the game's allocator callbacks and graphics work memory (guest addresses) for the NVN layer
// nn::vi::* display, layer and native window identities; the vsync event is bound here
// nvnBootstrapLoader the end of --boot (rt_boot_event "nvn"); otherwise the synthetic address of an NVN proc (nvn_procs.c)
#include "cfg.h"
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include "gfx.h"
#include "host.h"
#include "ov.h"
#include "platform/platform.h"
#define VI_R_INVALID 0xf601u // the result for a call on an unknown display or layer
static OvNvState nv;
static PlatMutex lock = PLAT_MUTEX_INIT;
const OvNvState *ov_nv_state(void) { return &nv; }
static void set_allocator(Cpu *c, OvNvAllocator *a) {
plat_mutex_lock(&lock);
*a = (OvNvAllocator){arg_x(c, 0), arg_x(c, 1), arg_x(c, 2), arg_x(c, 3)};
plat_mutex_unlock(&lock);
}
// void nv::SetGraphicsAllocator(AllocateFunction, FreeFunction, ReallocateFunction, void *user)
static void ov_graphics_allocator(Cpu *c) { set_allocator(c, &nv.graphics); }
// void nv::SetGraphicsDevtoolsAllocator(AllocateFunction, FreeFunction, ReallocateFunction, void *user)
static void ov_devtools_allocator(Cpu *c) { set_allocator(c, &nv.devtools); }
// void nv::InitializeGraphics(void *memory, size_t size)
static void ov_initialize_graphics(Cpu *c) {
uint64_t mem = arg_x(c, 0), size = arg_x(c, 1);
// Switch 2 titles pass (nullptr, 0): that SDK also has nv::InitializeGraphics() and the driver takes its memory
// from the allocator nv::SetGraphicsAllocator installed. Only a half-given region is an error.
if (!mem != !size) rt_fatal("nv::InitializeGraphics: inconsistent graphics work memory (%#llx, %#llx)",
(unsigned long long)mem, (unsigned long long)size);
if (!mem) rt_log("nv: no graphics work memory given; the driver allocates through the graphics allocator");
plat_mutex_lock(&lock);
nv.memory = mem;
nv.memory_size = size;
nv.initialized = 1;
plat_mutex_unlock(&lock);
rt_log("nv: graphics work memory %#llx+%#llx recorded", (unsigned long long)mem,
(unsigned long long)size);
}
// ---- nn::vi: the identities are small zeroed blocks in the guest-visible kernel region, in case SDK code reads them
static int vi_ready;
static void *display, *layer, *window;
// void nn::vi::Initialize()
static void ov_vi_initialize(Cpu *c) {
(void)c;
plat_mutex_lock(&lock);
if (!display) {
display = mem_kernel_alloc(64, 16);
layer = mem_kernel_alloc(64, 16);
window = mem_kernel_alloc(64, 16);
}
vi_ready = 1;
plat_mutex_unlock(&lock);
}
static int vi_up(void) {
plat_mutex_lock_shared(&lock);
int r = vi_ready;
plat_mutex_unlock_shared(&lock);
return r;
}
// Result nn::vi::OpenDefaultDisplay(Display **out)
static void ov_open_display(Cpu *c) {
void **out = arg_p(c, 0);
if (!out || !vi_up()) { ret_x(c, VI_R_INVALID); return; }
*out = display;
ret_x(c, 0);
}
// Result nn::vi::CreateLayer(Layer **out, Display *display)
static void ov_create_layer(Cpu *c) {
void **out = arg_p(c, 0);
if (!out || !vi_up() || arg_p(c, 1) != display) { ret_x(c, VI_R_INVALID); return; }
*out = layer;
ret_x(c, 0);
}
// Result nn::vi::GetNativeWindow(void **out, Layer *layer): a placeholder the NVN layer recognises
static void ov_native_window(Cpu *c) {
void **out = arg_p(c, 0);
if (!out || !vi_up() || arg_p(c, 1) != layer) { ret_x(c, VI_R_INVALID); return; }
*out = window;
ret_x(c, 0);
}
// Result nn::vi::GetDisplayVsyncEvent(os::SystemEventType *event, Display *display): auto-clear system event
static void ov_vsync_event(Cpu *c) {
uint64_t ev = arg_x(c, 0);
if (!ev || !vi_up() || arg_p(c, 1) != display) { ret_x(c, VI_R_INVALID); return; }
kern_bind_system_event(c, ev, 1);
gfx_vsync_bind(ev);
ret_x(c, 0);
}
// void *nvnBootstrapLoader(const char *name): the first NVN call
static void ov_nvn_bootstrap(Cpu *c) {
const char *name = arg_p(c, 0);
if (!name) name = "(null)";
static int32_t first = 1;
if (rt_config()->boot && plat_xchg32(&first, 0)) rt_boot_event("nvn", c, name); // ends --boot; returns
// when --seconds goes on
ret_x(c, nvn_proc_address(name));
}
// The NVN procs need their synthetic addresses before hostfn_seal; the loader seals at the end of rt_boot, so the
// registration runs at start-up instead of through boot.c.
__attribute__((constructor)) static void ov_nvn_procs_register(void) { nvn_procs_register(); }
// ---- Switch 2 vi display and layer queries. The SDK versions reach the display and layer objects through the
// vi service; the overridden OpenDefaultDisplay/CreateLayer hand out host stand-ins, so the SDK code would call
// through them (main+0x4dc1e0 hit a null virtual in ClearLayerExtendedSwapInterval). A desktop window is SDR,
// fixed 60 Hz, without VRR; HDR metadata and swap-interval changes are accepted and dropped.
static void vi_ok(Cpu *c) { ret_x(c, 0); }
// Result QueryDisplayHdrStatus(bool *enabled, HdrOutputFormat *format, uint16_t *peak, const Display *)
static void ov_vi_hdr_status(Cpu *c) {
uint8_t *on = arg_p(c, 0);
uint32_t *format = arg_p(c, 1);
uint16_t *peak = arg_p(c, 2);
if (on) *on = 0;
if (format) *format = 0;
if (peak) *peak = 0;
ret_x(c, 0);
}
// Result QueryDisplayHdrPaperWhite(uint16_t *nits, const Display *): the SDR reference white
static void ov_vi_paper_white(Cpu *c) {
uint16_t *nits = arg_p(c, 0);
if (nits) *nits = 203;
ret_x(c, 0);
}
// Result QueryDisplayCurrentRefreshRate(RefreshRate *rate, bool *variable, const Display *): RefreshRate is taken
// to be a 32-bit Hz value (a guess: no reference describes it); 60, not variable.
static void ov_vi_refresh_rate(Cpu *c) {
uint32_t *rate = arg_p(c, 0);
uint8_t *variable = arg_p(c, 1);
const char *hz = cfg_get("NX2NAVI_VI_HZ"), *vrr = cfg_get("NX2NAVI_VI_VRR");
if (rate) *rate = hz && *hz ? (uint32_t)atoi(hz) : 60;
if (variable) *variable = vrr && !strcmp(vrr, "1");
static int logged;
if (!logged++) rt_log("vi: QueryDisplayCurrentRefreshRate -> %u Hz, variable %d", rate ? *rate : 0, variable ? *variable : -1);
ret_x(c, 0);
}
// Result QueryDisplayVrrSupported(bool *supported, const Display *)
static void ov_vi_vrr_supported(Cpu *c) {
uint8_t *out = arg_p(c, 0);
const char *vrr = cfg_get("NX2NAVI_VI_VRR");
if (out) *out = vrr && !strcmp(vrr, "1");
static int logged;
if (!logged++) rt_log("vi: QueryDisplayVrrSupported -> %d", out ? *out : -1);
ret_x(c, 0);
}
HOST_OVERRIDE("_ZN2nn2vi21QueryDisplayHdrStatusEPbPNS0_15HdrOutputFormatEPtPKNS0_7DisplayE", ov_vi_hdr_status);
HOST_OVERRIDE("_ZN2nn2vi25QueryDisplayHdrPaperWhiteEPtPKNS0_7DisplayE", ov_vi_paper_white);
HOST_OVERRIDE("_ZN2nn2vi30QueryDisplayCurrentRefreshRateEPNS0_11RefreshRateEPbPKNS0_7DisplayE", ov_vi_refresh_rate);
HOST_OVERRIDE("_ZN2nn2vi24QueryDisplayVrrSupportedEPbPKNS0_7DisplayE", ov_vi_vrr_supported);
HOST_OVERRIDE("_ZN2nn2vi52SetLayerNextHdrStandardContentLuminanceRangeMetadataEPNS0_5LayerEtt", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi52SetLayerNextHdrExtendedContentLuminanceRangeMetadataEPNS0_5LayerEtt", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi35SetLayerNextHdrContentGamutMetadataEPNS0_5LayerENS0_15HdrContentGamutE", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi39SetLayerNextHdrToSdrToneMappingMetadataEPNS0_5LayerENS0_14HdrToneMappingE", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi28SetLayerExtendedSwapIntervalEPNS0_5LayerEii", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi30ClearLayerExtendedSwapIntervalEPNS0_5LayerE", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi36SetDisplay120HzRefreshRateCapabilityEPNS0_7DisplayEb", vi_ok);
HOST_OVERRIDE("_ZN2nn2vi23SetDisplayVrrCapabilityEPNS0_7DisplayEb", vi_ok);
HOST_OVERRIDE("_ZN2nv20SetGraphicsAllocatorEPFPvmmS0_EPFvS0_S0_EPFS0_S0_mS0_ES0_", ov_graphics_allocator);
HOST_OVERRIDE("_ZN2nv18InitializeGraphicsEPvm", ov_initialize_graphics);
// void nv::InitCheck(): the SDK's checks its own "graphics initialised" state, which the overridden
// InitializeGraphics never sets, and aborts (subsdk0's movie::VideoDecoder::Initialize calls it). The host's
// record answers instead.
static void ov_nv_init_check(Cpu *c) {
(void)c;
if (!nv.initialized) rt_fatal("nv::InitCheck: graphics not initialised (nv::InitializeGraphics was not called)");
}
HOST_OVERRIDE("_ZN2nv9InitCheckEv", ov_nv_init_check);
HOST_OVERRIDE("_ZN2nv28SetGraphicsDevtoolsAllocatorEPFPvmmS0_EPFvS0_S0_EPFS0_S0_mS0_ES0_", ov_devtools_allocator);
HOST_OVERRIDE("_ZN2nn2vi10InitializeEv", ov_vi_initialize);
HOST_OVERRIDE("_ZN2nn2vi18OpenDefaultDisplayEPPNS0_7DisplayE", ov_open_display);
HOST_OVERRIDE("_ZN2nn2vi11CreateLayerEPPNS0_5LayerEPNS0_7DisplayE", ov_create_layer);
HOST_OVERRIDE("_ZN2nn2vi15GetNativeWindowEPPvPNS0_5LayerE", ov_native_window);
HOST_OVERRIDE("_ZN2nn2vi20GetDisplayVsyncEventEPNS_2os15SystemEventTypeEPNS0_7DisplayE", ov_vsync_event);
HOST_OVERRIDE("nvnBootstrapLoader", ov_nvn_bootstrap);