Files
Triforce-Source/tests/input_background_test.c
ruckus7382sfgsgdf e6f2f248f2 Triforce v0.7.0 "Sage Of Courage"
The 0.6 crashes after warps and area changes fixed (no write-back into memory the capture leaves out), invisible objects fixed (occlusion gate), DLSS frame generation flicker fixed, achievements, the renderer built with a play profile, faster translated game code, helper threads judged on settled scenes, memory, shader preparation, audio effects, launcher, controls and Linux fixes.
2026-11-22 11:59:06 -06:00

319 lines
16 KiB
C

/* Authored memory, clock and API spies; input_actual.inc contains the unmodified production path. */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL:%d %s\n", __LINE__, #x); exit(1); } } while (0)
#include "input_constants.inc"
/* API spies must not collide with Windows SDK/import-library names. */
#define GetCurrentProcessId fixture_GetCurrentProcessId
#define InterlockedCompareExchange64 fixture_InterlockedCompareExchange64
typedef void *HWND;
typedef uint32_t DWORD;
typedef intptr_t LONG_PTR;
typedef struct { uint64_t x[32]; } Ctx;
enum { GWL_EXSTYLE = -20, WS_EX_TOOLWINDOW = 0x80, WS_EX_NOACTIVATE = 0x8000000,
VK_MENU = 0x12, VK_RETURN = 0x0d, VK_ESCAPE = 0x1b, VK_LEFT = 0x25, VK_UP, VK_RIGHT, VK_DOWN,
VK_LBUTTON = 1, VK_RBUTTON = 2, VK_MBUTTON = 4, VK_XBUTTON1 = 5, VK_XBUTTON2 = 6,
VK_TAB = 0x09, VK_SHIFT = 0x10, VK_CONTROL = 0x11, VK_CAPITAL = 0x14 }; /* (the Walk key row's keys) */
static int front, menu_background, bootstrap_polls, pad_merges, key_queries, mouse_queries, focus_queries, commands;
static int no_window; /* (no window in front at all: GetForegroundWindow answers NULL) */
typedef int64_t LONG64;
volatile LONG64 hos_present_count = 1000;
static int frame_reads;
LONG64 InterlockedCompareExchange64(volatile LONG64 *p, LONG64 value, LONG64 expected) {
const LONG64 old = *p;
frame_reads++;
if (old == expected) *p = value;
return old;
}
static int64_t now_ns = 10000000000LL, sampling;
static int key_bind[HOS_KEY_N][2], pad_raw_now; /* (the keys-only controls after the Switch's buttons) */
static unsigned char *memory;
static char last_log[256];
volatile int64_t hos_hid_last_read;
volatile int hos_nvn_sync_log_on;
static void *at(uint64_t address) { CHECK(address <= 512 - 8); return memory + address; }
#define GP(a) at(a)
#define G32(a) (*(uint32_t *)at(a))
#define G64(a) (*(uint64_t *)at(a))
#define ARG(n) (c->x[n])
#define RET(value) (c->x[0] = (uint64_t)(value))
/* (the Insert menu's Walk key row and Walk scale, 0 the scale's default, and whether Caps Lock, the row's first key, is held) */
static int walk_row, walk_scale, walk_held;
/* ((Triforce) the "options-back" case: our options open (rx_option 1) over the game's Options screen, the mouse's right
button held, and the game's Back tapped for it) */
static int options_open, options_front, right_held;
static char tapped[64];
int rx_option(int id, int otherwise) {
if (id == HOS_OPT_WALK_KEY) return walk_row;
if (id == 1 && options_open) return 1;
if (id == HOS_OPT_WALK_SCALE && walk_scale) return walk_scale;
return id == 4 ? menu_background : id == 1 ? 0 : otherwise;
}
int64_t hos_now_ns(void) { return now_ns; }
void hos_log(const char *format, ...) {
va_list args; va_start(args, format); vsnprintf(last_log, sizeof last_log, format, args); va_end(args);
}
HWND GetForegroundWindow(void) { focus_queries++; return no_window ? (HWND)0 : (HWND)(uintptr_t)(front ? 1 : 2); }
/* (the program in front, by its file name: production asks Windows) */
static void front_program(DWORD pid, char *name, int size) { (void)pid; snprintf(name, (size_t)size, "fixture.exe"); }
DWORD GetWindowThreadProcessId(HWND window, DWORD *pid) { *pid = window == (HWND)(uintptr_t)1 ? 10 : 20; return 1; }
DWORD GetCurrentProcessId(void) { return 10; }
LONG_PTR GetWindowLongPtrA(HWND window, int index) { (void)window; (void)index; return 0; }
int GetClassNameA(HWND window, char *text, int size) { (void)window; return snprintf(text, (size_t)size, "fixture"); }
short GetAsyncKeyState(int key) {
key_queries++;
return key == 'P' || key == 'D' || (walk_held && key == VK_CAPITAL) || (right_held && key == VK_RBUTTON) ? (short)-32768 : 0;
}
int hos_sdl_pads(uint64_t *buttons, int32_t stick[4]) {
bootstrap_polls++; *buttons = 1ULL << B_Y; stick[0] = -31000; return 1;
}
void pads_read(uint64_t *buttons, int32_t stick[4]) {
/* The physical backend boundary is a spy; actual routing merges its result with the script below. */
pad_merges++; *buttons |= 1ULL << B_B; stick[0] = -12000; stick[2] = 8000;
}
void binds_load(void) {
key_bind[B_X][0] = 'P';
/* (the left stick's and the camera's keys are bindings too: the defaults, WASD and the arrows) */
key_bind[HOS_KEY_MOVE_UP][0] = 'W', key_bind[HOS_KEY_MOVE_DOWN][0] = 'S', key_bind[HOS_KEY_MOVE_LEFT][0] = 'A';
key_bind[HOS_KEY_MOVE_RIGHT][0] = 'D', key_bind[HOS_KEY_CAM_UP][0] = VK_UP, key_bind[HOS_KEY_CAM_DOWN][0] = VK_DOWN;
key_bind[HOS_KEY_CAM_LEFT][0] = VK_LEFT, key_bind[HOS_KEY_CAM_RIGHT][0] = VK_RIGHT;
}
/* the native mouse look (no camera found: the motion goes to mouse_stick) and the mouse's sensitivity, which
read_input calls */
int hos_mouse_native(void) { return -1; }
void hos_mouse_native_free(int free) { (void)free; }
/* ((Triforce, 11-22) whether the right stick turns the camera, told after every read: behind another window too, where the
pads alone turned it, and the native mouse put the angles back each frame) */
static int native_held = -1;
void hos_mouse_native_stick(int held) { native_held = held; }
static void mouse_setup(void) {}
static void mouse_sens_keys(void) {}
int mouse_stick(int32_t *x, int32_t *y, int held) { (void)x; (void)y; (void)held; mouse_queries++; return 0; }
/* (the options tabs inside the game's own Options screen, which read_input looks at: never open here, so the Back it
would tap for the game is never asked for) */
int hos_binding(int set, int button, int slot) { (void)set; (void)button; (void)slot; return -1; }
int hos_oot_options_front(void) { return options_front; }
/* (the sprint button, which takes its press out of the buttons while Link plays: off here; and the pipeline crawl's
lines of a live script, which no case writes) */
void hos_oot_sprint_pad(uint64_t *buttons) { (void)buttons; }
void hos_oot_live_crawl(const char *line) { (void)line; CHECK(!"unexpected crawl line"); }
void hos_hid_tap(const char *press) { CHECK(options_front && "unexpected tap of the game's Back"); snprintf(tapped, sizeof tapped, "%s", press); }
void rx_request_frame_dump(void) { commands++; }
void rx_set_screenshot_ms(int64_t ms) { (void)ms; commands++; }
void rx_request_rdoc_capture(int frames) { (void)frames; commands++; }
void rx_flash_dark_arm(void) { commands++; }
#include "input_actual.inc"
static void packet(uint64_t buttons, int32_t lx, int32_t ly, int32_t rx) {
static int64_t expected_sampling;
Ctx context = {{0}};
context.x[0] = 64; context.x[1] = 2; context.x[2] = 16; context.x[30] = 0x1234;
G32(16) = NPAD_NO1;
memset(memory + 64, 0xa5, 2 * STATE_SIZE + 8);
native_held = -1;
npad_states(&context);
CHECK(context.x[0] == 2);
CHECK(native_held == (rx != 0)); /* (the stick the game is given, told to the native mouse, the window in front or not) */
expected_sampling++;
for (int i = 0; i < 2; i++) {
const uint64_t address = 64 + (uint64_t)i * STATE_SIZE;
CHECK(G64(address) == (uint64_t)(expected_sampling - i));
CHECK(G64(address + 8) == buttons);
CHECK((int32_t)G32(address + 16) == lx && (int32_t)G32(address + 20) == ly);
CHECK((int32_t)G32(address + 24) == rx && G32(address + 28) == 0);
CHECK(G32(address + 32) == ATTR_CONNECTED && G32(address + 36) == 0);
}
for (int i = 0; i < 8; i++) CHECK(memory[64 + 2 * STATE_SIZE + i] == 0xa5);
CHECK(commands == 0);
CHECK(hos_npad_buttons == buttons); /* (the mods' cheats see the buttons the game was given: host/mod_cheats.c) */
}
static void append_live(const char *text) {
const char *path = getenv("HOS_INPUT_LIVE"); CHECK(path);
FILE *file = fopen(path, "ab"); CHECK(file);
CHECK(fputs(text, file) >= 0 && fclose(file) == 0);
}
static void frame_clock_case(const char *name) {
const int hold = !strcmp(name, "frame-hold");
const int live = !strcmp(name, "live-frame");
const int reuse = !strcmp(name, "reuse-frame");
const int wall = !strcmp(name, "wall") || !strcmp(name, "zero") || !strcmp(name, "empty");
CHECK(hold || live || reuse || wall);
front = hold || wall;
packet(hold || wall ? 1ULL << B_A : 0, 0, hold || wall ? 32767 : 0, 0);
if (hold) {
now_ns += 7000000000LL; /* no native present returns during a compile */
packet(1ULL << B_A, 0, 32767, 0);
CHECK(hos_hid_last_read == now_ns); /* HID diagnostics stay wall-clock */
hos_present_count = 1011;
packet(1ULL << B_A, 0, 32767, 0);
hos_present_count = 1012; /* exactly 200 virtual ms, relative to initial frame 1000 */
packet(0, 0, 0, 0);
CHECK(pad_merges == 0 && key_queries == 0 && mouse_queries == 0);
hos_present_count = 1311;
packet(0, 0, 0, 0); /* exclusive margin still held at 5183 ms */
hos_present_count = 1312;
packet((1ULL << B_B) | (1ULL << B_X), 32767, 0, 8000);
CHECK(pad_merges > 0 && frame_reads > 0);
} else if (wall) {
now_ns += 7000000000LL;
packet((1ULL << B_B) | (1ULL << B_X), 32767, 0, 8000);
CHECK(pad_merges > 0 && frame_reads == 0);
} else if (live) {
append_live("0:A+LUP/200"); now_ns += 30000000;
packet(0, 0, 0, 0); /* incomplete live line remains unconsumed */
hos_present_count = 1060;
append_live("\n"); now_ns += 30000000;
packet(1ULL << B_A, 0, 32767, 0);
CHECK(presses[0].start_ms == 1000 && presses[0].end_ms == 1200);
append_live("0:B/200\n"); now_ns += 5000000;
packet(1ULL << B_A, 0, 32767, 0); /* file polling stays on the 30 ms wall clock */
now_ns += 30000000;
packet((1ULL << B_A) | (1ULL << B_B), 0, 32767, 0);
CHECK(presses[1].start_ms == 1000);
now_ns += 7000000000LL;
packet((1ULL << B_A) | (1ULL << B_B), 0, 32767, 0);
hos_present_count = 1072;
packet(0, 0, 0, 0);
} else {
for (int i = 0; i < MAX_PRESSES; i++) CHECK(parse_presses("0:A/200", 0, 1) == 1);
now_ns += 7000000000LL;
CHECK(parse_presses("0:B/200", 0, 1) == 0);
hos_present_count = 1012;
CHECK(parse_presses("0:B/200", 200, 1) == 0); /* original strict reuse boundary */
hos_present_count = 1013;
CHECK(parse_presses("0:B/200", 216, 1) == 1);
packet(1ULL << B_B, 0, 0, 0);
CHECK(npresses == MAX_PRESSES);
}
CHECK(bootstrap_polls == 1);
}
int main(int argc, char **argv) {
CHECK(argc == 2);
CHECK(!pads_in_background(NULL, 0)); /* out of the box: the window in front only */
CHECK(pads_in_background(NULL, 1)); /* the menu's row */
CHECK(pads_in_background("1", 0)); /* HOS_INPUT_BACKGROUND=1 without the menu */
CHECK(!pads_in_background("0", 1)); /* HOS_INPUT_BACKGROUND=0 wins over the menu */
memory = calloc(512, 1); CHECK(memory);
const char *name = argv[1];
if (!strcmp(name, "frame-hold") || !strcmp(name, "live-frame") || !strcmp(name, "reuse-frame") ||
!strcmp(name, "wall") || !strcmp(name, "zero") || !strcmp(name, "empty")) {
frame_clock_case(name);
printf("PASS: actual input frame clock %s\n", name);
free(memory);
return 0;
}
if (!strcmp(name, "no-window")) {
/* No window is in front for a moment, with the game's in front before it: the pads and the keys still count. For
longer than a quarter of a second nothing counts, and everything counts again once the game's window is back */
const uint64_t held = (1ULL << B_B) | (1ULL << B_X);
front = 1;
packet((1ULL << B_A) | held, 32767, 32767, 8000);
now_ns += 201000000;
no_window = 1;
packet(held, 32767, 0, 8000);
const int merges = pad_merges, keys = key_queries;
now_ns += 251000000;
packet(0, 0, 0, 0);
CHECK(pad_merges == merges && key_queries == keys);
CHECK(strstr(last_log, "game window not in front"));
no_window = 0;
now_ns += 3000000;
packet(held, 32767, 0, 8000);
CHECK(strstr(last_log, "was not in front for"));
CHECK(bootstrap_polls == 1);
printf("PASS: no window in front for a moment keeps the input %s\n", name);
free(memory);
return 0;
}
if (!strcmp(name, "options-back")) {
/* (Triforce) Our tabs open inside the game's own Options screen, left: with the mouse's right button held (the menu's
Back, as Esc is) the game's Back is tapped for it, as for the pad's B and Esc; left with nothing held (L or R, a
click on the game's own tab), no tap */
front = 1, options_front = 1;
Ctx context = {{0}};
for (int step = 0; step < 6; step++) {
options_open = step == 1 || step == 4, right_held = step >= 4;
context.x[0] = 64, context.x[1] = 2, context.x[2] = 16, context.x[30] = 0x1234;
G32(16) = NPAD_NO1;
npad_states(&context);
now_ns += 16666667;
if (step == 2) CHECK(tapped[0] == 0);
}
CHECK(!strcmp(tapped, "0:B/80"));
printf("PASS: our tabs left with the right button are the game's Back too %s\n", name);
free(memory);
return 0;
}
if (!strcmp(name, "walk")) {
/* (Triforce) The Walk key row. The script holds A and the left stick up; the pad holds B and its stick 12000 to
the left; the keys hold P (X) and D (move right). Off, D pushes the stick all the way. Caps Lock chosen and not
held: the same. Held: D pushes it 0.51 of the way, the row's default, and the script's push up is as it was;
0.90 the same way; at 0.20 the pad's 12000 is the further of the two and is what the game gets, as of any two
sticks. Off again with the key still held: all the way */
const uint64_t all = (1ULL << B_A) | (1ULL << B_B) | (1ULL << B_X);
front = 1;
packet(all, 32767, 32767, 8000);
walk_row = 1;
packet(all, 32767, 32767, 8000);
walk_held = 1;
packet(all, 16711, 32767, 8000);
walk_scale = 90;
packet(all, 29490, 32767, 8000);
walk_scale = 20;
packet(all, -12000, 32767, 8000);
walk_row = 0;
packet(all, 32767, 32767, 8000);
walk_row = 2, walk_scale = 0; /* (Shift is the walk key, and it is Caps Lock that is held: no walk) */
packet(all, 32767, 32767, 8000);
CHECK(bootstrap_polls == 1);
printf("PASS: the walk key scales the movement keys' stick alone %s\n", name);
free(memory);
return 0;
}
front = !strcmp(name, "foreground") || !strcmp(name, "exclusive-foreground");
menu_background = !strcmp(name, "pads-menu") || !strcmp(name, "pads-off");
const int exclusive = !strncmp(name, "exclusive-", 10);
const int pads = !exclusive && (front || !strcmp(name, "pads-env") || !strcmp(name, "pads-menu"));
const uint64_t physical = pads ? (1ULL << B_B) | (front ? 1ULL << B_X : 0) : 0;
if (!strcmp(name, "live-background")) {
packet(0, 0, 0, 0);
append_live("0:A+LUP/200"); now_ns += 30000000;
packet(0, 0, 0, 0); /* incomplete authored line is not consumed */
append_live("\n"); now_ns += 30000000;
packet(1ULL << B_A, 0, 32767, 0);
now_ns += 200000000;
packet(0, 0, 0, 0); /* consumed once, then released at the actual hold boundary */
} else if (!strcmp(name, "no-script-background")) {
packet(0, 0, 0, 0);
} else {
packet((1ULL << B_A) | physical, pads ? (front ? 32767 : -12000) : 0, 32767, pads ? 8000 : 0);
now_ns += 201000000;
packet(physical, pads ? (front ? 32767 : -12000) : 0, 0, pads ? 8000 : 0);
if (exclusive) {
CHECK(pad_merges == 0 && key_queries == 0 && mouse_queries == 0);
now_ns += 5100000000LL;
packet(front ? (1ULL << B_B) | (1ULL << B_X) : 0, front ? 32767 : 0, 0, front ? 8000 : 0);
}
}
CHECK(bootstrap_polls == 1); /* production startup poll is allowed, but its Y/stick result is discarded */
if (!front) {
CHECK(key_queries == 0 && mouse_queries == 0);
if (!pads) CHECK(pad_merges == 0);
}
if (!strcmp(name, "script-background")) CHECK(strstr(last_log, "game window not in front"));
if (front) CHECK(pad_merges > 0 && key_queries > 0 && mouse_queries > 0);
CHECK(focus_queries > 0);
printf("PASS: actual scripted parse/merge/Npad route %s\n", name);
free(memory);
return 0;
}