SDL  2.0
SDL_test_common.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 
22 /* Ported from original test\common.c file. */
23 
24 #include "SDL_config.h"
25 #include "SDL_test.h"
26 
27 #include <stdio.h>
28 
29 #define VIDEO_USAGE \
30 "[--video driver] [--renderer driver] [--gldebug] [--info all|video|modes|render|event] [--log all|error|system|audio|video|render|input] [--display N] [--fullscreen | --fullscreen-desktop | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--min-geometry WxH] [--max-geometry WxH] [--logical WxH] [--scale N] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab] [--allow-highdpi]"
31 
32 #define AUDIO_USAGE \
33 "[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
34 
35 static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... )
36 {
37  size_t length = SDL_strlen(text);
38  va_list ap;
39 
40  va_start(ap, fmt);
41  text += length;
42  maxlen -= length;
43  SDL_vsnprintf(text, maxlen, fmt, ap);
44  va_end(ap);
45 }
46 
49 {
50  int i;
52 
53  /* Do this first so we catch all allocations */
54  for (i = 1; argv[i]; ++i) {
55  if (SDL_strcasecmp(argv[i], "--trackmem") == 0) {
57  break;
58  }
59  }
60 
61  state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
62  if (!state) {
64  return NULL;
65  }
66 
67  /* Initialize some defaults */
68  state->argv = argv;
69  state->flags = flags;
70  state->window_title = argv[0];
71  state->window_flags = 0;
72  state->window_x = SDL_WINDOWPOS_UNDEFINED;
73  state->window_y = SDL_WINDOWPOS_UNDEFINED;
74  state->window_w = DEFAULT_WINDOW_WIDTH;
75  state->window_h = DEFAULT_WINDOW_HEIGHT;
76  state->num_windows = 1;
77  state->audiospec.freq = 22050;
78  state->audiospec.format = AUDIO_S16;
79  state->audiospec.channels = 2;
80  state->audiospec.samples = 2048;
81 
82  /* Set some very sane GL defaults */
83  state->gl_red_size = 3;
84  state->gl_green_size = 3;
85  state->gl_blue_size = 2;
86  state->gl_alpha_size = 0;
87  state->gl_buffer_size = 0;
88  state->gl_depth_size = 16;
89  state->gl_stencil_size = 0;
90  state->gl_double_buffer = 1;
91  state->gl_accum_red_size = 0;
92  state->gl_accum_green_size = 0;
93  state->gl_accum_blue_size = 0;
94  state->gl_accum_alpha_size = 0;
95  state->gl_stereo = 0;
96  state->gl_multisamplebuffers = 0;
97  state->gl_multisamplesamples = 0;
98  state->gl_retained_backing = 1;
99  state->gl_accelerated = -1;
100  state->gl_debug = 0;
101 
102  return state;
103 }
104 
105 int
107 {
108  char **argv = state->argv;
109 
110  if (SDL_strcasecmp(argv[index], "--video") == 0) {
111  ++index;
112  if (!argv[index]) {
113  return -1;
114  }
115  state->videodriver = argv[index];
116  return 2;
117  }
118  if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
119  ++index;
120  if (!argv[index]) {
121  return -1;
122  }
123  state->renderdriver = argv[index];
124  return 2;
125  }
126  if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
127  state->gl_debug = 1;
128  return 1;
129  }
130  if (SDL_strcasecmp(argv[index], "--info") == 0) {
131  ++index;
132  if (!argv[index]) {
133  return -1;
134  }
135  if (SDL_strcasecmp(argv[index], "all") == 0) {
136  state->verbose |=
138  VERBOSE_EVENT);
139  return 2;
140  }
141  if (SDL_strcasecmp(argv[index], "video") == 0) {
142  state->verbose |= VERBOSE_VIDEO;
143  return 2;
144  }
145  if (SDL_strcasecmp(argv[index], "modes") == 0) {
146  state->verbose |= VERBOSE_MODES;
147  return 2;
148  }
149  if (SDL_strcasecmp(argv[index], "render") == 0) {
150  state->verbose |= VERBOSE_RENDER;
151  return 2;
152  }
153  if (SDL_strcasecmp(argv[index], "event") == 0) {
154  state->verbose |= VERBOSE_EVENT;
155  return 2;
156  }
157  return -1;
158  }
159  if (SDL_strcasecmp(argv[index], "--log") == 0) {
160  ++index;
161  if (!argv[index]) {
162  return -1;
163  }
164  if (SDL_strcasecmp(argv[index], "all") == 0) {
166  return 2;
167  }
168  if (SDL_strcasecmp(argv[index], "error") == 0) {
170  return 2;
171  }
172  if (SDL_strcasecmp(argv[index], "system") == 0) {
174  return 2;
175  }
176  if (SDL_strcasecmp(argv[index], "audio") == 0) {
178  return 2;
179  }
180  if (SDL_strcasecmp(argv[index], "video") == 0) {
182  return 2;
183  }
184  if (SDL_strcasecmp(argv[index], "render") == 0) {
186  return 2;
187  }
188  if (SDL_strcasecmp(argv[index], "input") == 0) {
190  return 2;
191  }
192  return -1;
193  }
194  if (SDL_strcasecmp(argv[index], "--display") == 0) {
195  ++index;
196  if (!argv[index]) {
197  return -1;
198  }
199  state->display = SDL_atoi(argv[index]);
200  if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
201  state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
202  state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
203  }
204  if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
205  state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
206  state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
207  }
208  return 2;
209  }
210  if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
211  state->window_flags |= SDL_WINDOW_FULLSCREEN;
212  state->num_windows = 1;
213  return 1;
214  }
215  if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
216  state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
217  state->num_windows = 1;
218  return 1;
219  }
220  if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
221  state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
222  return 1;
223  }
224  if (SDL_strcasecmp(argv[index], "--windows") == 0) {
225  ++index;
226  if (!argv[index] || !SDL_isdigit(*argv[index])) {
227  return -1;
228  }
229  if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
230  state->num_windows = SDL_atoi(argv[index]);
231  }
232  return 2;
233  }
234  if (SDL_strcasecmp(argv[index], "--title") == 0) {
235  ++index;
236  if (!argv[index]) {
237  return -1;
238  }
239  state->window_title = argv[index];
240  return 2;
241  }
242  if (SDL_strcasecmp(argv[index], "--icon") == 0) {
243  ++index;
244  if (!argv[index]) {
245  return -1;
246  }
247  state->window_icon = argv[index];
248  return 2;
249  }
250  if (SDL_strcasecmp(argv[index], "--center") == 0) {
251  state->window_x = SDL_WINDOWPOS_CENTERED;
252  state->window_y = SDL_WINDOWPOS_CENTERED;
253  return 1;
254  }
255  if (SDL_strcasecmp(argv[index], "--position") == 0) {
256  char *x, *y;
257  ++index;
258  if (!argv[index]) {
259  return -1;
260  }
261  x = argv[index];
262  y = argv[index];
263  while (*y && *y != ',') {
264  ++y;
265  }
266  if (!*y) {
267  return -1;
268  }
269  *y++ = '\0';
270  state->window_x = SDL_atoi(x);
271  state->window_y = SDL_atoi(y);
272  return 2;
273  }
274  if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
275  char *w, *h;
276  ++index;
277  if (!argv[index]) {
278  return -1;
279  }
280  w = argv[index];
281  h = argv[index];
282  while (*h && *h != 'x') {
283  ++h;
284  }
285  if (!*h) {
286  return -1;
287  }
288  *h++ = '\0';
289  state->window_w = SDL_atoi(w);
290  state->window_h = SDL_atoi(h);
291  return 2;
292  }
293  if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
294  char *w, *h;
295  ++index;
296  if (!argv[index]) {
297  return -1;
298  }
299  w = argv[index];
300  h = argv[index];
301  while (*h && *h != 'x') {
302  ++h;
303  }
304  if (!*h) {
305  return -1;
306  }
307  *h++ = '\0';
308  state->window_minW = SDL_atoi(w);
309  state->window_minH = SDL_atoi(h);
310  return 2;
311  }
312  if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
313  char *w, *h;
314  ++index;
315  if (!argv[index]) {
316  return -1;
317  }
318  w = argv[index];
319  h = argv[index];
320  while (*h && *h != 'x') {
321  ++h;
322  }
323  if (!*h) {
324  return -1;
325  }
326  *h++ = '\0';
327  state->window_maxW = SDL_atoi(w);
328  state->window_maxH = SDL_atoi(h);
329  return 2;
330  }
331  if (SDL_strcasecmp(argv[index], "--logical") == 0) {
332  char *w, *h;
333  ++index;
334  if (!argv[index]) {
335  return -1;
336  }
337  w = argv[index];
338  h = argv[index];
339  while (*h && *h != 'x') {
340  ++h;
341  }
342  if (!*h) {
343  return -1;
344  }
345  *h++ = '\0';
346  state->logical_w = SDL_atoi(w);
347  state->logical_h = SDL_atoi(h);
348  return 2;
349  }
350  if (SDL_strcasecmp(argv[index], "--scale") == 0) {
351  ++index;
352  if (!argv[index]) {
353  return -1;
354  }
355  state->scale = (float)SDL_atof(argv[index]);
356  return 2;
357  }
358  if (SDL_strcasecmp(argv[index], "--depth") == 0) {
359  ++index;
360  if (!argv[index]) {
361  return -1;
362  }
363  state->depth = SDL_atoi(argv[index]);
364  return 2;
365  }
366  if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
367  ++index;
368  if (!argv[index]) {
369  return -1;
370  }
371  state->refresh_rate = SDL_atoi(argv[index]);
372  return 2;
373  }
374  if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
375  state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
376  return 1;
377  }
378  if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
379  state->window_flags |= SDL_WINDOW_BORDERLESS;
380  return 1;
381  }
382  if (SDL_strcasecmp(argv[index], "--resize") == 0) {
383  state->window_flags |= SDL_WINDOW_RESIZABLE;
384  return 1;
385  }
386  if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
387  state->window_flags |= SDL_WINDOW_MINIMIZED;
388  return 1;
389  }
390  if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
391  state->window_flags |= SDL_WINDOW_MAXIMIZED;
392  return 1;
393  }
394  if (SDL_strcasecmp(argv[index], "--grab") == 0) {
395  state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
396  return 1;
397  }
398  if (SDL_strcasecmp(argv[index], "--rate") == 0) {
399  ++index;
400  if (!argv[index]) {
401  return -1;
402  }
403  state->audiospec.freq = SDL_atoi(argv[index]);
404  return 2;
405  }
406  if (SDL_strcasecmp(argv[index], "--format") == 0) {
407  ++index;
408  if (!argv[index]) {
409  return -1;
410  }
411  if (SDL_strcasecmp(argv[index], "U8") == 0) {
412  state->audiospec.format = AUDIO_U8;
413  return 2;
414  }
415  if (SDL_strcasecmp(argv[index], "S8") == 0) {
416  state->audiospec.format = AUDIO_S8;
417  return 2;
418  }
419  if (SDL_strcasecmp(argv[index], "U16") == 0) {
420  state->audiospec.format = AUDIO_U16;
421  return 2;
422  }
423  if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
424  state->audiospec.format = AUDIO_U16LSB;
425  return 2;
426  }
427  if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
428  state->audiospec.format = AUDIO_U16MSB;
429  return 2;
430  }
431  if (SDL_strcasecmp(argv[index], "S16") == 0) {
432  state->audiospec.format = AUDIO_S16;
433  return 2;
434  }
435  if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
436  state->audiospec.format = AUDIO_S16LSB;
437  return 2;
438  }
439  if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
440  state->audiospec.format = AUDIO_S16MSB;
441  return 2;
442  }
443  return -1;
444  }
445  if (SDL_strcasecmp(argv[index], "--channels") == 0) {
446  ++index;
447  if (!argv[index]) {
448  return -1;
449  }
450  state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
451  return 2;
452  }
453  if (SDL_strcasecmp(argv[index], "--samples") == 0) {
454  ++index;
455  if (!argv[index]) {
456  return -1;
457  }
458  state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
459  return 2;
460  }
461  if (SDL_strcasecmp(argv[index], "--trackmem") == 0) {
462  /* Already handled in SDLTest_CommonCreateState() */
463  return 1;
464  }
465  if ((SDL_strcasecmp(argv[index], "-h") == 0)
466  || (SDL_strcasecmp(argv[index], "--help") == 0)) {
467  /* Print the usage message */
468  return -1;
469  }
470  if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
471  /* Debug flag sent by Xcode */
472  return 2;
473  }
474  return 0;
475 }
476 
477 const char *
479 {
480  switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
481  case SDL_INIT_VIDEO:
482  return "[--trackmem] " VIDEO_USAGE;
483  case SDL_INIT_AUDIO:
484  return "[--trackmem] " AUDIO_USAGE;
486  return "[--trackmem] " VIDEO_USAGE " " AUDIO_USAGE;
487  default:
488  return "[--trackmem]";
489  }
490 }
491 
492 static void
493 SDLTest_PrintRendererFlag(char *text, size_t maxlen, Uint32 flag)
494 {
495  switch (flag) {
497  SDL_snprintfcat(text, maxlen, "Software");
498  break;
500  SDL_snprintfcat(text, maxlen, "Accelerated");
501  break;
503  SDL_snprintfcat(text, maxlen, "PresentVSync");
504  break;
506  SDL_snprintfcat(text, maxlen, "TargetTexturesSupported");
507  break;
508  default:
509  SDL_snprintfcat(text, maxlen, "0x%8.8x", flag);
510  break;
511  }
512 }
513 
514 static void
516 {
517  switch (format) {
519  SDL_snprintfcat(text, maxlen, "Unknown");
520  break;
522  SDL_snprintfcat(text, maxlen, "Index1LSB");
523  break;
525  SDL_snprintfcat(text, maxlen, "Index1MSB");
526  break;
528  SDL_snprintfcat(text, maxlen, "Index4LSB");
529  break;
531  SDL_snprintfcat(text, maxlen, "Index4MSB");
532  break;
534  SDL_snprintfcat(text, maxlen, "Index8");
535  break;
537  SDL_snprintfcat(text, maxlen, "RGB332");
538  break;
540  SDL_snprintfcat(text, maxlen, "RGB444");
541  break;
543  SDL_snprintfcat(text, maxlen, "RGB555");
544  break;
546  SDL_snprintfcat(text, maxlen, "BGR555");
547  break;
549  SDL_snprintfcat(text, maxlen, "ARGB4444");
550  break;
552  SDL_snprintfcat(text, maxlen, "ABGR4444");
553  break;
555  SDL_snprintfcat(text, maxlen, "ARGB1555");
556  break;
558  SDL_snprintfcat(text, maxlen, "ABGR1555");
559  break;
561  SDL_snprintfcat(text, maxlen, "RGB565");
562  break;
564  SDL_snprintfcat(text, maxlen, "BGR565");
565  break;
567  SDL_snprintfcat(text, maxlen, "RGB24");
568  break;
570  SDL_snprintfcat(text, maxlen, "BGR24");
571  break;
573  SDL_snprintfcat(text, maxlen, "RGB888");
574  break;
576  SDL_snprintfcat(text, maxlen, "BGR888");
577  break;
579  SDL_snprintfcat(text, maxlen, "ARGB8888");
580  break;
582  SDL_snprintfcat(text, maxlen, "RGBA8888");
583  break;
585  SDL_snprintfcat(text, maxlen, "ABGR8888");
586  break;
588  SDL_snprintfcat(text, maxlen, "BGRA8888");
589  break;
591  SDL_snprintfcat(text, maxlen, "ARGB2101010");
592  break;
594  SDL_snprintfcat(text, maxlen, "YV12");
595  break;
597  SDL_snprintfcat(text, maxlen, "IYUV");
598  break;
600  SDL_snprintfcat(text, maxlen, "YUY2");
601  break;
603  SDL_snprintfcat(text, maxlen, "UYVY");
604  break;
606  SDL_snprintfcat(text, maxlen, "YVYU");
607  break;
609  SDL_snprintfcat(text, maxlen, "NV12");
610  break;
612  SDL_snprintfcat(text, maxlen, "NV21");
613  break;
614  default:
615  SDL_snprintfcat(text, maxlen, "0x%8.8x", format);
616  break;
617  }
618 }
619 
620 static void
622 {
623  int i, count;
624  char text[1024];
625 
626  SDL_Log(" Renderer %s:\n", info->name);
627 
628  SDL_snprintf(text, sizeof(text), " Flags: 0x%8.8X", info->flags);
629  SDL_snprintfcat(text, sizeof(text), " (");
630  count = 0;
631  for (i = 0; i < sizeof(info->flags) * 8; ++i) {
632  Uint32 flag = (1 << i);
633  if (info->flags & flag) {
634  if (count > 0) {
635  SDL_snprintfcat(text, sizeof(text), " | ");
636  }
637  SDLTest_PrintRendererFlag(text, sizeof(text), flag);
638  ++count;
639  }
640  }
641  SDL_snprintfcat(text, sizeof(text), ")");
642  SDL_Log("%s\n", text);
643 
644  SDL_snprintf(text, sizeof(text), " Texture formats (%d): ", info->num_texture_formats);
645  for (i = 0; i < (int) info->num_texture_formats; ++i) {
646  if (i > 0) {
647  SDL_snprintfcat(text, sizeof(text), ", ");
648  }
650  }
651  SDL_Log("%s\n", text);
652 
653  if (info->max_texture_width || info->max_texture_height) {
654  SDL_Log(" Max Texture Size: %dx%d\n",
656  }
657 }
658 
659 static SDL_Surface *
660 SDLTest_LoadIcon(const char *file)
661 {
662  SDL_Surface *icon;
663 
664  /* Load the icon surface */
665  icon = SDL_LoadBMP(file);
666  if (icon == NULL) {
667  SDL_Log("Couldn't load %s: %s\n", file, SDL_GetError());
668  return (NULL);
669  }
670 
671  if (icon->format->palette) {
672  /* Set the colorkey */
673  SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
674  }
675 
676  return (icon);
677 }
678 
681 {
682  int w, h;
683  const int RESIZE_BORDER = 8;
684  const int DRAGGABLE_TITLE = 32;
685 
686  /*SDL_Log("Hit test point %d,%d\n", area->x, area->y);*/
687 
688  SDL_GetWindowSize(win, &w, &h);
689 
690  if (area->x < RESIZE_BORDER) {
691  if (area->y < RESIZE_BORDER) {
692  SDL_Log("SDL_HITTEST_RESIZE_TOPLEFT\n");
694  } else if (area->y >= (h-RESIZE_BORDER)) {
695  SDL_Log("SDL_HITTEST_RESIZE_BOTTOMLEFT\n");
697  } else {
698  SDL_Log("SDL_HITTEST_RESIZE_LEFT\n");
700  }
701  } else if (area->x >= (w-RESIZE_BORDER)) {
702  if (area->y < RESIZE_BORDER) {
703  SDL_Log("SDL_HITTEST_RESIZE_TOPRIGHT\n");
705  } else if (area->y >= (h-RESIZE_BORDER)) {
706  SDL_Log("SDL_HITTEST_RESIZE_BOTTOMRIGHT\n");
708  } else {
709  SDL_Log("SDL_HITTEST_RESIZE_RIGHT\n");
711  }
712  } else if (area->y >= (h-RESIZE_BORDER)) {
713  SDL_Log("SDL_HITTEST_RESIZE_BOTTOM\n");
715  } else if (area->y < RESIZE_BORDER) {
716  SDL_Log("SDL_HITTEST_RESIZE_TOP\n");
717  return SDL_HITTEST_RESIZE_TOP;
718  } else if (area->y < DRAGGABLE_TITLE) {
719  SDL_Log("SDL_HITTEST_DRAGGABLE\n");
720  return SDL_HITTEST_DRAGGABLE;
721  }
722  return SDL_HITTEST_NORMAL;
723 }
724 
725 SDL_bool
727 {
728  int i, j, m, n, w, h;
729  SDL_DisplayMode fullscreen_mode;
730  char text[1024];
731 
732  if (state->flags & SDL_INIT_VIDEO) {
733  if (state->verbose & VERBOSE_VIDEO) {
735  if (n == 0) {
736  SDL_Log("No built-in video drivers\n");
737  } else {
738  SDL_snprintf(text, sizeof(text), "Built-in video drivers:");
739  for (i = 0; i < n; ++i) {
740  if (i > 0) {
741  SDL_snprintfcat(text, sizeof(text), ",");
742  }
743  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetVideoDriver(i));
744  }
745  SDL_Log("%s\n", text);
746  }
747  }
748  if (SDL_VideoInit(state->videodriver) < 0) {
749  SDL_Log("Couldn't initialize video driver: %s\n",
750  SDL_GetError());
751  return SDL_FALSE;
752  }
753  if (state->verbose & VERBOSE_VIDEO) {
754  SDL_Log("Video driver: %s\n",
756  }
757 
758  /* Upload GL settings */
763  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
764  SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
766  SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
767  SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
768  SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
769  SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
770  SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
772  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
773  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
774  if (state->gl_accelerated >= 0) {
776  state->gl_accelerated);
777  }
778  SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
779  if (state->gl_major_version) {
782  }
783  if (state->gl_debug) {
785  }
786  if (state->gl_profile_mask) {
788  }
789 
790  if (state->verbose & VERBOSE_MODES) {
791  SDL_Rect bounds, usablebounds;
792  float hdpi = 0;
793  float vdpi = 0;
795  int bpp;
796  Uint32 Rmask, Gmask, Bmask, Amask;
797 #if SDL_VIDEO_DRIVER_WINDOWS
798  int adapterIndex = 0;
799  int outputIndex = 0;
800 #endif
802  SDL_Log("Number of displays: %d\n", n);
803  for (i = 0; i < n; ++i) {
804  SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
805 
806  SDL_zero(bounds);
807  SDL_GetDisplayBounds(i, &bounds);
808 
809  SDL_zero(usablebounds);
810  SDL_GetDisplayUsableBounds(i, &usablebounds);
811 
812  SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
813 
814  SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
815  SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
816  SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
817 
819  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
820  &Bmask, &Amask);
821  SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
822  mode.w, mode.h, mode.refresh_rate, bpp,
823  SDL_GetPixelFormatName(mode.format));
824  if (Rmask || Gmask || Bmask) {
825  SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
826  SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
827  SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
828  if (Amask)
829  SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
830  }
831 
832  /* Print available fullscreen video modes */
834  if (m == 0) {
835  SDL_Log("No available fullscreen video modes\n");
836  } else {
837  SDL_Log(" Fullscreen video modes:\n");
838  for (j = 0; j < m; ++j) {
840  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
841  &Gmask, &Bmask, &Amask);
842  SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
843  j, mode.w, mode.h, mode.refresh_rate, bpp,
844  SDL_GetPixelFormatName(mode.format));
845  if (Rmask || Gmask || Bmask) {
846  SDL_Log(" Red Mask = 0x%.8x\n",
847  Rmask);
848  SDL_Log(" Green Mask = 0x%.8x\n",
849  Gmask);
850  SDL_Log(" Blue Mask = 0x%.8x\n",
851  Bmask);
852  if (Amask)
853  SDL_Log(" Alpha Mask = 0x%.8x\n",
854  Amask);
855  }
856  }
857  }
858 
859 #if SDL_VIDEO_DRIVER_WINDOWS
860  /* Print the D3D9 adapter index */
861  adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
862  SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
863 
864  /* Print the DXGI adapter and output indices */
865  SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
866  SDL_Log("DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex);
867 #endif
868  }
869  }
870 
871  if (state->verbose & VERBOSE_RENDER) {
872  SDL_RendererInfo info;
873 
875  if (n == 0) {
876  SDL_Log("No built-in render drivers\n");
877  } else {
878  SDL_Log("Built-in render drivers:\n");
879  for (i = 0; i < n; ++i) {
880  SDL_GetRenderDriverInfo(i, &info);
881  SDLTest_PrintRenderer(&info);
882  }
883  }
884  }
885 
886  SDL_zero(fullscreen_mode);
887  switch (state->depth) {
888  case 8:
889  fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
890  break;
891  case 15:
892  fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
893  break;
894  case 16:
895  fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
896  break;
897  case 24:
898  fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
899  break;
900  default:
901  fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
902  break;
903  }
904  fullscreen_mode.refresh_rate = state->refresh_rate;
905 
906  state->windows =
907  (SDL_Window **) SDL_calloc(state->num_windows,
908  sizeof(*state->windows));
909  state->renderers =
910  (SDL_Renderer **) SDL_calloc(state->num_windows,
911  sizeof(*state->renderers));
912  state->targets =
913  (SDL_Texture **) SDL_calloc(state->num_windows,
914  sizeof(*state->targets));
915  if (!state->windows || !state->renderers) {
916  SDL_Log("Out of memory!\n");
917  return SDL_FALSE;
918  }
919  for (i = 0; i < state->num_windows; ++i) {
920  char title[1024];
921 
922  if (state->num_windows > 1) {
923  SDL_snprintf(title, SDL_arraysize(title), "%s %d",
924  state->window_title, i + 1);
925  } else {
926  SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
927  }
928  state->windows[i] =
929  SDL_CreateWindow(title, state->window_x, state->window_y,
930  state->window_w, state->window_h,
931  state->window_flags);
932  if (!state->windows[i]) {
933  SDL_Log("Couldn't create window: %s\n",
934  SDL_GetError());
935  return SDL_FALSE;
936  }
937  if (state->window_minW || state->window_minH) {
938  SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
939  }
940  if (state->window_maxW || state->window_maxH) {
941  SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
942  }
943  SDL_GetWindowSize(state->windows[i], &w, &h);
944  if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
945  (w != state->window_w || h != state->window_h)) {
946  printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
947  state->window_w = w;
948  state->window_h = h;
949  }
950  if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
951  SDL_Log("Can't set up fullscreen display mode: %s\n",
952  SDL_GetError());
953  return SDL_FALSE;
954  }
955 
956  /* Add resize/drag areas for windows that are borderless and resizable */
957  if ((state->window_flags & (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) ==
960  }
961 
962  if (state->window_icon) {
963  SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
964  if (icon) {
965  SDL_SetWindowIcon(state->windows[i], icon);
966  SDL_FreeSurface(icon);
967  }
968  }
969 
970  SDL_ShowWindow(state->windows[i]);
971 
972  if (!state->skip_renderer
973  && (state->renderdriver
974  || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
975  m = -1;
976  if (state->renderdriver) {
977  SDL_RendererInfo info;
979  for (j = 0; j < n; ++j) {
980  SDL_GetRenderDriverInfo(j, &info);
981  if (SDL_strcasecmp(info.name, state->renderdriver) ==
982  0) {
983  m = j;
984  break;
985  }
986  }
987  if (m == -1) {
988  SDL_Log("Couldn't find render driver named %s",
989  state->renderdriver);
990  return SDL_FALSE;
991  }
992  }
993  state->renderers[i] = SDL_CreateRenderer(state->windows[i],
994  m, state->render_flags);
995  if (!state->renderers[i]) {
996  SDL_Log("Couldn't create renderer: %s\n",
997  SDL_GetError());
998  return SDL_FALSE;
999  }
1000  if (state->logical_w && state->logical_h) {
1001  SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
1002  } else if (state->scale) {
1003  SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
1004  }
1005  if (state->verbose & VERBOSE_RENDER) {
1006  SDL_RendererInfo info;
1007 
1008  SDL_Log("Current renderer:\n");
1009  SDL_GetRendererInfo(state->renderers[i], &info);
1010  SDLTest_PrintRenderer(&info);
1011  }
1012  }
1013  }
1014  }
1015 
1016  if (state->flags & SDL_INIT_AUDIO) {
1017  if (state->verbose & VERBOSE_AUDIO) {
1019  if (n == 0) {
1020  SDL_Log("No built-in audio drivers\n");
1021  } else {
1022  SDL_snprintf(text, sizeof(text), "Built-in audio drivers:");
1023  for (i = 0; i < n; ++i) {
1024  if (i > 0) {
1025  SDL_snprintfcat(text, sizeof(text), ",");
1026  }
1027  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetAudioDriver(i));
1028  }
1029  SDL_Log("%s\n", text);
1030  }
1031  }
1032  if (SDL_AudioInit(state->audiodriver) < 0) {
1033  SDL_Log("Couldn't initialize audio driver: %s\n",
1034  SDL_GetError());
1035  return SDL_FALSE;
1036  }
1037  if (state->verbose & VERBOSE_VIDEO) {
1038  SDL_Log("Audio driver: %s\n",
1040  }
1041 
1042  if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
1043  SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
1044  return SDL_FALSE;
1045  }
1046  }
1047 
1048  return SDL_TRUE;
1049 }
1050 
1051 static const char *
1052 DisplayOrientationName(int orientation)
1053 {
1054  switch (orientation)
1055  {
1056 #define CASE(X) case SDL_ORIENTATION_##X: return #X
1057  CASE(UNKNOWN);
1058  CASE(LANDSCAPE);
1059  CASE(LANDSCAPE_FLIPPED);
1060  CASE(PORTRAIT);
1061  CASE(PORTRAIT_FLIPPED);
1062 #undef CASE
1063 default: return "???";
1064  }
1065 }
1066 
1067 static const char *
1069 {
1070  switch (axis)
1071  {
1072 #define AXIS_CASE(ax) case SDL_CONTROLLER_AXIS_##ax: return #ax
1073  AXIS_CASE(INVALID);
1074  AXIS_CASE(LEFTX);
1075  AXIS_CASE(LEFTY);
1076  AXIS_CASE(RIGHTX);
1077  AXIS_CASE(RIGHTY);
1078  AXIS_CASE(TRIGGERLEFT);
1079  AXIS_CASE(TRIGGERRIGHT);
1080 #undef AXIS_CASE
1081 default: return "???";
1082  }
1083 }
1084 
1085 static const char *
1087 {
1088  switch (button)
1089  {
1090 #define BUTTON_CASE(btn) case SDL_CONTROLLER_BUTTON_##btn: return #btn
1091  BUTTON_CASE(INVALID);
1092  BUTTON_CASE(A);
1093  BUTTON_CASE(B);
1094  BUTTON_CASE(X);
1095  BUTTON_CASE(Y);
1096  BUTTON_CASE(BACK);
1097  BUTTON_CASE(GUIDE);
1098  BUTTON_CASE(START);
1099  BUTTON_CASE(LEFTSTICK);
1100  BUTTON_CASE(RIGHTSTICK);
1101  BUTTON_CASE(LEFTSHOULDER);
1102  BUTTON_CASE(RIGHTSHOULDER);
1103  BUTTON_CASE(DPAD_UP);
1104  BUTTON_CASE(DPAD_DOWN);
1105  BUTTON_CASE(DPAD_LEFT);
1106  BUTTON_CASE(DPAD_RIGHT);
1107 #undef BUTTON_CASE
1108 default: return "???";
1109  }
1110 }
1111 
1112 static void
1114 {
1115  if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
1116  /* Mouse and finger motion are really spammy */
1117  return;
1118  }
1119 
1120  switch (event->type) {
1121  case SDL_DISPLAYEVENT:
1122  switch (event->display.event) {
1124  SDL_Log("SDL EVENT: Display %d changed orientation to %s", event->display.display, DisplayOrientationName(event->display.data1));
1125  break;
1126  default:
1127  SDL_Log("SDL EVENT: Display %d got unknown event 0x%4.4x",
1128  event->display.display, event->display.event);
1129  break;
1130  }
1131  break;
1132  case SDL_WINDOWEVENT:
1133  switch (event->window.event) {
1134  case SDL_WINDOWEVENT_SHOWN:
1135  SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
1136  break;
1138  SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
1139  break;
1141  SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
1142  break;
1143  case SDL_WINDOWEVENT_MOVED:
1144  SDL_Log("SDL EVENT: Window %d moved to %d,%d",
1145  event->window.windowID, event->window.data1,
1146  event->window.data2);
1147  break;
1149  SDL_Log("SDL EVENT: Window %d resized to %dx%d",
1150  event->window.windowID, event->window.data1,
1151  event->window.data2);
1152  break;
1154  SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
1155  event->window.windowID, event->window.data1,
1156  event->window.data2);
1157  break;
1159  SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
1160  break;
1162  SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
1163  break;
1165  SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
1166  break;
1167  case SDL_WINDOWEVENT_ENTER:
1168  SDL_Log("SDL EVENT: Mouse entered window %d",
1169  event->window.windowID);
1170  break;
1171  case SDL_WINDOWEVENT_LEAVE:
1172  SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
1173  break;
1175  SDL_Log("SDL EVENT: Window %d gained keyboard focus",
1176  event->window.windowID);
1177  break;
1179  SDL_Log("SDL EVENT: Window %d lost keyboard focus",
1180  event->window.windowID);
1181  break;
1182  case SDL_WINDOWEVENT_CLOSE:
1183  SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
1184  break;
1186  SDL_Log("SDL EVENT: Window %d take focus", event->window.windowID);
1187  break;
1189  SDL_Log("SDL EVENT: Window %d hit test", event->window.windowID);
1190  break;
1191  default:
1192  SDL_Log("SDL EVENT: Window %d got unknown event 0x%4.4x",
1193  event->window.windowID, event->window.event);
1194  break;
1195  }
1196  break;
1197  case SDL_KEYDOWN:
1198  SDL_Log("SDL EVENT: Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1199  event->key.windowID,
1200  event->key.keysym.scancode,
1201  SDL_GetScancodeName(event->key.keysym.scancode),
1202  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1203  break;
1204  case SDL_KEYUP:
1205  SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1206  event->key.windowID,
1207  event->key.keysym.scancode,
1208  SDL_GetScancodeName(event->key.keysym.scancode),
1209  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1210  break;
1211  case SDL_TEXTEDITING:
1212  SDL_Log("SDL EVENT: Keyboard: text editing \"%s\" in window %d",
1213  event->edit.text, event->edit.windowID);
1214  break;
1215  case SDL_TEXTINPUT:
1216  SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
1217  event->text.text, event->text.windowID);
1218  break;
1219  case SDL_KEYMAPCHANGED:
1220  SDL_Log("SDL EVENT: Keymap changed");
1221  break;
1222  case SDL_MOUSEMOTION:
1223  SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
1224  event->motion.x, event->motion.y,
1225  event->motion.xrel, event->motion.yrel,
1226  event->motion.windowID);
1227  break;
1228  case SDL_MOUSEBUTTONDOWN:
1229  SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
1230  event->button.button, event->button.x, event->button.y, event->button.clicks,
1231  event->button.windowID);
1232  break;
1233  case SDL_MOUSEBUTTONUP:
1234  SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
1235  event->button.button, event->button.x, event->button.y, event->button.clicks,
1236  event->button.windowID);
1237  break;
1238  case SDL_MOUSEWHEEL:
1239  SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
1240  event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
1241  break;
1242  case SDL_JOYDEVICEADDED:
1243  SDL_Log("SDL EVENT: Joystick index %d attached",
1244  event->jdevice.which);
1245  break;
1246  case SDL_JOYDEVICEREMOVED:
1247  SDL_Log("SDL EVENT: Joystick %d removed",
1248  event->jdevice.which);
1249  break;
1250  case SDL_JOYBALLMOTION:
1251  SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
1252  event->jball.which, event->jball.ball, event->jball.xrel,
1253  event->jball.yrel);
1254  break;
1255  case SDL_JOYHATMOTION:
1256  {
1257  const char *position = "UNKNOWN";
1258  switch (event->jhat.value) {
1259  case SDL_HAT_CENTERED:
1260  position = "CENTER";
1261  break;
1262  case SDL_HAT_UP:
1263  position = "UP";
1264  break;
1265  case SDL_HAT_RIGHTUP:
1266  position = "RIGHTUP";
1267  break;
1268  case SDL_HAT_RIGHT:
1269  position = "RIGHT";
1270  break;
1271  case SDL_HAT_RIGHTDOWN:
1272  position = "RIGHTDOWN";
1273  break;
1274  case SDL_HAT_DOWN:
1275  position = "DOWN";
1276  break;
1277  case SDL_HAT_LEFTDOWN:
1278  position = "LEFTDOWN";
1279  break;
1280  case SDL_HAT_LEFT:
1281  position = "LEFT";
1282  break;
1283  case SDL_HAT_LEFTUP:
1284  position = "LEFTUP";
1285  break;
1286  }
1287  SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
1288  event->jhat.hat, position);
1289  }
1290  break;
1291  case SDL_JOYBUTTONDOWN:
1292  SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
1293  event->jbutton.which, event->jbutton.button);
1294  break;
1295  case SDL_JOYBUTTONUP:
1296  SDL_Log("SDL EVENT: Joystick %d: button %d released",
1297  event->jbutton.which, event->jbutton.button);
1298  break;
1300  SDL_Log("SDL EVENT: Controller index %d attached",
1301  event->cdevice.which);
1302  break;
1304  SDL_Log("SDL EVENT: Controller %d removed",
1305  event->cdevice.which);
1306  break;
1308  SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
1309  event->caxis.which,
1310  event->caxis.axis,
1312  event->caxis.value);
1313  break;
1315  SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
1316  event->cbutton.which, event->cbutton.button,
1318  break;
1320  SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
1321  event->cbutton.which, event->cbutton.button,
1323  break;
1324  case SDL_CLIPBOARDUPDATE:
1325  SDL_Log("SDL EVENT: Clipboard updated");
1326  break;
1327 
1328  case SDL_FINGERMOTION:
1329  SDL_Log("SDL EVENT: Finger: motion touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1330  (long) event->tfinger.touchId,
1331  (long) event->tfinger.fingerId,
1332  event->tfinger.x, event->tfinger.y,
1333  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1334  break;
1335  case SDL_FINGERDOWN:
1336  case SDL_FINGERUP:
1337  SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1338  (event->type == SDL_FINGERDOWN) ? "down" : "up",
1339  (long) event->tfinger.touchId,
1340  (long) event->tfinger.fingerId,
1341  event->tfinger.x, event->tfinger.y,
1342  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1343  break;
1344  case SDL_DOLLARGESTURE:
1345  SDL_Log("SDL_EVENT: Dollar gesture detect: %ld", (long) event->dgesture.gestureId);
1346  break;
1347  case SDL_DOLLARRECORD:
1348  SDL_Log("SDL_EVENT: Dollar gesture record: %ld", (long) event->dgesture.gestureId);
1349  break;
1350  case SDL_MULTIGESTURE:
1351  SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
1352  break;
1353 
1355  SDL_Log("SDL EVENT: render device reset");
1356  break;
1358  SDL_Log("SDL EVENT: render targets reset");
1359  break;
1360 
1361  case SDL_APP_TERMINATING:
1362  SDL_Log("SDL EVENT: App terminating");
1363  break;
1364  case SDL_APP_LOWMEMORY:
1365  SDL_Log("SDL EVENT: App running low on memory");
1366  break;
1368  SDL_Log("SDL EVENT: App will enter the background");
1369  break;
1371  SDL_Log("SDL EVENT: App entered the background");
1372  break;
1374  SDL_Log("SDL EVENT: App will enter the foreground");
1375  break;
1377  SDL_Log("SDL EVENT: App entered the foreground");
1378  break;
1379  case SDL_DROPBEGIN:
1380  SDL_Log("SDL EVENT: Drag and drop beginning");
1381  break;
1382  case SDL_DROPFILE:
1383  SDL_Log("SDL EVENT: Drag and drop file: '%s'", event->drop.file);
1384  break;
1385  case SDL_DROPTEXT:
1386  SDL_Log("SDL EVENT: Drag and drop text: '%s'", event->drop.file);
1387  break;
1388  case SDL_DROPCOMPLETE:
1389  SDL_Log("SDL EVENT: Drag and drop ending");
1390  break;
1391  case SDL_QUIT:
1392  SDL_Log("SDL EVENT: Quit requested");
1393  break;
1394  case SDL_USEREVENT:
1395  SDL_Log("SDL EVENT: User event %d", event->user.code);
1396  break;
1397  default:
1398  SDL_Log("Unknown event 0x%4.4x", event->type);
1399  break;
1400  }
1401 }
1402 
1403 static void
1405 {
1408 
1409  if (!renderer) {
1410  return;
1411  }
1412 
1416  0x00FF0000, 0x0000FF00, 0x000000FF,
1417 #else
1418  0x000000FF, 0x0000FF00, 0x00FF0000,
1419 #endif
1420  0x00000000);
1421  if (!surface) {
1422  SDL_Log("Couldn't create surface: %s\n", SDL_GetError());
1423  return;
1424  }
1425 
1426  if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
1427  surface->pixels, surface->pitch) < 0) {
1428  SDL_Log("Couldn't read screen: %s\n", SDL_GetError());
1429  SDL_free(surface);
1430  return;
1431  }
1432 
1433  if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
1434  SDL_Log("Couldn't save screenshot.bmp: %s\n", SDL_GetError());
1435  SDL_free(surface);
1436  return;
1437  }
1438 }
1439 
1440 static void
1441 FullscreenTo(int index, int windowId)
1442 {
1443  Uint32 flags;
1444  struct SDL_Rect rect = { 0, 0, 0, 0 };
1445  SDL_Window *window = SDL_GetWindowFromID(windowId);
1446  if (!window) {
1447  return;
1448  }
1449 
1451 
1453  if (flags & SDL_WINDOW_FULLSCREEN) {
1455  SDL_Delay( 15 );
1456  }
1457 
1460 }
1461 
1462 void
1464 {
1465  int i;
1466  static SDL_MouseMotionEvent lastEvent;
1467 
1468  if (state->verbose & VERBOSE_EVENT) {
1470  }
1471 
1472  switch (event->type) {
1473  case SDL_WINDOWEVENT:
1474  switch (event->window.event) {
1475  case SDL_WINDOWEVENT_CLOSE:
1476  {
1477  SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
1478  if (window) {
1479  for (i = 0; i < state->num_windows; ++i) {
1480  if (window == state->windows[i]) {
1481  if (state->targets[i]) {
1482  SDL_DestroyTexture(state->targets[i]);
1483  state->targets[i] = NULL;
1484  }
1485  if (state->renderers[i]) {
1486  SDL_DestroyRenderer(state->renderers[i]);
1487  state->renderers[i] = NULL;
1488  }
1489  SDL_DestroyWindow(state->windows[i]);
1490  state->windows[i] = NULL;
1491  break;
1492  }
1493  }
1494  }
1495  }
1496  break;
1497  }
1498  break;
1499  case SDL_KEYDOWN: {
1500  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1501  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1502  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1503 
1504  switch (event->key.keysym.sym) {
1505  /* Add hotkeys here */
1506  case SDLK_PRINTSCREEN: {
1507  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1508  if (window) {
1509  for (i = 0; i < state->num_windows; ++i) {
1510  if (window == state->windows[i]) {
1511  SDLTest_ScreenShot(state->renderers[i]);
1512  }
1513  }
1514  }
1515  }
1516  break;
1517  case SDLK_EQUALS:
1518  if (withControl) {
1519  /* Ctrl-+ double the size of the window */
1520  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1521  if (window) {
1522  int w, h;
1523  SDL_GetWindowSize(window, &w, &h);
1524  SDL_SetWindowSize(window, w*2, h*2);
1525  }
1526  }
1527  break;
1528  case SDLK_MINUS:
1529  if (withControl) {
1530  /* Ctrl-- half the size of the window */
1531  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1532  if (window) {
1533  int w, h;
1534  SDL_GetWindowSize(window, &w, &h);
1535  SDL_SetWindowSize(window, w/2, h/2);
1536  }
1537  }
1538  break;
1539  case SDLK_UP:
1540  case SDLK_DOWN:
1541  case SDLK_LEFT:
1542  case SDLK_RIGHT:
1543  if (withAlt) {
1544  /* Alt-Up/Down/Left/Right switches between displays */
1545  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1546  if (window) {
1547  int currentIndex = SDL_GetWindowDisplayIndex(window);
1548  int numDisplays = SDL_GetNumVideoDisplays();
1549 
1550  if (currentIndex >= 0 && numDisplays >= 1) {
1551  int dest;
1552  if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
1553  dest = (currentIndex + numDisplays - 1) % numDisplays;
1554  } else {
1555  dest = (currentIndex + numDisplays + 1) % numDisplays;
1556  }
1557  SDL_Log("Centering on display %d\n", dest);
1561  }
1562  }
1563  }
1564  if (withShift) {
1565  /* Shift-Up/Down/Left/Right shift the window by 100px */
1566  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1567  if (window) {
1568  const int delta = 100;
1569  int x, y;
1571 
1572  if (event->key.keysym.sym == SDLK_UP) y -= delta;
1573  if (event->key.keysym.sym == SDLK_DOWN) y += delta;
1574  if (event->key.keysym.sym == SDLK_LEFT) x -= delta;
1575  if (event->key.keysym.sym == SDLK_RIGHT) x += delta;
1576 
1577  SDL_Log("Setting position to (%d, %d)\n", x, y);
1579  }
1580  }
1581  break;
1582  case SDLK_o:
1583  if (withControl) {
1584  /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
1585  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1586  if (window) {
1587  float opacity;
1588  if (SDL_GetWindowOpacity(window, &opacity) == 0) {
1589  if (withShift) {
1590  opacity += 0.20f;
1591  } else {
1592  opacity -= 0.20f;
1593  }
1594  SDL_SetWindowOpacity(window, opacity);
1595  }
1596  }
1597  }
1598  break;
1599 
1600  case SDLK_c:
1601  if (withControl) {
1602  /* Ctrl-C copy awesome text! */
1603  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1604  printf("Copied text to clipboard\n");
1605  }
1606  if (withAlt) {
1607  /* Alt-C toggle a render clip rectangle */
1608  for (i = 0; i < state->num_windows; ++i) {
1609  int w, h;
1610  if (state->renderers[i]) {
1611  SDL_Rect clip;
1612  SDL_GetWindowSize(state->windows[i], &w, &h);
1613  SDL_RenderGetClipRect(state->renderers[i], &clip);
1614  if (SDL_RectEmpty(&clip)) {
1615  clip.x = w/4;
1616  clip.y = h/4;
1617  clip.w = w/2;
1618  clip.h = h/2;
1619  SDL_RenderSetClipRect(state->renderers[i], &clip);
1620  } else {
1621  SDL_RenderSetClipRect(state->renderers[i], NULL);
1622  }
1623  }
1624  }
1625  }
1626  if (withShift) {
1627  SDL_Window *current_win = SDL_GetKeyboardFocus();
1628  if (current_win) {
1629  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1630  const int rc = SDL_CaptureMouse(shouldCapture);
1631  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1632  }
1633  }
1634  break;
1635  case SDLK_v:
1636  if (withControl) {
1637  /* Ctrl-V paste awesome text! */
1638  char *text = SDL_GetClipboardText();
1639  if (*text) {
1640  printf("Clipboard: %s\n", text);
1641  } else {
1642  printf("Clipboard is empty\n");
1643  }
1644  SDL_free(text);
1645  }
1646  break;
1647  case SDLK_g:
1648  if (withControl) {
1649  /* Ctrl-G toggle grab */
1650  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1651  if (window) {
1653  }
1654  }
1655  break;
1656  case SDLK_m:
1657  if (withControl) {
1658  /* Ctrl-M maximize */
1659  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1660  if (window) {
1662  if (flags & SDL_WINDOW_MAXIMIZED) {
1664  } else {
1666  }
1667  }
1668  }
1669  break;
1670  case SDLK_r:
1671  if (withControl) {
1672  /* Ctrl-R toggle mouse relative mode */
1674  }
1675  break;
1676  case SDLK_z:
1677  if (withControl) {
1678  /* Ctrl-Z minimize */
1679  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1680  if (window) {
1682  }
1683  }
1684  break;
1685  case SDLK_RETURN:
1686  if (withControl) {
1687  /* Ctrl-Enter toggle fullscreen */
1688  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1689  if (window) {
1691  if (flags & SDL_WINDOW_FULLSCREEN) {
1693  } else {
1695  }
1696  }
1697  } else if (withAlt) {
1698  /* Alt-Enter toggle fullscreen desktop */
1699  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1700  if (window) {
1702  if (flags & SDL_WINDOW_FULLSCREEN) {
1704  } else {
1706  }
1707  }
1708  } else if (withShift) {
1709  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1710  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1711  if (window) {
1715  } else {
1717  }
1718  }
1719  }
1720 
1721  break;
1722  case SDLK_b:
1723  if (withControl) {
1724  /* Ctrl-B toggle window border */
1725  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1726  if (window) {
1728  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1730  }
1731  }
1732  break;
1733  case SDLK_a:
1734  if (withControl) {
1735  /* Ctrl-A reports absolute mouse position. */
1736  int x, y;
1737  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1738  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1739  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1740  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1741  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1742  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1743  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1744  }
1745  break;
1746  case SDLK_0:
1747  if (withControl) {
1748  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1749  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1750  }
1751  break;
1752  case SDLK_1:
1753  if (withControl) {
1754  FullscreenTo(0, event->key.windowID);
1755  }
1756  break;
1757  case SDLK_2:
1758  if (withControl) {
1759  FullscreenTo(1, event->key.windowID);
1760  }
1761  break;
1762  case SDLK_ESCAPE:
1763  *done = 1;
1764  break;
1765  case SDLK_SPACE:
1766  {
1767  char message[256];
1768  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1769 
1770  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1772  break;
1773  }
1774  default:
1775  break;
1776  }
1777  break;
1778  }
1779  case SDL_QUIT:
1780  *done = 1;
1781  break;
1782  case SDL_MOUSEMOTION:
1783  lastEvent = event->motion;
1784  break;
1785 
1786  case SDL_DROPFILE:
1787  case SDL_DROPTEXT:
1788  SDL_free(event->drop.file);
1789  break;
1790  }
1791 }
1792 
1793 void
1795 {
1796  int i;
1797 
1798  SDL_free(state->windows);
1799  if (state->targets) {
1800  for (i = 0; i < state->num_windows; ++i) {
1801  if (state->targets[i]) {
1802  SDL_DestroyTexture(state->targets[i]);
1803  }
1804  }
1805  SDL_free(state->targets);
1806  }
1807  if (state->renderers) {
1808  for (i = 0; i < state->num_windows; ++i) {
1809  if (state->renderers[i]) {
1810  SDL_DestroyRenderer(state->renderers[i]);
1811  }
1812  }
1813  SDL_free(state->renderers);
1814  }
1815  if (state->flags & SDL_INIT_VIDEO) {
1816  SDL_VideoQuit();
1817  }
1818  if (state->flags & SDL_INIT_AUDIO) {
1819  SDL_AudioQuit();
1820  }
1821  SDL_free(state);
1822  SDL_Quit();
1824 }
1825 
1826 /* vi: set ts=4 sw=4 expandtab: */
SDL_HITTEST_DRAGGABLE
@ SDL_HITTEST_DRAGGABLE
Definition: SDL_video.h:1023
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
SDL_WINDOW_MOUSE_CAPTURE
@ SDL_WINDOW_MOUSE_CAPTURE
Definition: SDL_video.h:116
SDL_PIXELFORMAT_ARGB8888
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248
SDL_GetWindowDisplayIndex
#define SDL_GetWindowDisplayIndex
Definition: SDL_dynapi_overrides.h:510
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
VERBOSE_VIDEO
#define VERBOSE_VIDEO
Definition: SDL_test_common.h:45
SDL_CONTROLLERDEVICEREMOVED
@ SDL_CONTROLLERDEVICEREMOVED
Definition: SDL_events.h:124
SDL_OpenAudio
#define SDL_OpenAudio
Definition: SDL_dynapi_overrides.h:78
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
SDL_Point::x
int x
Definition: SDL_rect.h:50
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:113
SDL_SetClipboardText
#define SDL_SetClipboardText
Definition: SDL_dynapi_overrides.h:98
SDL_GetPixelFormatName
#define SDL_GetPixelFormatName
Definition: SDL_dynapi_overrides.h:277
SDL_DisplayMode::format
Uint32 format
Definition: SDL_video.h:55
SDL_WINDOW_ALLOW_HIGHDPI
@ SDL_WINDOW_ALLOW_HIGHDPI
Definition: SDL_video.h:113
SDL_DXGIGetOutputInfo
SDL_bool SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
Returns the DXGI Adapter and Output indices for the specified display index.
SDL_strlcpy
#define SDL_strlcpy
Definition: SDL_dynapi_overrides.h:394
SDL_MouseMotionEvent::y
Sint32 y
Definition: SDL_events.h:261
SDL_APP_TERMINATING
@ SDL_APP_TERMINATING
Definition: SDL_events.h:63
SDL_SetWindowMinimumSize
#define SDL_SetWindowMinimumSize
Definition: SDL_dynapi_overrides.h:528
SDL_GL_MULTISAMPLESAMPLES
@ SDL_GL_MULTISAMPLESAMPLES
Definition: SDL_video.h:214
SDL_AudioInit
#define SDL_AudioInit
Definition: SDL_dynapi_overrides.h:75
SDL_MouseMotionEvent
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:254
SDL_APP_DIDENTERBACKGROUND
@ SDL_APP_DIDENTERBACKGROUND
Definition: SDL_events.h:75
SDL_APP_DIDENTERFOREGROUND
@ SDL_APP_DIDENTERFOREGROUND
Definition: SDL_events.h:83
mask
GLenum GLint GLuint mask
Definition: SDL_opengl_glext.h:657
Uint16
uint16_t Uint16
Definition: SDL_stdinc.h:191
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:70
SDL_ShowWindow
#define SDL_ShowWindow
Definition: SDL_dynapi_overrides.h:533
SDL_PIXELFORMAT_ARGB4444
@ SDL_PIXELFORMAT_ARGB4444
Definition: SDL_pixels.h:200
SDL_PIXELFORMAT_INDEX4MSB
@ SDL_PIXELFORMAT_INDEX4MSB
Definition: SDL_pixels.h:183
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDLTest_LogAllocations
void SDLTest_LogAllocations()
Print a log of any outstanding allocations.
Definition: SDL_test_memory.c:222
SDL_DISPLAYEVENT
@ SDL_DISPLAYEVENT
Definition: SDL_events.h:89
SDLK_2
@ SDLK_2
Definition: SDL_keycode.h:76
SDL_DISPLAYEVENT_ORIENTATION
@ SDL_DISPLAYEVENT_ORIENTATION
Definition: SDL_video.h:178
SDL_WINDOWPOS_CENTERED
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:139
SDL_PRINTF_FORMAT_STRING
#define SDL_PRINTF_FORMAT_STRING
Definition: SDL_stdinc.h:300
SDL_WINDOW_MINIMIZED
@ SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:106
SDL_PIXELFORMAT_BGRA8888
@ SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:257
SDL_PIXELFORMAT_UYVY
@ SDL_PIXELFORMAT_UYVY
Definition: SDL_pixels.h:283
SDL_GetNumVideoDrivers
#define SDL_GetNumVideoDrivers
Definition: SDL_dynapi_overrides.h:496
SDL_test.h
SDL_SetWindowSize
#define SDL_SetWindowSize
Definition: SDL_dynapi_overrides.h:526
SDL_RenderGetClipRect
#define SDL_RenderGetClipRect
Definition: SDL_dynapi_overrides.h:327
SDL_HAT_CENTERED
#define SDL_HAT_CENTERED
Definition: SDL_joystick.h:329
NULL
#define NULL
Definition: begin_code.h:164
surface
EGLSurface surface
Definition: eglext.h:248
SDL_HAT_DOWN
#define SDL_HAT_DOWN
Definition: SDL_joystick.h:332
SDL_PIXELFORMAT_INDEX1LSB
@ SDL_PIXELFORMAT_INDEX1LSB
Definition: SDL_pixels.h:174
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2483
SDL_GL_DEPTH_SIZE
@ SDL_GL_DEPTH_SIZE
Definition: SDL_video.h:206
SDL_WINDOWEVENT_FOCUS_LOST
@ SDL_WINDOWEVENT_FOCUS_LOST
Definition: SDL_video.h:166
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_PIXELFORMAT_BGR24
@ SDL_PIXELFORMAT_BGR24
Definition: SDL_pixels.h:233
SDL_GetNumRenderDrivers
#define SDL_GetNumRenderDrivers
Definition: SDL_dynapi_overrides.h:298
SDL_KEYUP
@ SDL_KEYUP
Definition: SDL_events.h:97
SDL_GetDisplayMode
#define SDL_GetDisplayMode
Definition: SDL_dynapi_overrides.h:506
SDLTest_CommonState
Definition: SDL_test_common.h:52
SDL_WINDOWEVENT_CLOSE
@ SDL_WINDOWEVENT_CLOSE
Definition: SDL_video.h:167
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
SDL_SetWindowDisplayMode
#define SDL_SetWindowDisplayMode
Definition: SDL_dynapi_overrides.h:511
SDL_GetDisplayName
#define SDL_GetDisplayName
Definition: SDL_dynapi_overrides.h:502
SDL_CONTROLLERBUTTONDOWN
@ SDL_CONTROLLERBUTTONDOWN
Definition: SDL_events.h:121
SDL_snprintfcat
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
Definition: SDL_test_common.c:35
SDL_BUTTON_RMASK
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:289
SDL_WINDOWEVENT_ENTER
@ SDL_WINDOWEVENT_ENTER
Definition: SDL_video.h:163
SDL_DOLLARRECORD
@ SDL_DOLLARRECORD
Definition: SDL_events.h:134
SDL_PIXELFORMAT_RGB444
@ SDL_PIXELFORMAT_RGB444
Definition: SDL_pixels.h:191
SDL_SetWindowFullscreen
#define SDL_SetWindowFullscreen
Definition: SDL_dynapi_overrides.h:539
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:518
SDLTest_ScreenShot
static void SDLTest_ScreenShot(SDL_Renderer *renderer)
Definition: SDL_test_common.c:1404
SDLCALL
#define SDLCALL
Definition: SDL_internal.h:45
SDL_WINDOW_FULLSCREEN
@ SDL_WINDOW_FULLSCREEN
Definition: SDL_video.h:100
SDL_GL_BUFFER_SIZE
@ SDL_GL_BUFFER_SIZE
Definition: SDL_video.h:204
SDL_WINDOW_OPENGL
@ SDL_WINDOW_OPENGL
Definition: SDL_video.h:101
SDL_MOUSEBUTTONUP
@ SDL_MOUSEBUTTONUP
Definition: SDL_events.h:107
SDL_WINDOWEVENT_RESIZED
@ SDL_WINDOWEVENT_RESIZED
Definition: SDL_video.h:155
SDLK_DOWN
@ SDLK_DOWN
Definition: SDL_keycode.h:153
viewport
SDL_Rect viewport
Definition: testviewport.c:28
SDL_BUTTON_X2MASK
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:291
SDL_TEXTEDITING
@ SDL_TEXTEDITING
Definition: SDL_events.h:98
SDL_WINDOW_FULLSCREEN_DESKTOP
@ SDL_WINDOW_FULLSCREEN_DESKTOP
Definition: SDL_video.h:111
SDL_WINDOWPOS_UNDEFINED
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:130
SDL_GL_RETAINED_BACKING
@ SDL_GL_RETAINED_BACKING
Definition: SDL_video.h:216
SDL_GetDesktopDisplayMode
#define SDL_GetDesktopDisplayMode
Definition: SDL_dynapi_overrides.h:507
SDL_LOG_CATEGORY_INPUT
@ SDL_LOG_CATEGORY_INPUT
Definition: SDL_log.h:73
CASE
#define CASE(X)
SDL_LOG_CATEGORY_AUDIO
@ SDL_LOG_CATEGORY_AUDIO
Definition: SDL_log.h:70
SDL_GL_CONTEXT_PROFILE_MASK
@ SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:221
SDLK_UP
@ SDLK_UP
Definition: SDL_keycode.h:154
SDL_RectEmpty
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
Definition: SDL_rect.h:82
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_LOG_CATEGORY_SYSTEM
@ SDL_LOG_CATEGORY_SYSTEM
Definition: SDL_log.h:69
SDL_HITTEST_RESIZE_TOPLEFT
@ SDL_HITTEST_RESIZE_TOPLEFT
Definition: SDL_video.h:1024
SDL_GL_ALPHA_SIZE
@ SDL_GL_ALPHA_SIZE
Definition: SDL_video.h:203
SDL_WINDOWPOS_ISCENTERED
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:140
SDL_PIXELFORMAT_INDEX8
@ SDL_PIXELFORMAT_INDEX8
Definition: SDL_pixels.h:186
SDL_WINDOW_MAXIMIZED
@ SDL_WINDOW_MAXIMIZED
Definition: SDL_video.h:107
SDL_JOYDEVICEREMOVED
@ SDL_JOYDEVICEREMOVED
Definition: SDL_events.h:117
SDL_PIXELFORMAT_YUY2
@ SDL_PIXELFORMAT_YUY2
Definition: SDL_pixels.h:281
SDL_PIXELFORMAT_INDEX4LSB
@ SDL_PIXELFORMAT_INDEX4LSB
Definition: SDL_pixels.h:180
VERBOSE_MODES
#define VERBOSE_MODES
Definition: SDL_test_common.h:46
SDL_WINDOWEVENT_MOVED
@ SDL_WINDOWEVENT_MOVED
Definition: SDL_video.h:153
index
GLuint index
Definition: SDL_opengl_glext.h:660
SDLTest_CommonArg
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
Definition: SDL_test_common.c:106
SDL_GetDisplayUsableBounds
#define SDL_GetDisplayUsableBounds
Definition: SDL_dynapi_overrides.h:596
SDL_AudioQuit
#define SDL_AudioQuit
Definition: SDL_dynapi_overrides.h:76
SDL_KEYDOWN
@ SDL_KEYDOWN
Definition: SDL_events.h:96
SDL_CreateWindow
#define SDL_CreateWindow
Definition: SDL_dynapi_overrides.h:514
SDL_APP_LOWMEMORY
@ SDL_APP_LOWMEMORY
Definition: SDL_events.h:67
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
length
GLuint GLsizei GLsizei * length
Definition: SDL_opengl_glext.h:669
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDLK_LEFT
@ SDLK_LEFT
Definition: SDL_keycode.h:152
SDL_CONTROLLERDEVICEADDED
@ SDL_CONTROLLERDEVICEADDED
Definition: SDL_events.h:123
SDL_SetWindowIcon
#define SDL_SetWindowIcon
Definition: SDL_dynapi_overrides.h:521
SDL_GetNumVideoDisplays
#define SDL_GetNumVideoDisplays
Definition: SDL_dynapi_overrides.h:501
SDLTest_PrintRendererFlag
static void SDLTest_PrintRendererFlag(char *text, size_t maxlen, Uint32 flag)
Definition: SDL_test_common.c:493
SDL_RendererInfo
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:79
SDLK_m
@ SDLK_m
Definition: SDL_keycode.h:112
SDL_WINDOW_RESIZABLE
@ SDL_WINDOW_RESIZABLE
Definition: SDL_video.h:105
SDL_APP_WILLENTERFOREGROUND
@ SDL_APP_WILLENTERFOREGROUND
Definition: SDL_events.h:79
SDL_CONTROLLERAXISMOTION
@ SDL_CONTROLLERAXISMOTION
Definition: SDL_events.h:120
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_HAT_LEFTDOWN
#define SDL_HAT_LEFTDOWN
Definition: SDL_joystick.h:337
SDL_RENDER_TARGETS_RESET
@ SDL_RENDER_TARGETS_RESET
Definition: SDL_events.h:154
SDL_PIXELFORMAT_YVYU
@ SDL_PIXELFORMAT_YVYU
Definition: SDL_pixels.h:285
SDL_SetRelativeMouseMode
#define SDL_SetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:249
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:74
SDL_GetRenderDriverInfo
#define SDL_GetRenderDriverInfo
Definition: SDL_dynapi_overrides.h:299
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:54
SDL_GetKeyboardFocus
#define SDL_GetKeyboardFocus
Definition: SDL_dynapi_overrides.h:216
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
SDL_PIXELFORMAT_RGB24
@ SDL_PIXELFORMAT_RGB24
Definition: SDL_pixels.h:230
SDL_strcasecmp
#define SDL_strcasecmp
Definition: SDL_dynapi_overrides.h:419
ControllerButtonName
static const char * ControllerButtonName(const SDL_GameControllerButton button)
Definition: SDL_test_common.c:1086
SDL_WINDOWEVENT_SHOWN
@ SDL_WINDOWEVENT_SHOWN
Definition: SDL_video.h:149
SDLTest_LoadIcon
static SDL_Surface * SDLTest_LoadIcon(const char *file)
Definition: SDL_test_common.c:660
SDLK_v
@ SDLK_v
Definition: SDL_keycode.h:121
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_PIXELFORMAT_BGR888
@ SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:242
SDLK_ESCAPE
@ SDLK_ESCAPE
Definition: SDL_keycode.h:55
SDL_MinimizeWindow
#define SDL_MinimizeWindow
Definition: SDL_dynapi_overrides.h:537
SDLTest_PrintPixelFormat
static void SDLTest_PrintPixelFormat(char *text, size_t maxlen, Uint32 format)
Definition: SDL_test_common.c:515
SDL_FINGERUP
@ SDL_FINGERUP
Definition: SDL_events.h:129
SDLK_g
@ SDLK_g
Definition: SDL_keycode.h:106
SDL_RENDERER_SOFTWARE
@ SDL_RENDERER_SOFTWARE
Definition: SDL_render.h:66
SDL_PIXELFORMAT_YV12
@ SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:277
BUTTON_CASE
#define BUTTON_CASE(btn)
SDL_GL_DOUBLEBUFFER
@ SDL_GL_DOUBLEBUFFER
Definition: SDL_video.h:205
SDL_GL_CONTEXT_DEBUG_FLAG
@ SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:238
SDL_LIL_ENDIAN
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
SDL_HITTEST_RESIZE_BOTTOMRIGHT
@ SDL_HITTEST_RESIZE_BOTTOMRIGHT
Definition: SDL_video.h:1028
SDL_ShowSimpleMessageBox
#define SDL_ShowSimpleMessageBox
Definition: SDL_dynapi_overrides.h:244
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDLTest_TrackAllocations
int SDLTest_TrackAllocations()
Start tracking SDL memory allocations.
Definition: SDL_test_memory.c:197
SDL_Renderer
Definition: SDL_sysrender.h:86
done
int done
Definition: checkkeys.c:28
SDL_MOUSEMOTION
@ SDL_MOUSEMOTION
Definition: SDL_events.h:105
SDL_PIXELFORMAT_NV21
@ SDL_PIXELFORMAT_NV21
Definition: SDL_pixels.h:289
SDL_GL_GREEN_SIZE
@ SDL_GL_GREEN_SIZE
Definition: SDL_video.h:201
SDL_HITTEST_RESIZE_TOPRIGHT
@ SDL_HITTEST_RESIZE_TOPRIGHT
Definition: SDL_video.h:1026
SDL_FINGERDOWN
@ SDL_FINGERDOWN
Definition: SDL_events.h:128
SDL_SetWindowGrab
#define SDL_SetWindowGrab
Definition: SDL_dynapi_overrides.h:543
SDL_HitTestResult
SDL_HitTestResult
Possible return values from the SDL_HitTest callback.
Definition: SDL_video.h:1021
SDL_PIXELFORMAT_BGR555
@ SDL_PIXELFORMAT_BGR555
Definition: SDL_pixels.h:197
SDL_atof
#define SDL_atof
Definition: SDL_dynapi_overrides.h:411
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
SDL_CONTROLLERBUTTONUP
@ SDL_CONTROLLERBUTTONUP
Definition: SDL_events.h:122
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:31
SDL_TEXTINPUT
@ SDL_TEXTINPUT
Definition: SDL_events.h:99
SDL_RendererInfo::flags
Uint32 flags
Definition: SDL_render.h:81
SDL_DROPCOMPLETE
@ SDL_DROPCOMPLETE
Definition: SDL_events.h:144
SDL_GL_SetAttribute
#define SDL_GL_SetAttribute
Definition: SDL_dynapi_overrides.h:557
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_GetRelativeMouseMode
#define SDL_GetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:250
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_LOG_CATEGORY_ERROR
@ SDL_LOG_CATEGORY_ERROR
Definition: SDL_log.h:67
SDL_MouseMotionEvent::xrel
Sint32 xrel
Definition: SDL_events.h:262
SDL_DROPTEXT
@ SDL_DROPTEXT
Definition: SDL_events.h:142
SDL_HITTEST_RESIZE_BOTTOM
@ SDL_HITTEST_RESIZE_BOTTOM
Definition: SDL_video.h:1029
SDL_RenderGetViewport
#define SDL_RenderGetViewport
Definition: SDL_dynapi_overrides.h:325
SDLTest_PrintRenderer
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
Definition: SDL_test_common.c:621
SDL_GetClipboardText
#define SDL_GetClipboardText
Definition: SDL_dynapi_overrides.h:99
DEFAULT_WINDOW_HEIGHT
#define DEFAULT_WINDOW_HEIGHT
Definition: SDL_test_common.h:42
SDL_QUIT
@ SDL_QUIT
Definition: SDL_events.h:60
SDL_DisplayMode::refresh_rate
int refresh_rate
Definition: SDL_video.h:58
AXIS_CASE
#define AXIS_CASE(ax)
SDL_RENDERER_PRESENTVSYNC
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_WINDOWPOS_UNDEFINED_DISPLAY
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X)
Definition: SDL_video.h:129
SDL_vsnprintf
#define SDL_vsnprintf
Definition: SDL_dynapi_overrides.h:421
SDL_Direct3D9GetAdapterIndex
int SDL_Direct3D9GetAdapterIndex(int displayIndex)
Returns the D3D9 adapter index that matches the specified display index.
DEFAULT_WINDOW_WIDTH
#define DEFAULT_WINDOW_WIDTH
Definition: SDL_test_common.h:41
SDLK_SPACE
@ SDLK_SPACE
Definition: SDL_keycode.h:58
SDL_HITTEST_RESIZE_LEFT
@ SDL_HITTEST_RESIZE_LEFT
Definition: SDL_video.h:1031
rect
SDL_Rect rect
Definition: testrelative.c:27
SDL_GL_ACCELERATED_VISUAL
@ SDL_GL_ACCELERATED_VISUAL
Definition: SDL_video.h:215
SDL_WINDOWEVENT_EXPOSED
@ SDL_WINDOWEVENT_EXPOSED
Definition: SDL_video.h:151
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:446
SDL_MOUSEWHEEL
@ SDL_MOUSEWHEEL
Definition: SDL_events.h:108
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:318
SDL_isdigit
#define SDL_isdigit
Definition: SDL_dynapi_overrides.h:382
SDLK_z
@ SDLK_z
Definition: SDL_keycode.h:125
SDL_LOG_CATEGORY_VIDEO
@ SDL_LOG_CATEGORY_VIDEO
Definition: SDL_log.h:71
SDL_PixelFormatEnumToMasks
#define SDL_PixelFormatEnumToMasks
Definition: SDL_dynapi_overrides.h:278
SDL_SetColorKey
#define SDL_SetColorKey
Definition: SDL_dynapi_overrides.h:453
SDL_VideoInit
#define SDL_VideoInit
Definition: SDL_dynapi_overrides.h:498
SDL_GetWindowFromID
#define SDL_GetWindowFromID
Definition: SDL_dynapi_overrides.h:517
SDL_HAT_LEFT
#define SDL_HAT_LEFT
Definition: SDL_joystick.h:333
SDL_BUTTON_LMASK
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:287
SDL_GameControllerAxis
SDL_GameControllerAxis
Definition: SDL_gamecontroller.h:273
SDLK_a
@ SDLK_a
Definition: SDL_keycode.h:100
SDL_Quit
#define SDL_Quit
Definition: SDL_dynapi_overrides.h:58
SDL_FINGERMOTION
@ SDL_FINGERMOTION
Definition: SDL_events.h:130
SDL_GetWindowPosition
#define SDL_GetWindowPosition
Definition: SDL_dynapi_overrides.h:525
SDL_WINDOWEVENT_HIT_TEST
@ SDL_WINDOWEVENT_HIT_TEST
Definition: SDL_video.h:169
text
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
SDL_WINDOW_INPUT_GRABBED
@ SDL_WINDOW_INPUT_GRABBED
Definition: SDL_video.h:108
SDL_APP_WILLENTERBACKGROUND
@ SDL_APP_WILLENTERBACKGROUND
Definition: SDL_events.h:71
SDL_PIXELFORMAT_RGB555
@ SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:194
SDLK_0
@ SDLK_0
Definition: SDL_keycode.h:74
SDL_WINDOWEVENT_SIZE_CHANGED
@ SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:156
SDL_GL_ACCUM_ALPHA_SIZE
@ SDL_GL_ACCUM_ALPHA_SIZE
Definition: SDL_video.h:211
SDL_PIXELFORMAT_UNKNOWN
@ SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:173
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_RenderSetLogicalSize
#define SDL_RenderSetLogicalSize
Definition: SDL_dynapi_overrides.h:322
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
SDL_GetDisplayBounds
#define SDL_GetDisplayBounds
Definition: SDL_dynapi_overrides.h:503
SDL_PIXELFORMAT_IYUV
@ SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:279
SDL_LoadBMP
#define SDL_LoadBMP(file)
Definition: SDL_surface.h:200
SDL_PIXELFORMAT_RGBA8888
@ SDL_PIXELFORMAT_RGBA8888
Definition: SDL_pixels.h:251
SDL_RestoreWindow
#define SDL_RestoreWindow
Definition: SDL_dynapi_overrides.h:538
SDL_HAT_LEFTUP
#define SDL_HAT_LEFTUP
Definition: SDL_joystick.h:336
KMOD_SHIFT
#define KMOD_SHIFT
Definition: SDL_keycode.h:343
SDLTest_ExampleHitTestCallback
static SDL_HitTestResult SDLTest_ExampleHitTestCallback(SDL_Window *win, const SDL_Point *area, void *data)
Definition: SDL_test_common.c:680
SDL_BUTTON_X1MASK
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:290
SDL_SetWindowOpacity
#define SDL_SetWindowOpacity
Definition: SDL_dynapi_overrides.h:598
SDL_GL_ACCUM_BLUE_SIZE
@ SDL_GL_ACCUM_BLUE_SIZE
Definition: SDL_video.h:210
SDL_WINDOWEVENT_MINIMIZED
@ SDL_WINDOWEVENT_MINIMIZED
Definition: SDL_video.h:159
SDL_WINDOWPOS_CENTERED_DISPLAY
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:138
SDL_WINDOWEVENT_TAKE_FOCUS
@ SDL_WINDOWEVENT_TAKE_FOCUS
Definition: SDL_video.h:168
axis
SDL_Texture * axis
Definition: testgamecontroller.c:67
SDL_GetAudioDriver
#define SDL_GetAudioDriver
Definition: SDL_dynapi_overrides.h:74
SDLTest_CommonUsage
const char * SDLTest_CommonUsage(SDLTest_CommonState *state)
Returns common usage information.
Definition: SDL_test_common.c:478
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_GetCurrentAudioDriver
#define SDL_GetCurrentAudioDriver
Definition: SDL_dynapi_overrides.h:77
SDL_MESSAGEBOX_INFORMATION
@ SDL_MESSAGEBOX_INFORMATION
Definition: SDL_messagebox.h:41
VERBOSE_RENDER
#define VERBOSE_RENDER
Definition: SDL_test_common.h:47
SDL_GetWindowOpacity
#define SDL_GetWindowOpacity
Definition: SDL_dynapi_overrides.h:599
SDLTest_CommonEvent
void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done)
Common event handler for test windows.
Definition: SDL_test_common.c:1463
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_HITTEST_NORMAL
@ SDL_HITTEST_NORMAL
Definition: SDL_video.h:1022
SDL_LOG_CATEGORY_RENDER
@ SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
SDL_GetVideoDriver
#define SDL_GetVideoDriver
Definition: SDL_dynapi_overrides.h:497
SDL_RenderSetScale
#define SDL_RenderSetScale
Definition: SDL_dynapi_overrides.h:328
SDL_GL_BLUE_SIZE
@ SDL_GL_BLUE_SIZE
Definition: SDL_video.h:202
SDL_DROPBEGIN
@ SDL_DROPBEGIN
Definition: SDL_events.h:143
SDL_KEYMAPCHANGED
@ SDL_KEYMAPCHANGED
Definition: SDL_events.h:100
SDL_CreateRGBSurface
#define SDL_CreateRGBSurface
Definition: SDL_dynapi_overrides.h:444
SDL_HITTEST_RESIZE_RIGHT
@ SDL_HITTEST_RESIZE_RIGHT
Definition: SDL_video.h:1027
VIDEO_USAGE
#define VIDEO_USAGE
Definition: SDL_test_common.c:29
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
SDL_PIXELFORMAT_ABGR4444
@ SDL_PIXELFORMAT_ABGR4444
Definition: SDL_pixels.h:206
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_DestroyTexture
#define SDL_DestroyTexture
Definition: SDL_dynapi_overrides.h:347
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:410
SDL_PIXELFORMAT_INDEX1MSB
@ SDL_PIXELFORMAT_INDEX1MSB
Definition: SDL_pixels.h:177
AUDIO_USAGE
#define AUDIO_USAGE
Definition: SDL_test_common.c:32
m
const GLfloat * m
Definition: SDL_opengl_glext.h:6092
SDL_GetScancodeName
#define SDL_GetScancodeName
Definition: SDL_dynapi_overrides.h:222
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:79
SDLK_RETURN
@ SDLK_RETURN
Definition: SDL_keycode.h:54
SDLK_MINUS
@ SDLK_MINUS
Definition: SDL_keycode.h:71
renderer
static SDL_Renderer * renderer
Definition: testaudiocapture.c:21
SDL_GetWindowGrab
#define SDL_GetWindowGrab
Definition: SDL_dynapi_overrides.h:544
SDL_OUT_Z_CAP
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 SDL_AssertionHandler void SDL_SpinLock SDL_atomic_t int int return SDL_atomic_t return void void void return void return int return SDL_AudioSpec SDL_AudioSpec return int int return return int SDL_RWops int SDL_AudioSpec Uint8 Uint32 return SDL_AudioCVT SDL_AudioFormat Uint8 int SDL_AudioFormat Uint8 int return Uint8 const Uint8 Uint32 int const char return return return return return return return return Uint32 return Uint32 SDL_Event return SDL_Event int return SDL_EventFilter void SDL_EventFilter void SDL_EventFilter void int return const char const char return SDL_JoystickGUID return int return int return SDL_GameController return int return const char return SDL_GameController SDL_GameControllerAxis return const char return SDL_GameController SDL_GameControllerButton return SDL_GameController SDL_RWops return SDL_TouchID SDL_RWops return int return int return return SDL_Joystick return SDL_Haptic SDL_Haptic return SDL_Haptic return SDL_Haptic SDL_HapticEffect return SDL_Haptic int Uint32 return SDL_Haptic int SDL_Haptic int return SDL_Haptic return SDL_Haptic return SDL_Haptic return SDL_Haptic return const char const char return const char SDL_HintCallback void int return SDL_Joystick return SDL_Joystick return const char return SDL_Joystick return SDL_Joystick return SDL_Joystick return int return SDL_Joystick int return SDL_Joystick int return return return SDL_Scancode return SDL_Scancode return SDL_Keycode return return const char return void int SDL_LogPriority SDL_LogOutputFunction void Uint32 const char const char SDL_Window return int int return SDL_Window int int return SDL_Surface int int return SDL_Cursor return int return SDL_mutex return SDL_mutex return Uint32 return SDL_sem return SDL_sem Uint32 return SDL_sem return SDL_cond SDL_cond return SDL_cond SDL_mutex Uint32 return Uint32 int Uint32 Uint32 Uint32 Uint32 return Uint32 return int return SDL_Palette const SDL_Color int int return const SDL_PixelFormat Uint8 Uint8 Uint8 return Uint32 const SDL_PixelFormat Uint8 Uint8 Uint8 float Uint16 int int return const SDL_Rect const SDL_Rect SDL_Rect return const SDL_Point int const SDL_Rect SDL_Rect return return int int Uint32 SDL_Window SDL_Renderer return SDL_Surface return SDL_Renderer SDL_RendererInfo return SDL_Renderer Uint32 int int int return SDL_Texture Uint32 int int int return SDL_Texture Uint8 Uint8 Uint8 return SDL_Texture Uint8 return SDL_Texture SDL_BlendMode return SDL_Texture const SDL_Rect const Uint8 int const Uint8 int const Uint8 int return SDL_Texture SDL_Renderer SDL_Texture return SDL_Renderer int int return SDL_Renderer const SDL_Rect return SDL_Renderer const SDL_Rect return SDL_Renderer float float return SDL_Renderer Uint8 Uint8 Uint8 Uint8 return SDL_Renderer SDL_BlendMode return SDL_Renderer return SDL_Renderer const SDL_Point int return SDL_Renderer const SDL_Point int return SDL_Renderer const SDL_Rect int return SDL_Renderer const SDL_Rect int return SDL_Renderer SDL_Texture const SDL_Rect const SDL_Rect const double const SDL_Point const SDL_RendererFlip return SDL_Renderer SDL_Renderer SDL_Texture return void int return return SDL_RWops return SDL_RWops return SDL_RWops return SDL_RWops return SDL_RWops Uint16 return SDL_RWops Uint32 return SDL_RWops Uint64 return const char unsigned int unsigned int unsigned int unsigned int Uint32 return SDL_Window SDL_Surface SDL_WindowShapeMode return size_t return void size_t return const char return void size_t size_t int(*) int return int return int size_t return size_t return const wchar_t return const wchar_t size_t retur SDL_OUT_Z_CAP)(c) char *a
Definition: SDL_dynapi_procs.h:425
SDL_GetCurrentVideoDriver
#define SDL_GetCurrentVideoDriver
Definition: SDL_dynapi_overrides.h:500
SDL_MouseMotionEvent::x
Sint32 x
Definition: SDL_events.h:260
SDL_SetWindowHitTest
#define SDL_SetWindowHitTest
Definition: SDL_dynapi_overrides.h:585
SDL_Point
The structure that defines a point.
Definition: SDL_rect.h:49
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:236
SDL_SetWindowBordered
#define SDL_SetWindowBordered
Definition: SDL_dynapi_overrides.h:532
SDL_HAT_RIGHT
#define SDL_HAT_RIGHT
Definition: SDL_joystick.h:331
SDL_RENDERER_TARGETTEXTURE
@ SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
SDL_GL_STENCIL_SIZE
@ SDL_GL_STENCIL_SIZE
Definition: SDL_video.h:207
SDL_GetKeyName
#define SDL_GetKeyName
Definition: SDL_dynapi_overrides.h:224
SDL_GL_CONTEXT_MINOR_VERSION
@ SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:218
SDLTest_CommonCreateState
SDLTest_CommonState * SDLTest_CommonCreateState(char **argv, Uint32 flags)
Parse command line parameters and create common state.
Definition: SDL_test_common.c:48
SDL_snprintf
#define SDL_snprintf
Definition: SDL_dynapi_overrides.h:40
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:65
j
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
Definition: SDL_x11sym.h:50
SDL_RendererInfo::max_texture_width
int max_texture_width
Definition: SDL_render.h:84
VERBOSE_AUDIO
#define VERBOSE_AUDIO
Definition: SDL_test_common.h:49
KMOD_ALT
#define KMOD_ALT
Definition: SDL_keycode.h:344
SDL_GL_MULTISAMPLEBUFFERS
@ SDL_GL_MULTISAMPLEBUFFERS
Definition: SDL_video.h:213
SDL_JOYBUTTONUP
@ SDL_JOYBUTTONUP
Definition: SDL_events.h:115
SDL_Texture
Definition: SDL_sysrender.h:58
SDL_MULTIGESTURE
@ SDL_MULTIGESTURE
Definition: SDL_events.h:135
SDL_PIXELFORMAT_RGB332
@ SDL_PIXELFORMAT_RGB332
Definition: SDL_pixels.h:188
SDL_RENDER_DEVICE_RESET
@ SDL_RENDER_DEVICE_RESET
Definition: SDL_events.h:155
SDL_PIXELFORMAT_RGB565
@ SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:224
SDL_LOG_PRIORITY_VERBOSE
@ SDL_LOG_PRIORITY_VERBOSE
Definition: SDL_log.h:104
SDLK_EQUALS
@ SDLK_EQUALS
Definition: SDL_keycode.h:87
SDL_MaximizeWindow
#define SDL_MaximizeWindow
Definition: SDL_dynapi_overrides.h:536
KMOD_CTRL
#define KMOD_CTRL
Definition: SDL_keycode.h:342
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDLK_c
@ SDLK_c
Definition: SDL_keycode.h:102
SDL_MOUSEBUTTONDOWN
@ SDL_MOUSEBUTTONDOWN
Definition: SDL_events.h:106
SDL_PIXELFORMAT_NV12
@ SDL_PIXELFORMAT_NV12
Definition: SDL_pixels.h:287
SDL_strlen
#define SDL_strlen
Definition: SDL_dynapi_overrides.h:393
SDL_JOYDEVICEADDED
@ SDL_JOYDEVICEADDED
Definition: SDL_events.h:116
SDL_PIXELFORMAT_BGR565
@ SDL_PIXELFORMAT_BGR565
Definition: SDL_pixels.h:227
SDL_GL_ACCUM_RED_SIZE
@ SDL_GL_ACCUM_RED_SIZE
Definition: SDL_video.h:208
SDL_GetGlobalMouseState
#define SDL_GetGlobalMouseState
Definition: SDL_dynapi_overrides.h:586
SDL_CaptureMouse
#define SDL_CaptureMouse
Definition: SDL_dynapi_overrides.h:584
SDLTest_PrintEvent
static void SDLTest_PrintEvent(SDL_Event *event)
Definition: SDL_test_common.c:1113
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
SDL_HAT_UP
#define SDL_HAT_UP
Definition: SDL_joystick.h:330
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
SDL_GetDisplayDPI
#define SDL_GetDisplayDPI
Definition: SDL_dynapi_overrides.h:504
SDL_RendererInfo::name
const char * name
Definition: SDL_render.h:80
SDL_VideoQuit
#define SDL_VideoQuit
Definition: SDL_dynapi_overrides.h:499
SDL_WINDOWEVENT_HIDDEN
@ SDL_WINDOWEVENT_HIDDEN
Definition: SDL_video.h:150
SDL_PIXELFORMAT_ARGB2101010
@ SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:260
SDL_Event
General event structure.
Definition: SDL_events.h:558
SDL_WINDOWEVENT
@ SDL_WINDOWEVENT
Definition: SDL_events.h:92
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_WINDOWEVENT_RESTORED
@ SDL_WINDOWEVENT_RESTORED
Definition: SDL_video.h:161
SDL_GL_STEREO
@ SDL_GL_STEREO
Definition: SDL_video.h:212
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_LogSetAllPriority
#define SDL_LogSetAllPriority
Definition: SDL_dynapi_overrides.h:235
RESIZE_BORDER
#define RESIZE_BORDER
Definition: testhittesting.c:6
SDL_MouseMotionEvent::yrel
Sint32 yrel
Definition: SDL_events.h:263
SDLK_RIGHT
@ SDLK_RIGHT
Definition: SDL_keycode.h:151
SDL_GL_RED_SIZE
@ SDL_GL_RED_SIZE
Definition: SDL_video.h:200
SDL_PIXELFORMAT_ABGR8888
@ SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:254
SDL_JOYBUTTONDOWN
@ SDL_JOYBUTTONDOWN
Definition: SDL_events.h:114
SDL_RENDERER_ACCELERATED
@ SDL_RENDERER_ACCELERATED
Definition: SDL_render.h:67
SDL_RendererInfo::texture_formats
Uint32 texture_formats[16]
Definition: SDL_render.h:83
SDL_CreateRenderer
#define SDL_CreateRenderer
Definition: SDL_dynapi_overrides.h:301
SDL_RenderSetClipRect
#define SDL_RenderSetClipRect
Definition: SDL_dynapi_overrides.h:326
SDL_RendererInfo::max_texture_height
int max_texture_height
Definition: SDL_render.h:85
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
SDL_BYTEORDER
#define SDL_BYTEORDER
Definition: SDL_config_pandora.h:37
SDL_GL_CONTEXT_FLAGS
@ SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:220
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDLK_o
@ SDLK_o
Definition: SDL_keycode.h:114
VERBOSE_EVENT
#define VERBOSE_EVENT
Definition: SDL_test_common.h:48
SDL_config.h
SDL_WINDOWEVENT_FOCUS_GAINED
@ SDL_WINDOWEVENT_FOCUS_GAINED
Definition: SDL_video.h:165
SDL_DestroyRenderer
#define SDL_DestroyRenderer
Definition: SDL_dynapi_overrides.h:348
SDL_SaveBMP
#define SDL_SaveBMP(surface, file)
Definition: SDL_surface.h:223
SDLTest_CommonInit
SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
Open test window.
Definition: SDL_test_common.c:726
SDL_GetNumDisplayModes
#define SDL_GetNumDisplayModes
Definition: SDL_dynapi_overrides.h:505
SDL_SetWindowPosition
#define SDL_SetWindowPosition
Definition: SDL_dynapi_overrides.h:524
DisplayOrientationName
static const char * DisplayOrientationName(int orientation)
Definition: SDL_test_common.c:1052
SDL_PIXELFORMAT_ABGR1555
@ SDL_PIXELFORMAT_ABGR1555
Definition: SDL_pixels.h:218
FullscreenTo
static void FullscreenTo(int index, int windowId)
Definition: SDL_test_common.c:1441
SDLK_r
@ SDLK_r
Definition: SDL_keycode.h:117
SDL_HITTEST_RESIZE_TOP
@ SDL_HITTEST_RESIZE_TOP
Definition: SDL_video.h:1025
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_RenderReadPixels
#define SDL_RenderReadPixels
Definition: SDL_dynapi_overrides.h:345
SDL_HAT_RIGHTDOWN
#define SDL_HAT_RIGHTDOWN
Definition: SDL_joystick.h:335
state
struct xkb_state * state
Definition: SDL_waylandsym.h:113
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
i
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
SDLK_1
@ SDLK_1
Definition: SDL_keycode.h:75
SDL_JOYHATMOTION
@ SDL_JOYHATMOTION
Definition: SDL_events.h:113
SDL_DOLLARGESTURE
@ SDL_DOLLARGESTURE
Definition: SDL_events.h:133
AUDIO_U16
#define AUDIO_U16
Definition: SDL_audio.h:95
SDL_PIXELFORMAT_RGB888
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
ControllerAxisName
static const char * ControllerAxisName(const SDL_GameControllerAxis axis)
Definition: SDL_test_common.c:1068
SDL_BUTTON_MMASK
#define SDL_BUTTON_MMASK
Definition: SDL_mouse.h:288
SDLK_b
@ SDLK_b
Definition: SDL_keycode.h:101
SDL_DROPFILE
@ SDL_DROPFILE
Definition: SDL_events.h:141
SDL_SetWindowMaximumSize
#define SDL_SetWindowMaximumSize
Definition: SDL_dynapi_overrides.h:530
SDL_DestroyWindow
#define SDL_DestroyWindow
Definition: SDL_dynapi_overrides.h:549
button
SDL_Texture * button
Definition: testgamecontroller.c:67
SDLTest_CommonQuit
void SDLTest_CommonQuit(SDLTest_CommonState *state)
Close test window.
Definition: SDL_test_common.c:1794
SDL_HAT_RIGHTUP
#define SDL_HAT_RIGHTUP
Definition: SDL_joystick.h:334
SDL_WINDOWPOS_ISUNDEFINED
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:131
SDLK_PRINTSCREEN
@ SDLK_PRINTSCREEN
Definition: SDL_keycode.h:142
SDL_HITTEST_RESIZE_BOTTOMLEFT
@ SDL_HITTEST_RESIZE_BOTTOMLEFT
Definition: SDL_video.h:1030
SDL_Point::y
int y
Definition: SDL_rect.h:51
SDL_GetNumAudioDrivers
#define SDL_GetNumAudioDrivers
Definition: SDL_dynapi_overrides.h:73
SDL_WINDOWEVENT_MAXIMIZED
@ SDL_WINDOWEVENT_MAXIMIZED
Definition: SDL_video.h:160
SDL_CLIPBOARDUPDATE
@ SDL_CLIPBOARDUPDATE
Definition: SDL_events.h:138
SDL_JOYBALLMOTION
@ SDL_JOYBALLMOTION
Definition: SDL_events.h:112
SDL_WINDOWEVENT_LEAVE
@ SDL_WINDOWEVENT_LEAVE
Definition: SDL_video.h:164
SDL_RendererInfo::num_texture_formats
Uint32 num_texture_formats
Definition: SDL_render.h:82
SDL_GL_CONTEXT_MAJOR_VERSION
@ SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:217
SDL_USEREVENT
@ SDL_USEREVENT
Definition: SDL_events.h:160
SDL_PIXELFORMAT_ARGB1555
@ SDL_PIXELFORMAT_ARGB1555
Definition: SDL_pixels.h:212
SDL_WINDOW_BORDERLESS
@ SDL_WINDOW_BORDERLESS
Definition: SDL_video.h:104
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
SDL_GL_ACCUM_GREEN_SIZE
@ SDL_GL_ACCUM_GREEN_SIZE
Definition: SDL_video.h:209
SDL_GetRendererInfo
#define SDL_GetRendererInfo
Definition: SDL_dynapi_overrides.h:304
SDL_WINDOW_VULKAN
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:78
SDL_GameControllerButton
SDL_GameControllerButton
Definition: SDL_gamecontroller.h:317