SDL_test_common.c
Go to the documentation of this file.
/*
Simple DirectMedia Layer
Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
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]"
SDLTest_CommonState *
SDLTest_CommonCreateState(char **argv, Uint32 flags)
{
SDLTest_CommonState *state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
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;
}
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:
return VIDEO_USAGE;
case SDL_INIT_AUDIO:
return AUDIO_USAGE;
case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
return VIDEO_USAGE " " AUDIO_USAGE;
default:
return "";
}
}
static void
SDLTest_PrintRendererFlag(Uint32 flag)
{
switch (flag) {
case SDL_RENDERER_PRESENTVSYNC:
fprintf(stderr, "PresentVSync");
break;
case SDL_RENDERER_ACCELERATED:
fprintf(stderr, "Accelerated");
break;
default:
fprintf(stderr, "0x%8.8x", flag);
break;
}
}
static void
SDLTest_PrintPixelFormat(Uint32 format)
{
switch (format) {
case SDL_PIXELFORMAT_UNKNOWN:
fprintf(stderr, "Unknwon");
break;
case SDL_PIXELFORMAT_INDEX1LSB:
fprintf(stderr, "Index1LSB");
break;
case SDL_PIXELFORMAT_INDEX1MSB:
fprintf(stderr, "Index1MSB");
break;
case SDL_PIXELFORMAT_INDEX4LSB:
fprintf(stderr, "Index4LSB");
break;
case SDL_PIXELFORMAT_INDEX4MSB:
fprintf(stderr, "Index4MSB");
break;
case SDL_PIXELFORMAT_INDEX8:
fprintf(stderr, "Index8");
break;
case SDL_PIXELFORMAT_RGB332:
fprintf(stderr, "RGB332");
break;
case SDL_PIXELFORMAT_RGB444:
fprintf(stderr, "RGB444");
break;
case SDL_PIXELFORMAT_RGB555:
fprintf(stderr, "RGB555");
break;
case SDL_PIXELFORMAT_BGR555:
fprintf(stderr, "BGR555");
break;
case SDL_PIXELFORMAT_ARGB4444:
fprintf(stderr, "ARGB4444");
break;
case SDL_PIXELFORMAT_ABGR4444:
fprintf(stderr, "ABGR4444");
break;
case SDL_PIXELFORMAT_ARGB1555:
fprintf(stderr, "ARGB1555");
break;
case SDL_PIXELFORMAT_ABGR1555:
fprintf(stderr, "ABGR1555");
break;
case SDL_PIXELFORMAT_RGB565:
fprintf(stderr, "RGB565");
break;
case SDL_PIXELFORMAT_BGR565:
fprintf(stderr, "BGR565");
break;
case SDL_PIXELFORMAT_RGB24:
fprintf(stderr, "RGB24");
break;
case SDL_PIXELFORMAT_BGR24:
fprintf(stderr, "BGR24");
break;
case SDL_PIXELFORMAT_RGB888:
fprintf(stderr, "RGB888");
break;
case SDL_PIXELFORMAT_BGR888:
fprintf(stderr, "BGR888");
break;
case SDL_PIXELFORMAT_ARGB8888:
fprintf(stderr, "ARGB8888");
break;
case SDL_PIXELFORMAT_RGBA8888:
fprintf(stderr, "RGBA8888");
break;
case SDL_PIXELFORMAT_ABGR8888:
fprintf(stderr, "ABGR8888");
break;
case SDL_PIXELFORMAT_BGRA8888:
fprintf(stderr, "BGRA8888");
break;
case SDL_PIXELFORMAT_ARGB2101010:
fprintf(stderr, "ARGB2101010");
break;
case SDL_PIXELFORMAT_YV12:
fprintf(stderr, "YV12");
break;
case SDL_PIXELFORMAT_IYUV:
fprintf(stderr, "IYUV");
break;
case SDL_PIXELFORMAT_YUY2:
fprintf(stderr, "YUY2");
break;
case SDL_PIXELFORMAT_UYVY:
fprintf(stderr, "UYVY");
break;
case SDL_PIXELFORMAT_YVYU:
fprintf(stderr, "YVYU");
break;
case SDL_PIXELFORMAT_NV12:
fprintf(stderr, "NV12");
break;
case SDL_PIXELFORMAT_NV21:
fprintf(stderr, "NV21");
break;
default:
fprintf(stderr, "0x%8.8x", format);
break;
}
}
static void
SDLTest_PrintRenderer(SDL_RendererInfo * info)
{
int i, count;
fprintf(stderr, " Renderer %s:\n", info->name);
fprintf(stderr, " Flags: 0x%8.8X", info->flags);
fprintf(stderr, " (");
count = 0;
for (i = 0; i < sizeof(info->flags) * 8; ++i) {
Uint32 flag = (1 << i);
if (info->flags & flag) {
if (count > 0) {
fprintf(stderr, " | ");
}
SDLTest_PrintRendererFlag(flag);
++count;
}
}
fprintf(stderr, ")\n");
fprintf(stderr, " Texture formats (%d): ", info->num_texture_formats);
for (i = 0; i < (int) info->num_texture_formats; ++i) {
if (i > 0) {
fprintf(stderr, ", ");
}
SDLTest_PrintPixelFormat(info->texture_formats[i]);
}
fprintf(stderr, "\n");
if (info->max_texture_width || info->max_texture_height) {
fprintf(stderr, " Max Texture Size: %dx%d\n",
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) {
fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError());
return (NULL);
}
if (icon->format->palette) {
/* Set the colorkey */
SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
}
return (icon);
}
SDL_bool
SDLTest_CommonInit(SDLTest_CommonState * state)
{
int i, j, m, n, w, h;
SDL_DisplayMode fullscreen_mode;
if (state->flags & SDL_INIT_VIDEO) {
if (state->verbose & VERBOSE_VIDEO) {
n = SDL_GetNumVideoDrivers();
if (n == 0) {
fprintf(stderr, "No built-in video drivers\n");
} else {
fprintf(stderr, "Built-in video drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetVideoDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_VideoInit(state->videodriver) < 0) {
fprintf(stderr, "Couldn't initialize video driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "Video driver: %s\n",
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) {
SDL_Rect bounds;
SDL_DisplayMode mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
#if SDL_VIDEO_DRIVER_WINDOWS
int adapterIndex = 0;
int outputIndex = 0;
#endif
n = SDL_GetNumVideoDisplays();
fprintf(stderr, "Number of displays: %d\n", n);
for (i = 0; i < n; ++i) {
fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i));
SDL_zero(bounds);
SDL_GetDisplayBounds(i, &bounds);
fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
SDL_GetDesktopDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
fprintf(stderr,
" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask);
}
/* Print available fullscreen video modes */
m = SDL_GetNumDisplayModes(i);
if (m == 0) {
fprintf(stderr, "No available fullscreen video modes\n");
} else {
fprintf(stderr, " Fullscreen video modes:\n");
for (j = 0; j < m; ++j) {
SDL_GetDisplayMode(i, j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
fprintf(stderr,
" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
j, mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
fprintf(stderr, " Red Mask = 0x%.8x\n",
Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n",
Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n",
Bmask);
if (Amask)
fprintf(stderr,
" Alpha Mask = 0x%.8x\n",
Amask);
}
}
}
#if SDL_VIDEO_DRIVER_WINDOWS
/* Print the D3D9 adapter index */
adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
fprintf( stderr, "D3D9 Adapter Index: %d", adapterIndex );
/* Print the DXGI adapter and output indices */
SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
fprintf( stderr, "DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex );
#endif
}
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
if (n == 0) {
fprintf(stderr, "No built-in render drivers\n");
} else {
fprintf(stderr, "Built-in render drivers:\n");
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 =
(SDL_Window **) SDL_malloc(state->num_windows *
sizeof(*state->windows));
state->renderers =
(SDL_Renderer **) SDL_malloc(state->num_windows *
sizeof(*state->renderers));
state->targets =
(SDL_Texture **) SDL_malloc(state->num_windows *
sizeof(*state->targets));
if (!state->windows || !state->renderers) {
fprintf(stderr, "Out of memory!\n");
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]) {
fprintf(stderr, "Couldn't create window: %s\n",
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) {
fprintf(stderr, "Can't set up fullscreen display mode: %s\n",
SDL_GetError());
return SDL_FALSE;
}
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]);
state->renderers[i] = NULL;
state->targets[i] = NULL;
if (!state->skip_renderer
&& (state->renderdriver
|| !(state->window_flags & SDL_WINDOW_OPENGL))) {
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) {
fprintf(stderr,
"Couldn't find render driver named %s",
state->renderdriver);
return SDL_FALSE;
}
}
state->renderers[i] = SDL_CreateRenderer(state->windows[i],
m, state->render_flags);
if (!state->renderers[i]) {
fprintf(stderr, "Couldn't create renderer: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->logical_w && state->logical_h) {
SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
} else if (state->scale) {
SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
fprintf(stderr, "Current renderer:\n");
SDL_GetRendererInfo(state->renderers[i], &info);
SDLTest_PrintRenderer(&info);
}
}
}
}
if (state->flags & SDL_INIT_AUDIO) {
if (state->verbose & VERBOSE_AUDIO) {
n = SDL_GetNumAudioDrivers();
if (n == 0) {
fprintf(stderr, "No built-in audio drivers\n");
} else {
fprintf(stderr, "Built-in audio drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetAudioDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_AudioInit(state->audiodriver) < 0) {
fprintf(stderr, "Couldn't initialize audio driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "Audio driver: %s\n",
SDL_GetCurrentAudioDriver());
}
if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
return SDL_FALSE;
}
}
return SDL_TRUE;
}
static const char *
ControllerAxisName(const SDL_GameControllerAxis axis)
{
switch (axis)
{
#define AXIS_CASE(ax) case SDL_CONTROLLER_AXIS_##ax: return #ax
AXIS_CASE(INVALID);
AXIS_CASE(LEFTX);
AXIS_CASE(LEFTY);
AXIS_CASE(RIGHTX);
AXIS_CASE(RIGHTY);
AXIS_CASE(TRIGGERLEFT);
AXIS_CASE(TRIGGERRIGHT);
#undef AXIS_CASE
default: return "???";
}
}
static const char *
ControllerButtonName(const SDL_GameControllerButton button)
{
switch (button)
{
#define BUTTON_CASE(btn) case SDL_CONTROLLER_BUTTON_##btn: return #btn
BUTTON_CASE(INVALID);
BUTTON_CASE(A);
BUTTON_CASE(B);
BUTTON_CASE(X);
BUTTON_CASE(Y);
BUTTON_CASE(BACK);
BUTTON_CASE(GUIDE);
BUTTON_CASE(START);
BUTTON_CASE(LEFTSTICK);
BUTTON_CASE(RIGHTSTICK);
BUTTON_CASE(LEFTSHOULDER);
BUTTON_CASE(RIGHTSHOULDER);
BUTTON_CASE(DPAD_UP);
BUTTON_CASE(DPAD_DOWN);
BUTTON_CASE(DPAD_LEFT);
BUTTON_CASE(DPAD_RIGHT);
#undef BUTTON_CASE
default: return "???";
}
}
static void
SDLTest_PrintEvent(SDL_Event * event)
{
if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
/* Mouse and finger motion are really spammy */
return;
}
switch (event->type) {
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
break;
case SDL_WINDOWEVENT_HIDDEN:
SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
break;
case SDL_WINDOWEVENT_EXPOSED:
SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
break;
case SDL_WINDOWEVENT_MOVED:
SDL_Log("SDL EVENT: Window %d moved to %d,%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_RESIZED:
SDL_Log("SDL EVENT: Window %d resized to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
event->window.windowID, event->window.data1,
event->window.data2);
break;
case SDL_WINDOWEVENT_MINIMIZED:
SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
break;
case SDL_WINDOWEVENT_RESTORED:
SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
break;
case SDL_WINDOWEVENT_ENTER:
SDL_Log("SDL EVENT: Mouse entered window %d",
event->window.windowID);
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
SDL_Log("SDL EVENT: Window %d gained keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
SDL_Log("SDL EVENT: Window %d lost keyboard focus",
event->window.windowID);
break;
case SDL_WINDOWEVENT_CLOSE:
SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
break;
default:
SDL_Log("SDL EVENT: Window %d got unknown event %d",
event->window.windowID, event->window.event);
break;
}
break;
case SDL_KEYDOWN:
SDL_Log("SDL EVENT: Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
event->key.windowID,
event->key.keysym.scancode,
SDL_GetScancodeName(event->key.keysym.scancode),
event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
break;
case SDL_KEYUP:
SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
event->key.windowID,
event->key.keysym.scancode,
SDL_GetScancodeName(event->key.keysym.scancode),
event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
break;
case SDL_TEXTINPUT:
SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
event->text.text, event->text.windowID);
break;
case SDL_MOUSEMOTION:
SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
event->motion.x, event->motion.y,
event->motion.xrel, event->motion.yrel,
event->motion.windowID);
break;
case SDL_MOUSEBUTTONDOWN:
SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
event->button.button, event->button.x, event->button.y, event->button.clicks,
event->button.windowID);
break;
case SDL_MOUSEBUTTONUP:
SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
event->button.button, event->button.x, event->button.y, event->button.clicks,
event->button.windowID);
break;
case SDL_MOUSEWHEEL:
SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
break;
case SDL_JOYDEVICEADDED:
SDL_Log("SDL EVENT: Joystick index %d attached",
event->jdevice.which);
break;
case SDL_JOYDEVICEREMOVED:
SDL_Log("SDL EVENT: Joystick %d removed",
event->jdevice.which);
break;
case SDL_JOYBALLMOTION:
SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
event->jball.which, event->jball.ball, event->jball.xrel,
event->jball.yrel);
break;
case SDL_JOYHATMOTION:
{
const char *position = "UNKNOWN";
switch (event->jhat.value) {
case SDL_HAT_CENTERED:
position = "CENTER";
break;
case SDL_HAT_UP:
position = "UP";
break;
case SDL_HAT_RIGHTUP:
position = "RIGHTUP";
break;
case SDL_HAT_RIGHT:
position = "RIGHT";
break;
case SDL_HAT_RIGHTDOWN:
position = "RIGHTDOWN";
break;
case SDL_HAT_DOWN:
position = "DOWN";
break;
case SDL_HAT_LEFTDOWN:
position = "LEFTDOWN";
break;
case SDL_HAT_LEFT:
position = "LEFT";
break;
case SDL_HAT_LEFTUP:
position = "LEFTUP";
break;
}
SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
event->jhat.hat, position);
}
break;
case SDL_JOYBUTTONDOWN:
SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
event->jbutton.which, event->jbutton.button);
break;
case SDL_JOYBUTTONUP:
SDL_Log("SDL EVENT: Joystick %d: button %d released",
event->jbutton.which, event->jbutton.button);
break;
case SDL_CONTROLLERDEVICEADDED:
SDL_Log("SDL EVENT: Controller index %d attached",
event->cdevice.which);
break;
case SDL_CONTROLLERDEVICEREMOVED:
SDL_Log("SDL EVENT: Controller %d removed",
event->cdevice.which);
break;
case SDL_CONTROLLERAXISMOTION:
SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
event->caxis.which,
event->caxis.axis,
ControllerAxisName((SDL_GameControllerAxis)event->caxis.axis),
event->caxis.value);
break;
case SDL_CONTROLLERBUTTONDOWN:
SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
event->cbutton.which, event->cbutton.button,
ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
break;
case SDL_CONTROLLERBUTTONUP:
SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
event->cbutton.which, event->cbutton.button,
ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
break;
case SDL_CLIPBOARDUPDATE:
SDL_Log("SDL EVENT: Clipboard updated");
break;
case SDL_FINGERDOWN:
case SDL_FINGERUP:
SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
(event->type == SDL_FINGERDOWN) ? "down" : "up",
(long) event->tfinger.touchId,
(long) event->tfinger.fingerId,
event->tfinger.x, event->tfinger.y,
event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
break;
case SDL_DOLLARGESTURE:
SDL_Log("SDL_EVENT: Dollar gesture detect: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
break;
case SDL_DOLLARRECORD:
SDL_Log("SDL_EVENT: Dollar gesture record: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
break;
case SDL_MULTIGESTURE:
SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
break;
case SDL_RENDER_DEVICE_RESET:
SDL_Log("SDL EVENT: render device reset");
break;
case SDL_RENDER_TARGETS_RESET:
SDL_Log("SDL EVENT: render targets reset");
break;
case SDL_QUIT:
SDL_Log("SDL EVENT: Quit requested");
break;
case SDL_USEREVENT:
SDL_Log("SDL EVENT: User event %d", event->user.code);
break;
default:
SDL_Log("Unknown event %04x", event->type);
break;
}
}
static void
SDLTest_ScreenShot(SDL_Renderer *renderer)
{
SDL_Rect viewport;
SDL_Surface *surface;
if (!renderer) {
return;
}
SDL_RenderGetViewport(renderer, &viewport);
surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
0x00FF0000, 0x0000FF00, 0x000000FF,
#else
0x000000FF, 0x0000FF00, 0x00FF0000,
#endif
0x00000000);
if (!surface) {
fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError());
return;
}
if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
surface->pixels, surface->pitch) < 0) {
fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError());
SDL_free(surface);
return;
}
if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError());
SDL_free(surface);
return;
}
}
static void
FullscreenTo(int index, int windowId)
{
Uint32 flags;
struct SDL_Rect rect = { 0, 0, 0, 0 };
SDL_Window *window = SDL_GetWindowFromID(windowId);
if (!window) {
return;
}
SDL_GetDisplayBounds( index, &rect );
flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen( window, SDL_FALSE );
SDL_Delay( 15 );
}
SDL_SetWindowPosition( window, rect.x, rect.y );
SDL_SetWindowFullscreen( window, SDL_TRUE );
}
void
SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
{
int i;
static SDL_MouseMotionEvent lastEvent;
if (state->verbose & VERBOSE_EVENT) {
SDLTest_PrintEvent(event);
}
switch (event->type) {
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_CLOSE:
{
SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
if (window) {
for (i = 0; i < state->num_windows; ++i) {
if (window == state->windows[i]) {
if (state->targets[i]) {
SDL_DestroyTexture(state->targets[i]);
state->targets[i] = NULL;
}
if (state->renderers[i]) {
SDL_DestroyRenderer(state->renderers[i]);
state->renderers[i] = NULL;
}
SDL_DestroyWindow(state->windows[i]);
state->windows[i] = NULL;
break;
}
}
}
}
break;
}
break;
case SDL_KEYDOWN: {
SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
switch (event->key.keysym.sym) {
/* Add hotkeys here */
case SDLK_PRINTSCREEN: {
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
for (i = 0; i < state->num_windows; ++i) {
if (window == state->windows[i]) {
SDLTest_ScreenShot(state->renderers[i]);
}
}
}
}
break;
case SDLK_EQUALS:
if (withControl) {
/* Ctrl-+ double the size of the window */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
int w, h;
SDL_GetWindowSize(window, &w, &h);
SDL_SetWindowSize(window, w*2, h*2);
}
}
break;
case SDLK_MINUS:
if (withControl) {
/* Ctrl-- half the size of the window */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
int w, h;
SDL_GetWindowSize(window, &w, &h);
SDL_SetWindowSize(window, w/2, h/2);
}
}
break;
case SDLK_c:
if (withControl) {
/* Ctrl-C copy awesome text! */
SDL_SetClipboardText("SDL rocks!\nYou know it!");
printf("Copied text to clipboard\n");
}
if (withAlt) {
/* Alt-C toggle a render clip rectangle */
for (i = 0; i < state->num_windows; ++i) {
int w, h;
if (state->renderers[i]) {
SDL_Rect clip;
SDL_GetWindowSize(state->windows[i], &w, &h);
SDL_RenderGetClipRect(state->renderers[i], &clip);
if (SDL_RectEmpty(&clip)) {
clip.x = w/4;
clip.y = h/4;
clip.w = w/2;
clip.h = h/2;
SDL_RenderSetClipRect(state->renderers[i], &clip);
} else {
SDL_RenderSetClipRect(state->renderers[i], NULL);
}
}
}
}
if (withShift) {
SDL_Window *current_win = SDL_GetKeyboardFocus();
if (current_win) {
const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
const int rc = SDL_CaptureMouse(shouldCapture);
SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
}
}
break;
case SDLK_v:
if (withControl) {
/* Ctrl-V paste awesome text! */
char *text = SDL_GetClipboardText();
if (*text) {
printf("Clipboard: %s\n", text);
} else {
printf("Clipboard is empty\n");
}
SDL_free(text);
}
break;
case SDLK_g:
if (withControl) {
/* Ctrl-G toggle grab */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
}
}
break;
case SDLK_m:
if (withControl) {
/* Ctrl-M maximize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_MAXIMIZED) {
SDL_RestoreWindow(window);
} else {
SDL_MaximizeWindow(window);
}
}
}
break;
case SDLK_r:
if (withControl) {
/* Ctrl-R toggle mouse relative mode */
SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE);
}
break;
case SDLK_z:
if (withControl) {
/* Ctrl-Z minimize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_MinimizeWindow(window);
}
}
break;
case SDLK_RETURN:
if (withControl) {
/* Ctrl-Enter toggle fullscreen */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(window, SDL_FALSE);
} else {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
}
}
} else if (withAlt) {
/* Alt-Enter toggle fullscreen desktop */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(window, SDL_FALSE);
} else {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
}
}
} else if (withShift) {
/* Shift-Enter toggle fullscreen desktop / fullscreen */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
} else {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
}
}
}
break;
case SDLK_b:
if (withControl) {
/* Ctrl-B toggle window border */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
const Uint32 flags = SDL_GetWindowFlags(window);
const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
SDL_SetWindowBordered(window, b);
}
}
break;
case SDLK_a:
if (withControl) {
/* Ctrl-A reports absolute mouse position. */
int x, y;
const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
(mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
(mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
(mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
(mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
(mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
}
break;
case SDLK_0:
if (withControl) {
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
}
break;
case SDLK_1:
if (withControl) {
FullscreenTo(0, event->key.windowID);
}
break;
case SDLK_2:
if (withControl) {
FullscreenTo(1, event->key.windowID);
}
break;
case SDLK_ESCAPE:
*done = 1;
break;
case SDLK_SPACE:
{
char message[256];
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
break;
}
default:
break;
}
break;
}
case SDL_QUIT:
*done = 1;
break;
case SDL_MOUSEMOTION:
lastEvent = event->motion;
break;
}
}
void
SDLTest_CommonQuit(SDLTest_CommonState * state)
{
int i;
SDL_free(state->windows);
if (state->targets) {
for (i = 0; i < state->num_windows; ++i) {
if (state->targets[i]) {
SDL_DestroyTexture(state->targets[i]);
}
}
SDL_free(state->targets);
}
if (state->renderers) {
for (i = 0; i < state->num_windows; ++i) {
if (state->renderers[i]) {
SDL_DestroyRenderer(state->renderers[i]);
}
}
SDL_free(state->renderers);
}
if (state->flags & SDL_INIT_VIDEO) {
SDL_VideoQuit();
}
if (state->flags & SDL_INIT_AUDIO) {
SDL_AudioQuit();
}
SDL_free(state);
SDL_Quit();
}
/* vi: set ts=4 sw=4 expandtab: */
SDL_HAT_LEFTDOWN
#define SDL_HAT_LEFTDOWN
Definition: SDL_joystick.h:215
SDL_WINDOWPOS_ISUNDEFINED
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:121
SDL_JOYBUTTONUP
Definition: SDL_events.h:112
SDL_RenderReadPixels
#define SDL_RenderReadPixels
Definition: SDL_dynapi_overrides.h:351
SDL_ControllerAxisEvent::which
SDL_JoystickID which
Definition: SDL_events.h:357
SDLTest_CommonState::gl_stereo
int gl_stereo
Definition: SDL_test_common.h:104
SDLK_g
Definition: SDL_keycode.h:103
SDL_test.h
SDL_GetNumAudioDrivers
#define SDL_GetNumAudioDrivers
Definition: SDL_dynapi_overrides.h:79
SDL_strlcpy
#define SDL_strlcpy
Definition: SDL_dynapi_overrides.h:400
SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:247
SDL_Event::motion
SDL_MouseMotionEvent motion
Definition: SDL_events.h:529
SDL_SetWindowMaximumSize
#define SDL_SetWindowMaximumSize
Definition: SDL_dynapi_overrides.h:534
SDL_JoyButtonEvent::which
SDL_JoystickID which
Definition: SDL_events.h:332
SDLTest_CommonState::argv
char ** argv
Definition: SDL_test_common.h:54
SDL_ShowWindow
#define SDL_ShowWindow
Definition: SDL_dynapi_overrides.h:537
SDL_JOYHATMOTION
Definition: SDL_events.h:110
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
SDLTest_CommonState::targets
SDL_Texture ** targets
Definition: SDL_test_common.h:85
SDL_LOG_CATEGORY_VIDEO
Definition: SDL_log.h:71
SDLTest_CommonState::gl_minor_version
int gl_minor_version
Definition: SDL_test_common.h:110
SDL_PIXELFORMAT_INDEX4LSB
Definition: SDL_pixels.h:179
SDL_WINDOWPOS_CENTERED
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:129
SDL_LOG_CATEGORY_SYSTEM
Definition: SDL_log.h:69
SDL_KEYDOWN
Definition: SDL_events.h:93
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:119
SDL_GetNumVideoDrivers
#define SDL_GetNumVideoDrivers
Definition: SDL_dynapi_overrides.h:500
SDL_Event::caxis
SDL_ControllerAxisEvent caxis
Definition: SDL_events.h:537
SDL_Event::jdevice
SDL_JoyDeviceEvent jdevice
Definition: SDL_events.h:536
SDL_RendererInfo::max_texture_width
int max_texture_width
Definition: SDL_render.h:84
SDL_SetWindowDisplayMode
#define SDL_SetWindowDisplayMode
Definition: SDL_dynapi_overrides.h:515
SDL_OpenAudio
#define SDL_OpenAudio
Definition: SDL_dynapi_overrides.h:84
button
SDL_Texture * button
Definition: testgamecontroller.c:67
SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:259
SDL_LOG_CATEGORY_INPUT
Definition: SDL_log.h:73
SDLTest_LoadIcon
static SDL_Surface * SDLTest_LoadIcon(const char *file)
Definition: SDL_test_common.c:625
SDL_Event::dgesture
SDL_DollarGestureEvent dgesture
Definition: SDL_events.h:546
SDL_RenderGetClipRect
#define SDL_RenderGetClipRect
Definition: SDL_dynapi_overrides.h:333
SDLTest_CommonState::gl_accelerated
int gl_accelerated
Definition: SDL_test_common.h:108
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
SDL_MouseMotionEvent::y
Sint32 y
Definition: SDL_events.h:237
SDL_RENDERER_ACCELERATED
Definition: SDL_render.h:67
SDL_GetDisplayMode
#define SDL_GetDisplayMode
Definition: SDL_dynapi_overrides.h:510
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
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_MOUSEBUTTONUP
Definition: SDL_events.h:104
SDL_GL_ACCUM_RED_SIZE
Definition: SDL_video.h:179
SDL_SetWindowFullscreen
#define SDL_SetWindowFullscreen
Definition: SDL_dynapi_overrides.h:543
SDL_SetWindowMinimumSize
#define SDL_SetWindowMinimumSize
Definition: SDL_dynapi_overrides.h:532
SDL_WINDOWEVENT_MINIMIZED
Definition: SDL_video.h:149
SDLTest_CommonState::skip_renderer
SDL_bool skip_renderer
Definition: SDL_test_common.h:83
SDL_RendererInfo::flags
Uint32 flags
Definition: SDL_render.h:81
SDL_ControllerAxisEvent::value
Sint16 value
Definition: SDL_events.h:362
SDL_CONTROLLERDEVICEREMOVED
Definition: SDL_events.h:121
SDL_BUTTON_RMASK
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:287
SDLK_EQUALS
Definition: SDL_keycode.h:84
SDL_Event::cdevice
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:539
SDL_LoadBMP
#define SDL_LoadBMP(file)
Definition: SDL_surface.h:182
SDL_GL_ACCUM_BLUE_SIZE
Definition: SDL_video.h:181
SDL_DisplayMode::w
int w
Definition: SDL_video.h:56
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2483
SDL_PIXELFORMAT_BGR24
Definition: SDL_pixels.h:232
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDL_Event::jbutton
SDL_JoyButtonEvent jbutton
Definition: SDL_events.h:535
SDL_MouseButtonEvent::y
Sint32 y
Definition: SDL_events.h:256
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1567
SDL_AudioInit
#define SDL_AudioInit
Definition: SDL_dynapi_overrides.h:81
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1564
m
const GLfloat * m
Definition: SDL_opengl_glext.h:6092
KMOD_CTRL
#define KMOD_CTRL
Definition: SDL_keycode.h:334
SDL_BUTTON_X2MASK
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:289
window
SDL_Window * window
Definition: testautomation_render.c:26
SDL_JoyBallEvent::ball
Uint8 ball
Definition: SDL_events.h:297
SDL_TouchFingerEvent::dx
float dx
Definition: SDL_events.h:418
SDL_TouchFingerEvent::pressure
float pressure
Definition: SDL_events.h:420
SDL_GetNumRenderDrivers
#define SDL_GetNumRenderDrivers
Definition: SDL_dynapi_overrides.h:304
SDL_JOYDEVICEADDED
Definition: SDL_events.h:113
SDL_HAT_RIGHTUP
#define SDL_HAT_RIGHTUP
Definition: SDL_joystick.h:212
SDLK_a
Definition: SDL_keycode.h:97
AXIS_CASE
#define AXIS_CASE(ax)
SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_SetWindowSize
#define SDL_SetWindowSize
Definition: SDL_dynapi_overrides.h:530
state
struct xkb_state * state
Definition: SDL_waylandsym.h:94
SDL_MOUSEBUTTONDOWN
Definition: SDL_events.h:103
SDL_Event::jball
SDL_JoyBallEvent jball
Definition: SDL_events.h:533
SDLTest_CommonState::window_w
int window_w
Definition: SDL_test_common.h:66
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDLTest_CommonState::gl_buffer_size
int gl_buffer_size
Definition: SDL_test_common.h:96
SDL_QUIT
Definition: SDL_events.h:60
SDL_TouchFingerEvent::touchId
SDL_TouchID touchId
Definition: SDL_events.h:414
SDL_GetDesktopDisplayMode
#define SDL_GetDesktopDisplayMode
Definition: SDL_dynapi_overrides.h:511
SDLTest_CommonState::window_x
int window_x
Definition: SDL_test_common.h:64
SDL_GetDisplayName
#define SDL_GetDisplayName
Definition: SDL_dynapi_overrides.h:506
SDLTest_CommonState::window_icon
const char * window_icon
Definition: SDL_test_common.h:62
AUDIO_USAGE
#define AUDIO_USAGE
Definition: SDL_test_common.c:32
SDL_RendererInfo::texture_formats
Uint32 texture_formats[16]
Definition: SDL_render.h:83
SDL_GL_ACCUM_ALPHA_SIZE
Definition: SDL_video.h:182
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:53
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:522
SDL_Renderer
Definition: SDL_sysrender.h:76
SDL_USEREVENT
Definition: SDL_events.h:151
SDLK_0
Definition: SDL_keycode.h:71
SDL_MouseMotionEvent::x
Sint32 x
Definition: SDL_events.h:236
SDL_JoyBallEvent::xrel
Sint16 xrel
Definition: SDL_events.h:301
SDLTest_CommonState::verbose
Uint32 verbose
Definition: SDL_test_common.h:56
SDL_WINDOWPOS_ISCENTERED
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:130
SDL_Keysym::scancode
SDL_Scancode scancode
Definition: SDL_keyboard.h:49
SDL_AudioSpec::samples
Uint16 samples
Definition: SDL_audio.h:174
SDL_DisplayMode::refresh_rate
int refresh_rate
Definition: SDL_video.h:58
KMOD_ALT
#define KMOD_ALT
Definition: SDL_keycode.h:336
SDL_GL_ACCELERATED_VISUAL
Definition: SDL_video.h:186
SDL_WINDOWEVENT_MAXIMIZED
Definition: SDL_video.h:150
SDL_SaveBMP
#define SDL_SaveBMP(surface, file)
Definition: SDL_surface.h:199
SDL_LIL_ENDIAN
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
SDL_PIXELFORMAT_NV21
Definition: SDL_pixels.h:275
SDL_MouseButtonEvent::clicks
Uint8 clicks
Definition: SDL_events.h:253
SDL_JOYBALLMOTION
Definition: SDL_events.h:109
SDLTest_CommonInit
SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
Open test window.
Definition: SDL_test_common.c:645
SDL_CreateWindow
#define SDL_CreateWindow
Definition: SDL_dynapi_overrides.h:518
SDLTest_CommonState::renderdriver
const char * renderdriver
Definition: SDL_test_common.h:81
VERBOSE_EVENT
#define VERBOSE_EVENT
Definition: SDL_test_common.h:48
SDL_WINDOWPOS_UNDEFINED
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:120
axis
SDL_Texture * axis
Definition: testgamecontroller.c:67
SDL_SetRelativeMouseMode
#define SDL_SetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:255
SDL_PIXELFORMAT_INDEX1LSB
Definition: SDL_pixels.h:173
SDL_GetKeyboardFocus
#define SDL_GetKeyboardFocus
Definition: SDL_dynapi_overrides.h:222
SDL_GL_RED_SIZE
Definition: SDL_video.h:171
SDL_GameControllerButton
SDL_GameControllerButton
Definition: SDL_gamecontroller.h:262
SDL_strcasecmp
#define SDL_strcasecmp
Definition: SDL_dynapi_overrides.h:425
SDL_DollarGestureEvent::gestureId
SDL_GestureID gestureId
Definition: SDL_events.h:449
SDL_MOUSEWHEEL
Definition: SDL_events.h:105
SDL_RendererInfo::name
const char * name
Definition: SDL_render.h:80
SDL_CONTROLLERDEVICEADDED
Definition: SDL_events.h:120
SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:146
SDL_MinimizeWindow
#define SDL_MinimizeWindow
Definition: SDL_dynapi_overrides.h:541
SDL_ControllerButtonEvent::which
SDL_JoystickID which
Definition: SDL_events.h:374
SDL_RendererInfo::max_texture_height
int max_texture_height
Definition: SDL_render.h:85
SDL_GetRenderDriverInfo
#define SDL_GetRenderDriverInfo
Definition: SDL_dynapi_overrides.h:305
SDL_LOG_PRIORITY_VERBOSE
Definition: SDL_log.h:104
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
SDL_Event::wheel
SDL_MouseWheelEvent wheel
Definition: SDL_events.h:531
SDLK_RETURN
Definition: SDL_keycode.h:51
SDLTest_PrintPixelFormat
static void SDLTest_PrintPixelFormat(Uint32 format)
Definition: SDL_test_common.c:482
SDL_config.h
SDL_ControllerDeviceEvent::which
Sint32 which
Definition: SDL_events.h:389
SDL_MESSAGEBOX_INFORMATION
Definition: SDL_messagebox.h:41
SDLTest_CommonState::gl_double_buffer
int gl_double_buffer
Definition: SDL_test_common.h:99
SDLTest_CommonState::window_y
int window_y
Definition: SDL_test_common.h:65
SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:235
SDL_WINDOWEVENT_HIDDEN
Definition: SDL_video.h:140
SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:241
SDLTest_CommonState::audiospec
SDL_AudioSpec audiospec
Definition: SDL_test_common.h:89
SDL_PIXELFORMAT_ARGB4444
Definition: SDL_pixels.h:199
SDL_AudioQuit
#define SDL_AudioQuit
Definition: SDL_dynapi_overrides.h:82
SDL_Texture
Definition: SDL_sysrender.h:49
SDL_KeyboardEvent::windowID
Uint32 windowID
Definition: SDL_events.h:191
SDL_GL_STEREO
Definition: SDL_video.h:183
SDL_CONTROLLERBUTTONUP
Definition: SDL_events.h:119
SDLTest_CommonState::windows
SDL_Window ** windows
Definition: SDL_test_common.h:78
SDLK_MINUS
Definition: SDL_keycode.h:68
SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:189
SDLTest_CommonState::scale
float scale
Definition: SDL_test_common.h:74
SDL_TouchFingerEvent::dy
float dy
Definition: SDL_events.h:419
SDL_SetWindowIcon
#define SDL_SetWindowIcon
Definition: SDL_dynapi_overrides.h:525
SDL_PIXELFORMAT_YVYU
Definition: SDL_pixels.h:271
SDL_GetNumVideoDisplays
#define SDL_GetNumVideoDisplays
Definition: SDL_dynapi_overrides.h:505
SDL_JOYDEVICEREMOVED
Definition: SDL_events.h:114
SDL_PIXELFORMAT_RGB332
Definition: SDL_pixels.h:187
SDL_Direct3D9GetAdapterIndex
int SDL_Direct3D9GetAdapterIndex(int displayIndex)
Returns the D3D9 adapter index that matches the specified display index.
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
SDLTest_CommonState::flags
Uint32 flags
Definition: SDL_test_common.h:55
SDLK_1
Definition: SDL_keycode.h:72
SDL_DOLLARGESTURE
Definition: SDL_events.h:130
SDL_WINDOWEVENT_FOCUS_GAINED
Definition: SDL_video.h:155
SDL_Event::window
SDL_WindowEvent window
Definition: SDL_events.h:525
SDLTest_CommonState::num_windows
int num_windows
Definition: SDL_test_common.h:77
VERBOSE_AUDIO
#define VERBOSE_AUDIO
Definition: SDL_test_common.h:49
SDL_PIXELFORMAT_RGBA8888
Definition: SDL_pixels.h:250
SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:191
renderer
SDL_Renderer * renderer
Definition: testautomation_render.c:27
SDL_RENDER_DEVICE_RESET
Definition: SDL_events.h:146
SDL_GL_SetAttribute
#define SDL_GL_SetAttribute
Definition: SDL_dynapi_overrides.h:561
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:531
SDL_PIXELFORMAT_NV12
Definition: SDL_pixels.h:273
SDL_MouseMotionEvent::yrel
Sint32 yrel
Definition: SDL_events.h:239
SDLTest_CommonState::window_flags
Uint32 window_flags
Definition: SDL_test_common.h:63
SDL_WINDOW_MOUSE_CAPTURE
Definition: SDL_video.h:112
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_HAT_RIGHT
#define SDL_HAT_RIGHT
Definition: SDL_joystick.h:209
SDL_JoyBallEvent::which
SDL_JoystickID which
Definition: SDL_events.h:296
SDLK_c
Definition: SDL_keycode.h:99
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:37
SDL_MouseButtonEvent::button
Uint8 button
Definition: SDL_events.h:251
SDL_GetRelativeMouseMode
#define SDL_GetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:256
SDL_FINGERDOWN
Definition: SDL_events.h:125
SDL_PIXELFORMAT_INDEX8
Definition: SDL_pixels.h:185
SDL_Event::text
SDL_TextInputEvent text
Definition: SDL_events.h:528
SDL_calloc
void * SDL_calloc(size_t nmemb, size_t size)
SDL_PIXELFORMAT_BGR555
Definition: SDL_pixels.h:196
SDL_MouseMotionEvent::xrel
Sint32 xrel
Definition: SDL_events.h:238
SDL_PRIs64
#define SDL_PRIs64
Definition: SDL_stdinc.h:175
SDL_TextInputEvent::text
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]
Definition: SDL_events.h:223
SDL_ShowSimpleMessageBox
#define SDL_ShowSimpleMessageBox
Definition: SDL_dynapi_overrides.h:250
SDL_AudioSpec::freq
int freq
Definition: SDL_audio.h:170
SDL_GetClipboardText
#define SDL_GetClipboardText
Definition: SDL_dynapi_overrides.h:105
SDL_PIXELFORMAT_INDEX4MSB
Definition: SDL_pixels.h:182
SDL_HAT_RIGHTDOWN
#define SDL_HAT_RIGHTDOWN
Definition: SDL_joystick.h:213
SDLTest_CommonState::display
int display
Definition: SDL_test_common.h:60
ControllerButtonName
static const char * ControllerButtonName(const SDL_GameControllerButton button)
Definition: SDL_test_common.c:979
SDLTest_CommonState::gl_retained_backing
int gl_retained_backing
Definition: SDL_test_common.h:107
SDL_VideoInit
#define SDL_VideoInit
Definition: SDL_dynapi_overrides.h:502
SDLTest_CommonState::gl_multisamplebuffers
int gl_multisamplebuffers
Definition: SDL_test_common.h:105
SDL_GL_STENCIL_SIZE
Definition: SDL_video.h:178
SDL_WINDOWPOS_UNDEFINED_DISPLAY
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X)
Definition: SDL_video.h:119
SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:188
SDL_atof
#define SDL_atof
Definition: SDL_dynapi_overrides.h:417
SDLTest_PrintRenderer
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
Definition: SDL_test_common.c:588
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1567
SDL_SetWindowGrab
#define SDL_SetWindowGrab
Definition: SDL_dynapi_overrides.h:547
SDL_isdigit
#define SDL_isdigit
Definition: SDL_dynapi_overrides.h:388
SDL_JOYBUTTONDOWN
Definition: SDL_events.h:111
SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:253
KMOD_SHIFT
#define KMOD_SHIFT
Definition: SDL_keycode.h:335
SDL_HAT_LEFT
#define SDL_HAT_LEFT
Definition: SDL_joystick.h:211
SDL_AudioSpec::channels
Uint8 channels
Definition: SDL_audio.h:172
SDLTest_CommonState::gl_depth_size
int gl_depth_size
Definition: SDL_test_common.h:97
SDL_GL_MULTISAMPLEBUFFERS
Definition: SDL_video.h:184
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_WINDOWEVENT_RESTORED
Definition: SDL_video.h:151
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:450
SDL_TouchFingerEvent::x
float x
Definition: SDL_events.h:416
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_MultiGestureEvent::numFingers
Uint16 numFingers
Definition: SDL_events.h:436
SDL_Event::mgesture
SDL_MultiGestureEvent mgesture
Definition: SDL_events.h:545
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_free
void SDL_free(void *mem)
SDL_GL_RETAINED_BACKING
Definition: SDL_video.h:187
SDLTest_CommonEvent
void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done)
Common event handler for test windows.
Definition: SDL_test_common.c:1295
SDL_KEYUP
Definition: SDL_events.h:94
SDLK_b
Definition: SDL_keycode.h:98
SDL_RenderSetLogicalSize
#define SDL_RenderSetLogicalSize
Definition: SDL_dynapi_overrides.h:328
SDL_PIXELFORMAT_ABGR4444
Definition: SDL_pixels.h:205
SDL_Quit
#define SDL_Quit
Definition: SDL_dynapi_overrides.h:64
done
int done
Definition: checkkeys.c:28
SDL_WINDOW_ALLOW_HIGHDPI
Definition: SDL_video.h:111
SDL_WindowEvent::data2
Sint32 data2
Definition: SDL_events.h:181
SDLTest_CommonQuit
void SDLTest_CommonQuit(SDLTest_CommonState *state)
Close test window.
Definition: SDL_test_common.c:1560
SDLTest_CommonState::window_h
int window_h
Definition: SDL_test_common.h:67
SDL_GL_ALPHA_SIZE
Definition: SDL_video.h:174
SDLTest_CommonState::refresh_rate
int refresh_rate
Definition: SDL_test_common.h:76
SDL_MouseWheelEvent::windowID
Uint32 windowID
Definition: SDL_events.h:266
SDL_WINDOWEVENT_FOCUS_LOST
Definition: SDL_video.h:156
SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:172
SDL_BUTTON_X1MASK
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:288
SDL_RenderGetViewport
#define SDL_RenderGetViewport
Definition: SDL_dynapi_overrides.h:331
SDLK_r
Definition: SDL_keycode.h:114
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
VIDEO_USAGE
#define VIDEO_USAGE
Definition: SDL_test_common.c:29
SDL_GetDisplayBounds
#define SDL_GetDisplayBounds
Definition: SDL_dynapi_overrides.h:507
SDLTest_CommonState::depth
int depth
Definition: SDL_test_common.h:75
SDLTest_CommonCreateState
SDLTest_CommonState * SDLTest_CommonCreateState(char **argv, Uint32 flags)
Parse command line parameters and create common state.
Definition: SDL_test_common.c:36
SDL_WINDOWEVENT
Definition: SDL_events.h:89
SDLTest_CommonState::window_minH
int window_minH
Definition: SDL_test_common.h:69
SDLTest_CommonState::gl_multisamplesamples
int gl_multisamplesamples
Definition: SDL_test_common.h:106
SDL_LOG_CATEGORY_AUDIO
Definition: SDL_log.h:70
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
DEFAULT_WINDOW_HEIGHT
#define DEFAULT_WINDOW_HEIGHT
Definition: SDL_test_common.h:42
SDL_CONTROLLERBUTTONDOWN
Definition: SDL_events.h:118
SDLTest_CommonState::gl_profile_mask
int gl_profile_mask
Definition: SDL_test_common.h:112
SDL_BUTTON_LMASK
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:285
SDL_DisplayMode::h
int h
Definition: SDL_video.h:57
SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:104
BUTTON_CASE
#define BUTTON_CASE(btn)
SDL_SetColorKey
#define SDL_SetColorKey
Definition: SDL_dynapi_overrides.h:457
SDL_GetAudioDriver
#define SDL_GetAudioDriver
Definition: SDL_dynapi_overrides.h:80
SDL_TextInputEvent::windowID
Uint32 windowID
Definition: SDL_events.h:222
SDL_PixelFormatEnumToMasks
#define SDL_PixelFormatEnumToMasks
Definition: SDL_dynapi_overrides.h:284
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_WindowEvent::event
Uint8 event
Definition: SDL_events.h:176
SDL_KeyboardEvent::keysym
SDL_Keysym keysym
Definition: SDL_events.h:196
SDL_UserEvent::code
Sint32 code
Definition: SDL_events.h:496
SDL_WINDOWEVENT_LEAVE
Definition: SDL_video.h:154
SDL_GetWindowFromID
#define SDL_GetWindowFromID
Definition: SDL_dynapi_overrides.h:521
SDL_TRUE
Definition: SDL_stdinc.h:129
SDLTest_PrintRendererFlag
static void SDLTest_PrintRendererFlag(Uint32 flag)
Definition: SDL_test_common.c:466
SDL_GL_ACCUM_GREEN_SIZE
Definition: SDL_video.h:180
SDL_FINGERMOTION
Definition: SDL_events.h:127
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_GL_DEPTH_SIZE
Definition: SDL_video.h:177
SDLK_PRINTSCREEN
Definition: SDL_keycode.h:139
SDL_RenderSetScale
#define SDL_RenderSetScale
Definition: SDL_dynapi_overrides.h:334
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:416
mask
GLenum GLint GLuint mask
Definition: SDL_opengl_glext.h:657
SDL_WINDOWEVENT_CLOSE
Definition: SDL_video.h:157
SDLTest_CommonState
Definition: SDL_test_common.h:51
index
GLuint index
Definition: SDL_opengl_glext.h:660
SDLTest_CommonState::gl_green_size
int gl_green_size
Definition: SDL_test_common.h:93
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:490
SDL_RestoreWindow
#define SDL_RestoreWindow
Definition: SDL_dynapi_overrides.h:542
SDLTest_CommonState::renderers
SDL_Renderer ** renderers
Definition: SDL_test_common.h:84
SDLTest_PrintEvent
static void SDLTest_PrintEvent(SDL_Event *event)
Definition: SDL_test_common.c:1006
SDL_WINDOWPOS_CENTERED_DISPLAY
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:128
SDLTest_CommonUsage
const char * SDLTest_CommonUsage(SDLTest_CommonState *state)
Returns common usage information.
Definition: SDL_test_common.c:451
SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:192
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:42
SDL_GL_DOUBLEBUFFER
Definition: SDL_video.h:176
SDLK_m
Definition: SDL_keycode.h:109
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:242
SDL_GetCurrentAudioDriver
#define SDL_GetCurrentAudioDriver
Definition: SDL_dynapi_overrides.h:83
SDLTest_CommonState::window_maxW
int window_maxW
Definition: SDL_test_common.h:70
NULL
#define NULL
Definition: begin_code.h:143
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_GetCurrentVideoDriver
#define SDL_GetCurrentVideoDriver
Definition: SDL_dynapi_overrides.h:504
SDL_SetWindowBordered
#define SDL_SetWindowBordered
Definition: SDL_dynapi_overrides.h:536
SDL_WINDOW_RESIZABLE
Definition: SDL_video.h:103
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
VERBOSE_MODES
#define VERBOSE_MODES
Definition: SDL_test_common.h:46
SDL_ControllerButtonEvent::button
Uint8 button
Definition: SDL_events.h:375
SDL_WINDOW_BORDERLESS
Definition: SDL_video.h:102
SDL_FINGERUP
Definition: SDL_events.h:126
SDL_GetVideoDriver
#define SDL_GetVideoDriver
Definition: SDL_dynapi_overrides.h:501
SDL_RendererInfo
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:78
SDLK_2
Definition: SDL_keycode.h:73
SDL_MOUSEMOTION
Definition: SDL_events.h:102
SDL_PIXELFORMAT_INDEX1MSB
Definition: SDL_pixels.h:176
text
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:34
SDLTest_CommonState::gl_blue_size
int gl_blue_size
Definition: SDL_test_common.h:94
SDLK_v
Definition: SDL_keycode.h:118
VERBOSE_RENDER
#define VERBOSE_RENDER
Definition: SDL_test_common.h:47
SDL_MouseMotionEvent
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:229
SDL_JoyHatEvent::hat
Uint8 hat
Definition: SDL_events.h:313
SDL_CreateRGBSurface
#define SDL_CreateRGBSurface
Definition: SDL_dynapi_overrides.h:448
SDLTest_CommonState::audiodriver
const char * audiodriver
Definition: SDL_test_common.h:88
SDL_GetScancodeName
#define SDL_GetScancodeName
Definition: SDL_dynapi_overrides.h:228
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:76
SDL_JoyDeviceEvent::which
Sint32 which
Definition: SDL_events.h:346
SDL_WINDOWEVENT_SHOWN
Definition: SDL_video.h:139
SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:263
SDL_TEXTINPUT
Definition: SDL_events.h:96
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:223
SDL_Event::key
SDL_KeyboardEvent key
Definition: SDL_events.h:526
SDL_DestroyTexture
#define SDL_DestroyTexture
Definition: SDL_dynapi_overrides.h:353
SDLTest_CommonState::gl_stencil_size
int gl_stencil_size
Definition: SDL_test_common.h:98
SDL_Event::cbutton
SDL_ControllerButtonEvent cbutton
Definition: SDL_events.h:538
SDL_ControllerAxisEvent::axis
Uint8 axis
Definition: SDL_events.h:358
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:265
SDL_HAT_LEFTUP
#define SDL_HAT_LEFTUP
Definition: SDL_joystick.h:214
SDL_AudioSpec::format
SDL_AudioFormat format
Definition: SDL_audio.h:171
SDL_MouseMotionEvent::windowID
Uint32 windowID
Definition: SDL_events.h:233
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:71
SDL_WINDOW_MAXIMIZED
Definition: SDL_video.h:105
SDL_GetWindowGrab
#define SDL_GetWindowGrab
Definition: SDL_dynapi_overrides.h:548
SDL_TouchFingerEvent::y
float y
Definition: SDL_events.h:417
SDL_PIXELFORMAT_RGB444
Definition: SDL_pixels.h:190
viewport
SDL_Rect viewport
Definition: testviewport.c:28
SDL_VideoQuit
#define SDL_VideoQuit
Definition: SDL_dynapi_overrides.h:503
SDL_MouseWheelEvent::x
Sint32 x
Definition: SDL_events.h:268
SDL_FALSE
Definition: SDL_stdinc.h:128
SDLTest_CommonState::logical_h
int logical_h
Definition: SDL_test_common.h:73
SDL_CaptureMouse
#define SDL_CaptureMouse
Definition: SDL_dynapi_overrides.h:588
SDL_WINDOW_FULLSCREEN
Definition: SDL_video.h:98
SDL_GL_MULTISAMPLESAMPLES
Definition: SDL_video.h:185
SDL_JoyHatEvent::value
Uint8 value
Definition: SDL_events.h:314
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
SDL_WINDOWEVENT_ENTER
Definition: SDL_video.h:153
SDL_GetKeyName
#define SDL_GetKeyName
Definition: SDL_dynapi_overrides.h:230
SDL_WINDOWEVENT_EXPOSED
Definition: SDL_video.h:141
SDL_TouchFingerEvent::fingerId
SDL_FingerID fingerId
Definition: SDL_events.h:415
SDL_Keysym::sym
SDL_Keycode sym
Definition: SDL_keyboard.h:50
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
ControllerAxisName
static const char * ControllerAxisName(const SDL_GameControllerAxis axis)
Definition: SDL_test_common.c:961
SDL_GetGlobalMouseState
#define SDL_GetGlobalMouseState
Definition: SDL_dynapi_overrides.h:590
SDL_LogSetAllPriority
#define SDL_LogSetAllPriority
Definition: SDL_dynapi_overrides.h:241
SDL_Event::button
SDL_MouseButtonEvent button
Definition: SDL_events.h:530
SDL_MouseButtonEvent::x
Sint32 x
Definition: SDL_events.h:255
SDLTest_ScreenShot
static void SDLTest_ScreenShot(SDL_Renderer *renderer)
Definition: SDL_test_common.c:1236
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
SDL_PIXELFORMAT_RGB24
Definition: SDL_pixels.h:229
SDLTest_CommonState::gl_alpha_size
int gl_alpha_size
Definition: SDL_test_common.h:95
SDL_RendererInfo::num_texture_formats
Uint32 num_texture_formats
Definition: SDL_render.h:82
SDL_snprintf
#define SDL_snprintf
Definition: SDL_dynapi_overrides.h:46
SDLTest_CommonState::window_maxH
int window_maxH
Definition: SDL_test_common.h:71
SDL_PIXELFORMAT_UYVY
Definition: SDL_pixels.h:269
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_Event
General event structure.
Definition: SDL_events.h:521
SDL_MouseWheelEvent::y
Sint32 y
Definition: SDL_events.h:269
SDL_WINDOW_OPENGL
Definition: SDL_video.h:99
SDL_RenderSetClipRect
#define SDL_RenderSetClipRect
Definition: SDL_dynapi_overrides.h:332
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:380
SDL_WINDOWEVENT_RESIZED
Definition: SDL_video.h:145
SDL_Event::user
SDL_UserEvent user
Definition: SDL_events.h:542
SDL_GetNumDisplayModes
#define SDL_GetNumDisplayModes
Definition: SDL_dynapi_overrides.h:509
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:302
SDL_DestroyRenderer
#define SDL_DestroyRenderer
Definition: SDL_dynapi_overrides.h:354
SDL_MaximizeWindow
#define SDL_MaximizeWindow
Definition: SDL_dynapi_overrides.h:540
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:423
SDL_PIXELFORMAT_YUY2
Definition: SDL_pixels.h:267
SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:256
FullscreenTo
static void FullscreenTo(int index, int windowId)
Definition: SDL_test_common.c:1273
SDL_DisplayMode::format
Uint32 format
Definition: SDL_video.h:55
Sint64
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:160
SDL_JoyBallEvent::yrel
Sint16 yrel
Definition: SDL_events.h:302
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:301
SDL_Event::jhat
SDL_JoyHatEvent jhat
Definition: SDL_events.h:534
SDL_RENDER_TARGETS_RESET
Definition: SDL_events.h:145
SDL_JoyButtonEvent::button
Uint8 button
Definition: SDL_events.h:333
SDLTest_CommonState::gl_accum_red_size
int gl_accum_red_size
Definition: SDL_test_common.h:100
SDLTest_CommonState::gl_red_size
int gl_red_size
Definition: SDL_test_common.h:92
SDLTest_CommonState::gl_accum_green_size
int gl_accum_green_size
Definition: SDL_test_common.h:101
SDL_HAT_CENTERED
#define SDL_HAT_CENTERED
Definition: SDL_joystick.h:207
SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:207
SDL_LOG_CATEGORY_ERROR
Definition: SDL_log.h:67
SDLK_z
Definition: SDL_keycode.h:122
SDLTest_CommonState::gl_major_version
int gl_major_version
Definition: SDL_test_common.h:109
SDL_PIXELFORMAT_ABGR1555
Definition: SDL_pixels.h:217
AUDIO_U16
#define AUDIO_U16
Definition: SDL_audio.h:95
SDLK_ESCAPE
Definition: SDL_keycode.h:52
SDL_WindowEvent::data1
Sint32 data1
Definition: SDL_events.h:180
VERBOSE_VIDEO
#define VERBOSE_VIDEO
Definition: SDL_test_common.h:45
SDL_MouseButtonEvent::windowID
Uint32 windowID
Definition: SDL_events.h:249
SDL_GL_GREEN_SIZE
Definition: SDL_video.h:172
SDL_CLIPBOARDUPDATE
Definition: SDL_events.h:135
SDL_BUTTON_MMASK
#define SDL_BUTTON_MMASK
Definition: SDL_mouse.h:286
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
SDL_WINDOWEVENT_MOVED
Definition: SDL_video.h:143
SDL_CONTROLLERAXISMOTION
Definition: SDL_events.h:117
SDLTest_CommonState::gl_accum_alpha_size
int gl_accum_alpha_size
Definition: SDL_test_common.h:103
SDL_HAT_UP
#define SDL_HAT_UP
Definition: SDL_joystick.h:208
SDL_DestroyWindow
#define SDL_DestroyWindow
Definition: SDL_dynapi_overrides.h:553
SDL_GL_BLUE_SIZE
Definition: SDL_video.h:173
SDL_HAT_DOWN
#define SDL_HAT_DOWN
Definition: SDL_joystick.h:210
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_BYTEORDER
#define SDL_BYTEORDER
Definition: SDL_config_pandora.h:36
SDL_GL_BUFFER_SIZE
Definition: SDL_video.h:175
DEFAULT_WINDOW_WIDTH
#define DEFAULT_WINDOW_WIDTH
Definition: SDL_test_common.h:41
SDL_JoyHatEvent::which
SDL_JoystickID which
Definition: SDL_events.h:312
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDLTest_CommonState::videodriver
const char * videodriver
Definition: SDL_test_common.h:59
SDL_GameControllerAxis
SDL_GameControllerAxis
Definition: SDL_gamecontroller.h:218
SDL_SetWindowPosition
#define SDL_SetWindowPosition
Definition: SDL_dynapi_overrides.h:528
SDL_WindowEvent::windowID
Uint32 windowID
Definition: SDL_events.h:175
SDL_WINDOW_INPUT_GRABBED
Definition: SDL_video.h:106
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SDLK_SPACE
Definition: SDL_keycode.h:55
SDL_DOLLARRECORD
Definition: SDL_events.h:131
SDL_WINDOW_FULLSCREEN_DESKTOP
Definition: SDL_video.h:109
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:77
SDL_CreateRenderer
#define SDL_CreateRenderer
Definition: SDL_dynapi_overrides.h:307
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
SDL_GetRendererInfo
#define SDL_GetRendererInfo
Definition: SDL_dynapi_overrides.h:310
SDLTest_CommonState::gl_debug
int gl_debug
Definition: SDL_test_common.h:111
SDLTest_CommonArg
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
Definition: SDL_test_common.c:83
SDL_SetClipboardText
#define SDL_SetClipboardText
Definition: SDL_dynapi_overrides.h:104
SDLTest_CommonState::window_minW
int window_minW
Definition: SDL_test_common.h:68
SDL_Event::type
Uint32 type
Definition: SDL_events.h:523
SDL_PIXELFORMAT_ARGB1555
Definition: SDL_pixels.h:211
SDLTest_CommonState::gl_accum_blue_size
int gl_accum_blue_size
Definition: SDL_test_common.h:102
SDL_MULTIGESTURE
Definition: SDL_events.h:132
SDLTest_CommonState::render_flags
Uint32 render_flags
Definition: SDL_test_common.h:82
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
SDLTest_CommonState::logical_w
int logical_w
Definition: SDL_test_common.h:72
SDL_PIXELFORMAT_BGR565
Definition: SDL_pixels.h:226
SDL_Event::tfinger
SDL_TouchFingerEvent tfinger
Definition: SDL_events.h:544
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:42
SDL_MouseWheelEvent::direction
Uint32 direction
Definition: SDL_events.h:270
SDLTest_CommonState::window_title
const char * window_title
Definition: SDL_test_common.h:61
SDL_GetPixelFormatName
#define SDL_GetPixelFormatName
Definition: SDL_dynapi_overrides.h:283
SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:193