mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-16 11:49:59 -04:00
mouse_mode = direct is the default, but on 1.1.1 it did nothing: only the 1.4.3 patch table had the sites, so the mouse always went through the stick emulation, which gives no turn at slow mouse speeds and tops out at about 107 degrees a second. The 1.1.1 table now has the set mouse_direct (on by default): at main+0x37c45c, where the camera's input update holds the processed stick in s1 and s0, a host call performs the displaced store and adds the raw mouse counts to both, so the mouse meets no dead zone and no curve; at main+0x37c4f0 a second call clears the idle bit for an update the mouse moved in. The counts are divided by the frames the game steps per update and by the stick camera speed, so the same hand movement turns the same angle at every frame rate. The Controls tab gets the mouse mode and mouse sensitivity rows, and mouse_mode = stick or NX2NAVI_MOUSE_DIRECT_PATCH=0 gives the old behaviour. Checked here: the generator lifts the 1.1.1 game with the two sites (it compares each site's original word), the lifted game compiles and links with the runtime, and tests/mouse_direct_check.py passes its 1.1.1 harness (register contract, displaced store and load, equal turn at every frame rate and stick speed, the reset pause, capture and mode). Not checked here: the game was not run, so aiming with the mouse was not tried, and the differential tests against Unicorn were not run because no Python on this PC has Unicorn. The contributor measured 0.0800 degrees per count on both axes in the game. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> (cherry picked from commit bb8fecfbe43517006eafd7be9c22e8dbe9601de7)
402 lines
24 KiB
Python
402 lines
24 KiB
Python
"""Check the direct camera hook's register contract and raw-count routing without game data.
|
|
|
|
Usage: python tests/mouse_direct_check.py --cc <clang.exe>
|
|
"""
|
|
import argparse
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import tempfile
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
# What both harnesses stand in for the rest of the runtime with.
|
|
STUBS = r'''
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include "mouse_direct.c"
|
|
static int raw_x, raw_y, takes, captured=1, foreground=1, allowed=1, mode=1, patched=1, selecting;
|
|
static float ratio=0.5f, frames=1, speed=1;
|
|
static double sens=1;
|
|
static uint64_t now=1000000000;
|
|
static GuestFn hook, activity_hook, begin_hook, angles_hook, hand_hook;
|
|
const char *cfg_get(const char *key) { return strcmp(key, "NX2NAVI_MOUSE_MODE") ? NULL : mode ? "direct" : "stick"; }
|
|
const char *cfg_value(const char *key) { return cfg_get(key); }
|
|
double cfg_double(const char *key) { (void)key; return sens; }
|
|
float frame_step_frames(void) { return frames; }
|
|
float cam_speed_applied(void) { return speed; }
|
|
int rt_patch_set(const char *s) { (void)s; return 0; }
|
|
int rt_patch_enabled(int s) { (void)s; return patched; }
|
|
int ikb_captured(void) { return captured; }
|
|
int ikb_foreground(void) { return foreground; }
|
|
int input_cursor_allowed(void) { return allowed; }
|
|
int input_direct_mouse_selector_active(void) { return selecting; }
|
|
void ikb_mouse_take(int32_t *x, int32_t *y) { ++takes; *x=raw_x; *y=raw_y; raw_x=raw_y=0; }
|
|
void input_direct_mouse_sample(int enabled, int32_t *x, int32_t *y) {
|
|
*x=*y=0;
|
|
if(enabled && captured && foreground && allowed) ikb_mouse_take(x,y);
|
|
}
|
|
uint64_t plat_now_ns(void) { return now; }
|
|
int frame_step_realtime(void) { return 1; }
|
|
double frame_step_limit_hz(void) { return 60; }
|
|
void *rt_patch_page(void) { return ∶ }
|
|
void rt_register_host(uint64_t addr, GuestFn fn) {
|
|
if(addr==HOST_MOUSE_DIRECT) hook=fn; else if(addr==HOST_MOUSE_ACTIVITY) activity_hook=fn;
|
|
else if(addr==HOST_MOUSE_ORBIT_BEGIN) begin_hook=fn; else if(addr==HOST_MOUSE_ORBIT_ANGLES) angles_hook=fn;
|
|
else if(addr==HOST_MOUSE_HAND) hand_hook=fn; else abort();
|
|
}
|
|
void plat_mutex_lock(PlatMutex *m) { (void)m; }
|
|
void plat_mutex_unlock(PlatMutex *m) { (void)m; }
|
|
void rt_log(const char *fmt, ...) { (void)fmt; }
|
|
static float scalar(__uint128_t v) { float f; memcpy(&f,&v,4); return f; }
|
|
'''
|
|
|
|
HARNESS = STUBS + r'''
|
|
const int rt_game_version = 143;
|
|
int main(void) {
|
|
assert(hook && activity_hook && begin_hook && angles_hook && hand_hook);
|
|
Cpu c, expected;
|
|
unsigned char target[0x500] = {0};
|
|
memset(&c, 0x5a, sizeof c);
|
|
c.x[20]=(uintptr_t)target; c.x[21]=0; c.v[9]=c.v[10]=0;
|
|
expected=c;
|
|
raw_x=100; raw_y=-50;
|
|
hook(&c);
|
|
assert(fabsf(scalar(c.v[9])-2)<1e-6f);
|
|
assert(fabsf(scalar(c.v[10])-1)<1e-6f);
|
|
float stored; memcpy(&stored,target+0x420,4); assert(stored==scalar(c.v[9]));
|
|
expected.v[9]=c.v[9]; expected.v[10]=c.v[10]; assert(!memcmp(&expected,&c,sizeof c));
|
|
assert(input_direct_mouse_active());
|
|
// The next read sees no repeated movement. Gamepad/keyboard input is preserved.
|
|
expected=c; hook(&c); assert(!memcmp(&expected,&c,sizeof c));
|
|
// Equal mouse distance produces equal integrated input at 30, 60 and 144 Hz; there is no unit-circle clamp.
|
|
float rates[]={30,60,144};
|
|
for(int i=0;i<3;i++) {
|
|
ratio=30/rates[i]; raw_x=10000; raw_y=10000; c.v[9]=c.v[10]=0; hook(&c);
|
|
assert(fabsf(scalar(c.v[9])*ratio-100)<0.001f);
|
|
assert(fabsf(scalar(c.v[10])*ratio+100)<0.001f);
|
|
}
|
|
// One count is not discarded by a dead zone.
|
|
ratio=0.5f; raw_x=1; raw_y=0; c.v[9]=c.v[10]=0; hook(&c); assert(scalar(c.v[9])>0);
|
|
uint64_t stack[4]={0,0x123456789abcdef0ull,0x456789abcdef0123ull,0}; c.sp=(uintptr_t)stack;
|
|
// The flags are in w8 at the site: the game's next instruction stores w8 to +0x418, so memory is not touched.
|
|
uint32_t inactive=0x28, mem=0x77; memcpy(target+0x418,&mem,4);
|
|
c.x[8]=inactive; activity_hook(&c);
|
|
assert((uint32_t)c.x[8]==0x11);
|
|
uint32_t after; memcpy(&after,target+0x418,4); assert(after==mem);
|
|
assert(c.v[9]==stack[1] && c.v[8]==stack[2]);
|
|
// A controller-only update keeps the game's activity bits.
|
|
c.x[8]=inactive; activity_hook(&c); assert((uint32_t)c.x[8]==inactive);
|
|
// Disabled game camera input leaves raw counts for the menu's legacy mouse-to-stick path.
|
|
c.x[21]=1; raw_x=42; int before=takes; hook(&c);
|
|
assert(takes==before && raw_x==42 && !input_direct_mouse_active()); c.x[21]=0;
|
|
// Focus loss and host menus do not move the camera.
|
|
captured=0; before=takes; hook(&c); assert(takes==before); captured=1;
|
|
foreground=0; hook(&c); assert(takes==before); foreground=1;
|
|
allowed=0; hook(&c); assert(takes==before); allowed=1;
|
|
mode=0; hook(&c); assert(takes==before && !input_direct_mouse_active()); mode=1;
|
|
patched=0; hook(&c); assert(takes==before && !input_direct_mouse_active()); patched=1;
|
|
now+=150000001; assert(!input_direct_mouse_active());
|
|
// Orbit input removes the mouse from the stick path and writes equal degrees per count at the final angles.
|
|
unsigned char camera[0x300]={0}, frame[0x100]={0}, hand[0x300]={0};
|
|
uint64_t input_address=(uintptr_t)target; memcpy(camera+0x20,&input_address,8);
|
|
for(int rate=0;rate<3;rate++) {
|
|
memset(orbit_seen,0,sizeof orbit_seen);
|
|
ratio=30/rates[rate]; c.x[20]=(uintptr_t)target; c.x[21]=0; c.v[9]=c.v[10]=0;
|
|
raw_x=100; raw_y=-50; hook(&c);
|
|
guest_float_store((uintptr_t)camera+0x108,30); guest_float_store((uintptr_t)camera+0x120,40);
|
|
guest_float_store((uintptr_t)frame+0x44,30); guest_float_store((uintptr_t)frame+0x48,40);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c);
|
|
assert(guest_float((uintptr_t)target+0x420)==0 && guest_float((uintptr_t)target+0x424)==0);
|
|
c.x[20]=(uintptr_t)camera; c.sp=(uintptr_t)frame; angles_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x44)-26)<0.0001f);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x48)-32)<0.0001f);
|
|
assert(fabsf(guest_float((uintptr_t)camera+0x15c)-26)<0.0001f);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c); angles_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x48)-32)<0.0001f); // one sample cannot repeat next update
|
|
// The next input frame is stationary and the game's parameter update rewrites the old default target.
|
|
// Restoring the mouse's desired target makes the camera filter stay at the new pitch, not spring to zero.
|
|
c.x[20]=(uintptr_t)target; c.v[9]=c.v[10]=0; raw_x=raw_y=0; hook(&c);
|
|
guest_float_store((uintptr_t)camera+0x15c,0);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c);
|
|
float current=guest_float((uintptr_t)camera+0x108), goal=guest_float((uintptr_t)camera+0x15c);
|
|
assert(fabsf(goal-26)<0.0001f && fabsf((current+goal)*0.5f-26)<0.0001f);
|
|
// A later game filter overwrites the pitch after the begin hook. Neither a stationary frame nor the next
|
|
// tiny mouse delta may integrate from that recentered result.
|
|
guest_float_store((uintptr_t)camera+0x108,0);
|
|
guest_float_store((uintptr_t)camera+0x11c,5);
|
|
guest_float_store((uintptr_t)camera+0x10c,20);
|
|
guest_float_store((uintptr_t)camera+0x88,0.3f);
|
|
guest_float_store((uintptr_t)frame+0x44,0);
|
|
c.x[20]=(uintptr_t)camera; angles_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x44)-26)<0.0001f);
|
|
assert(fabsf(guest_float((uintptr_t)camera+0x15c)-7)<0.0001f);
|
|
assert(fabsf(guest_float((uintptr_t)camera+0x108)-12)<0.0001f);
|
|
for(int i=0;i<100;i++) {
|
|
guest_float_store((uintptr_t)frame+0x44,0); angles_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)camera+0x108)-12)<0.0001f);
|
|
}
|
|
c.x[20]=(uintptr_t)target; c.v[9]=c.v[10]=0; raw_y=1; hook(&c);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c);
|
|
guest_float_store((uintptr_t)frame+0x44,0);
|
|
c.x[20]=(uintptr_t)camera; angles_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x44)-26.08f)<0.0001f);
|
|
// An explicit controller recenter still hands pitch back to the game.
|
|
uint64_t recenter=0x20; memcpy(target+0x148,&recenter,8);
|
|
c.x[20]=(uintptr_t)target; c.v[9]=c.v[10]=0; hook(&c);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c);
|
|
guest_float_store((uintptr_t)frame+0x44,5);
|
|
c.x[20]=(uintptr_t)camera; angles_hook(&c);
|
|
assert(guest_float((uintptr_t)frame+0x44)==5);
|
|
memset(target+0x148,0,8);
|
|
memset(camera+0x88,0,4); memset(camera+0x10c,0,4); memset(camera+0x11c,0,4);
|
|
}
|
|
// A gamepad-only step (no mouse motion, no pitch hold) leaves the camera input and the angles as the game made them.
|
|
memset(orbit_seen,0,sizeof orbit_seen);
|
|
c.x[20]=(uintptr_t)target; c.x[21]=0; raw_x=raw_y=0; c.v[9]=c.v[10]=0;
|
|
{ float px=0.25f, py=-0.5f; memcpy(&c.v[9],&px,4); memcpy(&c.v[10],&py,4); }
|
|
hook(&c);
|
|
guest_float_store((uintptr_t)target+0x420,0.25f); guest_float_store((uintptr_t)target+0x424,0.75f);
|
|
guest_float_store((uintptr_t)frame+0x44,11); guest_float_store((uintptr_t)frame+0x48,22);
|
|
guest_float_store((uintptr_t)camera+0x15c,3);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c);
|
|
assert(guest_float((uintptr_t)target+0x420)==0.25f && guest_float((uintptr_t)target+0x424)==0.75f);
|
|
c.x[20]=(uintptr_t)camera; c.sp=(uintptr_t)frame; angles_hook(&c);
|
|
assert(guest_float((uintptr_t)frame+0x44)==11 && guest_float((uintptr_t)frame+0x48)==22);
|
|
assert(guest_float((uintptr_t)camera+0x15c)==3);
|
|
guest_float_store((uintptr_t)camera+0x108,30); guest_float_store((uintptr_t)camera+0x120,40);
|
|
for(int count=0;count<100;count++) {
|
|
c.x[20]=(uintptr_t)target; c.x[21]=0; c.v[9]=c.v[10]=0; raw_x=1; raw_y=0; hook(&c);
|
|
c.x[0]=(uintptr_t)camera; begin_hook(&c); c.x[20]=(uintptr_t)camera;
|
|
guest_float_store((uintptr_t)frame+0x44,guest_float((uintptr_t)camera+0x108));
|
|
guest_float_store((uintptr_t)frame+0x48,guest_float((uintptr_t)camera+0x120));
|
|
angles_hook(&c);
|
|
}
|
|
assert(fabsf(guest_float((uintptr_t)camera+0x120)-32)<0.001f);
|
|
// A held object receives mouse deltas after its own curves, once per sample, including with camera input off.
|
|
c.x[20]=(uintptr_t)target; c.v[9]=c.v[10]=0; raw_x=100; raw_y=50; ratio=0.5f; hook(&c);
|
|
c.x[19]=(uintptr_t)hand; c.x[8]=0x12345678; c.v[15]=0;
|
|
guest_float_store((uintptr_t)frame+0x60,0); hand_hook(&c);
|
|
assert(fabsf(guest_float((uintptr_t)frame+0x60)-2)<0.00001f);
|
|
assert(fabsf(scalar(c.v[15])+1)<0.00001f);
|
|
hand_hook(&c); assert(fabsf(scalar(c.v[15])+1)<0.00001f);
|
|
c.x[21]=1; raw_x=5; raw_y=6; hook(&c); assert(raw_x==0 && raw_y==0 && input_direct_mouse_active());
|
|
// A radial selector retains its virtual cursor between mouse packets, including repeated HID polls.
|
|
float cursor[2]={0}; int32_t selector[2], held_selector[2];
|
|
input_direct_mouse_radial(100,50,1,cursor,selector);
|
|
held_selector[0]=selector[0]; held_selector[1]=selector[1];
|
|
for(int i=0;i<100;i++) {
|
|
input_direct_mouse_radial(0,0,1,cursor,selector);
|
|
assert(selector[0]==held_selector[0] && selector[1]==held_selector[1]);
|
|
}
|
|
input_direct_mouse_radial(-100,-50,1,cursor,selector); assert(!selector[0] && !selector[1]);
|
|
input_direct_mouse_radial(100000,100000,1,cursor,selector);
|
|
assert((int64_t)selector[0]*selector[0]+(int64_t)selector[1]*selector[1]<=32768ll*32768);
|
|
// Quick lists must not latch a wheel direction or automatically drain a large flick after the mouse stops.
|
|
InputMouseRow row={0}; uint64_t row_time=0;
|
|
input_direct_mouse_row(10000,1,row_time,&row,selector); assert(selector[0]==32767 && !selector[1]);
|
|
input_direct_mouse_row(0,1,row_time+10000000,&row,selector); assert(selector[0]==32767);
|
|
for(int i=1;i<=100;i++) {
|
|
input_direct_mouse_row(0,1,row_time+i*100000000ull,&row,selector); assert(!selector[0] && !selector[1]);
|
|
}
|
|
// Repeated HID polls do not rearm a pulse; a frame that skips its deadline must still observe neutral first.
|
|
row=(InputMouseRow){0};
|
|
for(int i=0;i<31;i++) { input_direct_mouse_row(1,1,0,&row,selector); assert(!selector[0]); }
|
|
input_direct_mouse_row(1,1,0,&row,selector); assert(selector[0]==32767);
|
|
input_direct_mouse_row(1000,1,100000000,&row,selector); assert(!selector[0]);
|
|
input_direct_mouse_row(1000,1,110000000,&row,selector); assert(!selector[0]);
|
|
input_direct_mouse_row(1000,1,140000000,&row,selector); assert(selector[0]==32767);
|
|
input_direct_mouse_row(-1000,1,141000000,&row,selector); assert(!selector[0]);
|
|
input_direct_mouse_row(-1,1,180000000,&row,selector); assert(selector[0]==-32767);
|
|
selecting=1; c.x[20]=(uintptr_t)target; raw_x=42; raw_y=0; before=takes; hook(&c);
|
|
assert(takes==before && raw_x==42); selecting=0; raw_x=0;
|
|
puts("direct mouse: register contract, routing, linearity, frame ratio and capture checks passed");
|
|
puts("direct mouse: final orbit angles, single-count motion, equal axes and held-object routing passed");
|
|
puts("direct mouse: persistent pitch target, radial cursor hold and gamepad-only steps untouched passed");
|
|
puts("direct mouse: final-pitch recenter rejection, explicit handoff and bounded quick-list steps passed");
|
|
}
|
|
'''
|
|
|
|
# Ocarina 1.1.1 (recomp/patches-v111.txt, set mouse_direct): the two sites of camera_input_oot and camera_activity_oot.
|
|
OOT_HARNESS = STUBS + r'''
|
|
const int rt_game_version = 111;
|
|
int main(void) {
|
|
assert(hook && activity_hook && !begin_hook && !angles_hook && !hand_hook); // no orbit or held-object site
|
|
Cpu c, expected;
|
|
unsigned char target[0x600] = {0};
|
|
memset(&c, 0x5a, sizeof c);
|
|
c.x[20]=(uintptr_t)target; c.x[21]=0; c.v[1]=c.v[0]=0;
|
|
expected=c;
|
|
// s1 and s0 carry the processed x and y. 100 counts to the right and 50 up, at one frame per update.
|
|
raw_x=100; raw_y=-50;
|
|
hook(&c);
|
|
assert(fabsf(scalar(c.v[1])-100*(float)INPUT_OOT_COUNT_X)<1e-5f);
|
|
assert(fabsf(scalar(c.v[0])-50*(float)INPUT_OOT_COUNT_Y)<1e-5f);
|
|
// The displaced store of s1 at +0x538 carries the mouse's part; the store of s0 at +0x53c is the game's own.
|
|
float stored; memcpy(&stored,target+0x538,4); assert(stored==scalar(c.v[1]));
|
|
memcpy(&stored,target+0x53c,4); assert(stored==0);
|
|
expected.v[1]=c.v[1]; expected.v[0]=c.v[0]; assert(!memcmp(&expected,&c,sizeof c));
|
|
assert(input_direct_mouse_active() && input_direct_mouse_available());
|
|
// The next update sees no repeated movement.
|
|
expected=c; hook(&c); assert(!memcmp(&expected,&c,sizeof c));
|
|
// The game multiplies the processed stick by the frames it steps and by its camera speed: an equal mouse distance
|
|
// gives an equal turn at 30, 60 and 144 fps and at every stick camera speed, and nothing clamps a fast flick.
|
|
float steps[]={2,1,60/144.0f}, speeds[]={1,3};
|
|
for(int i=0;i<3;i++) for(int j=0;j<2;j++) {
|
|
frames=steps[i]; speed=speeds[j]; raw_x=10000; raw_y=10000; c.v[1]=c.v[0]=0; hook(&c);
|
|
assert(fabsf(scalar(c.v[1])*frames*speed-10000*(float)INPUT_OOT_COUNT_X)<0.01f);
|
|
assert(fabsf(scalar(c.v[0])*frames*speed+10000*(float)INPUT_OOT_COUNT_Y)<0.01f);
|
|
}
|
|
frames=speed=1;
|
|
// One count is not discarded by a dead zone, and the sensitivity scales it.
|
|
raw_x=1; raw_y=0; c.v[1]=c.v[0]=0; hook(&c); assert(scalar(c.v[1])>0);
|
|
float one=scalar(c.v[1]);
|
|
sens=2.5; raw_x=1; c.v[1]=c.v[0]=0; hook(&c); assert(fabsf(scalar(c.v[1])-2.5f*one)<1e-6f);
|
|
sens=0; raw_x=1; c.v[1]=c.v[0]=0; hook(&c); assert(c.v[1]==0 && c.v[0]==0); sens=1;
|
|
// The stick's own processed value stays and the mouse adds to it.
|
|
{ float px=0.25f, py=-0.5f; uint32_t b; memcpy(&b,&px,4); c.v[1]=b; memcpy(&b,&py,4); c.v[0]=b; }
|
|
raw_x=10; raw_y=0; hook(&c);
|
|
assert(fabsf(scalar(c.v[1])-(0.25f+10*(float)INPUT_OOT_COUNT_X))<1e-6f && scalar(c.v[0])==-0.5f);
|
|
// The idle bit of the flags (w8 at the second site) is cleared for an update the mouse moved in; the site's
|
|
// displaced ldp d9, d8, [sp, #0x10] is performed. The game's next instruction stores w8, so memory is not touched.
|
|
uint64_t stack[4]={0,0,0x123456789abcdef0ull,0x456789abcdef0123ull}; c.sp=(uintptr_t)stack;
|
|
uint32_t idle=0x38, mem=0x77; memcpy(target+0x530,&mem,4);
|
|
c.x[8]=idle; activity_hook(&c);
|
|
assert((uint32_t)c.x[8]==0x28);
|
|
uint32_t after; memcpy(&after,target+0x530,4); assert(after==mem);
|
|
assert(c.v[9]==stack[2] && c.v[8]==stack[3]);
|
|
// A controller-only update keeps the game's idle bit.
|
|
c.v[1]=c.v[0]=0; hook(&c); c.x[8]=idle; activity_hook(&c); assert((uint32_t)c.x[8]==idle);
|
|
// While the pause after a camera reset runs (+0x5e0) or camera input is off (w21 bit 0), the game reads no stick:
|
|
// the counts are left where they are and the registers as the game made them.
|
|
float pause=12; memcpy(target+0x5e0,&pause,4);
|
|
raw_x=42; int before=takes; c.v[1]=c.v[0]=0; expected=c; hook(&c);
|
|
assert(takes==before && raw_x==42 && !memcmp(&expected,&c,sizeof c));
|
|
assert(!input_direct_mouse_active());
|
|
pause=0; memcpy(target+0x5e0,&pause,4);
|
|
c.x[21]=1; hook(&c);
|
|
assert(takes==before && raw_x==42 && !input_direct_mouse_active()); c.x[21]=0;
|
|
selecting=1; hook(&c); assert(takes==before && raw_x==42); selecting=0;
|
|
// Focus loss and host menus do not move the camera.
|
|
captured=0; hook(&c); assert(takes==before); captured=1;
|
|
foreground=0; hook(&c); assert(takes==before); foreground=1;
|
|
allowed=0; hook(&c); assert(takes==before); allowed=1;
|
|
// Stick emulation: the counts stay for the stick path.
|
|
mode=0; hook(&c);
|
|
assert(takes==before && raw_x==42 && !input_direct_mouse_active()); mode=1;
|
|
patched=0; hook(&c);
|
|
assert(takes==before && !input_direct_mouse_active() && !input_direct_mouse_available()); patched=1;
|
|
raw_x=0; hook(&c); assert(input_direct_mouse_active());
|
|
now+=150000001; assert(!input_direct_mouse_active());
|
|
puts("direct mouse 1.1.1: register contract, displaced store and load, equal turn at every frame rate and stick speed passed");
|
|
puts("direct mouse 1.1.1: single count, sensitivity, stick kept, idle bit, reset pause, capture and mode checks passed");
|
|
}
|
|
'''
|
|
|
|
INPUT_HARNESS = r'''
|
|
#include <assert.h>
|
|
#include "input.c"
|
|
GfxStats gfx_counters;
|
|
InputMap input_map;
|
|
// Other input entry points are linked by PE unwind metadata; reaching them is outside this script-only test.
|
|
void ikb_cursor_update(void) { abort(); }
|
|
void ikb_menu_closed(void) { abort(); }
|
|
// The gamepad thread's (sdl_enter, probe_gamepad): not reached by a script.
|
|
void plat_wait_ns(uint64_t ns) { (void)ns; abort(); }
|
|
int plat_mutex_trylock(PlatMutex *m) { (void)m; abort(); }
|
|
int cfg_setenv(const char *name, const char *value) { (void)name; (void)value; abort(); }
|
|
const char *SDL_GetGamepadName(SDL_Gamepad *g) { (void)g; abort(); }
|
|
int cfg_bool(const char *key) { (void)key; abort(); }
|
|
int input_menu_gate(int *h,int open,uint64_t *b,int32_t s[4]) { (void)h;(void)open;(void)b;(void)s;abort(); }
|
|
int input_overlay_gate(int *h,uint64_t *b) { (void)h;(void)b;abort(); }
|
|
int menu_is_open(void) { abort(); }
|
|
void menu_toggle(void) { abort(); }
|
|
void menu_perf_cycle(void) { abort(); }
|
|
const char *input_action_name(int action) { (void)action;abort(); }
|
|
void input_map_configure(void) { abort(); }
|
|
int input_direct_mouse_active(void) { return 1; }
|
|
int input_direct_mouse_enabled(void) { return 1; }
|
|
static int row_calls, radial_calls, live_mouse;
|
|
void input_direct_mouse_row(int32_t dx,float sensitivity,uint64_t now,InputMouseRow *row,int32_t out[2]) {
|
|
(void)dx;(void)sensitivity;(void)now; row_calls++; out[0]=123;out[1]=0;row->direction=1;
|
|
}
|
|
void input_direct_mouse_radial(int32_t dx,int32_t dy,float sensitivity,float cursor[2],int32_t out[2]) {
|
|
(void)dx;(void)dy;(void)sensitivity;radial_calls++;cursor[0]=1;out[0]=456;out[1]=789;
|
|
}
|
|
static const char *script_path;
|
|
static uint64_t test_tick;
|
|
static int64_t test_world=-1;
|
|
const char *cfg_get(const char *key) {
|
|
if (!strcmp(key,"NX2NAVI_INPUT_SCRIPT")) return script_path;
|
|
if (!strcmp(key,"NX2NAVI_INPUT")) return "none";
|
|
return NULL;
|
|
}
|
|
unsigned cfg_version(void) { return 0; }
|
|
double cfg_double(const char *key) { (void)key; return 1; }
|
|
uint64_t frame_step_ticks(void) { return test_tick; }
|
|
int64_t frame_step_world_us(void) { return test_world; }
|
|
void rt_log(const char *fmt, ...) { (void)fmt; }
|
|
void plat_mutex_lock(PlatMutex *m) { (void)m; }
|
|
void plat_mutex_unlock(PlatMutex *m) { (void)m; }
|
|
int ikb_captured(void) { return live_mouse; }
|
|
int ikb_foreground(void) { return 0; }
|
|
void ikb_mouse_take(int32_t *x,int32_t *y) { *x=*y=0; }
|
|
uint64_t plat_now_ns(void) { return 1000000000ull; }
|
|
int main(int argc,char **argv) {
|
|
assert(argc==2); script_path=argv[1];
|
|
uint64_t buttons=0; int32_t left[2]={0},right[2]={0},dx,dy;
|
|
test_tick=10;
|
|
for(int i=0;i<3;i++) script_apply(&buttons,left,right);
|
|
input_direct_mouse_sample(1,&dx,&dy);
|
|
assert(dx==123 && dy==-45 && !buttons && !right[0] && !right[1]);
|
|
input_direct_mouse_sample(1,&dx,&dy); assert(!dx && !dy);
|
|
test_tick=20; script_apply(&buttons,left,right);
|
|
g_menu=1; input_direct_mouse_sample(1,&dx,&dy); assert(!dx && !dy);
|
|
g_menu=0; input_direct_mouse_sample(1,&dx,&dy); assert(!dx && !dy);
|
|
test_world=100000;
|
|
for(int i=0;i<3;i++) script_apply(&buttons,left,right);
|
|
rec=tmpfile(); assert(rec); rec_state=1;
|
|
input_direct_mouse_sample(1,&dx,&dy); assert(dx==-100 && dy==50);
|
|
rewind(rec); char line[128]; assert(fgets(line,sizeof line,rec));
|
|
assert(strstr(line,"MOUSE -100 50")); assert(!fgets(line,sizeof line,rec));
|
|
fclose(rec); rec_state=-1;
|
|
live_mouse=1;
|
|
mouse_camera(right,1); assert(radial_calls==1 && !row_calls && right[0]==456 && right[1]==789);
|
|
assert(input_direct_mouse_selector_active());
|
|
mouse_camera(right,2); assert(row_calls==1 && radial_calls==1 && right[0]==123 && !right[1]);
|
|
mouse_camera(right,0); assert(!input_direct_mouse_selector_active() && !right[0] && !right[1]);
|
|
mouse_camera(right,3); assert(row_calls==2 && right[0]==123 && !right[1]);
|
|
live_mouse=0; mouse_camera(right,3);
|
|
assert(!input_direct_mouse_selector_active() && !right[0] && !right[1]);
|
|
puts("direct mouse: one-shot script replay, host-menu blocking and raw-count recording passed");
|
|
puts("direct mouse: separate wheel/list routing, selector ownership and release passed");
|
|
}
|
|
'''
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description=__doc__)
|
|
ap.add_argument('--cc', required=True)
|
|
ap.add_argument('--deps', type=Path, help='dependency include directory (SDL3/Vulkan), to also check input scripts')
|
|
args = ap.parse_args()
|
|
with tempfile.TemporaryDirectory(prefix='nx2navi-mouse-') as tmp:
|
|
folder = Path(tmp)
|
|
(folder / 'patches.h').write_text('#define RT_PATCH_PAGE 0x7003adf000ull\n')
|
|
source = folder / 'check.c'
|
|
exe = folder / ('check.exe' if os.name == 'nt' else 'check')
|
|
link = [] if os.name == 'nt' else ['-lm']
|
|
for harness in (HARNESS, OOT_HARNESS):
|
|
source.write_text(harness)
|
|
subprocess.run([args.cc, '-O2', '-Wall', '-Wextra', '-I', str(folder), '-I', str(ROOT/'runtime'),
|
|
str(source), *link, '-o', str(exe)], check=True)
|
|
subprocess.run([str(exe)], check=True)
|
|
if args.deps:
|
|
source.write_text(INPUT_HARNESS)
|
|
script = folder / 'input.txt'
|
|
script.write_text('10 MOUSE 123 -45\n20 MOUSE 1000 0\n@100 MOUSE -100 50\n')
|
|
subprocess.run([args.cc, '-O2', '-flto', '-ffunction-sections', '-fdata-sections', '-Wl,--gc-sections', *(['-fuse-ld=lld', '-Wl,--exclude-all-symbols'] if os.name == 'nt' else []),
|
|
'-I', str(ROOT/'runtime'), '-I', str(args.deps), '-I', str(args.deps/'vma'),
|
|
str(source), *link, '-o', str(exe)], check=True)
|
|
subprocess.run([str(exe), str(script)], check=True)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|