LOVE/megasource
1
0
Fork 0
mirror of https://github.com/love2d/megasource.git synced 2026-08-17 11:11:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

update SDL to libsdl-org/SDL@b8036bd

Browse Source
This commit is contained in:
Sasha Szpakowski
2024-12-25 20:18:57 -04:00
parent a275d78e12
commit f27a1c24b3
426 changed files with 22204 additions and 16006 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/SDL3/test/CMakeLists.txt
+2
View File
@@ -331,6 +331,7 @@ files2headers(gamepad_image_headers
files2headers(icon_bmp_header icon.bmp)
files2headers(glass_bmp_header glass.bmp)
add_sdl_test_executable(testasyncio MAIN_CALLBACKS NEEDS_RESOURCES TESTUTILS SOURCES testasyncio.c)
add_sdl_test_executable(testaudio MAIN_CALLBACKS NEEDS_RESOURCES TESTUTILS SOURCES testaudio.c)
add_sdl_test_executable(testcolorspace SOURCES testcolorspace.c)
add_sdl_test_executable(testfile NONINTERACTIVE SOURCES testfile.c)
@@ -406,6 +407,7 @@ add_sdl_test_executable(testdialog SOURCES testdialog.c)
add_sdl_test_executable(testtime SOURCES testtime.c)
add_sdl_test_executable(testmanymouse SOURCES testmanymouse.c)
add_sdl_test_executable(testmodal SOURCES testmodal.c)
add_sdl_test_executable(testtray SOURCES testtray.c)
add_sdl_test_executable(testprocess
libs/SDL3/test/LICENSE.txt
+8
View File
@@ -34,6 +34,14 @@ Thanks to Will for permitting us to distribute this sample with SDL!
This directory contains sword.wav:
sword04.wav by Erdie
Original: https://freesound.org/s/27858/
License: https://creativecommons.org/licenses/by/4.0/
The .bmp files used by testaudio.c were made by AlDraw:
https://linktr.ee/AlexDraw
libs/SDL3/test/sdl-test_round.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 144 KiB

libs/SDL3/test/sword.wav
BIN
View File
Binary file not shown.
libs/SDL3/test/testasyncio.c
+191
View File
@@ -0,0 +1,191 @@
/*
Copyright (C) 1997-2024 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.
*/
#define SDL_MAIN_USE_CALLBACKS 1
#include <SDL3/SDL_main.h>
#include <SDL3/SDL_test.h>
#include <SDL3/SDL_test_common.h>
static SDL_Renderer *renderer = NULL;
static SDL_Texture *texture = NULL;
static SDL_AsyncIOQueue *queue = NULL;
static SDLTest_CommonState *state = NULL;
SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
const char *base = NULL;
SDL_AsyncIO *asyncio = NULL;
char **bmps = NULL;
int bmpcount = 0;
int i;
SDL_srand(0);
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return SDL_APP_FAILURE;
}
/* Enable standard application logging */
SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Parse commandline */
for (i = 1; i < argc;) {
int consumed = SDLTest_CommonArg(state, i);
if (consumed <= 0) {
static const char *options[] = {
NULL,
};
SDLTest_CommonLogUsage(state, argv[0], options);
SDL_Quit();
SDLTest_CommonDestroyState(state);
return 1;
}
i += consumed;
}
state->num_windows = 1;
/* Load the SDL library */
if (!SDLTest_CommonInit(state)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s", SDL_GetError());
return SDL_APP_FAILURE;
}
SDL_SetLogPriorities(SDL_LOG_PRIORITY_VERBOSE);
renderer = state->renderers[0];
if (!renderer) {
/* SDL_Log("Couldn't create renderer: %s", SDL_GetError()); */
return SDL_APP_FAILURE;
}
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STATIC, 512, 512);
if (!texture) {
SDL_Log("Couldn't create texture: %s", SDL_GetError());
return SDL_APP_FAILURE;
} else {
static const Uint32 blank[512 * 512];
const SDL_Rect rect = { 0, 0, 512, 512 };
SDL_UpdateTexture(texture, &rect, blank, 512 * sizeof (Uint32));
}
queue = SDL_CreateAsyncIOQueue();
if (!queue) {
SDL_Log("Couldn't create async i/o queue: %s", SDL_GetError());
return SDL_APP_FAILURE;
}
base = SDL_GetBasePath();
bmps = SDL_GlobDirectory(base, "*.bmp", SDL_GLOB_CASEINSENSITIVE, &bmpcount);
if (!bmps || (bmpcount == 0)) {
SDL_Log("No BMP files found.");
return SDL_APP_FAILURE;
}
for (i = 0; i < bmpcount; i++) {
char *path = NULL;
if (SDL_asprintf(&path, "%s%s", base, bmps[i]) < 0) {
SDL_free(path);
} else {
SDL_Log("Loading %s...", path);
SDL_LoadFileAsync(path, queue, path);
}
}
SDL_free(bmps);
SDL_Log("Opening asyncio.tmp...");
asyncio = SDL_AsyncIOFromFile("asyncio.tmp", "w");
if (!asyncio) {
SDL_Log("Failed!");
return SDL_APP_FAILURE;
}
SDL_WriteAsyncIO(asyncio, "hello", 0, 5, queue, "asyncio.tmp (write)");
SDL_CloseAsyncIO(asyncio, true, queue, "asyncio.tmp (flush/close)");
return SDL_APP_CONTINUE;
}
SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
{
switch (event->type) {
case SDL_EVENT_QUIT:
return SDL_APP_SUCCESS;
default:
break;
}
return SDLTest_CommonEventMainCallbacks(state, event);
}
static void async_io_task_complete(const SDL_AsyncIOOutcome *outcome)
{
const char *fname = (const char *) outcome->userdata;
const char *resultstr = "[unknown result]";
switch (outcome->result) {
#define RESCASE(x) case x: resultstr = #x; break
RESCASE(SDL_ASYNCIO_COMPLETE);
RESCASE(SDL_ASYNCIO_FAILURE);
RESCASE(SDL_ASYNCIO_CANCELLED);
#undef RESCASE
}
SDL_Log("File '%s' async results: %s", fname, resultstr);
if (SDL_strncmp(fname, "asyncio.tmp", 11) == 0) {
return;
}
if (outcome->result == SDL_ASYNCIO_COMPLETE) {
SDL_Surface *surface = SDL_LoadBMP_IO(SDL_IOFromConstMem(outcome->buffer, (size_t) outcome->bytes_transferred), true);
if (surface) {
SDL_Surface *converted = SDL_ConvertSurface(surface, SDL_PIXELFORMAT_RGBA8888);
SDL_DestroySurface(surface);
if (converted) {
const SDL_Rect rect = { 50 + SDL_rand(512 - 100), 50 + SDL_rand(512 - 100), converted->w, converted->h };
SDL_UpdateTexture(texture, &rect, converted->pixels, converted->pitch);
SDL_DestroySurface(converted);
}
}
}
SDL_free(outcome->userdata);
SDL_free(outcome->buffer);
}
SDL_AppResult SDL_AppIterate(void *appstate)
{
SDL_AsyncIOOutcome outcome;
if (SDL_GetAsyncIOResult(queue, &outcome)) {
async_io_task_complete(&outcome);
}
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
SDL_RenderTexture(renderer, texture, NULL, NULL);
SDL_RenderPresent(renderer);
return SDL_APP_CONTINUE;
}
void SDL_AppQuit(void *appstate, SDL_AppResult result)
{
SDL_DestroyAsyncIOQueue(queue);
SDL_DestroyTexture(texture);
SDL_RemovePath("asyncio.tmp");
SDLTest_CommonQuit(state);
}
libs/SDL3/test/testautomation_events.c
+61
View File
@@ -203,6 +203,62 @@ static int SDLCALL events_addDelEventWatchWithUserdata(void *arg)
return TEST_COMPLETED;
}
/**
* Runs callbacks on the main thread.
*
* \sa SDL_IsMainThread
* \sa SDL_RunOnMainThread
*
*/
static void SDLCALL IncrementCounter(void *userdata)
{
int *value = (int *)userdata;
*value = *value + 1;
}
#ifndef SDL_PLATFORM_EMSCRIPTEN /* Emscripten doesn't have threads */
static int SDLCALL IncrementCounterThread(void *userdata)
{
SDL_assert(!SDL_IsMainThread());
SDL_RunOnMainThread(IncrementCounter, userdata, false);
SDL_RunOnMainThread(IncrementCounter, userdata, true);
return 0;
}
#endif /* !SDL_PLATFORM_EMSCRIPTEN */
static int SDLCALL events_mainThreadCallbacks(void *arg)
{
int counter = 0;
/* Make sure we're on the main thread */
SDLTest_AssertCheck(SDL_IsMainThread(), "Verify we're on the main thread");
SDL_RunOnMainThread(IncrementCounter, &counter, true);
SDLTest_AssertCheck(counter == 1, "Incremented counter on main thread, expected 1, got %d", counter);
#ifndef SDL_PLATFORM_EMSCRIPTEN /* Emscripten doesn't have threads */
{
SDL_Thread *thread;
thread = SDL_CreateThread(IncrementCounterThread, NULL, &counter);
SDLTest_AssertCheck(thread != NULL, "Create counter thread");
/* Wait for both increment calls to be queued up */
SDL_Delay(100);
/* Run the main callbacks */
while (counter < 3) {
SDL_PumpEvents();
}
SDL_WaitThread(thread, NULL);
SDLTest_AssertCheck(counter == 3, "Incremented counter on main thread, expected 3, got %d", counter);
}
#endif /* !SDL_PLATFORM_EMSCRIPTEN */
return TEST_COMPLETED;
}
/* ================= Test References ================== */
/* Events test cases */
@@ -218,11 +274,16 @@ static const SDLTest_TestCaseReference eventsTest_addDelEventWatchWithUserdata =
events_addDelEventWatchWithUserdata, "events_addDelEventWatchWithUserdata", "Adds and deletes an event watch function with userdata", TEST_ENABLED
};
static const SDLTest_TestCaseReference eventsTest_mainThreadCallbacks = {
events_mainThreadCallbacks, "events_mainThreadCallbacks", "Run callbacks on the main thread", TEST_ENABLED
};
/* Sequence of Events test cases */
static const SDLTest_TestCaseReference *eventsTests[] = {
&eventsTest_pushPumpAndPollUserevent,
&eventsTest_addDelEventWatch,
&eventsTest_addDelEventWatchWithUserdata,
&eventsTest_mainThreadCallbacks,
NULL
};
libs/SDL3/test/testautomation_hints.c
-2
View File
@@ -11,7 +11,6 @@ static const char *HintsEnum[] = {
SDL_HINT_GAMECONTROLLERCONFIG,
SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS,
SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK,
SDL_HINT_MOUSE_RELATIVE_MODE_WARP,
SDL_HINT_ORIENTATIONS,
SDL_HINT_RENDER_DIRECT3D_THREADSAFE,
SDL_HINT_RENDER_VSYNC,
@@ -28,7 +27,6 @@ static const char *HintsVerbose[] = {
"SDL_GAMECONTROLLERCONFIG",
"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK",
"SDL_MOUSE_RELATIVE_MODE_WARP",
"SDL_ORIENTATIONS",
"SDL_RENDER_DIRECT3D_THREADSAFE",
"SDL_RENDER_VSYNC",
libs/SDL3/test/testautomation_keyboard.c
+2 -2
View File
@@ -124,9 +124,9 @@ static int SDLCALL keyboard_getKeyFromScancode(void *arg)
SDL_Keycode result;
/* Case where input is valid */
result = SDL_GetKeyFromScancode(SDL_SCANCODE_A, SDL_KMOD_NONE, false);
result = SDL_GetKeyFromScancode(SDL_SCANCODE_SPACE, SDL_KMOD_NONE, false);
SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(valid)");
SDLTest_AssertCheck(result == SDLK_A, "Verify result from call, expected: %d, got: %" SDL_PRIu32, SDLK_A, result);
SDLTest_AssertCheck(result == SDLK_SPACE, "Verify result from call, expected: %d, got: %" SDL_PRIu32, SDLK_SPACE, result);
/* Case where input is zero */
result = SDL_GetKeyFromScancode(SDL_SCANCODE_UNKNOWN, SDL_KMOD_NONE, false);
libs/SDL3/test/testautomation_pixels.c
+662 -73
View File
@@ -101,6 +101,27 @@ static const char *g_AllFormatsVerbose[] = {
"SDL_PIXELFORMAT_NV21"
};
static const SDL_PixelFormat g_AllLargeFormats[] = {
SDL_PIXELFORMAT_RGB48,
SDL_PIXELFORMAT_BGR48,
SDL_PIXELFORMAT_RGBA64,
SDL_PIXELFORMAT_ARGB64,
SDL_PIXELFORMAT_BGRA64,
SDL_PIXELFORMAT_ABGR64,
SDL_PIXELFORMAT_RGB48_FLOAT,
SDL_PIXELFORMAT_BGR48_FLOAT,
SDL_PIXELFORMAT_RGBA64_FLOAT,
SDL_PIXELFORMAT_ARGB64_FLOAT,
SDL_PIXELFORMAT_BGRA64_FLOAT,
SDL_PIXELFORMAT_ABGR64_FLOAT,
SDL_PIXELFORMAT_RGB96_FLOAT,
SDL_PIXELFORMAT_BGR96_FLOAT,
SDL_PIXELFORMAT_RGBA128_FLOAT,
SDL_PIXELFORMAT_ARGB128_FLOAT,
SDL_PIXELFORMAT_BGRA128_FLOAT,
SDL_PIXELFORMAT_ABGR128_FLOAT
};
/* Definition of some invalid formats for negative tests */
static Uint32 g_invalidPixelFormats[] = {
SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1010102 + 1, 32, 4),
@@ -114,68 +135,510 @@ static const char *g_invalidPixelFormatsVerbose[] = {
/* Verify the pixel formats are laid out as expected */
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_FORMAT, SDL_PIXELFORMAT_INDEX1LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0, 1, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1LSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX1LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_FORMAT, SDL_PIXELFORMAT_INDEX1MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0, 1, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX1MSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX1MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_FORMAT, SDL_PIXELFORMAT_INDEX2LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX2, SDL_BITMAPORDER_4321, 0, 2, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2LSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX2LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_FORMAT, SDL_PIXELFORMAT_INDEX2MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX2, SDL_BITMAPORDER_1234, 0, 2, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX2MSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX2MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_FORMAT, SDL_PIXELFORMAT_INDEX4LSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0, 4, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4LSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX4LSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_FORMAT, SDL_PIXELFORMAT_INDEX4MSB == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0, 4, 0));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX4MSB_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX4MSB));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_FORMAT, SDL_PIXELFORMAT_INDEX8 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_INDEXED, SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_INDEX8_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_INDEX8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_FORMAT, SDL_PIXELFORMAT_RGB332 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_332, 8, 1));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB332_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB332));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_FORMAT, SDL_PIXELFORMAT_XRGB4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_4444, 12, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB4444_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XRGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_FORMAT, SDL_PIXELFORMAT_XBGR4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_4444, 12, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR4444_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XBGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_FORMAT, SDL_PIXELFORMAT_XRGB1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_1555, 15, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB1555_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XRGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_FORMAT, SDL_PIXELFORMAT_XBGR1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_1555, 15, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR1555_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XBGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_FORMAT, SDL_PIXELFORMAT_ARGB4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_4444, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB4444_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_FORMAT, SDL_PIXELFORMAT_RGBA4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_4444, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA4444_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_FORMAT, SDL_PIXELFORMAT_ABGR4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_4444, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR4444_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_FORMAT, SDL_PIXELFORMAT_BGRA4444 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_4444, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA4444_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA4444));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_FORMAT, SDL_PIXELFORMAT_ARGB1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_1555, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB1555_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_FORMAT, SDL_PIXELFORMAT_RGBA5551 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_5551, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA5551_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_FORMAT, SDL_PIXELFORMAT_ABGR1555 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1555, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR1555_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR1555));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_FORMAT, SDL_PIXELFORMAT_BGRA5551 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_5551, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA5551_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA5551));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_FORMAT, SDL_PIXELFORMAT_RGB565 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_565, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB565_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_FORMAT, SDL_PIXELFORMAT_BGR565 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_565, 16, 2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR565_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGR565));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_FORMAT, SDL_PIXELFORMAT_RGB24 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0, 24, 3));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB24_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_FORMAT, SDL_PIXELFORMAT_BGR24 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0, 24, 3));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR24_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGR24));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_FORMAT, SDL_PIXELFORMAT_XRGB8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_8888, 24, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB8888_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XRGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_FORMAT, SDL_PIXELFORMAT_RGBX8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBX, SDL_PACKEDLAYOUT_8888, 24, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBX8888_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_FORMAT, SDL_PIXELFORMAT_XBGR8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_8888, 24, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR8888_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XBGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_FORMAT, SDL_PIXELFORMAT_BGRX8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRX, SDL_PACKEDLAYOUT_8888, 24, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRX8888_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRX8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_FORMAT, SDL_PIXELFORMAT_ARGB8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_8888, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB8888_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_FORMAT, SDL_PIXELFORMAT_RGBA8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_8888, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA8888_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_FORMAT, SDL_PIXELFORMAT_ABGR8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_8888, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR8888_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_FORMAT, SDL_PIXELFORMAT_BGRA8888 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_8888, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA8888_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA8888));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_FORMAT, SDL_PIXELFORMAT_XRGB2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_2101010, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_10BIT, SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XRGB2101010_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XRGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_FORMAT, SDL_PIXELFORMAT_XBGR2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_2101010, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_10BIT, SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_XBGR2101010_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_XBGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_FORMAT, SDL_PIXELFORMAT_ARGB2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_2101010, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_10BIT, SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB2101010_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_FORMAT, SDL_PIXELFORMAT_ABGR2101010 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_2101010, 32, 4));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_PACKED, SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_10BIT, SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR2101010_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR2101010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FORMAT, SDL_PIXELFORMAT_RGB48 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_RGB, 0, 48, 6));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FORMAT, SDL_PIXELFORMAT_BGR48 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_BGR, 0, 48, 6));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGR48));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FORMAT, SDL_PIXELFORMAT_RGBA64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_RGBA, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FORMAT, SDL_PIXELFORMAT_ARGB64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_ARGB, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FORMAT, SDL_PIXELFORMAT_BGRA64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_BGRA, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FORMAT, SDL_PIXELFORMAT_ABGR64 == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU16, SDL_ARRAYORDER_ABGR, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR64));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_FORMAT, SDL_PIXELFORMAT_RGB48_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_RGB, 0, 48, 6));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB48_FLOAT_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_FORMAT, SDL_PIXELFORMAT_BGR48_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_BGR, 0, 48, 6));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR48_FLOAT_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGR48_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_FORMAT, SDL_PIXELFORMAT_RGBA64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_RGBA, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA64_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_FORMAT, SDL_PIXELFORMAT_ARGB64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_ARGB, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB64_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_FORMAT, SDL_PIXELFORMAT_BGRA64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_BGRA, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA64_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_FORMAT, SDL_PIXELFORMAT_ABGR64_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF16, SDL_ARRAYORDER_ABGR, 0, 64, 8));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR64_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR64_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_FORMAT, SDL_PIXELFORMAT_RGB96_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_RGB, 0, 96, 12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGB96_FLOAT_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGB96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_FORMAT, SDL_PIXELFORMAT_BGR96_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_BGR, 0, 96, 12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGR96_FLOAT_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGR96_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_FORMAT, SDL_PIXELFORMAT_RGBA128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_RGBA, 0, 128, 16));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_RGBA128_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_RGBA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_FORMAT, SDL_PIXELFORMAT_ARGB128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_ARGB, 0, 128, 16));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ARGB128_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ARGB128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_FORMAT, SDL_PIXELFORMAT_BGRA128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_BGRA, 0, 128, 16));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_BGRA128_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_BGRA128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_FORMAT, SDL_PIXELFORMAT_ABGR128_FLOAT == SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYF32, SDL_ARRAYORDER_ABGR, 0, 128, 16));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_FOURCC, !SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_ARRAY, SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_FLOAT, SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_ABGR128_FLOAT_ALPHA, SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_ABGR128_FLOAT));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_FORMAT, SDL_PIXELFORMAT_YV12 == SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YV12_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_YV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_FORMAT, SDL_PIXELFORMAT_IYUV == SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_IYUV_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_IYUV));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_FORMAT, SDL_PIXELFORMAT_YUY2 == SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YUY2_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_YUY2));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_FORMAT, SDL_PIXELFORMAT_UYVY == SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_UYVY_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_UYVY));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_FORMAT, SDL_PIXELFORMAT_YVYU == SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_YVYU_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_YVYU));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_FORMAT, SDL_PIXELFORMAT_NV12 == SDL_DEFINE_PIXELFOURCC('N', 'V', '1', '2'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV12_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_NV12));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_FORMAT, SDL_PIXELFORMAT_NV21 == SDL_DEFINE_PIXELFOURCC('N', 'V', '2', '1'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_NV21_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_NV21));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_FORMAT, SDL_PIXELFORMAT_P010 == SDL_DEFINE_PIXELFOURCC('P', '0', '1', '0'));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_P010_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_P010));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_FORMAT, SDL_PIXELFORMAT_EXTERNAL_OES == SDL_DEFINE_PIXELFOURCC('O', 'E', 'S', ' '));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_FOURCC, SDL_ISPIXELFORMAT_FOURCC(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_INDEXED, !SDL_ISPIXELFORMAT_INDEXED(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_PACKED, !SDL_ISPIXELFORMAT_PACKED(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_ARRAY, !SDL_ISPIXELFORMAT_ARRAY(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_10BIT, !SDL_ISPIXELFORMAT_10BIT(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_FLOAT, !SDL_ISPIXELFORMAT_FLOAT(SDL_PIXELFORMAT_EXTERNAL_OES));
SDL_COMPILE_TIME_ASSERT(SDL_PIXELFORMAT_EXTERNAL_OES_ALPHA, !SDL_ISPIXELFORMAT_ALPHA(SDL_PIXELFORMAT_EXTERNAL_OES));
/* Verify the colorspaces are laid out as expected */
SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_SRGB_FORMAT, SDL_COLORSPACE_SRGB ==
@@ -258,6 +721,73 @@ SDL_COMPILE_TIME_ASSERT(SDL_COLORSPACE_BT2020_FULL_FORMAT, SDL_COLORSPACE_BT2020
SDL_CHROMA_LOCATION_LEFT));
/* Test case functions */
/**
* Call to SDL_GetPixelFormatName
*
* \sa SDL_GetPixelFormatName
*/
static int SDLCALL pixels_getPixelFormatName(void *arg)
{
const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
const char *error;
int i;
SDL_PixelFormat format;
const char *result;
/* Blank/undefined format */
format = SDL_PIXELFORMAT_UNKNOWN;
SDLTest_Log("RGB Format: %s (%d)", unknownFormat, format);
/* Get name of format */
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0,
"Verify result text; expected: %s, got %s", unknownFormat, result);
}
/* RGB formats */
for (i = 0; i < g_numAllFormats; i++) {
format = g_AllFormats[i];
SDLTest_Log("RGB Format: %s (%d)", g_AllFormatsVerbose[i], format);
/* Get name of format */
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
SDLTest_AssertCheck(SDL_strcmp(result, g_AllFormatsVerbose[i]) == 0,
"Verify result text; expected: %s, got %s", g_AllFormatsVerbose[i], result);
}
}
/* Negative cases */
/* Invalid Formats */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
for (i = 0; i < g_numInvalidPixelFormats; i++) {
format = g_invalidPixelFormats[i];
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%d)", format);
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0',
"Verify result is non-empty; got: %s", result);
SDLTest_AssertCheck(SDL_strcmp(result, g_invalidPixelFormatsVerbose[i]) == 0,
"Validate name is UNKNOWN, expected: '%s', got: '%s'", g_invalidPixelFormatsVerbose[i], result);
}
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error == NULL || error[0] == '\0', "Validate that error message is empty");
}
return TEST_COMPLETED;
}
/**
* Call to SDL_GetPixelFormatDetails
*/
@@ -344,73 +874,6 @@ static int SDLCALL pixels_getPixelFormatDetails(void *arg)
return TEST_COMPLETED;
}
/**
* Call to SDL_GetPixelFormatName
*
* \sa SDL_GetPixelFormatName
*/
static int SDLCALL pixels_getPixelFormatName(void *arg)
{
const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
const char *error;
int i;
SDL_PixelFormat format;
const char *result;
/* Blank/undefined format */
format = SDL_PIXELFORMAT_UNKNOWN;
SDLTest_Log("RGB Format: %s (%d)", unknownFormat, format);
/* Get name of format */
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0,
"Verify result text; expected: %s, got %s", unknownFormat, result);
}
/* RGB formats */
for (i = 0; i < g_numAllFormats; i++) {
format = g_AllFormats[i];
SDLTest_Log("RGB Format: %s (%d)", g_AllFormatsVerbose[i], format);
/* Get name of format */
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
SDLTest_AssertCheck(SDL_strcmp(result, g_AllFormatsVerbose[i]) == 0,
"Verify result text; expected: %s, got %s", g_AllFormatsVerbose[i], result);
}
}
/* Negative cases */
/* Invalid Formats */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
for (i = 0; i < g_numInvalidPixelFormats; i++) {
format = g_invalidPixelFormats[i];
result = SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%d)", format);
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result[0] != '\0',
"Verify result is non-empty; got: %s", result);
SDLTest_AssertCheck(SDL_strcmp(result, g_invalidPixelFormatsVerbose[i]) == 0,
"Validate name is UNKNOWN, expected: '%s', got: '%s'", g_invalidPixelFormatsVerbose[i], result);
}
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error == NULL || error[0] == '\0', "Validate that error message is empty");
}
return TEST_COMPLETED;
}
/**
* Call to SDL_CreatePalette and SDL_DestroyPalette
*
@@ -496,24 +959,150 @@ static int SDLCALL pixels_allocFreePalette(void *arg)
return TEST_COMPLETED;
}
/**
* Call to SDL_SaveBMP and SDL_LoadBMP
*
* \sa SDL_SaveBMP
* \sa SDL_LoadBMP
*/
static int SDLCALL pixels_saveLoadBMP(void *arg)
{
int i;
SDL_Surface *surface;
bool result;
for (i = 0; i < g_numAllFormats; i++) {
SDL_PixelFormat format = g_AllFormats[i];
if (SDL_ISPIXELFORMAT_FOURCC(format)) {
continue;
}
if (SDL_ISPIXELFORMAT_INDEXED(format)) {
/* We'll test BMP with palette another time */
continue;
}
SDLTest_Log("Pixel Format: %s (%d)", g_AllFormatsVerbose[i], format);
/* Create surface */
surface = SDL_CreateSurface(1, 1, format);
SDLTest_AssertCheck(surface != NULL, "Verify surface is not NULL");
/* Fill with white */
result = SDL_ClearSurface(surface, 1.0f, 1.0f, 1.0f, 1.0f);
SDLTest_AssertCheck(result, "Verify SDL_ClearSurface() succeeded");
/* Save as BMP */
result = SDL_SaveBMP(surface, "test.bmp");
SDLTest_AssertCheck(result, "Verify SDL_SaveBMP() succeeded");
SDL_DestroySurface(surface);
/* Load BMP */
surface = SDL_LoadBMP("test.bmp");
SDLTest_AssertCheck(surface != NULL, "Verify SDL_LoadBMP() succeeded");
/* Remove BMP */
result = SDL_RemovePath("test.bmp");
SDLTest_AssertCheck(result, "Verify SDL_RemovePath() succeeded");
/* Verify the BMP contents */
if (surface) {
Uint8 *pixels = (Uint8 *)surface->pixels;
if (SDL_ISPIXELFORMAT_ALPHA(format)) {
SDLTest_AssertCheck(surface->format == SDL_PIXELFORMAT_ARGB8888, "Verify BMP surface format, expected %s, got %s", SDL_GetPixelFormatName(SDL_PIXELFORMAT_ARGB8888), SDL_GetPixelFormatName(surface->format));
SDLTest_AssertCheck(pixels[0] == 255 &&
pixels[1] == 255 &&
pixels[2] == 255 &&
pixels[3] == 255,
"Verify BMP colors, expected 255/255/255/255 got %d/%d/%d/%d", pixels[0], pixels[1], pixels[2], pixels[3]);
} else {
SDLTest_AssertCheck(surface->format == SDL_PIXELFORMAT_BGR24, "Verify BMP surface format, expected %s, got %s", SDL_GetPixelFormatName(SDL_PIXELFORMAT_BGR24), SDL_GetPixelFormatName(surface->format));
SDLTest_AssertCheck(pixels[0] == 255 &&
pixels[1] == 255 &&
pixels[2] == 255,
"Verify BMP colors, expected 255/255/255 got %d/%d/%d", pixels[0], pixels[1], pixels[2]);
}
SDL_DestroySurface(surface);
}
}
/* Test large formats */
for (i = 0; i < SDL_arraysize(g_AllLargeFormats); i++) {
SDL_PixelFormat format = g_AllLargeFormats[i];
SDLTest_Log("Pixel Format: %s (%d)", SDL_GetPixelFormatName(format), format);
/* Create surface */
surface = SDL_CreateSurface(1, 1, format);
SDLTest_AssertCheck(surface != NULL, "Verify surface is not NULL");
/* Fill with white */
result = SDL_ClearSurface(surface, 1.0f, 1.0f, 1.0f, 1.0f);
SDLTest_AssertCheck(result, "Verify SDL_ClearSurface() succeeded");
/* Save as BMP */
result = SDL_SaveBMP(surface, "test.bmp");
SDLTest_AssertCheck(result, "Verify SDL_SaveBMP() succeeded");
SDL_DestroySurface(surface);
/* Load BMP */
surface = SDL_LoadBMP("test.bmp");
SDLTest_AssertCheck(surface != NULL, "Verify SDL_LoadBMP() succeeded");
/* Remove BMP */
result = SDL_RemovePath("test.bmp");
SDLTest_AssertCheck(result, "Verify SDL_RemovePath() succeeded");
/* Verify the BMP contents */
if (surface) {
Uint8 *pixels = (Uint8 *)surface->pixels;
if (SDL_ISPIXELFORMAT_ALPHA(format)) {
SDLTest_AssertCheck(surface->format == SDL_PIXELFORMAT_ARGB8888, "Verify BMP surface format, expected %s, got %s", SDL_GetPixelFormatName(SDL_PIXELFORMAT_ARGB8888), SDL_GetPixelFormatName(surface->format));
SDLTest_AssertCheck(pixels[0] == 255 &&
pixels[1] == 255 &&
pixels[2] == 255 &&
pixels[3] == 255,
"Verify BMP colors, expected 255/255/255/255 got %d/%d/%d/%d", pixels[0], pixels[1], pixels[2], pixels[3]);
} else {
SDLTest_AssertCheck(surface->format == SDL_PIXELFORMAT_BGR24, "Verify BMP surface format, expected %s, got %s", SDL_GetPixelFormatName(SDL_PIXELFORMAT_BGR24), SDL_GetPixelFormatName(surface->format));
SDLTest_AssertCheck(pixels[0] == 255 &&
pixels[1] == 255 &&
pixels[2] == 255,
"Verify BMP colors, expected 255/255/255 got %d/%d/%d", pixels[0], pixels[1], pixels[2]);
}
SDL_DestroySurface(surface);
}
}
return TEST_COMPLETED;
}
/* ================= Test References ================== */
/* Pixels test cases */
static const SDLTest_TestCaseReference pixelsTest1 = {
pixels_getPixelFormatDetails, "pixels_allocFreeFormat", "Call to SDL_GetPixelFormatDetails", TEST_ENABLED
static const SDLTest_TestCaseReference pixelsTestGetPixelFormatName = {
pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED
};
static const SDLTest_TestCaseReference pixelsTest2 = {
static const SDLTest_TestCaseReference pixelsTestGetPixelFormatDetails = {
pixels_getPixelFormatDetails, "pixels_getPixelFormatDetails", "Call to SDL_GetPixelFormatDetails", TEST_ENABLED
};
static const SDLTest_TestCaseReference pixelsTestAllocFreePalette = {
pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_CreatePalette and SDL_DestroyPalette", TEST_ENABLED
};
static const SDLTest_TestCaseReference pixelsTest3 = {
pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED
static const SDLTest_TestCaseReference pixelsTestSaveLoadBMP = {
pixels_saveLoadBMP, "pixels_saveLoadBMP", "Call to SDL_SaveBMP and SDL_LoadBMP", TEST_ENABLED
};
/* Sequence of Pixels test cases */
static const SDLTest_TestCaseReference *pixelsTests[] = {
&pixelsTest1, &pixelsTest2, &pixelsTest3, NULL
&pixelsTestGetPixelFormatName,
&pixelsTestGetPixelFormatDetails,
&pixelsTestAllocFreePalette,
&pixelsTestSaveLoadBMP,
NULL
};
/* Pixels test suite (global) */
libs/SDL3/test/testautomation_surface.c
+63
View File
@@ -1479,6 +1479,64 @@ static int SDLCALL surface_testPremultiplyAlpha(void *arg)
}
static int SDLCALL surface_testScale(void *arg)
{
SDL_PixelFormat formats[] = {
SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGBA8888,
SDL_PIXELFORMAT_ARGB2101010, SDL_PIXELFORMAT_ABGR2101010,
SDL_PIXELFORMAT_ARGB64, SDL_PIXELFORMAT_RGBA64,
SDL_PIXELFORMAT_ARGB128_FLOAT, SDL_PIXELFORMAT_RGBA128_FLOAT,
};
SDL_ScaleMode modes[] = {
SDL_SCALEMODE_NEAREST, SDL_SCALEMODE_LINEAR
};
SDL_Surface *surface, *result;
SDL_PixelFormat format;
SDL_ScaleMode mode;
const float MAXIMUM_ERROR = 0.0001f;
float srcR = 10 / 255.0f, srcG = 128 / 255.0f, srcB = 240 / 255.0f, srcA = 170 / 255.0f;
float actualR, actualG, actualB, actualA;
float deltaR, deltaG, deltaB, deltaA;
int i, j, ret;
for (i = 0; i < SDL_arraysize(formats); ++i) {
for (j = 0; j < SDL_arraysize(modes); ++j) {
format = formats[i];
mode = modes[j];
surface = SDL_CreateSurface(1, 1, format);
SDLTest_AssertCheck(surface != NULL, "SDL_CreateSurface()");
ret = SDL_SetSurfaceColorspace(surface, SDL_COLORSPACE_SRGB);
SDLTest_AssertCheck(ret == true, "SDL_SetSurfaceColorspace()");
ret = SDL_ClearSurface(surface, srcR, srcG, srcB, srcA);
SDLTest_AssertCheck(ret == true, "SDL_ClearSurface()");
result = SDL_ScaleSurface(surface, 2, 2, mode);
SDLTest_AssertCheck(ret == true, "SDL_PremultiplySurfaceAlpha()");
ret = SDL_ReadSurfacePixelFloat(result, 1, 1, &actualR, &actualG, &actualB, &actualA);
SDLTest_AssertCheck(ret == true, "SDL_ReadSurfacePixelFloat()");
deltaR = SDL_fabsf(actualR - srcR);
deltaG = SDL_fabsf(actualG - srcG);
deltaB = SDL_fabsf(actualB - srcB);
deltaA = SDL_fabsf(actualA - srcA);
SDLTest_AssertCheck(
deltaR <= MAXIMUM_ERROR &&
deltaG <= MAXIMUM_ERROR &&
deltaB <= MAXIMUM_ERROR &&
deltaA <= MAXIMUM_ERROR,
"Checking %s %s scaling results, expected %.4f,%.4f,%.4f,%.4f got %.4f,%.4f,%.4f,%.4f",
SDL_GetPixelFormatName(format),
mode == SDL_SCALEMODE_NEAREST ? "nearest" : "linear",
srcR, srcG, srcB, srcA, actualR, actualG, actualB, actualA);
SDL_DestroySurface(surface);
SDL_DestroySurface(result);
}
}
return TEST_COMPLETED;
}
/* ================= Test References ================== */
/* Surface test cases */
@@ -1574,6 +1632,10 @@ static const SDLTest_TestCaseReference surfaceTestPremultiplyAlpha = {
surface_testPremultiplyAlpha, "surface_testPremultiplyAlpha", "Test alpha premultiply operations.", TEST_ENABLED
};
static const SDLTest_TestCaseReference surfaceTestScale = {
surface_testScale, "surface_testScale", "Test scaling operations.", TEST_ENABLED
};
/* Sequence of Surface test cases */
static const SDLTest_TestCaseReference *surfaceTests[] = {
&surfaceTestSaveLoadBitmap,
@@ -1599,6 +1661,7 @@ static const SDLTest_TestCaseReference *surfaceTests[] = {
&surfaceTestPalettization,
&surfaceTestClearSurface,
&surfaceTestPremultiplyAlpha,
&surfaceTestScale,
NULL
};
libs/SDL3/test/testautomation_video.c
+60 -13
View File
@@ -1843,7 +1843,7 @@ static int SDLCALL video_setWindowCenteredOnDisplay(void *arg)
SDLTest_AssertCheck(currentW == w, "Validate width (current: %d, expected: %d)", currentW, w);
SDLTest_AssertCheck(currentH == h, "Validate height (current: %d, expected: %d)", currentH, h);
}
if (video_driver_is_wayland) {
if (video_driver_is_emscripten || video_driver_is_wayland) {
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
} else {
SDLTest_AssertCheck(currentX == expectedX, "Validate x (current: %d, expected: %d)", currentX, expectedX);
@@ -1879,7 +1879,7 @@ static int SDLCALL video_setWindowCenteredOnDisplay(void *arg)
SDLTest_AssertCheck(currentW == w, "Validate width (current: %d, expected: %d)", currentW, w);
SDLTest_AssertCheck(currentH == h, "Validate height (current: %d, expected: %d)", currentH, h);
}
if (video_driver_is_wayland) {
if (video_driver_is_emscripten || video_driver_is_wayland) {
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
} else {
SDLTest_AssertCheck(currentX == expectedX, "Validate x (current: %d, expected: %d)", currentX, expectedX);
@@ -2133,7 +2133,54 @@ static int SDLCALL video_getSetWindowState(void *arg)
SDLTest_AssertCheck(windowedW == currentW, "Verify returned width; expected: %d, got: %d", windowedW, currentW);
SDLTest_AssertCheck(windowedH == currentH, "Verify returned height; expected: %d, got: %d", windowedH, currentH);
/* Maximize, change size, and restore */
/* Maximize, restore, and change size */
result = SDL_MaximizeWindow(window);
SDLTest_AssertPass("SDL_MaximizeWindow()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
result = SDL_RestoreWindow(window);
SDLTest_AssertPass("SDL_RestoreWindow()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
desiredW = windowedW + 10;
desiredH = windowedH + 10;
result = SDL_SetWindowSize(window, desiredW, desiredH);
SDLTest_AssertPass("SDL_SetWindowSize()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
if (!skipPos) {
desiredX = windowedX + 10;
desiredY = windowedY + 10;
result = SDL_SetWindowPosition(window, desiredX, desiredY);
SDLTest_AssertPass("SDL_SetWindowPosition()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
}
result = SDL_SyncWindow(window);
SDLTest_AssertPass("SDL_SyncWindow()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
flags = SDL_GetWindowFlags(window);
SDLTest_AssertPass("SDL_GetWindowFlags()");
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
if (!skipPos) {
currentX = desiredX + 1;
currentY = desiredY + 1;
SDL_GetWindowPosition(window, &currentX, &currentY);
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", desiredX, currentX);
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", desiredY, currentY);
}
currentW = desiredW + 1;
currentH = desiredH + 1;
SDL_GetWindowSize(window, &currentW, &currentH);
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
/* Maximize, change size/position (should be ignored), and restore. */
result = SDL_MaximizeWindow(window);
SDLTest_AssertPass("SDL_MaximizeWindow()");
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
@@ -2165,20 +2212,20 @@ static int SDLCALL video_getSetWindowState(void *arg)
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
if (!skipPos) {
currentX = desiredX + 1;
currentY = desiredY + 1;
SDL_GetWindowPosition(window, &currentX, &currentY);
int previousX = desiredX + 1;
int previousY = desiredY + 1;
SDL_GetWindowPosition(window, &previousX, &previousY);
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", desiredX, currentX);
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", desiredY, currentY);
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", previousX, currentX);
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", previousY, currentY);
}
currentW = desiredW + 1;
currentH = desiredH + 1;
SDL_GetWindowSize(window, &currentW, &currentH);
int previousW = desiredW + 1;
int previousH = desiredH + 1;
SDL_GetWindowSize(window, &previousW, &previousH);
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", previousW, currentW);
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", previousH, currentH);
/* Change size and position, maximize and restore */
desiredW = windowedW - 5;
libs/SDL3/test/testcontroller.c
+5 -1
View File
@@ -1027,7 +1027,10 @@ static void HandleGamepadAdded(SDL_JoystickID id, bool verbose)
SDL_PropertiesID props = SDL_GetGamepadProperties(gamepad);
const char *name = SDL_GetGamepadName(gamepad);
const char *path = SDL_GetGamepadPath(gamepad);
SDL_Log("Opened gamepad %s%s%s\n", name, path ? ", " : "", path ? path : "");
SDL_GUID guid = SDL_GetGamepadGUIDForID(id);
char guid_string[33];
SDL_GUIDToString(guid, guid_string, sizeof(guid_string));
SDL_Log("Opened gamepad %s, guid %s%s%s\n", name, guid_string, path ? ", " : "", path ? path : "");
firmware_version = SDL_GetGamepadFirmwareVersion(gamepad);
if (firmware_version) {
@@ -1074,6 +1077,7 @@ static void HandleGamepadAdded(SDL_JoystickID id, bool verbose)
}
HandleGamepadRemapped(id);
SetController(id);
}
static void HandleGamepadRemoved(SDL_JoystickID id)
libs/SDL3/test/testfilesystem.c
+10
View File
@@ -62,6 +62,7 @@ int main(int argc, char *argv[])
{
SDLTest_CommonState *state;
char *pref_path;
char *curdir;
const char *base_path;
/* Initialize test framework */
@@ -106,6 +107,15 @@ int main(int argc, char *argv[])
}
SDL_free(pref_path);
curdir = SDL_GetCurrentDirectory();
if (!curdir) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't find current directory: %s\n",
SDL_GetError());
} else {
SDL_Log("current directory: '%s'\n", curdir);
}
SDL_free(curdir);
if (base_path) {
char **globlist;
SDL_IOStream *stream;
libs/SDL3/test/testgl.c
+3 -3
View File
@@ -33,7 +33,7 @@ static SDL_GLContext context;
static GL_Context ctx;
static bool suspend_when_occluded;
static int LoadContext(GL_Context *data)
static bool LoadContext(GL_Context *data)
{
#ifdef SDL_VIDEO_DRIVER_UIKIT
#define __SDL_NOGETPROCADDR__
@@ -55,7 +55,7 @@ static int LoadContext(GL_Context *data)
#include "../src/render/opengl/SDL_glfuncs.h"
#undef SDL_PROC
return 0;
return true;
}
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
@@ -284,7 +284,7 @@ int main(int argc, char *argv[])
}
/* Important: call this *after* creating the context */
if (LoadContext(&ctx) < 0) {
if (!LoadContext(&ctx)) {
SDL_Log("Could not load GL functions\n");
quit(2);
return 0;
libs/SDL3/test/testgles2.c
+3 -3
View File
@@ -70,7 +70,7 @@ static bool suspend_when_occluded;
static GLES2_Context ctx;
static shader_data *datas;
static int LoadContext(GLES2_Context *data)
static bool LoadContext(GLES2_Context *data)
{
#ifdef SDL_VIDEO_DRIVER_UIKIT
#define __SDL_NOGETPROCADDR__
@@ -92,7 +92,7 @@ static int LoadContext(GLES2_Context *data)
#include "../src/render/opengles2/SDL_gles2funcs.h"
#undef SDL_PROC
return 0;
return true;
}
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
@@ -764,7 +764,7 @@ int main(int argc, char *argv[])
}
/* Important: call this *after* creating the context */
if (LoadContext(&ctx) < 0) {
if (!LoadContext(&ctx)) {
SDL_Log("Could not load GLES2 functions\n");
quit(2);
return 0;
libs/SDL3/test/testgles2_sdf.c
+3 -3
View File
@@ -61,7 +61,7 @@ static SDL_GLContext *context = NULL;
static int depth = 16;
static GLES2_Context ctx;
static int LoadContext(GLES2_Context *data)
static bool LoadContext(GLES2_Context *data)
{
#ifdef SDL_VIDEO_DRIVER_UIKIT
#define __SDL_NOGETPROCADDR__
@@ -83,7 +83,7 @@ static int LoadContext(GLES2_Context *data)
#include "../src/render/opengles2/SDL_gles2funcs.h"
#undef SDL_PROC
return 0;
return true;
}
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
@@ -523,7 +523,7 @@ int main(int argc, char *argv[])
}
/* Important: call this *after* creating the context */
if (LoadContext(&ctx) < 0) {
if (!LoadContext(&ctx)) {
SDL_Log("Could not load GLES2 functions\n");
quit(2);
return 0;
libs/SDL3/test/testgpu/build-shaders.sh
+2 -11
View File
@@ -82,18 +82,9 @@ if [[ "$OSTYPE" == "darwin"* ]]; then
elif [[ "$OSTYPE" == "cygwin"* ]] || [[ "$OSTYPE" == "msys"* ]]; then
# FXC
fxc cube.hlsl /E VSMain /T vs_5_0 /Fh cube.vert.h
fxc cube.hlsl /E PSMain /T ps_5_0 /Fh cube.frag.h
cat cube.vert.h | perl -w -p -e 's/BYTE/unsigned char/;s/g_VSMain/D3D11_CubeVert/;' > cube.vert.temp.h
cat cube.frag.h | perl -w -p -e 's/BYTE/unsigned char/;s/g_PSMain/D3D11_CubeFrag/;' > cube.frag.temp.h
cat cube.vert.temp.h cube.frag.temp.h > testgpu_dxbc.h
rm -f cube.vert.h cube.frag.h cube.vert.temp.h cube.frag.temp.h
# DXC
dxc cube.hlsl /E VSMain /T vs_6_0 /Fh cube.vert.h /D D3D12=1
dxc cube.hlsl /E PSMain /T ps_6_0 /Fh cube.frag.h /D D3D12=1
dxc cube.hlsl /E VSMain /T vs_6_0 /Fh cube.vert.h
dxc cube.hlsl /E PSMain /T ps_6_0 /Fh cube.frag.h
cat cube.vert.h | perl -w -p -e 's/BYTE/unsigned char/;s/g_VSMain/D3D12_CubeVert/;' > cube.vert.temp.h
cat cube.frag.h | perl -w -p -e 's/BYTE/unsigned char/;s/g_PSMain/D3D12_CubeFrag/;' > cube.frag.temp.h
libs/SDL3/test/testgpu/cube.hlsl
+1 -5
View File
@@ -1,8 +1,4 @@
#if D3D12
#define REG(reg, space) register(reg, space)
#else
#define REG(reg, space) register(reg)
#endif
cbuffer UBO : REG(b0, space1)
{
@@ -32,4 +28,4 @@ VSOutput VSMain(VSInput input)
float4 PSMain(VSOutput input) : SV_Target0
{
return input.Color;
}
}
libs/SDL3/test/testgpu/testgpu_dxbc.h
-333
View File
@@ -1,333 +0,0 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer UBO
// {
//
// float4x4 ModelViewProj; // Offset: 0 Size: 64
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim HLSL Bind Count
// ------------------------------ ---------- ------- ----------- -------------- ------
// UBO cbuffer NA NA cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// TEXCOORD 0 xyz 0 NONE float xyz
// TEXCOORD 1 xyz 1 NONE float xyz
//
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// TEXCOORD 0 xyzw 0 NONE float xyzw
// SV_Position 0 xyzw 1 POS float xyzw
//
vs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[4], immediateIndexed
dcl_input v0.xyz
dcl_input v1.xyz
dcl_output o0.xyzw
dcl_output_siv o1.xyzw, position
dcl_temps 1
mov o0.xyz, v1.xyzx
mov o0.w, l(1.000000)
mul r0.xyzw, v0.yyyy, cb0[1].xyzw
mad r0.xyzw, cb0[0].xyzw, v0.xxxx, r0.xyzw
mad r0.xyzw, cb0[2].xyzw, v0.zzzz, r0.xyzw
add o1.xyzw, r0.xyzw, cb0[3].xyzw
ret
// Approximately 7 instruction slots used
#endif
const unsigned char D3D11_CubeVert[] =
{
68, 88, 66, 67, 114, 13,
37, 16, 19, 3, 132, 73,
243, 18, 23, 177, 140, 169,
19, 240, 1, 0, 0, 0,
156, 3, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 1, 0, 0, 140, 1,
0, 0, 228, 1, 0, 0,
0, 3, 0, 0, 82, 68,
69, 70, 4, 1, 0, 0,
1, 0, 0, 0, 96, 0,
0, 0, 1, 0, 0, 0,
60, 0, 0, 0, 0, 5,
254, 255, 0, 1, 0, 0,
220, 0, 0, 0, 82, 68,
49, 49, 60, 0, 0, 0,
24, 0, 0, 0, 32, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
92, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0,
0, 0, 85, 66, 79, 0,
92, 0, 0, 0, 1, 0,
0, 0, 120, 0, 0, 0,
64, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
160, 0, 0, 0, 0, 0,
0, 0, 64, 0, 0, 0,
2, 0, 0, 0, 184, 0,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 77, 111,
100, 101, 108, 86, 105, 101,
119, 80, 114, 111, 106, 0,
102, 108, 111, 97, 116, 52,
120, 52, 0, 171, 3, 0,
3, 0, 4, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
174, 0, 0, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 73, 83, 71, 78,
68, 0, 0, 0, 2, 0,
0, 0, 8, 0, 0, 0,
56, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 7, 7, 0, 0,
56, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 1, 0,
0, 0, 7, 7, 0, 0,
84, 69, 88, 67, 79, 79,
82, 68, 0, 171, 171, 171,
79, 83, 71, 78, 80, 0,
0, 0, 2, 0, 0, 0,
8, 0, 0, 0, 56, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
15, 0, 0, 0, 65, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
15, 0, 0, 0, 84, 69,
88, 67, 79, 79, 82, 68,
0, 83, 86, 95, 80, 111,
115, 105, 116, 105, 111, 110,
0, 171, 171, 171, 83, 72,
69, 88, 20, 1, 0, 0,
80, 0, 1, 0, 69, 0,
0, 0, 106, 8, 0, 1,
89, 0, 0, 4, 70, 142,
32, 0, 0, 0, 0, 0,
4, 0, 0, 0, 95, 0,
0, 3, 114, 16, 16, 0,
0, 0, 0, 0, 95, 0,
0, 3, 114, 16, 16, 0,
1, 0, 0, 0, 101, 0,
0, 3, 242, 32, 16, 0,
0, 0, 0, 0, 103, 0,
0, 4, 242, 32, 16, 0,
1, 0, 0, 0, 1, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 54, 0,
0, 5, 114, 32, 16, 0,
0, 0, 0, 0, 70, 18,
16, 0, 1, 0, 0, 0,
54, 0, 0, 5, 130, 32,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 0,
128, 63, 56, 0, 0, 8,
242, 0, 16, 0, 0, 0,
0, 0, 86, 21, 16, 0,
0, 0, 0, 0, 70, 142,
32, 0, 0, 0, 0, 0,
1, 0, 0, 0, 50, 0,
0, 10, 242, 0, 16, 0,
0, 0, 0, 0, 70, 142,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 16,
16, 0, 0, 0, 0, 0,
70, 14, 16, 0, 0, 0,
0, 0, 50, 0, 0, 10,
242, 0, 16, 0, 0, 0,
0, 0, 70, 142, 32, 0,
0, 0, 0, 0, 2, 0,
0, 0, 166, 26, 16, 0,
0, 0, 0, 0, 70, 14,
16, 0, 0, 0, 0, 0,
0, 0, 0, 8, 242, 32,
16, 0, 1, 0, 0, 0,
70, 14, 16, 0, 0, 0,
0, 0, 70, 142, 32, 0,
0, 0, 0, 0, 3, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 7, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
};
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// TEXCOORD 0 xyzw 0 NONE float xyzw
// SV_Position 0 xyzw 1 POS float
//
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// SV_Target 0 xyzw 0 TARGET float xyzw
//
ps_5_0
dcl_globalFlags refactoringAllowed
dcl_input_ps linear v0.xyzw
dcl_output o0.xyzw
mov o0.xyzw, v0.xyzw
ret
// Approximately 2 instruction slots used
#endif
const unsigned char D3D11_CubeFrag[] =
{
68, 88, 66, 67, 100, 36,
97, 53, 102, 218, 120, 105,
57, 43, 222, 229, 58, 45,
195, 237, 1, 0, 0, 0,
12, 2, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
160, 0, 0, 0, 248, 0,
0, 0, 44, 1, 0, 0,
112, 1, 0, 0, 82, 68,
69, 70, 100, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
60, 0, 0, 0, 0, 5,
255, 255, 0, 1, 0, 0,
60, 0, 0, 0, 82, 68,
49, 49, 60, 0, 0, 0,
24, 0, 0, 0, 32, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 73, 83,
71, 78, 80, 0, 0, 0,
2, 0, 0, 0, 8, 0,
0, 0, 56, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 15, 15,
0, 0, 65, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 3, 0, 0, 0,
1, 0, 0, 0, 15, 0,
0, 0, 84, 69, 88, 67,
79, 79, 82, 68, 0, 83,
86, 95, 80, 111, 115, 105,
116, 105, 111, 110, 0, 171,
171, 171, 79, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 15, 0, 0, 0,
83, 86, 95, 84, 97, 114,
103, 101, 116, 0, 171, 171,
83, 72, 69, 88, 60, 0,
0, 0, 80, 0, 0, 0,
15, 0, 0, 0, 106, 8,
0, 1, 98, 16, 0, 3,
242, 16, 16, 0, 0, 0,
0, 0, 101, 0, 0, 3,
242, 32, 16, 0, 0, 0,
0, 0, 54, 0, 0, 5,
242, 32, 16, 0, 0, 0,
0, 0, 70, 30, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0
};
libs/SDL3/test/testgpu_simple_clear.c
+18 -14
View File
@@ -82,28 +82,32 @@ SDL_AppResult SDL_AppIterate(void *appstate)
}
SDL_GPUTexture *swapchainTexture;
if (!SDL_AcquireGPUSwapchainTexture(cmdbuf, state->windows[0], &swapchainTexture, NULL, NULL)) {
if (!SDL_WaitAndAcquireGPUSwapchainTexture(cmdbuf, state->windows[0], &swapchainTexture, NULL, NULL)) {
SDL_Log("SDL_AcquireGPUSwapchainTexture failed: %s", SDL_GetError());
return SDL_APP_FAILURE;
}
if (swapchainTexture != NULL) {
if (swapchainTexture != NULL) {
const double currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency();
SDL_GPURenderPass *renderPass;
SDL_GPUColorTargetInfo color_target_info;
SDL_GPUColorTargetInfo color_target_info;
SDL_zero(color_target_info);
color_target_info.texture = swapchainTexture;
color_target_info.clear_color.r = (float)(0.5 + 0.5 * SDL_sin(currentTime));
color_target_info.clear_color.g = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 2 / 3));
color_target_info.clear_color.b = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 4 / 3));
color_target_info.clear_color.a = 1.0f;
color_target_info.load_op = SDL_GPU_LOADOP_CLEAR;
color_target_info.store_op = SDL_GPU_STOREOP_STORE;
color_target_info.texture = swapchainTexture;
color_target_info.clear_color.r = (float)(0.5 + 0.5 * SDL_sin(currentTime));
color_target_info.clear_color.g = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 2 / 3));
color_target_info.clear_color.b = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 4 / 3));
color_target_info.clear_color.a = 1.0f;
color_target_info.load_op = SDL_GPU_LOADOP_CLEAR;
color_target_info.store_op = SDL_GPU_STOREOP_STORE;
renderPass = SDL_BeginGPURenderPass(cmdbuf, &color_target_info, 1, NULL);
SDL_EndGPURenderPass(renderPass);
}
renderPass = SDL_BeginGPURenderPass(cmdbuf, &color_target_info, 1, NULL);
SDL_EndGPURenderPass(renderPass);
SDL_SubmitGPUCommandBuffer(cmdbuf);
SDL_SubmitGPUCommandBuffer(cmdbuf);
} else {
/* Swapchain is unavailable, cancel work */
SDL_CancelGPUCommandBuffer(cmdbuf);
}
frames++;
libs/SDL3/test/testgpu_spinning_cube.c
+5 -11
View File
@@ -22,7 +22,6 @@
/* Regenerate the shaders with testgpu/build-shaders.sh */
#include "testgpu/testgpu_spirv.h"
#include "testgpu/testgpu_dxbc.h"
#include "testgpu/testgpu_dxil.h"
#include "testgpu/testgpu_metallib.h"
@@ -342,20 +341,20 @@ Render(SDL_Window *window, const int windownum)
SDL_Log("Failed to acquire command buffer :%s", SDL_GetError());
quit(2);
}
if (!SDL_AcquireGPUSwapchainTexture(cmd, state->windows[windownum], &swapchainTexture, &drawablew, &drawableh)) {
if (!SDL_WaitAndAcquireGPUSwapchainTexture(cmd, state->windows[windownum], &swapchainTexture, &drawablew, &drawableh)) {
SDL_Log("Failed to acquire swapchain texture: %s", SDL_GetError());
quit(2);
}
if (swapchainTexture == NULL) {
/* No swapchain was acquired, probably too many frames in flight */
SDL_SubmitGPUCommandBuffer(cmd);
/* Swapchain is unavailable, cancel work */
SDL_CancelGPUCommandBuffer(cmd);
return;
}
/*
* Do some rotation with Euler angles. It is not a fixed axis as
* quaterions would be, but the effect is cool.
* quaternions would be, but the effect is cool.
*/
rotate_matrix((float)winstate->angle_x, 1.0f, 0.0f, 0.0f, matrix_modelview);
rotate_matrix((float)winstate->angle_y, 0.0f, 1.0f, 0.0f, matrix_rotate);
@@ -471,12 +470,7 @@ load_shader(bool is_vertex)
createinfo.props = 0;
SDL_GPUShaderFormat format = SDL_GetGPUShaderFormats(gpu_device);
if (format & SDL_GPU_SHADERFORMAT_DXBC) {
createinfo.format = SDL_GPU_SHADERFORMAT_DXBC;
createinfo.code = is_vertex ? D3D11_CubeVert : D3D11_CubeFrag;
createinfo.code_size = is_vertex ? SDL_arraysize(D3D11_CubeVert) : SDL_arraysize(D3D11_CubeFrag);
createinfo.entrypoint = is_vertex ? "VSMain" : "PSMain";
} else if (format & SDL_GPU_SHADERFORMAT_DXIL) {
if (format & SDL_GPU_SHADERFORMAT_DXIL) {
createinfo.format = SDL_GPU_SHADERFORMAT_DXIL;
createinfo.code = is_vertex ? D3D12_CubeVert : D3D12_CubeFrag;
createinfo.code_size = is_vertex ? SDL_arraysize(D3D12_CubeVert) : SDL_arraysize(D3D12_CubeFrag);
libs/SDL3/test/testrelative.c
+6 -1
View File
@@ -32,7 +32,12 @@ static void DrawRects(SDL_Renderer *renderer)
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDLTest_DrawString(renderer, 0.f, 0.f, "Relative Mode: Enabled");
if (SDL_GetWindowRelativeMouseMode(SDL_GetRenderWindow(renderer))) {
SDLTest_DrawString(renderer, 0.f, 0.f, "Relative Mode: Enabled");
} else {
SDLTest_DrawString(renderer, 0.f, 0.f, "Relative Mode: Disabled");
}
}
static void CenterMouse(void)
libs/SDL3/test/testtray.c
+599
View File
@@ -0,0 +1,599 @@
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <SDL3/SDL_test.h>
static void SDLCALL tray_quit(void *ptr, SDL_TrayEntry *entry)
{
SDL_Event e;
e.type = SDL_EVENT_QUIT;
SDL_PushEvent(&e);
}
static void SDLCALL apply_icon(void *ptr, const char * const *filelist, int filter)
{
if (!*filelist) {
return;
}
SDL_Surface *icon = SDL_LoadBMP(*filelist);
if (!icon) {
SDL_Log("Couldn't load icon '%s': %s", *filelist, SDL_GetError());
return;
}
SDL_Tray *tray = (SDL_Tray *) ptr;
SDL_SetTrayIcon(tray, icon);
SDL_DestroySurface(icon);
}
static void SDLCALL change_icon(void *ptr, SDL_TrayEntry *entry)
{
SDL_DialogFileFilter filters[] = {
{ "BMP image files", "bmp" },
{ "All files", "*" },
};
SDL_ShowOpenFileDialog(apply_icon, ptr, NULL, filters, 2, NULL, 0);
}
static void SDLCALL print_entry(void *ptr, SDL_TrayEntry *entry)
{
SDL_Log("Clicked on button '%s'\n", SDL_GetTrayEntryLabel(entry));
}
static void SDLCALL set_entry_enabled(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayEntry *target = (SDL_TrayEntry *) ptr;
SDL_SetTrayEntryEnabled(target, true);
}
static void SDLCALL set_entry_disabled(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayEntry *target = (SDL_TrayEntry *) ptr;
SDL_SetTrayEntryEnabled(target, false);
}
static void SDLCALL set_entry_checked(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayEntry *target = (SDL_TrayEntry *) ptr;
SDL_SetTrayEntryChecked(target, true);
}
static void SDLCALL set_entry_unchecked(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayEntry *target = (SDL_TrayEntry *) ptr;
SDL_SetTrayEntryChecked(target, false);
}
static void SDLCALL remove_entry(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayEntry *target = (SDL_TrayEntry *) ptr;
SDL_RemoveTrayEntry(target);
SDL_TrayMenu *ctrl_submenu = SDL_GetTrayEntryParent(entry);
SDL_TrayEntry *ctrl_entry = SDL_GetTrayMenuParentEntry(ctrl_submenu);
if (!ctrl_entry) {
SDL_Log("Attempt to remove a menu that isn't a submenu. This shouldn't happen.\n");
return;
}
SDL_RemoveTrayEntry(ctrl_entry);
}
static void SDLCALL append_button_to(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayMenu *menu = (SDL_TrayMenu *) ptr;
SDL_TrayMenu *submenu;
SDL_TrayEntry *new_ctrl;
SDL_TrayEntry *new_ctrl_remove;
SDL_TrayEntry *new_ctrl_enabled;
SDL_TrayEntry *new_ctrl_disabled;
SDL_TrayEntry *new_example;
new_ctrl = SDL_InsertTrayEntryAt(SDL_GetTrayEntryParent(entry), -1, "New button", SDL_TRAYENTRY_SUBMENU);
if (!new_ctrl) {
SDL_Log("Couldn't insert entry in control tray: %s\n", SDL_GetError());
return;
}
/* ---------- */
submenu = SDL_CreateTraySubmenu(new_ctrl);
if (!new_ctrl) {
SDL_Log("Couldn't create control tray entry submenu: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
/* ---------- */
new_example = SDL_InsertTrayEntryAt(menu, -1, "New button", SDL_TRAYENTRY_BUTTON);
if (new_example == NULL) {
SDL_Log("Couldn't insert entry in example tray: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
SDL_SetTrayEntryCallback(new_example, print_entry, NULL);
/* ---------- */
new_ctrl_remove = SDL_InsertTrayEntryAt(submenu, -1, "Remove", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_remove == NULL) {
SDL_Log("Couldn't insert new_ctrl_remove: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_remove, remove_entry, new_example);
/* ---------- */
new_ctrl_enabled = SDL_InsertTrayEntryAt(submenu, -1, "Enable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_enabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_enabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_enabled, set_entry_enabled, new_example);
/* ---------- */
new_ctrl_disabled = SDL_InsertTrayEntryAt(submenu, -1, "Disable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_disabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_disabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_disabled, set_entry_disabled, new_example);
}
static void SDLCALL append_checkbox_to(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayMenu *menu = (SDL_TrayMenu *) ptr;
SDL_TrayMenu *submenu;
SDL_TrayEntry *new_ctrl;
SDL_TrayEntry *new_ctrl_remove;
SDL_TrayEntry *new_ctrl_enabled;
SDL_TrayEntry *new_ctrl_disabled;
SDL_TrayEntry *new_ctrl_checked;
SDL_TrayEntry *new_ctrl_unchecked;
SDL_TrayEntry *new_example;
new_ctrl = SDL_InsertTrayEntryAt(SDL_GetTrayEntryParent(entry), -1, "New checkbox", SDL_TRAYENTRY_SUBMENU);
if (!new_ctrl) {
SDL_Log("Couldn't insert entry in control tray: %s\n", SDL_GetError());
return;
}
/* ---------- */
submenu = SDL_CreateTraySubmenu(new_ctrl);
if (!new_ctrl) {
SDL_Log("Couldn't create control tray entry submenu: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
/* ---------- */
new_example = SDL_InsertTrayEntryAt(menu, -1, "New checkbox", SDL_TRAYENTRY_CHECKBOX);
if (new_example == NULL) {
SDL_Log("Couldn't insert entry in example tray: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
SDL_SetTrayEntryCallback(new_example, print_entry, NULL);
/* ---------- */
new_ctrl_remove = SDL_InsertTrayEntryAt(submenu, -1, "Remove", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_remove == NULL) {
SDL_Log("Couldn't insert new_ctrl_remove: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_remove, remove_entry, new_example);
/* ---------- */
new_ctrl_enabled = SDL_InsertTrayEntryAt(submenu, -1, "Enable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_enabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_enabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_enabled, set_entry_enabled, new_example);
/* ---------- */
new_ctrl_disabled = SDL_InsertTrayEntryAt(submenu, -1, "Disable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_disabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_disabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_disabled, set_entry_disabled, new_example);
/* ---------- */
new_ctrl_checked = SDL_InsertTrayEntryAt(submenu, -1, "Check", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_checked == NULL) {
SDL_Log("Couldn't insert new_ctrl_checked: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_checked, set_entry_checked, new_example);
/* ---------- */
new_ctrl_unchecked = SDL_InsertTrayEntryAt(submenu, -1, "Uncheck", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_unchecked == NULL) {
SDL_Log("Couldn't insert new_ctrl_unchecked: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_unchecked, set_entry_unchecked, new_example);
}
static void SDLCALL append_separator_to(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayMenu *menu = (SDL_TrayMenu *) ptr;
SDL_TrayMenu *submenu;
SDL_TrayEntry *new_ctrl;
SDL_TrayEntry *new_ctrl_remove;
SDL_TrayEntry *new_example;
new_ctrl = SDL_InsertTrayEntryAt(SDL_GetTrayEntryParent(entry), -1, "[Separator]", SDL_TRAYENTRY_SUBMENU);
if (!new_ctrl) {
SDL_Log("Couldn't insert entry in control tray: %s\n", SDL_GetError());
return;
}
/* ---------- */
submenu = SDL_CreateTraySubmenu(new_ctrl);
if (!new_ctrl) {
SDL_Log("Couldn't create control tray entry submenu: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
/* ---------- */
new_example = SDL_InsertTrayEntryAt(menu, -1, NULL, SDL_TRAYENTRY_BUTTON);
if (new_example == NULL) {
SDL_Log("Couldn't insert separator in example tray: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
/* ---------- */
new_ctrl_remove = SDL_InsertTrayEntryAt(submenu, -1, "Remove", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_remove == NULL) {
SDL_Log("Couldn't insert new_ctrl_remove: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_remove, remove_entry, new_example);
}
static void SDLCALL append_submenu_to(void *ptr, SDL_TrayEntry *entry)
{
SDL_TrayMenu *menu = (SDL_TrayMenu *) ptr;
SDL_TrayMenu *submenu;
SDL_TrayMenu *entry_submenu;
SDL_TrayEntry *new_ctrl;
SDL_TrayEntry *new_ctrl_remove;
SDL_TrayEntry *new_ctrl_enabled;
SDL_TrayEntry *new_ctrl_disabled;
SDL_TrayEntry *new_example;
new_ctrl = SDL_InsertTrayEntryAt(SDL_GetTrayEntryParent(entry), -1, "New submenu", SDL_TRAYENTRY_SUBMENU);
if (!new_ctrl) {
SDL_Log("Couldn't insert entry in control tray: %s\n", SDL_GetError());
return;
}
/* ---------- */
submenu = SDL_CreateTraySubmenu(new_ctrl);
if (!new_ctrl) {
SDL_Log("Couldn't create control tray entry submenu: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
/* ---------- */
new_example = SDL_InsertTrayEntryAt(menu, -1, "New submenu", SDL_TRAYENTRY_SUBMENU);
if (new_example == NULL) {
SDL_Log("Couldn't insert entry in example tray: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
return;
}
SDL_SetTrayEntryCallback(new_example, print_entry, NULL);
/* ---------- */
entry_submenu = SDL_CreateTraySubmenu(new_example);
if (entry_submenu == NULL) {
SDL_Log("Couldn't create new entry submenu: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
/* ---------- */
new_ctrl_remove = SDL_InsertTrayEntryAt(submenu, -1, "Remove", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_remove == NULL) {
SDL_Log("Couldn't insert new_ctrl_remove: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_remove, remove_entry, new_example);
/* ---------- */
new_ctrl_enabled = SDL_InsertTrayEntryAt(submenu, -1, "Enable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_enabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_enabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_enabled, set_entry_enabled, new_example);
/* ---------- */
new_ctrl_disabled = SDL_InsertTrayEntryAt(submenu, -1, "Disable", SDL_TRAYENTRY_BUTTON);
if (new_ctrl_disabled == NULL) {
SDL_Log("Couldn't insert new_ctrl_disabled: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(new_ctrl_disabled, set_entry_disabled, new_example);
/* ---------- */
SDL_InsertTrayEntryAt(submenu, -1, NULL, 0);
/* ---------- */
SDL_TrayEntry *entry_newbtn = SDL_InsertTrayEntryAt(submenu, -1, "Create button", SDL_TRAYENTRY_BUTTON);
if (entry_newbtn == NULL) {
SDL_Log("Couldn't insert entry_newbtn: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(entry_newbtn, append_button_to, entry_submenu);
/* ---------- */
SDL_TrayEntry *entry_newchk = SDL_InsertTrayEntryAt(submenu, -1, "Create checkbox", SDL_TRAYENTRY_BUTTON);
if (entry_newchk == NULL) {
SDL_Log("Couldn't insert entry_newchk: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(entry_newchk, append_checkbox_to, entry_submenu);
/* ---------- */
SDL_TrayEntry *entry_newsub = SDL_InsertTrayEntryAt(submenu, -1, "Create submenu", SDL_TRAYENTRY_BUTTON);
if (entry_newsub == NULL) {
SDL_Log("Couldn't insert entry_newsub: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(entry_newsub, append_submenu_to, entry_submenu);
/* ---------- */
SDL_TrayEntry *entry_newsep = SDL_InsertTrayEntryAt(submenu, -1, "Create separator", SDL_TRAYENTRY_BUTTON);
if (entry_newsep == NULL) {
SDL_Log("Couldn't insert entry_newsep: %s\n", SDL_GetError());
SDL_RemoveTrayEntry(new_ctrl);
SDL_RemoveTrayEntry(new_example);
return;
}
SDL_SetTrayEntryCallback(entry_newsep, append_separator_to, entry_submenu);
/* ---------- */
SDL_InsertTrayEntryAt(submenu, -1, NULL, 0);
}
int main(int argc, char **argv)
{
SDLTest_CommonState *state;
int i;
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, 0);
if (state == NULL) {
return 1;
}
/* Parse commandline */
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed <= 0) {
static const char *options[] = { NULL };
SDLTest_CommonLogUsage(state, argv[0], options);
return 1;
}
i += consumed;
}
if (!SDL_Init(SDL_INIT_VIDEO)) {
SDL_Log("SDL_Init failed (%s)", SDL_GetError());
return 1;
}
/* TODO: Resource paths? */
SDL_Surface *icon = SDL_LoadBMP("../test/sdl-test_round.bmp");
if (!icon) {
SDL_Log("Couldn't load icon 1, proceeding without: %s", SDL_GetError());
}
SDL_Surface *icon2 = SDL_LoadBMP("../test/speaker.bmp");
if (!icon2) {
SDL_Log("Couldn't load icon 2, proceeding without: %s", SDL_GetError());
}
SDL_Tray *tray = SDL_CreateTray(icon, "SDL Tray control menu");
if (!tray) {
SDL_Log("Couldn't create control tray: %s", SDL_GetError());
goto quit;
}
SDL_Tray *tray2 = SDL_CreateTray(icon2, "SDL Tray example");
if (!tray2) {
SDL_Log("Couldn't create example tray: %s", SDL_GetError());
goto clean_tray1;
}
SDL_DestroySurface(icon);
SDL_DestroySurface(icon2);
#define CHECK(name) \
if (!name) { \
SDL_Log("Couldn't create " #name ": %s", SDL_GetError()); \
goto clean_all; \
}
SDL_TrayMenu *menu = SDL_CreateTrayMenu(tray);
CHECK(menu);
SDL_TrayMenu *menu2 = SDL_CreateTrayMenu(tray2);
CHECK(menu2);
SDL_TrayEntry *entry_quit = SDL_InsertTrayEntryAt(menu, -1, "Quit", SDL_TRAYENTRY_BUTTON);
CHECK(entry_quit);
SDL_SetTrayEntryCallback(entry_quit, tray_quit, NULL);
SDL_InsertTrayEntryAt(menu, -1, NULL, 0);
SDL_TrayEntry *entry_icon = SDL_InsertTrayEntryAt(menu, -1, "Change icon", SDL_TRAYENTRY_BUTTON);
CHECK(entry_icon);
SDL_SetTrayEntryCallback(entry_icon, change_icon, tray2);
SDL_InsertTrayEntryAt(menu, -1, NULL, 0);
SDL_TrayEntry *entry_newbtn = SDL_InsertTrayEntryAt(menu, -1, "Create button", SDL_TRAYENTRY_BUTTON);
CHECK(entry_newbtn);
SDL_SetTrayEntryCallback(entry_newbtn, append_button_to, menu2);
SDL_TrayEntry *entry_newchk = SDL_InsertTrayEntryAt(menu, -1, "Create checkbox", SDL_TRAYENTRY_BUTTON);
CHECK(entry_newchk);
SDL_SetTrayEntryCallback(entry_newchk, append_checkbox_to, menu2);
SDL_TrayEntry *entry_newsub = SDL_InsertTrayEntryAt(menu, -1, "Create submenu", SDL_TRAYENTRY_BUTTON);
CHECK(entry_newsub);
SDL_SetTrayEntryCallback(entry_newsub, append_submenu_to, menu2);
SDL_TrayEntry *entry_newsep = SDL_InsertTrayEntryAt(menu, -1, "Create separator", SDL_TRAYENTRY_BUTTON);
CHECK(entry_newsep);
SDL_SetTrayEntryCallback(entry_newsep, append_separator_to, menu2);
SDL_InsertTrayEntryAt(menu, -1, NULL, 0);
SDL_Event e;
while (SDL_WaitEvent(&e)) {
if (e.type == SDL_EVENT_QUIT) {
break;
}
}
clean_all:
SDL_DestroyTray(tray2);
clean_tray1:
SDL_DestroyTray(tray);
quit:
SDL_Quit();
SDLTest_CommonDestroyState(state);
return 0;
}
libs/SDL3/test/testwm.c
+2
View File
@@ -277,6 +277,8 @@ int main(int argc, char *argv[])
SDL_RenderClear(renderer);
}
SDL_StopTextInput(state->windows[0]);
SDL_StopTextInput(state->windows[0]);
/* Main render loop */
done = 0;
#ifdef SDL_PLATFORM_EMSCRIPTEN