From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- src/contrib/SDL-3.2.20/test/testpen.c | 287 ++++++++++++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/test/testpen.c (limited to 'src/contrib/SDL-3.2.20/test/testpen.c') diff --git a/src/contrib/SDL-3.2.20/test/testpen.c b/src/contrib/SDL-3.2.20/test/testpen.c new file mode 100644 index 0000000..bb6e7d2 --- /dev/null +++ b/src/contrib/SDL-3.2.20/test/testpen.c @@ -0,0 +1,287 @@ +/* + Copyright (C) 1997-2025 Sam Lantinga + + 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 +#include +#include + +typedef struct Pen +{ + SDL_PenID pen; + Uint8 r, g, b; + float axes[SDL_PEN_AXIS_COUNT]; + float x; + float y; + Uint32 buttons; + bool eraser; + bool touching; + struct Pen *next; +} Pen; + +static SDL_Renderer *renderer = NULL; +static SDLTest_CommonState *state = NULL; +static SDL_Texture *white_pixel = NULL; +static Pen pens; + + +SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) +{ + int i; + + SDL_srand(0); + + /* Initialize test framework */ + state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); + if (!state) { + return SDL_APP_FAILURE; + } + + /* 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; + } + + white_pixel = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STATIC, 16, 16); + if (!white_pixel) { + SDL_Log("Couldn't create white_pixel texture: %s", SDL_GetError()); + return SDL_APP_FAILURE; + } else { + const SDL_Rect rect = { 0, 0, 16, 16 }; + Uint32 pixels[16 * 16]; + SDL_memset(pixels, 0xFF, sizeof (pixels)); + SDL_UpdateTexture(white_pixel, &rect, pixels, 16 * sizeof (Uint32)); + } + + SDL_HideCursor(); + + return SDL_APP_CONTINUE; +} + +static Pen *FindPen(SDL_PenID which) +{ + Pen *i; + for (i = pens.next; i != NULL; i = i->next) { + if (i->pen == which) { + return i; + } + } + return NULL; +} + +SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) +{ + Pen *pen = NULL; + + switch (event->type) { + case SDL_EVENT_PEN_PROXIMITY_IN: { + pen = (Pen *) SDL_calloc(1, sizeof (*pen)); + if (!pen) { + SDL_Log("Out of memory!"); + return SDL_APP_FAILURE; + } + + SDL_Log("Pen %" SDL_PRIu32 " enters proximity!", event->pproximity.which); + pen->pen = event->pproximity.which; + pen->r = (Uint8) SDL_rand(256); + pen->g = (Uint8) SDL_rand(256); + pen->b = (Uint8) SDL_rand(256); + pen->x = 320.0f; + pen->y = 240.0f; + pen->next = pens.next; + pens.next = pen; + + return SDL_APP_CONTINUE; + } + + case SDL_EVENT_PEN_PROXIMITY_OUT: { + Pen *prev = &pens; + Pen *i; + + SDL_Log("Pen %" SDL_PRIu32 " leaves proximity!", event->pproximity.which); + for (i = pens.next; i != NULL; i = i->next) { + if (i->pen == event->pproximity.which) { + prev->next = i->next; + SDL_free(i); + break; + } + prev = i; + } + + return SDL_APP_CONTINUE; + } + + case SDL_EVENT_PEN_DOWN: + /*SDL_Log("Pen %" SDL_PRIu32 " down!", event->ptouch.which);*/ + pen = FindPen(event->ptouch.which); + if (pen) { + pen->touching = true; + pen->eraser = (event->ptouch.eraser != 0); + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_PEN_UP: + /*SDL_Log("Pen %" SDL_PRIu32 " up!", event->ptouch.which);*/ + pen = FindPen(event->ptouch.which); + if (pen) { + pen->touching = false; + pen->axes[SDL_PEN_AXIS_PRESSURE] = 0.0f; + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_PEN_BUTTON_DOWN: + /*SDL_Log("Pen %" SDL_PRIu32 " button %d down!", event->pbutton.which, (int) event->pbutton.button);*/ + pen = FindPen(event->ptouch.which); + if (pen) { + pen->buttons |= (1 << (event->pbutton.button-1)); + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_PEN_BUTTON_UP: + /*SDL_Log("Pen %" SDL_PRIu32 " button %d up!", event->pbutton.which, (int) event->pbutton.button);*/ + pen = FindPen(event->ptouch.which); + if (pen) { + pen->buttons &= ~(1 << (event->pbutton.button-1)); + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_PEN_MOTION: + /*SDL_Log("Pen %" SDL_PRIu32 " moved to (%f,%f)!", event->pmotion.which, event->pmotion.x, event->pmotion.y);*/ + pen = FindPen(event->ptouch.which); + if (pen) { + pen->x = event->pmotion.x; + pen->y = event->pmotion.y; + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_PEN_AXIS: + /*SDL_Log("Pen %" SDL_PRIu32 " axis %d is now %f!", event->paxis.which, (int) event->paxis.axis, event->paxis.value);*/ + pen = FindPen(event->ptouch.which); + if (pen && (event->paxis.axis < SDL_arraysize(pen->axes))) { + pen->axes[event->paxis.axis] = event->paxis.value; + } + return SDL_APP_CONTINUE; + + case SDL_EVENT_KEY_DOWN: { + const SDL_Keycode sym = event->key.key; + if (sym == SDLK_ESCAPE || sym == SDLK_AC_BACK) { + SDL_Log("Key : Escape!"); + return SDL_APP_SUCCESS; + } + break; + } + + case SDL_EVENT_QUIT: + return SDL_APP_SUCCESS; + + default: + break; + } + + return SDLTest_CommonEventMainCallbacks(state, event); +} + +static void DrawOnePen(Pen *pen, int num) +{ + int i; + + /* draw button presses for this pen. A square for each in the pen's color, offset down the screen so they don't overlap. */ + SDL_SetRenderDrawColor(renderer, pen->r, pen->g, pen->b, 255); + for (i = 0; i < 8; i++) { /* we assume you don't have more than 8 buttons atm... */ + if (pen->buttons & (1 << i)) { + const SDL_FRect rect = { 30.0f * ((float) i), ((float) num) * 30.0f, 30.0f, 30.0f }; + SDL_RenderFillRect(renderer, &rect); + } + } + + /* draw a square to represent pressure. Always green for eraser and blue for pen */ + /* we do this with a texture, so we can trivially rotate it, which SDL_RenderFillRect doesn't offer. */ + if (pen->axes[SDL_PEN_AXIS_PRESSURE] > 0.0f) { + const float size = (150.0f * pen->axes[SDL_PEN_AXIS_PRESSURE]) + 20.0f; + const float halfsize = size / 2.0f; + const SDL_FRect rect = { pen->x - halfsize, pen->y - halfsize, size, size }; + const SDL_FPoint center = { halfsize, halfsize }; + if (pen->eraser) { + SDL_SetTextureColorMod(white_pixel, 0, 255, 0); + } else { + SDL_SetTextureColorMod(white_pixel, 0, 0, 255); + } + SDL_RenderTextureRotated(renderer, white_pixel, NULL, &rect, pen->axes[SDL_PEN_AXIS_ROTATION], ¢er, SDL_FLIP_NONE); + } + + /* draw a little square for position in the center of the pressure, with the pen-specific color. */ + { + const float distance = pen->touching ? 0.0f : SDL_clamp(pen->axes[SDL_PEN_AXIS_DISTANCE], 0.0f, 1.0f); + const float size = 10 + (30.0f * (1.0f - distance)); + const float halfsize = size / 2.0f; + const SDL_FRect rect = { pen->x - halfsize, pen->y - halfsize, size, size }; + const SDL_FPoint center = { halfsize, halfsize }; + SDL_SetTextureColorMod(white_pixel, pen->r, pen->g, pen->b); + SDL_RenderTextureRotated(renderer, white_pixel, NULL, &rect, pen->axes[SDL_PEN_AXIS_ROTATION], ¢er, SDL_FLIP_NONE); + } +} + +SDL_AppResult SDL_AppIterate(void *appstate) +{ + int num = 0; + Pen *pen; + + SDL_SetRenderDrawColor(renderer, 0x99, 0x99, 0x99, 255); + SDL_RenderClear(renderer); + + for (pen = pens.next; pen != NULL; pen = pen->next, num++) { + DrawOnePen(pen, num); + } + + SDL_RenderPresent(renderer); + + return SDL_APP_CONTINUE; +} + +void SDL_AppQuit(void *appstate, SDL_AppResult result) +{ + Pen *i, *next; + for (i = pens.next; i != NULL; i = next) { + next = i->next; + SDL_free(i); + } + pens.next = NULL; + SDL_DestroyTexture(white_pixel); + SDLTest_CommonQuit(state); +} + -- cgit v1.2.3