/
SDL_test_common.c
1783 lines (1694 loc) · 62 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2017 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/* Ported from original test\common.c file. */
#include "SDL_config.h"
#include "SDL_test.h"
#include <stdio.h>
#define VIDEO_USAGE \
"[--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]"
#define AUDIO_USAGE \
"[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
35
36
37
38
39
40
41
42
43
44
45
46
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... )
{
size_t length = SDL_strlen(text);
va_list ap;
va_start(ap, fmt);
text += length;
maxlen -= length;
SDL_vsnprintf(text, maxlen, fmt, ap);
va_end(ap);
}
47
48
49
SDLTest_CommonState *
SDLTest_CommonCreateState(char **argv, Uint32 flags)
{
50
51
52
53
54
55
56
57
58
59
60
61
int i;
SDLTest_CommonState *state;
/* Do this first so we catch all allocations */
for (i = 1; argv[i]; ++i) {
if (SDL_strcasecmp(argv[i], "--trackmem") == 0) {
SDLTest_TrackAllocations();
break;
}
}
state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
if (!state) {
SDL_OutOfMemory();
return NULL;
}
/* Initialize some defaults */
state->argv = argv;
state->flags = flags;
state->window_title = argv[0];
state->window_flags = 0;
state->window_x = SDL_WINDOWPOS_UNDEFINED;
state->window_y = SDL_WINDOWPOS_UNDEFINED;
state->window_w = DEFAULT_WINDOW_WIDTH;
state->window_h = DEFAULT_WINDOW_HEIGHT;
state->num_windows = 1;
state->audiospec.freq = 22050;
state->audiospec.format = AUDIO_S16;
state->audiospec.channels = 2;
state->audiospec.samples = 2048;
/* Set some very sane GL defaults */
state->gl_red_size = 3;
state->gl_green_size = 3;
state->gl_blue_size = 2;
state->gl_alpha_size = 0;
state->gl_buffer_size = 0;
state->gl_depth_size = 16;
state->gl_stencil_size = 0;
state->gl_double_buffer = 1;
state->gl_accum_red_size = 0;
state->gl_accum_green_size = 0;
state->gl_accum_blue_size = 0;
state->gl_accum_alpha_size = 0;
state->gl_stereo = 0;
state->gl_multisamplebuffers = 0;
state->gl_multisamplesamples = 0;
state->gl_retained_backing = 1;
state->gl_accelerated = -1;
state->gl_debug = 0;
return state;
}
int
SDLTest_CommonArg(SDLTest_CommonState * state, int index)
{
char **argv = state->argv;
if (SDL_strcasecmp(argv[index], "--video") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->videodriver = argv[index];
return 2;
}
if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->renderdriver = argv[index];
return 2;
}
if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
state->gl_debug = 1;
return 1;
}
if (SDL_strcasecmp(argv[index], "--info") == 0) {
++index;
if (!argv[index]) {
return -1;
}
if (SDL_strcasecmp(argv[index], "all") == 0) {
state->verbose |=
(VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER |
VERBOSE_EVENT);
return 2;
}
if (SDL_strcasecmp(argv[index], "video") == 0) {
state->verbose |= VERBOSE_VIDEO;
return 2;
}
if (SDL_strcasecmp(argv[index], "modes") == 0) {
state->verbose |= VERBOSE_MODES;
return 2;
}
if (SDL_strcasecmp(argv[index], "render") == 0) {
state->verbose |= VERBOSE_RENDER;
return 2;
}
if (SDL_strcasecmp(argv[index], "event") == 0) {
state->verbose |= VERBOSE_EVENT;
return 2;
}
return -1;
}
if (SDL_strcasecmp(argv[index], "--log") == 0) {
++index;
if (!argv[index]) {
return -1;
}
if (SDL_strcasecmp(argv[index], "all") == 0) {
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "error") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "system") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "audio") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "video") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "render") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_RENDER, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
if (SDL_strcasecmp(argv[index], "input") == 0) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_INPUT, SDL_LOG_PRIORITY_VERBOSE);
return 2;
}
return -1;
}
if (SDL_strcasecmp(argv[index], "--display") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->display = SDL_atoi(argv[index]);
if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
}
if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
}
return 2;
}
if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
state->window_flags |= SDL_WINDOW_FULLSCREEN;
state->num_windows = 1;
return 1;
}
if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
state->num_windows = 1;
return 1;
}
if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
return 1;
}
if (SDL_strcasecmp(argv[index], "--windows") == 0) {
++index;
if (!argv[index] || !SDL_isdigit(*argv[index])) {
return -1;
}
if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
state->num_windows = SDL_atoi(argv[index]);
}
return 2;
}
if (SDL_strcasecmp(argv[index], "--title") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->window_title = argv[index];
return 2;
}
if (SDL_strcasecmp(argv[index], "--icon") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->window_icon = argv[index];
return 2;
}
if (SDL_strcasecmp(argv[index], "--center") == 0) {
state->window_x = SDL_WINDOWPOS_CENTERED;
state->window_y = SDL_WINDOWPOS_CENTERED;
return 1;
}
if (SDL_strcasecmp(argv[index], "--position") == 0) {
char *x, *y;
++index;
if (!argv[index]) {
return -1;
}
x = argv[index];
y = argv[index];
while (*y && *y != ',') {
++y;
}
if (!*y) {
return -1;
}
*y++ = '\0';
state->window_x = SDL_atoi(x);
state->window_y = SDL_atoi(y);
return 2;
}
if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
char *w, *h;
++index;
if (!argv[index]) {
return -1;
}
w = argv[index];
h = argv[index];
while (*h && *h != 'x') {
++h;
}
if (!*h) {
return -1;
}
*h++ = '\0';
state->window_w = SDL_atoi(w);
state->window_h = SDL_atoi(h);
return 2;
}
if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
char *w, *h;
++index;
if (!argv[index]) {
return -1;
}
w = argv[index];
h = argv[index];
while (*h && *h != 'x') {
++h;
}
if (!*h) {
return -1;
}
*h++ = '\0';
state->window_minW = SDL_atoi(w);
state->window_minH = SDL_atoi(h);
return 2;
}
if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
char *w, *h;
++index;
if (!argv[index]) {
return -1;
}
w = argv[index];
h = argv[index];
while (*h && *h != 'x') {
++h;
}
if (!*h) {
return -1;
}
*h++ = '\0';
state->window_maxW = SDL_atoi(w);
state->window_maxH = SDL_atoi(h);
return 2;
}
if (SDL_strcasecmp(argv[index], "--logical") == 0) {
char *w, *h;
++index;
if (!argv[index]) {
return -1;
}
w = argv[index];
h = argv[index];
while (*h && *h != 'x') {
++h;
}
if (!*h) {
return -1;
}
*h++ = '\0';
state->logical_w = SDL_atoi(w);
state->logical_h = SDL_atoi(h);
return 2;
}
if (SDL_strcasecmp(argv[index], "--scale") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->scale = (float)SDL_atof(argv[index]);
return 2;
}
if (SDL_strcasecmp(argv[index], "--depth") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->depth = SDL_atoi(argv[index]);
return 2;
}
if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->refresh_rate = SDL_atoi(argv[index]);
return 2;
}
if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
return 1;
}
if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
state->window_flags |= SDL_WINDOW_BORDERLESS;
return 1;
}
if (SDL_strcasecmp(argv[index], "--resize") == 0) {
state->window_flags |= SDL_WINDOW_RESIZABLE;
return 1;
}
if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
state->window_flags |= SDL_WINDOW_MINIMIZED;
return 1;
}
if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
state->window_flags |= SDL_WINDOW_MAXIMIZED;
return 1;
}
if (SDL_strcasecmp(argv[index], "--grab") == 0) {
state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
return 1;
}
if (SDL_strcasecmp(argv[index], "--rate") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->audiospec.freq = SDL_atoi(argv[index]);
return 2;
}
if (SDL_strcasecmp(argv[index], "--format") == 0) {
++index;
if (!argv[index]) {
return -1;
}
if (SDL_strcasecmp(argv[index], "U8") == 0) {
state->audiospec.format = AUDIO_U8;
return 2;
}
if (SDL_strcasecmp(argv[index], "S8") == 0) {
state->audiospec.format = AUDIO_S8;
return 2;
}
if (SDL_strcasecmp(argv[index], "U16") == 0) {
state->audiospec.format = AUDIO_U16;
return 2;
}
if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
state->audiospec.format = AUDIO_U16LSB;
return 2;
}
if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
state->audiospec.format = AUDIO_U16MSB;
return 2;
}
if (SDL_strcasecmp(argv[index], "S16") == 0) {
state->audiospec.format = AUDIO_S16;
return 2;
}
if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
state->audiospec.format = AUDIO_S16LSB;
return 2;
}
if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
state->audiospec.format = AUDIO_S16MSB;
return 2;
}
return -1;
}
if (SDL_strcasecmp(argv[index], "--channels") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
return 2;
}
if (SDL_strcasecmp(argv[index], "--samples") == 0) {
++index;
if (!argv[index]) {
return -1;
}
state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
return 2;
}
461
462
463
464
if (SDL_strcasecmp(argv[index], "--trackmem") == 0) {
/* Already handled in SDLTest_CommonCreateState() */
return 1;
}
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
if ((SDL_strcasecmp(argv[index], "-h") == 0)
|| (SDL_strcasecmp(argv[index], "--help") == 0)) {
/* Print the usage message */
return -1;
}
if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
/* Debug flag sent by Xcode */
return 2;
}
return 0;
}
const char *
SDLTest_CommonUsage(SDLTest_CommonState * state)
{
switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
case SDL_INIT_VIDEO:
482
return "[--trackmem] " VIDEO_USAGE;
483
case SDL_INIT_AUDIO:
484
return "[--trackmem] " AUDIO_USAGE;
485
case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
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) {
496
497
case SDL_RENDERER_SOFTWARE:
SDL_snprintfcat(text, maxlen, "Software");
498
499
break;
case SDL_RENDERER_ACCELERATED:
500
SDL_snprintfcat(text, maxlen, "Accelerated");
501
break;
502
503
504
505
506
507
case SDL_RENDERER_PRESENTVSYNC:
SDL_snprintfcat(text, maxlen, "PresentVSync");
break;
case SDL_RENDERER_TARGETTEXTURE:
SDL_snprintfcat(text, maxlen, "TargetTexturesSupported");
break;
508
default:
509
SDL_snprintfcat(text, maxlen, "0x%8.8x", flag);
510
511
512
513
514
break;
}
}
static void
515
SDLTest_PrintPixelFormat(char *text, size_t maxlen, Uint32 format)
516
517
518
{
switch (format) {
case SDL_PIXELFORMAT_UNKNOWN:
519
SDL_snprintfcat(text, maxlen, "Unknown");
520
521
break;
case SDL_PIXELFORMAT_INDEX1LSB:
522
SDL_snprintfcat(text, maxlen, "Index1LSB");
523
524
break;
case SDL_PIXELFORMAT_INDEX1MSB:
525
SDL_snprintfcat(text, maxlen, "Index1MSB");
526
527
break;
case SDL_PIXELFORMAT_INDEX4LSB:
528
SDL_snprintfcat(text, maxlen, "Index4LSB");
529
530
break;
case SDL_PIXELFORMAT_INDEX4MSB:
531
SDL_snprintfcat(text, maxlen, "Index4MSB");
532
533
break;
case SDL_PIXELFORMAT_INDEX8:
534
SDL_snprintfcat(text, maxlen, "Index8");
535
536
break;
case SDL_PIXELFORMAT_RGB332:
537
SDL_snprintfcat(text, maxlen, "RGB332");
538
539
break;
case SDL_PIXELFORMAT_RGB444:
540
SDL_snprintfcat(text, maxlen, "RGB444");
541
542
break;
case SDL_PIXELFORMAT_RGB555:
543
SDL_snprintfcat(text, maxlen, "RGB555");
544
545
break;
case SDL_PIXELFORMAT_BGR555:
546
SDL_snprintfcat(text, maxlen, "BGR555");
547
548
break;
case SDL_PIXELFORMAT_ARGB4444:
549
SDL_snprintfcat(text, maxlen, "ARGB4444");
550
551
break;
case SDL_PIXELFORMAT_ABGR4444:
552
SDL_snprintfcat(text, maxlen, "ABGR4444");
553
554
break;
case SDL_PIXELFORMAT_ARGB1555:
555
SDL_snprintfcat(text, maxlen, "ARGB1555");
556
557
break;
case SDL_PIXELFORMAT_ABGR1555:
558
SDL_snprintfcat(text, maxlen, "ABGR1555");
559
560
break;
case SDL_PIXELFORMAT_RGB565:
561
SDL_snprintfcat(text, maxlen, "RGB565");
562
563
break;
case SDL_PIXELFORMAT_BGR565:
564
SDL_snprintfcat(text, maxlen, "BGR565");
565
566
break;
case SDL_PIXELFORMAT_RGB24:
567
SDL_snprintfcat(text, maxlen, "RGB24");
568
569
break;
case SDL_PIXELFORMAT_BGR24:
570
SDL_snprintfcat(text, maxlen, "BGR24");
571
572
break;
case SDL_PIXELFORMAT_RGB888:
573
SDL_snprintfcat(text, maxlen, "RGB888");
574
575
break;
case SDL_PIXELFORMAT_BGR888:
576
SDL_snprintfcat(text, maxlen, "BGR888");
577
578
break;
case SDL_PIXELFORMAT_ARGB8888:
579
SDL_snprintfcat(text, maxlen, "ARGB8888");
580
581
break;
case SDL_PIXELFORMAT_RGBA8888:
582
SDL_snprintfcat(text, maxlen, "RGBA8888");
583
584
break;
case SDL_PIXELFORMAT_ABGR8888:
585
SDL_snprintfcat(text, maxlen, "ABGR8888");
586
587
break;
case SDL_PIXELFORMAT_BGRA8888:
588
SDL_snprintfcat(text, maxlen, "BGRA8888");
589
590
break;
case SDL_PIXELFORMAT_ARGB2101010:
591
SDL_snprintfcat(text, maxlen, "ARGB2101010");
592
593
break;
case SDL_PIXELFORMAT_YV12:
594
SDL_snprintfcat(text, maxlen, "YV12");
595
596
break;
case SDL_PIXELFORMAT_IYUV:
597
SDL_snprintfcat(text, maxlen, "IYUV");
598
599
break;
case SDL_PIXELFORMAT_YUY2:
600
SDL_snprintfcat(text, maxlen, "YUY2");
601
602
break;
case SDL_PIXELFORMAT_UYVY:
603
SDL_snprintfcat(text, maxlen, "UYVY");
604
605
break;
case SDL_PIXELFORMAT_YVYU:
606
SDL_snprintfcat(text, maxlen, "YVYU");
607
608
break;
case SDL_PIXELFORMAT_NV12:
609
SDL_snprintfcat(text, maxlen, "NV12");
610
611
break;
case SDL_PIXELFORMAT_NV21:
612
SDL_snprintfcat(text, maxlen, "NV21");
613
614
break;
default:
615
SDL_snprintfcat(text, maxlen, "0x%8.8x", format);
616
617
618
619
620
621
622
623
break;
}
}
static void
SDLTest_PrintRenderer(SDL_RendererInfo * info)
{
int i, count;
624
char text[1024];
625
626
SDL_Log(" Renderer %s:\n", info->name);
627
628
629
SDL_snprintf(text, sizeof(text), " Flags: 0x%8.8X", info->flags);
SDL_snprintfcat(text, sizeof(text), " (");
630
631
632
633
634
count = 0;
for (i = 0; i < sizeof(info->flags) * 8; ++i) {
Uint32 flag = (1 << i);
if (info->flags & flag) {
if (count > 0) {
635
SDL_snprintfcat(text, sizeof(text), " | ");
636
}
637
SDLTest_PrintRendererFlag(text, sizeof(text), flag);
638
639
640
++count;
}
}
641
642
SDL_snprintfcat(text, sizeof(text), ")");
SDL_Log("%s\n", text);
643
644
SDL_snprintf(text, sizeof(text), " Texture formats (%d): ", info->num_texture_formats);
645
646
for (i = 0; i < (int) info->num_texture_formats; ++i) {
if (i > 0) {
647
SDL_snprintfcat(text, sizeof(text), ", ");
648
}
649
SDLTest_PrintPixelFormat(text, sizeof(text), info->texture_formats[i]);
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",
655
656
657
658
659
660
661
662
663
664
665
666
info->max_texture_width, info->max_texture_height);
}
}
static SDL_Surface *
SDLTest_LoadIcon(const char *file)
{
SDL_Surface *icon;
/* Load the icon surface */
icon = SDL_LoadBMP(file);
if (icon == NULL) {
667
SDL_Log("Couldn't load %s: %s\n", file, SDL_GetError());
668
669
670
671
672
673
674
675
676
677
678
return (NULL);
}
if (icon->format->palette) {
/* Set the colorkey */
SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
}
return (icon);
}
679
static SDL_HitTestResult SDLCALL
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
SDLTest_ExampleHitTestCallback(SDL_Window *win, const SDL_Point *area, void *data)
{
int w, h;
const int RESIZE_BORDER = 8;
const int DRAGGABLE_TITLE = 32;
/*SDL_Log("Hit test point %d,%d\n", area->x, area->y);*/
SDL_GetWindowSize(win, &w, &h);
if (area->x < RESIZE_BORDER) {
if (area->y < RESIZE_BORDER) {
SDL_Log("SDL_HITTEST_RESIZE_TOPLEFT\n");
return SDL_HITTEST_RESIZE_TOPLEFT;
} else if (area->y >= (h-RESIZE_BORDER)) {
SDL_Log("SDL_HITTEST_RESIZE_BOTTOMLEFT\n");
return SDL_HITTEST_RESIZE_BOTTOMLEFT;
} else {
SDL_Log("SDL_HITTEST_RESIZE_LEFT\n");
return SDL_HITTEST_RESIZE_LEFT;
}
} else if (area->x >= (w-RESIZE_BORDER)) {
if (area->y < RESIZE_BORDER) {
SDL_Log("SDL_HITTEST_RESIZE_TOPRIGHT\n");
return SDL_HITTEST_RESIZE_TOPRIGHT;
} else if (area->y >= (h-RESIZE_BORDER)) {
SDL_Log("SDL_HITTEST_RESIZE_BOTTOMRIGHT\n");
return SDL_HITTEST_RESIZE_BOTTOMRIGHT;
} else {
SDL_Log("SDL_HITTEST_RESIZE_RIGHT\n");
return SDL_HITTEST_RESIZE_RIGHT;
}
} else if (area->y >= (h-RESIZE_BORDER)) {
SDL_Log("SDL_HITTEST_RESIZE_BOTTOM\n");
return SDL_HITTEST_RESIZE_BOTTOM;
} else if (area->y < RESIZE_BORDER) {
SDL_Log("SDL_HITTEST_RESIZE_TOP\n");
return SDL_HITTEST_RESIZE_TOP;
} else if (area->y < DRAGGABLE_TITLE) {
SDL_Log("SDL_HITTEST_DRAGGABLE\n");
return SDL_HITTEST_DRAGGABLE;
}
return SDL_HITTEST_NORMAL;
}
725
726
727
728
729
SDL_bool
SDLTest_CommonInit(SDLTest_CommonState * state)
{
int i, j, m, n, w, h;
SDL_DisplayMode fullscreen_mode;
730
char text[1024];
731
732
733
734
735
if (state->flags & SDL_INIT_VIDEO) {
if (state->verbose & VERBOSE_VIDEO) {
n = SDL_GetNumVideoDrivers();
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
740
for (i = 0; i < n; ++i) {
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
751
752
753
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
754
SDL_Log("Video driver: %s\n",
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
SDL_GetCurrentVideoDriver());
}
/* Upload GL settings */
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
if (state->gl_accelerated >= 0) {
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,
state->gl_accelerated);
}
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
if (state->gl_major_version) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version);
}
if (state->gl_debug) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
}
if (state->gl_profile_mask) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, state->gl_profile_mask);
}
if (state->verbose & VERBOSE_MODES) {
791
792
793
SDL_Rect bounds, usablebounds;
float hdpi = 0;
float vdpi = 0;
794
795
796
797
SDL_DisplayMode mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
#if SDL_VIDEO_DRIVER_WINDOWS
798
799
int adapterIndex = 0;
int outputIndex = 0;
800
801
#endif
n = SDL_GetNumVideoDisplays();
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
807
SDL_zero(bounds);
SDL_GetDisplayBounds(i, &bounds);
808
809
810
811
812
813
SDL_zero(usablebounds);
SDL_GetDisplayUsableBounds(i, &usablebounds);
SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
814
SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
815
816
SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
817
818
819
820
SDL_GetDesktopDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
821
SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
822
823
824
mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
825
826
827
SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
828
if (Amask)
829
SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
830
831
832
833
834
}
/* Print available fullscreen video modes */
m = SDL_GetNumDisplayModes(i);
if (m == 0) {
835
SDL_Log("No available fullscreen video modes\n");
836
} else {
837
SDL_Log(" Fullscreen video modes:\n");
838
839
840
841
for (j = 0; j < m; ++j) {
SDL_GetDisplayMode(i, j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
842
SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
843
844
845
j, mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
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
852
Bmask);
if (Amask)
853
SDL_Log(" Alpha Mask = 0x%.8x\n",
854
855
856
857
858
859
Amask);
}
}
}
#if SDL_VIDEO_DRIVER_WINDOWS
860
861
862
/* Print the D3D9 adapter index */
adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
863
864
865
866
/* Print the DXGI adapter and output indices */
SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
SDL_Log("DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex);
867
868
869
870
871
872
873
874
875
#endif
}
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
if (n == 0) {
876
SDL_Log("No built-in render drivers\n");
877
} else {
878
SDL_Log("Built-in render drivers:\n");
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
for (i = 0; i < n; ++i) {
SDL_GetRenderDriverInfo(i, &info);
SDLTest_PrintRenderer(&info);
}
}
}
SDL_zero(fullscreen_mode);
switch (state->depth) {
case 8:
fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
break;
case 15:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
break;
case 16:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
break;
case 24:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
break;
default:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
break;
}
fullscreen_mode.refresh_rate = state->refresh_rate;
state->windows =
907
(SDL_Window **) SDL_calloc(state->num_windows,
908
909
sizeof(*state->windows));
state->renderers =
910
(SDL_Renderer **) SDL_calloc(state->num_windows,
911
912
sizeof(*state->renderers));
state->targets =
913
(SDL_Texture **) SDL_calloc(state->num_windows,
914
915
sizeof(*state->targets));
if (!state->windows || !state->renderers) {
916
SDL_Log("Out of memory!\n");
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
return SDL_FALSE;
}
for (i = 0; i < state->num_windows; ++i) {
char title[1024];
if (state->num_windows > 1) {
SDL_snprintf(title, SDL_arraysize(title), "%s %d",
state->window_title, i + 1);
} else {
SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
}
state->windows[i] =
SDL_CreateWindow(title, state->window_x, state->window_y,
state->window_w, state->window_h,
state->window_flags);
if (!state->windows[i]) {
933
SDL_Log("Couldn't create window: %s\n",
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
SDL_GetError());
return SDL_FALSE;
}
if (state->window_minW || state->window_minH) {
SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
}
if (state->window_maxW || state->window_maxH) {
SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
}
SDL_GetWindowSize(state->windows[i], &w, &h);
if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
(w != state->window_w || h != state->window_h)) {
printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
state->window_w = w;
state->window_h = h;
}
if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
951
SDL_Log("Can't set up fullscreen display mode: %s\n",
952
953
954
955
SDL_GetError());
return SDL_FALSE;
}
956
/* Add resize/drag areas for windows that are borderless and resizable */
957
if ((state->window_flags & (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) ==
958
959
960
961
(SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) {
SDL_SetWindowHitTest(state->windows[i], SDLTest_ExampleHitTestCallback, NULL);
}
962
963
964
965
966
967
968
969
970
971
972
973
if (state->window_icon) {
SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
if (icon) {
SDL_SetWindowIcon(state->windows[i], icon);
SDL_FreeSurface(icon);
}
}
SDL_ShowWindow(state->windows[i]);
if (!state->skip_renderer
&& (state->renderdriver
974
|| !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
975
976
977
978
979
980
981
982
983
984
985
986
987
m = -1;
if (state->renderdriver) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
for (j = 0; j < n; ++j) {
SDL_GetRenderDriverInfo(j, &info);
if (SDL_strcasecmp(info.name, state->renderdriver) ==
0) {
m = j;
break;
}
}
if (m == -1) {
988
SDL_Log("Couldn't find render driver named %s",
989
990
991
992
993
994
995
state->renderdriver);
return SDL_FALSE;
}
}
state->renderers[i] = SDL_CreateRenderer(state->windows[i],
m, state->render_flags);
if (!state->renderers[i]) {
996
SDL_Log("Couldn't create renderer: %s\n",
997
998
999
1000
SDL_GetError());
return SDL_FALSE;
}
if (state->logical_w && state->logical_h) {