window_sdl3.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461
  1. /* SDL3 window backend for the host browser harness.
  2. *
  3. * SDL3 selects the Wayland driver on this desktop (and falls back to X11 if
  4. * it cannot connect); the browser still owns a plain RGB565 canvas and only
  5. * sees the generic win_* ABI through host/syscall.c. */
  6. #include <SDL3/SDL.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <unistd.h>
  11. #include "window.h"
  12. #define KEYQ_MAX 256
  13. #define EVQ_MAX 64
  14. static SDL_Window *win;
  15. static SDL_Renderer *ren;
  16. static SDL_Texture *tex;
  17. static unsigned short *fb;
  18. static int win_w, win_h;
  19. static int inited;
  20. static int focused;
  21. static int inside;
  22. static int close_sent;
  23. static int mouse_x, mouse_y;
  24. static unsigned mouse_buttons;
  25. static int scroll_x, scroll_y;
  26. static char backend[32] = "none";
  27. static int keyq[KEYQ_MAX];
  28. static unsigned int key_head, key_tail;
  29. static struct win_event evq[EVQ_MAX];
  30. static unsigned int ev_head, ev_tail;
  31. static void push_key(int k)
  32. {
  33. unsigned int next = (key_head + 1) % KEYQ_MAX;
  34. if (next == key_tail)
  35. return;
  36. keyq[key_head] = k;
  37. key_head = next;
  38. }
  39. static int pop_key(void)
  40. {
  41. int k;
  42. if (key_tail == key_head)
  43. return 0;
  44. k = keyq[key_tail];
  45. key_tail = (key_tail + 1) % KEYQ_MAX;
  46. return k;
  47. }
  48. static void push_event(unsigned int type, int x, int y)
  49. {
  50. unsigned int next = (ev_head + 1) % EVQ_MAX;
  51. struct win_event *ev;
  52. if (next == ev_tail)
  53. return;
  54. ev = &evq[ev_head];
  55. ev->type = type;
  56. ev->x = x;
  57. ev->y = y;
  58. ev->buttons = mouse_buttons;
  59. ev_head = next;
  60. }
  61. static unsigned int neb_buttons(Uint32 state)
  62. {
  63. unsigned int b = 0;
  64. if (state & SDL_BUTTON_LMASK)
  65. b |= 1;
  66. if (state & SDL_BUTTON_RMASK)
  67. b |= 2;
  68. if (state & SDL_BUTTON_MMASK)
  69. b |= 4;
  70. return b;
  71. }
  72. static void set_mouse(float x, float y, Uint32 state)
  73. {
  74. mouse_x = (int)x;
  75. mouse_y = (int)y;
  76. mouse_buttons = neb_buttons(state);
  77. inside = mouse_x >= 0 && mouse_y >= 0 &&
  78. mouse_x < win_w && mouse_y < win_h;
  79. }
  80. static void key_down(const SDL_KeyboardEvent *e)
  81. {
  82. SDL_Keycode k = e->key;
  83. SDL_Keymod mod = e->mod;
  84. int ctrl = (mod & SDL_KMOD_CTRL) != 0;
  85. /* Ctrl+letter -> ASCII control code (Ctrl+L = 0x0C, Ctrl+R = 0x12). */
  86. if (ctrl && k >= SDLK_A && k <= SDLK_Z) {
  87. push_key((int)(k - SDLK_A + 1));
  88. return;
  89. }
  90. switch (k) {
  91. case SDLK_ESCAPE:
  92. push_key(0x1B);
  93. return;
  94. case SDLK_BACKSPACE:
  95. push_key(ctrl ? 0x10C : 0x08);
  96. return;
  97. case SDLK_TAB:
  98. push_key(0x09);
  99. return;
  100. case SDLK_RETURN:
  101. case SDLK_KP_ENTER:
  102. push_key('\n');
  103. return;
  104. case SDLK_DELETE:
  105. push_key(ctrl ? 0x10B : 0x108);
  106. return;
  107. case SDLK_LEFT:
  108. push_key(ctrl ? 0x109 : 0x100);
  109. return;
  110. case SDLK_RIGHT:
  111. push_key(ctrl ? 0x10A : 0x101);
  112. return;
  113. case SDLK_UP:
  114. push_key(0x102);
  115. return;
  116. case SDLK_DOWN:
  117. push_key(0x103);
  118. return;
  119. case SDLK_PAGEUP:
  120. push_key(0x104);
  121. return;
  122. case SDLK_PAGEDOWN:
  123. push_key(0x105);
  124. return;
  125. case SDLK_HOME:
  126. push_key(0x106);
  127. return;
  128. case SDLK_END:
  129. push_key(0x107);
  130. return;
  131. default:
  132. break;
  133. }
  134. /* Printable characters arrive through SDL_EVENT_TEXT_INPUT, which
  135. * honours the keyboard layout and key repeat. */
  136. }
  137. static void text_utf8(const char *s)
  138. {
  139. const unsigned char *p = (const unsigned char *)s;
  140. while (p && *p) {
  141. unsigned int cp;
  142. int n;
  143. if (*p < 0x80) {
  144. cp = *p++;
  145. n = 0;
  146. } else if ((*p & 0xE0) == 0xC0) {
  147. cp = *p++ & 0x1F;
  148. n = 1;
  149. } else if ((*p & 0xF0) == 0xE0) {
  150. cp = *p++ & 0x0F;
  151. n = 2;
  152. } else if ((*p & 0xF8) == 0xF0) {
  153. cp = *p++ & 0x07;
  154. n = 3;
  155. } else {
  156. p++;
  157. continue;
  158. }
  159. while (n-- > 0) {
  160. if ((*p & 0xC0) != 0x80) {
  161. cp = 0xFFFD;
  162. break;
  163. }
  164. cp = (cp << 6) | (*p++ & 0x3F);
  165. }
  166. if (cp == '\r' || cp == '\n')
  167. push_key('\n');
  168. else if (cp >= 0x20 && cp <= 0xFF)
  169. push_key((int)cp);
  170. else if (cp > 0xFF)
  171. push_key('?');
  172. }
  173. }
  174. static void handle_event(SDL_Event *e)
  175. {
  176. switch (e->type) {
  177. case SDL_EVENT_QUIT:
  178. case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
  179. if (!close_sent) {
  180. close_sent = 1;
  181. push_key(0x1B);
  182. }
  183. break;
  184. case SDL_EVENT_WINDOW_FOCUS_GAINED:
  185. focused = 1;
  186. break;
  187. case SDL_EVENT_WINDOW_FOCUS_LOST:
  188. focused = 0;
  189. break;
  190. case SDL_EVENT_WINDOW_MOUSE_ENTER:
  191. inside = 1;
  192. break;
  193. case SDL_EVENT_WINDOW_MOUSE_LEAVE:
  194. inside = 0;
  195. break;
  196. case SDL_EVENT_MOUSE_MOTION:
  197. set_mouse(e->motion.x, e->motion.y, e->motion.state);
  198. break;
  199. case SDL_EVENT_MOUSE_BUTTON_DOWN:
  200. case SDL_EVENT_MOUSE_BUTTON_UP: {
  201. unsigned int bit = 0;
  202. if (e->button.button == SDL_BUTTON_LEFT)
  203. bit = 1;
  204. else if (e->button.button == SDL_BUTTON_RIGHT)
  205. bit = 2;
  206. else if (e->button.button == SDL_BUTTON_MIDDLE)
  207. bit = 4;
  208. mouse_x = (int)e->button.x;
  209. mouse_y = (int)e->button.y;
  210. inside = mouse_x >= 0 && mouse_y >= 0 &&
  211. mouse_x < win_w && mouse_y < win_h;
  212. if (bit) {
  213. if (e->type == SDL_EVENT_MOUSE_BUTTON_DOWN)
  214. mouse_buttons |= bit;
  215. else
  216. mouse_buttons &= ~bit;
  217. push_event(e->type == SDL_EVENT_MOUSE_BUTTON_DOWN ?
  218. WIN_EV_POINTER_DOWN : WIN_EV_POINTER_UP,
  219. mouse_x, mouse_y);
  220. }
  221. break;
  222. }
  223. case SDL_EVENT_MOUSE_WHEEL:
  224. /* SDL's y is positive away from the user; the browser wants
  225. * +dy = later content. */
  226. scroll_x += (int)(-e->wheel.x * 48.0f);
  227. scroll_y += (int)(-e->wheel.y * 48.0f);
  228. break;
  229. case SDL_EVENT_KEY_DOWN:
  230. key_down(&e->key);
  231. break;
  232. case SDL_EVENT_TEXT_INPUT:
  233. text_utf8(e->text.text);
  234. break;
  235. default:
  236. break;
  237. }
  238. }
  239. int host_sdl_open(unsigned int w, unsigned int h, const char *title)
  240. {
  241. const char *drv;
  242. if (inited)
  243. return (win_w == (int)w && win_h == (int)h) ? 0 : -1;
  244. if (!SDL_Init(SDL_INIT_VIDEO)) {
  245. fprintf(stderr, "browser-host: SDL_Init: %s\n", SDL_GetError());
  246. return -1;
  247. }
  248. drv = SDL_GetCurrentVideoDriver();
  249. snprintf(backend, sizeof(backend), "%s", drv ? drv : "?");
  250. win = SDL_CreateWindow(title ? title : "Browser", (int)w, (int)h, 0);
  251. if (!win) {
  252. fprintf(stderr, "browser-host: SDL_CreateWindow: %s\n",
  253. SDL_GetError());
  254. SDL_Quit();
  255. return -1;
  256. }
  257. ren = SDL_CreateRenderer(win, 0);
  258. if (!ren)
  259. ren = SDL_CreateRenderer(win, "software");
  260. if (!ren) {
  261. fprintf(stderr, "browser-host: SDL_CreateRenderer: %s\n",
  262. SDL_GetError());
  263. SDL_DestroyWindow(win);
  264. win = 0;
  265. SDL_Quit();
  266. return -1;
  267. }
  268. SDL_SetRenderVSync(ren, 0);
  269. tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGB565,
  270. SDL_TEXTUREACCESS_STREAMING, (int)w, (int)h);
  271. if (!tex) {
  272. fprintf(stderr, "browser-host: SDL_CreateTexture: %s\n",
  273. SDL_GetError());
  274. SDL_DestroyRenderer(ren);
  275. ren = 0;
  276. SDL_DestroyWindow(win);
  277. win = 0;
  278. SDL_Quit();
  279. return -1;
  280. }
  281. SDL_SetTextureScaleMode(tex, SDL_SCALEMODE_NEAREST);
  282. SDL_SetWindowResizable(win, false);
  283. SDL_SetWindowMinimumSize(win, (int)w, (int)h);
  284. SDL_SetWindowMaximumSize(win, (int)w, (int)h);
  285. SDL_StartTextInput(win);
  286. fb = (unsigned short *)calloc((size_t)w * h, sizeof(unsigned short));
  287. if (!fb) {
  288. SDL_DestroyTexture(tex);
  289. tex = 0;
  290. SDL_DestroyRenderer(ren);
  291. ren = 0;
  292. SDL_DestroyWindow(win);
  293. win = 0;
  294. SDL_Quit();
  295. return -1;
  296. }
  297. win_w = (int)w;
  298. win_h = (int)h;
  299. focused = 1;
  300. inside = 1;
  301. inited = 1;
  302. fprintf(stderr, "browser-host: video driver=%s window=%ux%u\n",
  303. backend, w, h);
  304. return 0;
  305. }
  306. void host_sdl_close(void)
  307. {
  308. if (!inited)
  309. return;
  310. SDL_StopTextInput(win);
  311. free(fb);
  312. fb = 0;
  313. SDL_DestroyTexture(tex);
  314. tex = 0;
  315. SDL_DestroyRenderer(ren);
  316. ren = 0;
  317. SDL_DestroyWindow(win);
  318. win = 0;
  319. SDL_Quit();
  320. inited = 0;
  321. }
  322. void *host_sdl_fb(void)
  323. {
  324. return fb;
  325. }
  326. unsigned int host_sdl_width(void)
  327. {
  328. return (unsigned int)win_w;
  329. }
  330. unsigned int host_sdl_height(void)
  331. {
  332. return (unsigned int)win_h;
  333. }
  334. void host_sdl_present(void)
  335. {
  336. if (!inited || !tex)
  337. return;
  338. if (!SDL_UpdateTexture(tex, 0, fb, win_w * (int)sizeof(unsigned short)))
  339. return;
  340. SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
  341. SDL_RenderClear(ren);
  342. SDL_RenderTexture(ren, tex, 0, 0);
  343. SDL_RenderPresent(ren);
  344. }
  345. void host_sdl_pump(unsigned int timeout_ms)
  346. {
  347. SDL_Event e;
  348. if (!inited) {
  349. if (timeout_ms)
  350. usleep(timeout_ms * 1000u);
  351. return;
  352. }
  353. if (timeout_ms) {
  354. if (SDL_WaitEventTimeout(&e, (Sint32)timeout_ms))
  355. handle_event(&e);
  356. } else {
  357. SDL_PumpEvents();
  358. }
  359. while (SDL_PollEvent(&e))
  360. handle_event(&e);
  361. }
  362. int host_sdl_pointer(struct win_pointer *out)
  363. {
  364. SDL_WindowFlags flags;
  365. if (!inited)
  366. return -1;
  367. flags = SDL_GetWindowFlags(win);
  368. focused = (flags & SDL_WINDOW_INPUT_FOCUS) ? 1 : 0;
  369. out->x = mouse_x;
  370. out->y = mouse_y;
  371. out->buttons = mouse_buttons;
  372. out->inside = inside ? 1u : 0u;
  373. out->focused = focused ? 1u : 0u;
  374. return 0;
  375. }
  376. int host_sdl_event(struct win_event *out)
  377. {
  378. if (ev_tail == ev_head)
  379. return 0;
  380. *out = evq[ev_tail];
  381. ev_tail = (ev_tail + 1) % EVQ_MAX;
  382. return 1;
  383. }
  384. int host_sdl_scroll(struct win_scroll *out)
  385. {
  386. if (!scroll_x && !scroll_y)
  387. return 0;
  388. out->dx = scroll_x;
  389. out->dy = scroll_y;
  390. scroll_x = scroll_y = 0;
  391. return 1;
  392. }
  393. int host_sdl_key(void)
  394. {
  395. return pop_key();
  396. }
  397. int host_sdl_screen(unsigned int *w, unsigned int *h)
  398. {
  399. SDL_Rect r;
  400. if (SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &r)) {
  401. *w = (unsigned int)r.w;
  402. *h = (unsigned int)r.h;
  403. } else {
  404. *w = (unsigned int)win_w;
  405. *h = (unsigned int)win_h;
  406. }
  407. return 0;
  408. }
  409. int host_sdl_key_wait(unsigned int timeout_ms)
  410. {
  411. int k = pop_key();
  412. if (k)
  413. return k;
  414. host_sdl_pump(timeout_ms);
  415. return pop_key();
  416. }
  417. const char *host_sdl_backend(void)
  418. {
  419. return backend;
  420. }