mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
Hotfix for v0.5.0: crashes (NX2navi game folder refused by Setup, heap-full retries, GTX 10 series noise pass and whole VRAM mirrors, code-patch mods kept with their code, no page file warning), graphics (DLSS with frame generation, DLSS coming back, AMD storage buffer alignment, mesh index map, shared memory barrier, shader conversions, integrated GPUs' uniform snapshot, a Mesh shaders row), controls (microphone after restart, button prompts with a mod's size table, sprint vs Hide text, native mouse camera, controller after Restart now), Setup's Preparing shaders step, and the Linux link fix.
536 lines
28 KiB
C
536 lines
28 KiB
C
/* The game's window (Windows): the renderer's surface (gpu/render/, WebGPU). The native NVN layer (nvn_native.c)
|
|
presents the game's window textures into it (rx_nvn_present). The title bar carries live numbers.
|
|
TOTKPort's hos/display.c, without its emulated-GPU fallback (the window buffer read from guest memory): MKW has
|
|
no emulated GPU, so the renderer is the only way to a picture.
|
|
HOS_HEADLESS=1: no window (scripted runs; the renderer draws offscreen). Closing the window ends the run.
|
|
HOS_WINDOW_NOACTIVATE=1: the window opens behind the one in front (test runs do not take the keyboard).
|
|
HOS_WINDOW_SIZE=<w>x<h>: the client area (default 1280x720 at 96 dpi). F10 or Alt+Enter: fullscreen (F11 is off).
|
|
Mouse: a click in the window captures the mouse (hidden, kept in the window), Esc or leaving the window releases
|
|
it (nn_hid.c reads its motion). While the Insert menu is open the mouse is free (the cursor shown, for the menu's
|
|
clicks: hos_mouse_pointer) and the game gets none of it; the capture it had comes back when the menu closes. The same
|
|
while one of the game's own menus is open (host/oot_menu.c: hos_mouse_game_menu each frame it runs), its clicks and
|
|
wheel for that menu (hos_mouse_game_pointer). */
|
|
#include "hos.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include "../gpu/render/rx.h"
|
|
void rx_close_asked(void); /* host/rx_backend.c */
|
|
#include "../gpu/vk/vk_api.h"
|
|
|
|
void hos_relaunch_ask(void); /* (host/hos_relaunch.c) */
|
|
void hos_bug_capture_key(void); /* (host/bug_capture.c) */
|
|
void hos_window_closed_exit(void);
|
|
#ifndef WM_DPICHANGED
|
|
#define WM_DPICHANGED 0x02E0
|
|
#endif
|
|
|
|
volatile LONG64 hos_present_count; /* (nvn_native.c: the game's presents) */
|
|
static HWND hwnd;
|
|
static int renderer; /* the renderer presents into the window */
|
|
|
|
/* mouse capture: raw motion accumulated here, taken by nn_hid.c */
|
|
static volatile LONG mouse_dx, mouse_dy;
|
|
static volatile LONG mouse_captured;
|
|
static int cursor_hidden;
|
|
|
|
int hos_mouse_take(int32_t *dx, int32_t *dy) {
|
|
*dx = InterlockedExchange(&mouse_dx, 0);
|
|
*dy = InterlockedExchange(&mouse_dy, 0);
|
|
return mouse_captured;
|
|
}
|
|
|
|
/* (mouse_native.c) motion taken and not used, put back for the next taker (the player camera's) */
|
|
void hos_mouse_give_back(int32_t dx, int32_t dy) {
|
|
InterlockedExchangeAdd(&mouse_dx, dx);
|
|
InterlockedExchangeAdd(&mouse_dy, dy);
|
|
}
|
|
|
|
/* the free mouse, for the Insert menu (gpu/vk/vk_api.h MkwVkPointer): set on the window's thread, read on the renderer's */
|
|
static volatile LONG ptr_x, ptr_y, ptr_w, ptr_h, ptr_in, ptr_pressed, ptr_wheel; /* (client pixels; wheel in WHEEL_DELTA units) */
|
|
static int menu_open, captured_before_menu;
|
|
/* the game's own menus: open while one of their screens runs with the mouse (stamped each frame on the
|
|
game's thread), their clicks */
|
|
static int game_menu_open;
|
|
static volatile LONG64 game_menu_seen_ns;
|
|
static volatile LONG gm_pressed, gm_wheel;
|
|
/* The cursor over the game's menus is hidden until the mouse is used (moved or a button pressed) and again once the
|
|
pads or the keys are (nn_hid.c: hos_player_input_ns): a player on a controller never sees it, and a mouse at rest
|
|
takes no part (no pointing or clicks while hidden). The wheel works hidden too, and does not show it: a button held
|
|
(R, for the item choice) counts as the pad in use, and hid the cursor again at each notch */
|
|
int64_t hos_player_input_ns(void);
|
|
static volatile LONG gm_shown, gm_mx = -1, gm_my = -1;
|
|
static volatile LONG64 gm_mouse_ns;
|
|
static void gm_mouse_used(void) { InterlockedExchange64(&gm_mouse_ns, (LONG64)hos_now_ns()); InterlockedExchange(&gm_shown, 1); }
|
|
static int gm_cursor_shown(void) {
|
|
if (gm_shown && hos_player_input_ns() > InterlockedCompareExchange64(&gm_mouse_ns, 0, 0)) InterlockedExchange(&gm_shown, 0);
|
|
return (int)gm_shown;
|
|
}
|
|
|
|
int hos_mouse_pointer(MkwVkPointer *out) {
|
|
memset(out, 0, sizeof *out);
|
|
if (!hwnd || mouse_captured) return 0;
|
|
out->x = ptr_x, out->y = ptr_y, out->width = ptr_w, out->height = ptr_h;
|
|
out->held = ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? HOS_MOUSE_LEFT : 0) |
|
|
((GetAsyncKeyState(VK_RBUTTON) & 0x8000) ? HOS_MOUSE_RIGHT : 0) |
|
|
((GetAsyncKeyState(VK_MBUTTON) & 0x8000) ? HOS_MOUSE_MIDDLE : 0);
|
|
out->pressed = (uint32_t)InterlockedExchange(&ptr_pressed, 0);
|
|
const LONG wheel = InterlockedExchange(&ptr_wheel, 0);
|
|
out->wheel = wheel / WHEEL_DELTA;
|
|
if (wheel % WHEEL_DELTA) InterlockedExchangeAdd(&ptr_wheel, wheel % WHEEL_DELTA); /* (a part of a notch: kept) */
|
|
return ptr_in && GetForegroundWindow() == hwnd && out->width > 0 && out->height > 0;
|
|
}
|
|
|
|
static HANDLE renderer_up;
|
|
static int fullscreen;
|
|
static WINDOWPLACEMENT windowed_place;
|
|
|
|
static void set_fullscreen(HWND w, int on) {
|
|
if (on == fullscreen) return;
|
|
const LONG style = GetWindowLongA(w, GWL_STYLE);
|
|
if (on) {
|
|
MONITORINFO mi;
|
|
mi.cbSize = sizeof mi;
|
|
windowed_place.length = sizeof windowed_place;
|
|
if (!GetWindowPlacement(w, &windowed_place) ||
|
|
!GetMonitorInfoA(MonitorFromWindow(w, MONITOR_DEFAULTTONEAREST), &mi))
|
|
return;
|
|
fullscreen = 1;
|
|
SetWindowLongA(w, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
|
|
SetWindowPos(w, HWND_TOP, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left,
|
|
mi.rcMonitor.bottom - mi.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
|
|
} else {
|
|
fullscreen = 0;
|
|
SetWindowLongA(w, GWL_STYLE, style | WS_OVERLAPPEDWINDOW);
|
|
SetWindowPlacement(w, &windowed_place);
|
|
SetWindowPos(w, NULL, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
|
|
}
|
|
hos_log("display: %s", on ? "fullscreen" : "windowed");
|
|
}
|
|
|
|
static void dpi_aware_thread(void) {
|
|
if (getenv("HOS_DPI_UNAWARE")) return;
|
|
typedef void *(WINAPI * SetCtx)(void *);
|
|
SetCtx set = (SetCtx)(void *)GetProcAddress(GetModuleHandleA("user32.dll"), "SetThreadDpiAwarenessContext");
|
|
if (set) set((void *)(intptr_t)-4);
|
|
}
|
|
|
|
static UINT window_dpi(HWND w) {
|
|
typedef UINT(WINAPI * GetDpi)(HWND);
|
|
GetDpi get = (GetDpi)(void *)GetProcAddress(GetModuleHandleA("user32.dll"), "GetDpiForWindow");
|
|
const UINT dpi = get ? get(w) : 96;
|
|
return dpi ? dpi : 96;
|
|
}
|
|
|
|
static void mouse_capture(HWND w, int on) {
|
|
if (on == (int)mouse_captured) return;
|
|
mouse_captured = on;
|
|
InterlockedExchange(&mouse_dx, 0);
|
|
InterlockedExchange(&mouse_dy, 0);
|
|
if (on) {
|
|
RECT rc;
|
|
GetClientRect(w, &rc);
|
|
MapWindowPoints(w, NULL, (POINT *)&rc, 2);
|
|
ClipCursor(&rc);
|
|
if (!cursor_hidden) { ShowCursor(FALSE); cursor_hidden = 1; }
|
|
} else {
|
|
ClipCursor(NULL);
|
|
if (cursor_hidden) { ShowCursor(TRUE); cursor_hidden = 0; }
|
|
}
|
|
}
|
|
|
|
/* the cursor hidden now while it is over the window (not at the next move's WM_SETCURSOR) */
|
|
static void gm_cursor_off(HWND w) {
|
|
POINT p;
|
|
RECT rc;
|
|
if (GetCursorPos(&p) && ScreenToClient(w, &p) && GetClientRect(w, &rc) && PtInRect(&rc, p)) SetCursor(NULL);
|
|
}
|
|
/* a menu opened (the Insert menu or the game's): the mouse let go (its capture kept for later); both closed: the capture
|
|
back, if the window still has the focus */
|
|
static void menus_mouse(HWND w, int insert_open, int game_open) {
|
|
const int was = menu_open || game_menu_open, now = insert_open || game_open, game_was = game_menu_open;
|
|
menu_open = insert_open, game_menu_open = game_open;
|
|
/* (hidden till used; a menu back within a second, a moment between its screens, keeps the cursor as it was) */
|
|
static int64_t game_closed_ns;
|
|
if (!game_open && game_was) game_closed_ns = hos_now_ns();
|
|
if (game_open && !game_was && (!game_closed_ns || hos_now_ns() - game_closed_ns > 1000000000LL))
|
|
InterlockedExchange(&gm_shown, 0), gm_mx = ptr_x, gm_my = ptr_y;
|
|
if (now && !was) {
|
|
captured_before_menu = (int)mouse_captured;
|
|
mouse_capture(w, 0);
|
|
} else if (!now && was) {
|
|
if (captured_before_menu && GetForegroundWindow() == w) mouse_capture(w, 1);
|
|
captured_before_menu = 0;
|
|
}
|
|
/* (a game menu opened: its cursor hidden till the mouse is used, at once; the release above showed it) */
|
|
if (game_open && !game_was && !insert_open) gm_cursor_off(w);
|
|
InterlockedExchange(&ptr_pressed, 0), InterlockedExchange(&ptr_wheel, 0);
|
|
InterlockedExchange(&gm_pressed, 0), InterlockedExchange(&gm_wheel, 0);
|
|
}
|
|
static void menu_mouse(HWND w, int open) {
|
|
if (open != menu_open) menus_mouse(w, open, game_menu_open);
|
|
}
|
|
|
|
/* (host/oot_menu.c, the game's thread) one of the game's menus ran this frame */
|
|
void hos_mouse_game_menu(void) {
|
|
const LONG64 before = InterlockedExchange64(&game_menu_seen_ns, (LONG64)hos_now_ns());
|
|
if (!before && hwnd) PostMessageA(hwnd, WM_APP + 10, 1, 0);
|
|
}
|
|
/* (host/oot_menu.c, the game's thread) frames go on with none of the game's menus holding the mouse: closed now */
|
|
void hos_mouse_game_menu_gone(void) {
|
|
const LONG64 seen = InterlockedCompareExchange64(&game_menu_seen_ns, 0, 0);
|
|
if (seen && hwnd && InterlockedCompareExchange64(&game_menu_seen_ns, 0, seen) == seen) PostMessageA(hwnd, WM_APP + 11, 0, 0);
|
|
}
|
|
/* (host/oot_menu.c, the game's thread) the wheel's notches since the last call, for a screen that takes only the wheel
|
|
and leaves the mouse as it is (the R button's item choice, in play: the mouse the camera's). Notches count only while
|
|
such a screen reads them (a call in the last 200 ms): a wheel turned in play does not wait for the next one */
|
|
static volatile LONG play_wheel;
|
|
static volatile LONG64 play_wheel_ns;
|
|
int hos_mouse_wheel_take(void) {
|
|
InterlockedExchange64(&play_wheel_ns, (LONG64)hos_now_ns());
|
|
const LONG wl = InterlockedExchange(&play_wheel, 0);
|
|
if (!hwnd || menu_open || GetForegroundWindow() != hwnd) return 0;
|
|
if (wl % WHEEL_DELTA) InterlockedExchangeAdd(&play_wheel, wl % WHEEL_DELTA);
|
|
return wl / WHEEL_DELTA;
|
|
}
|
|
/* the free mouse over the game's menus: its position (client pixels) and the window's size, the buttons pressed
|
|
(HOS_MOUSE_*) and the wheel's notches since the last call. 0 when the Insert menu has it or it is outside the window;
|
|
2 while the cursor is hidden: the wheel only (no presses; the position is not one to point with) */
|
|
int hos_mouse_game_pointer(int *x, int *y, int *w, int *h, uint32_t *pressed, int *wheel) {
|
|
*pressed = 0, *wheel = 0;
|
|
if (!hwnd || !game_menu_open || menu_open || mouse_captured) return 0;
|
|
const int shown = gm_cursor_shown();
|
|
*x = ptr_x, *y = ptr_y, *w = ptr_w, *h = ptr_h;
|
|
const LONG got = InterlockedExchange(&gm_pressed, 0); /* (hidden: what the buttons did meanwhile is not the menu's) */
|
|
if (shown) *pressed = (uint32_t)got;
|
|
const LONG wl = InterlockedExchange(&gm_wheel, 0);
|
|
*wheel = wl / WHEEL_DELTA;
|
|
if (wl % WHEEL_DELTA) InterlockedExchangeAdd(&gm_wheel, wl % WHEEL_DELTA);
|
|
if (!(ptr_in && GetForegroundWindow() == hwnd && *w > 0 && *h > 0)) return 0;
|
|
return shown ? 1 : 2;
|
|
}
|
|
int hos_oot_options_front(void); /* (host/oot_menu.c) */
|
|
static void game_menu_press(LPARAM lp, LONG bit) {
|
|
ptr_x = (short)LOWORD(lp), ptr_y = (short)HIWORD(lp), ptr_in = 1;
|
|
gm_mouse_used();
|
|
InterlockedOr(&gm_pressed, bit);
|
|
/* ((Triforce) the game's Options screen: the options' tabs over its header (gpu/vk/vk_menu.cpp draw_game_tab) take their
|
|
clicks through hos_mouse_pointer as the open menu does; host/oot_menu.c leaves the header to them, the rest is the game's) */
|
|
if (bit == HOS_MOUSE_LEFT && hos_oot_options_front()) InterlockedOr(&ptr_pressed, bit);
|
|
}
|
|
static void menu_press(HWND w, LPARAM lp, LONG bit) { /* (a click while the menu is open: the menu's) */
|
|
ptr_x = (short)LOWORD(lp), ptr_y = (short)HIWORD(lp), ptr_in = 1;
|
|
InterlockedOr(&ptr_pressed, bit);
|
|
SetCapture(w); /* (a drag past the window's edge still reaches it) */
|
|
}
|
|
|
|
/* ((Triforce) 11-17) Text typed while the menu wants it (the Mods screen's search: rx_option HOS_OPT_TEXT_WANTED), to the menu
|
|
as code points (HOS_OPT_TEXT_CHAR): the characters, 8 Backspace, 127 Ctrl+Backspace; Ctrl+V the clipboard's text. Enter, Esc
|
|
and Tab stay the menu's keys. The window is an ANSI one: a character's byte is in the code page of the keyboard's layout */
|
|
int rx_option(int id, int otherwise);
|
|
void rx_option_set(int id, int value);
|
|
static void typed_text_paste(HWND w) {
|
|
if (!IsClipboardFormatAvailable(CF_UNICODETEXT) || !OpenClipboard(w)) return;
|
|
HANDLE h = GetClipboardData(CF_UNICODETEXT);
|
|
const wchar_t *t = h ? (const wchar_t *)GlobalLock(h) : NULL;
|
|
for (int i = 0, n = 0; t && t[i] && n < 100; i++, n++) {
|
|
unsigned cp = t[i];
|
|
if (cp >= 0xD800 && cp < 0xDC00 && t[i + 1] >= 0xDC00 && t[i + 1] < 0xE000) cp = 0x10000 + ((cp - 0xD800) << 10) + (t[++i] - 0xDC00);
|
|
else if (cp >= 0xD800 && cp < 0xE000) continue; /* (half of a pair alone: no character) */
|
|
if (cp < 0x20 || cp == 0x7f) cp = ' '; /* (a line's end, a tab, a DEL: a space, never the menu's own codes) */
|
|
rx_option_set(HOS_OPT_TEXT_CHAR, (int)cp);
|
|
}
|
|
if (h) GlobalUnlock(h);
|
|
CloseClipboard();
|
|
}
|
|
static void typed_text(HWND w, WPARAM wp) {
|
|
if (!menu_open || !rx_option(HOS_OPT_TEXT_WANTED, 0)) return;
|
|
if (wp == 0x16) { typed_text_paste(w); return; } /* (Ctrl+V) */
|
|
if (wp == 8 || wp == 127) { rx_option_set(HOS_OPT_TEXT_CHAR, (int)wp); return; }
|
|
if (wp < 0x20) return; /* (Enter, Esc, Tab and the other control keys) */
|
|
wchar_t u = (wchar_t)wp;
|
|
if (wp >= 0x80) {
|
|
char cp[8] = "", b = (char)wp;
|
|
const LCID layout = (LCID)(LOWORD((uintptr_t)GetKeyboardLayout(0)));
|
|
/* (no layout's code page: the byte left out, never read in the system's own: tests/test_utf8_paths.py) */
|
|
const UINT page = GetLocaleInfoA(layout, LOCALE_IDEFAULTANSICODEPAGE, cp, sizeof cp) > 0 ? (UINT)atoi(cp) : 0;
|
|
if (!page || MultiByteToWideChar(page, 0, &b, 1, &u, 1) != 1) return;
|
|
}
|
|
rx_option_set(HOS_OPT_TEXT_CHAR, (int)u);
|
|
}
|
|
|
|
static LRESULT CALLBACK wndproc(HWND w, UINT msg, WPARAM wp, LPARAM lp) {
|
|
switch (msg) {
|
|
case WM_MOUSEMOVE:
|
|
ptr_x = (short)LOWORD(lp), ptr_y = (short)HIWORD(lp);
|
|
if (game_menu_open && !menu_open && (ptr_x != gm_mx || ptr_y != gm_my)) { /* (a move: not a repeat at rest) */
|
|
gm_mx = ptr_x, gm_my = ptr_y;
|
|
gm_mouse_used();
|
|
}
|
|
if (!ptr_in) {
|
|
TRACKMOUSEEVENT t = {sizeof t, TME_LEAVE, w, 0};
|
|
TrackMouseEvent(&t);
|
|
ptr_in = 1;
|
|
}
|
|
return 0;
|
|
case WM_MOUSELEAVE:
|
|
ptr_in = 0;
|
|
return 0;
|
|
case WM_MOUSEWHEEL:
|
|
if (menu_open) InterlockedExchangeAdd(&ptr_wheel, GET_WHEEL_DELTA_WPARAM(wp));
|
|
else if (game_menu_open) InterlockedExchangeAdd(&gm_wheel, GET_WHEEL_DELTA_WPARAM(wp)); /* (hidden or not) */
|
|
else if ((LONG64)hos_now_ns() - InterlockedCompareExchange64(&play_wheel_ns, 0, 0) < 200000000LL)
|
|
InterlockedExchangeAdd(&play_wheel, GET_WHEEL_DELTA_WPARAM(wp)); /* (a screen that takes the wheel only) */
|
|
return 0;
|
|
case WM_RBUTTONDOWN:
|
|
if (menu_open) menu_press(w, lp, HOS_MOUSE_RIGHT);
|
|
else if (game_menu_open) game_menu_press(lp, HOS_MOUSE_RIGHT);
|
|
return 0;
|
|
case WM_MBUTTONDOWN:
|
|
if (menu_open) menu_press(w, lp, HOS_MOUSE_MIDDLE);
|
|
else if (game_menu_open) game_menu_press(lp, HOS_MOUSE_MIDDLE);
|
|
return 0;
|
|
case WM_LBUTTONUP:
|
|
case WM_RBUTTONUP:
|
|
case WM_MBUTTONUP:
|
|
if (GetCapture() == w && !(wp & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON))) ReleaseCapture();
|
|
return 0;
|
|
case WM_APP + 8: /* (the Insert menu opened or closed: gpu/vk/vk_menu.cpp) */
|
|
menu_mouse(w, (int)wp);
|
|
return 0;
|
|
case WM_APP + 10: /* (a game menu opened: hos_mouse_game_menu) */
|
|
if (!game_menu_open) menus_mouse(w, menu_open, 1);
|
|
return 0;
|
|
case WM_APP + 11: /* (the game's menus closed: hos_mouse_game_menu_gone) */
|
|
if (game_menu_open) menus_mouse(w, menu_open, 0);
|
|
return 0;
|
|
case WM_TIMER: {
|
|
/* (hookshot, #1532) a controller is not input to Windows: playing with one, the display went off at the power
|
|
plan's timeout. While the game's window is in front and not minimized, the display's idle timer is reset every
|
|
30 s (ES_DISPLAY_REQUIRED without ES_CONTINUOUS: nothing is held when the game is left or closed).
|
|
HOS_KEEP_DISPLAY=0: Windows' timeout as before */
|
|
static ULONGLONG last_awake;
|
|
static int keep = -1;
|
|
if (keep < 0) keep = !getenv("HOS_KEEP_DISPLAY") || atoi(getenv("HOS_KEEP_DISPLAY")) != 0;
|
|
const ULONGLONG now = GetTickCount64();
|
|
if (keep && renderer && now - last_awake >= 30000 && GetForegroundWindow() == w && !IsIconic(w)) {
|
|
last_awake = now;
|
|
SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED);
|
|
}
|
|
/* (the game's menus closed: no frame of one for 300 ms) */
|
|
const LONG64 seen = InterlockedCompareExchange64(&game_menu_seen_ns, 0, 0);
|
|
if (game_menu_open && seen && (LONG64)hos_now_ns() - seen > 300000000LL &&
|
|
InterlockedCompareExchange64(&game_menu_seen_ns, 0, seen) == seen)
|
|
menus_mouse(w, menu_open, 0);
|
|
if (game_menu_open && !menu_open && !gm_cursor_shown()) gm_cursor_off(w); /* (hidden by the pads or keys: at once) */
|
|
return 0;
|
|
}
|
|
case WM_SYSCOMMAND:
|
|
if ((wp & 0xFFF0) == SC_SCREENSAVE && !(wp & SCF_ISSECURE) &&
|
|
renderer && GetForegroundWindow() == w && !IsIconic(w)) {
|
|
BOOL secure = TRUE; /* unknown or protected policy keeps Windows' normal handling */
|
|
if (SystemParametersInfoA(SPI_GETSCREENSAVESECURE, 0, &secure, 0) && !secure) return 0;
|
|
}
|
|
break;
|
|
case WM_INPUT: {
|
|
RAWINPUT ri;
|
|
UINT size = sizeof ri;
|
|
if (mouse_captured && GetRawInputData((HRAWINPUT)lp, RID_INPUT, &ri, &size, sizeof(RAWINPUTHEADER)) != (UINT)-1 &&
|
|
ri.header.dwType == RIM_TYPEMOUSE && !(ri.data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE)) {
|
|
InterlockedExchangeAdd(&mouse_dx, ri.data.mouse.lLastX);
|
|
InterlockedExchangeAdd(&mouse_dy, ri.data.mouse.lLastY);
|
|
}
|
|
return DefWindowProcA(w, msg, wp, lp);
|
|
}
|
|
case WM_LBUTTONDOWN:
|
|
if (menu_open) menu_press(w, lp, HOS_MOUSE_LEFT);
|
|
else if (game_menu_open) game_menu_press(lp, HOS_MOUSE_LEFT);
|
|
else if (renderer && !mouse_captured) mouse_capture(w, 1);
|
|
return 0;
|
|
case WM_KEYDOWN: {
|
|
extern void hos_vk_note_key_press(unsigned key);
|
|
if (!(lp & (1 << 30))) hos_vk_note_key_press((unsigned)wp);
|
|
if (wp == VK_ESCAPE) mouse_capture(w, 0);
|
|
/* (Triforce, after NX2navi's F8) a bug capture: only noted here, written on a thread of its own (host/bug_capture.c) */
|
|
if (wp == VK_F8 && !(lp & (1 << 30))) hos_bug_capture_key();
|
|
/* (Triforce: F11 does nothing; F10 and Alt+Enter switch fullscreen, below: F10 comes as a system key) */
|
|
return 0;
|
|
}
|
|
case WM_SYSKEYDOWN: /* Alt+Enter and F10, as on Linux (display_sdl.c); other Alt keys (Alt+F4) go on to Windows */
|
|
if ((wp == VK_RETURN && (lp & (1 << 29))) || wp == VK_F10) {
|
|
if (!(lp & (1 << 30))) set_fullscreen(w, !fullscreen);
|
|
return 0;
|
|
}
|
|
break;
|
|
case WM_SYSKEYUP: /* (the release of F10: left to Windows it enters the menu loop, and the game seems to freeze until a key) */
|
|
if (wp == VK_F10) return 0;
|
|
break;
|
|
case WM_SYSCHAR: /* (its character: without this Windows beeps, as for an Alt key with no menu) */
|
|
if (wp == '\r') return 0;
|
|
break;
|
|
case WM_CHAR: /* ((Triforce) a character typed: the menu's when it takes text) */
|
|
typed_text(w, wp);
|
|
return 0;
|
|
case WM_APP + 7: /* (the Insert menu's row) */
|
|
set_fullscreen(w, (int)wp);
|
|
return 0;
|
|
case WM_DPICHANGED:
|
|
if (!fullscreen) {
|
|
const RECT *s = (const RECT *)lp;
|
|
SetWindowPos(w, NULL, s->left, s->top, s->right - s->left, s->bottom - s->top,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
return 0;
|
|
case WM_KILLFOCUS:
|
|
case WM_CANCELMODE:
|
|
mouse_capture(w, 0);
|
|
break;
|
|
case WM_SETCURSOR:
|
|
if ((mouse_captured || (game_menu_open && !menu_open && !gm_cursor_shown())) && LOWORD(lp) == HTCLIENT) {
|
|
SetCursor(NULL);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
case WM_MOVE:
|
|
if (mouse_captured) { mouse_capture(w, 0); mouse_capture(w, 1); } /* (the clip follows the window) */
|
|
break;
|
|
case WM_SIZE:
|
|
ptr_w = LOWORD(lp), ptr_h = HIWORD(lp);
|
|
if (mouse_captured) { mouse_capture(w, 0); mouse_capture(w, 1); }
|
|
if (renderer) rx_resize(LOWORD(lp), HIWORD(lp));
|
|
return 0;
|
|
case WM_PAINT:
|
|
if (renderer) { /* the renderer's surface: nothing to paint */
|
|
ValidateRect(w, NULL);
|
|
return 0;
|
|
}
|
|
break;
|
|
case WM_ERASEBKGND:
|
|
return renderer ? 1 : DefWindowProcA(w, msg, wp, lp);
|
|
case WM_APP + 9: /* (the Insert menu's Restart now: closed as by the player, then started again: host/hos_relaunch.c) */
|
|
hos_relaunch_ask();
|
|
/* fall through */
|
|
case WM_CLOSE:
|
|
rx_close_asked(); /* (a start still preparing the shaders keeps what it made) */
|
|
hos_window_closed_exit();
|
|
return 0;
|
|
}
|
|
return DefWindowProcA(w, msg, wp, lp);
|
|
}
|
|
|
|
/* (Triforce) The title bar in Triforce's colours instead of Windows' white one: black, gold title, a dark gold edge (Windows 11's
|
|
caption colours, DWMWA 34-36), and Windows' dark title bar where those are not there (Windows 10: DWMWA 20, 19 before 2004).
|
|
dwmapi is loaded here, so nothing changes for a Windows without it */
|
|
static void theme_caption(HWND w) {
|
|
HMODULE dwm = LoadLibraryA("dwmapi.dll");
|
|
typedef HRESULT (WINAPI *set_fn)(HWND, DWORD, LPCVOID, DWORD);
|
|
set_fn set = dwm ? (set_fn)(void *)GetProcAddress(dwm, "DwmSetWindowAttribute") : NULL;
|
|
if (!set) return;
|
|
const BOOL dark = TRUE;
|
|
if (FAILED(set(w, 20, &dark, sizeof dark))) set(w, 19, &dark, sizeof dark);
|
|
const COLORREF caption = RGB(11, 10, 9), text = RGB(224, 178, 62), border = RGB(110, 84, 30);
|
|
set(w, 35, &caption, sizeof caption);
|
|
set(w, 36, &text, sizeof text);
|
|
set(w, 34, &border, sizeof border);
|
|
}
|
|
|
|
static void display_start_failed(const char *operation) {
|
|
const DWORD error = GetLastError();
|
|
hos_log("display: %s failed (error %lu)", operation, (unsigned long)error);
|
|
hos_log_flush();
|
|
ExitProcess(1);
|
|
}
|
|
|
|
static DWORD WINAPI display_main(void *p) {
|
|
(void)p;
|
|
{ /* (nothing is typed here. Windows' text services, set up under DefWindowProc as the window was sized, ended the process: a
|
|
fail-fast in CoreMessaging, called from textinputframework) */
|
|
HMODULE imm = LoadLibraryExA("imm32.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32); /* (hookshot: System32's only) */
|
|
BOOL (WINAPI *ime_off)(DWORD) = imm ? (BOOL (WINAPI *)(DWORD))GetProcAddress(imm, "ImmDisableIME") : NULL;
|
|
if (ime_off) ime_off((DWORD)-1);
|
|
}
|
|
WNDCLASSA wc;
|
|
memset(&wc, 0, sizeof wc);
|
|
wc.lpfnWndProc = wndproc;
|
|
wc.hInstance = GetModuleHandleA(NULL);
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hIcon = LoadIconA(wc.hInstance, MAKEINTRESOURCEA(1)); /* (nx2/make_icon.py; none in a build without the picture) */
|
|
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wc.lpszClassName = "Triforce";
|
|
RegisterClassA(&wc);
|
|
dpi_aware_thread();
|
|
extern float hos_aspect_ratio;
|
|
/* (the picture's shape when Monitor's shape set one, wider or narrower than 16:9: 960 x 720 for 4:3, 1720 x 720 for 21:9) */
|
|
int win_w = hos_aspect_ratio > 0.0f ? (int)(720 * hos_aspect_ratio + 0.5f) : 1280, win_h = 720;
|
|
if (getenv("HOS_WINDOW_SIZE")) {
|
|
int w = 0, h = 0;
|
|
/* ((Triforce) at most 16384 a side: the window's rectangle with its frame, and the size times the screen's dpi
|
|
below, are ints, and wrapped for a huge one) */
|
|
if (sscanf(getenv("HOS_WINDOW_SIZE"), "%dx%d", &w, &h) == 2 && w >= 64 && h >= 64 && w <= 16384 && h <= 16384)
|
|
win_w = w, win_h = h;
|
|
}
|
|
RECT r = {0, 0, win_w, win_h};
|
|
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
|
|
const int noactivate = getenv("HOS_WINDOW_NOACTIVATE") != NULL;
|
|
hwnd = CreateWindowA("Triforce", HOS_GAME_TITLE, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, r.right - r.left, r.bottom - r.top, NULL, NULL, wc.hInstance, NULL);
|
|
if (!hwnd) display_start_failed("CreateWindowA");
|
|
theme_caption(hwnd);
|
|
if (window_dpi(hwnd) != 96) {
|
|
const UINT dpi = window_dpi(hwnd);
|
|
RECT s = {0, 0, (LONG)((int64_t)win_w * dpi / 96), (LONG)((int64_t)win_h * dpi / 96)};
|
|
AdjustWindowRect(&s, WS_OVERLAPPEDWINDOW, FALSE);
|
|
SetWindowPos(hwnd, NULL, 0, 0, s.right - s.left, s.bottom - s.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
/* (no activate: shown at the bottom of the z-order, so a game in front keeps its focus) */
|
|
if (noactivate)
|
|
SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
else {
|
|
ShowWindow(hwnd, SW_SHOW);
|
|
/* ((Triforce, 11-18) brought to the front: after the Insert menu's Restart now the new window opened behind
|
|
another one (the run that started it had exited meanwhile, and the window it handed the front to kept it), and
|
|
the controllers, which count only while the game is in front (nn_hid.c), did nothing until the game was quit
|
|
and started by hand (#bug-tracker "Controller fails to work upon restart"). The run before allows it
|
|
(hos_relaunch.c AllowSetForegroundWindow); a start from Setup or an icon is in front already) */
|
|
SetForegroundWindow(hwnd);
|
|
if (GetForegroundWindow() != hwnd)
|
|
hos_log("display: the window did not come to the front at its start (controllers count once it is in front)");
|
|
}
|
|
if (getenv("HOS_FULLSCREEN") && atoi(getenv("HOS_FULLSCREEN"))) set_fullscreen(hwnd, 1);
|
|
RAWINPUTDEVICE rid = {1, 2, 0, hwnd}; /* generic desktop mouse: WM_INPUT while the window is in front */
|
|
RegisterRawInputDevices(&rid, 1, sizeof rid);
|
|
renderer = rx_start(hwnd);
|
|
if (!renderer) hos_log("display: no WebGPU device: the window stays black");
|
|
SetEvent(renderer_up);
|
|
SetTimer(hwnd, 1, 250, NULL);
|
|
MSG m;
|
|
while (GetMessageA(&m, NULL, 0, 0) > 0) {
|
|
TranslateMessage(&m);
|
|
DispatchMessageA(&m);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* (hookshot) The game's first work for the GPU waits for the renderer. It ran beside the renderer's start, and what it submitted while the
|
|
shaders were being prepared (80 s on a first start) was lost: that run had no ambient light, black foliage and dark characters. The
|
|
game itself goes on starting as it did: held at the start instead, it left holes in the ground */
|
|
void hos_renderer_wait(void) {
|
|
{ const char *e = getenv("HOS_NO_RENDERER_WAIT"); if (e && atoi(e) != 0) return; } /* (=0: the wait, as without it) */ /* (a test: the game's first GPU work no longer waits for the renderer, as before lighting-fix) */
|
|
if (renderer_up) WaitForSingleObject(renderer_up, INFINITE);
|
|
}
|
|
|
|
void hos_display_start(void) {
|
|
if (getenv("HOS_HEADLESS")) { /* no window: the renderer still draws, offscreen (screenshots, frame dumps) */
|
|
rx_start(NULL);
|
|
return;
|
|
}
|
|
renderer_up = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
if (!renderer_up) display_start_failed("CreateEventA");
|
|
HANDLE thread = CreateThread(NULL, 0, display_main, NULL, 0, NULL);
|
|
if (!thread) display_start_failed("CreateThread");
|
|
CloseHandle(thread);
|
|
}
|