mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2026-02-12 23:03:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed handling GameCube adapters in PC mode on Linux and macOS

Browse Source 
On Windows there is a separate HIDAPI device for each slot. On Linux and macOS, there is a single HIDAPI device and the slot is included in the report.
This commit is contained in:
Sam Lantinga
2026-02-02 15:43:35 -08:00
parent 12f97dbc97
commit cdffbdfeaf
2 changed files with 37 additions and 604 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/joystick/hidapi/SDL_hidapi_gamecube.c
View File

@@ -202,8 +202,16 @@ static bool HIDAPI_DriverGameCube_InitDevice(SDL_HIDAPI_Device *device)
}
if (ctx->pc_mode) {
#ifdef SDL_PLATFORM_WIN32
// We get a separate device for each slot
ResetAxisRange(ctx, 0);
HIDAPI_JoystickConnected(device, &ctx->joysticks[0]);
#else
for (i = 0; i < MAX_CONTROLLERS; ++i) {
ResetAxisRange(ctx, i);
HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
}
#endif
} else {
if (!HIDAPI_DriverGameCube_EnableAdapter(device)) {
return false;
@@ -267,14 +275,25 @@ static void HIDAPI_DriverGameCube_SetDevicePlayerIndex(SDL_HIDAPI_Device *device
{
}
static void HIDAPI_DriverGameCube_HandleJoystickPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, const Uint8 *packet, bool invert_c_stick)
static void HIDAPI_DriverGameCube_HandleJoystickPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, Uint8 slot, const Uint8 *packet, bool invert_c_stick)
{
SDL_Joystick *joystick;
const Uint8 i = 0; // We have a separate context for each connected controller in PC mode, just use the first index
Uint8 i;
Uint8 v;
Sint16 axis_value;
Uint64 timestamp = SDL_GetTicksNS();
#ifdef SDL_PLATFORM_WIN32
// We get a separate device for each slot
i = 0;
#else
i = slot;
if (i >= MAX_CONTROLLERS) {
// Invalid packet?
return;
}
#endif
joystick = SDL_GetJoystickFromID(ctx->joysticks[i]);
if (!joystick) {
// Hasn't been opened yet, skip
@@ -424,11 +443,11 @@ static bool HIDAPI_DriverGameCube_UpdateDevice(SDL_HIDAPI_Device *device)
// This is the older firmware
// The first byte is the index of the connected controller
// The C stick has an inverted value range compared to the left stick
HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, &packet[1], true);
HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, packet[0] - 1, &packet[1], true);
} else if (size == 9) {
// This is the newer firmware (version 0x7)
// The C stick has the same value range compared to the left stick
HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, packet, false);
HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, 0, packet, false);
} else {
// How do we handle this packet?
}

614
test/testsprite.c
View File

@@ -1,603 +1,17 @@
/*
Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
#include <SDL3/SDL.h>
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.
int main(void) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window *window = SDL_CreateWindow("", 500, 500, SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY);
SDL_Renderer *renderer = SDL_CreateRenderer(window, NULL);
SDL_Event event;
bool running = true;
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely.
*/
/* Simple program: Move N sprites around on the screen as fast as possible */
#define SDL_MAIN_USE_CALLBACKS 1
#include <SDL3/SDL_test.h>
#include <SDL3/SDL_test_common.h>
#include <SDL3/SDL_main.h>
#include "testutils.h"
#define NUM_SPRITES 100
#define MAX_SPEED 1
static SDLTest_CommonState *state;
static const char *icon = "icon.png";
static int num_sprites;
static SDL_Texture **sprites;
static bool cycle_color;
static bool cycle_alpha;
static int cycle_direction = 1;
static int current_alpha = 0;
static int current_color = 0;
static SDL_FRect *positions;
static SDL_FRect *velocities;
static float sprite_w, sprite_h;
static SDL_BlendMode blendMode = SDL_BLENDMODE_BLEND;
static Uint64 next_fps_check;
static Uint32 frames;
static const int fps_check_delay = 5000;
static int use_rendergeometry = 0;
static bool suspend_when_occluded;
/* Number of iterations to move sprites - used for visual tests. */
/* -1: infinite random moves (default); >=0: enables N deterministic moves */
static int iterations = -1;
void SDL_AppQuit(void *appstate, SDL_AppResult result)
{
SDL_free(sprites);
SDL_free(positions);
SDL_free(velocities);
SDLTest_CommonQuit(state);
}
static bool LoadSprite(const char *file)
{
int i;
for (i = 0; i < state->num_windows; ++i) {
/* This does the SDL_LoadPNG step repeatedly, but that's OK for test code. */
if (sprites[i]) {
SDL_DestroyTexture(sprites[i]);
}
sprites[i] = LoadTexture(state->renderers[i], file, true);
if (sprites[i]) {
sprite_w = (float)sprites[i]->w;
sprite_h = (float)sprites[i]->h;
}
if (!sprites[i]) {
return false;
}
if (!SDL_SetTextureBlendMode(sprites[i], blendMode)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s", SDL_GetError());
SDL_DestroyTexture(sprites[i]);
return false;
}
}
/* We're ready to roll. :) */
return true;
}
static void MoveSprites(SDL_Renderer *renderer, SDL_Texture *sprite)
{
int i;
SDL_Rect viewport;
SDL_FRect temp;
SDL_FRect *position, *velocity;
/* Query the sizes */
SDL_SetRenderViewport(renderer, NULL);
SDL_GetRenderSafeArea(renderer, &viewport);
SDL_SetRenderViewport(renderer, &viewport);
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureColorMod(sprite, 255, (Uint8)current_color,
(Uint8)current_color);
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureAlphaMod(sprite, (Uint8)current_alpha);
}
/* Draw a gray background */
if (SDL_GetWindowFlags(SDL_GetRenderWindow(renderer)) & SDL_WINDOW_TRANSPARENT) {
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, SDL_ALPHA_TRANSPARENT);
} else {
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, SDL_ALPHA_OPAQUE);
}
SDL_RenderClear(renderer);
/* Test points */
SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
SDL_RenderPoint(renderer, 0.0f, 0.0f);
SDL_RenderPoint(renderer, (float)(viewport.w - 1), 0.0f);
SDL_RenderPoint(renderer, 0.0f, (float)(viewport.h - 1));
SDL_RenderPoint(renderer, (float)(viewport.w - 1), (float)(viewport.h - 1));
/* Test horizontal and vertical lines */
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderLine(renderer, 1.0f, 0.0f, (float)(viewport.w - 2), 0.0f);
SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
SDL_RenderLine(renderer, 1.0f, (float)(viewport.h - 1), (float)(viewport.w - 2), (float)(viewport.h - 1));
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0xFF, 0xFF);
SDL_RenderLine(renderer, 0.0f, 1.0f, 0.0f, (float)(viewport.h - 2));
SDL_RenderLine(renderer, (float)(viewport.w - 1), 1.0f, (float)(viewport.w - 1), (float)(viewport.h - 2));
/* Test fill and copy */
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
temp.x = 1.0f;
temp.y = 1.0f;
temp.w = sprite_w;
temp.h = sprite_h;
if (use_rendergeometry == 0) {
SDL_RenderFillRect(renderer, &temp);
} else {
/* Draw two triangles, filled, uniform */
SDL_FColor color;
SDL_Vertex verts[3];
SDL_zeroa(verts);
color.r = 1.0f;
color.g = 1.0f;
color.b = 1.0f;
color.a = 1.0f;
verts[0].position.x = temp.x;
verts[0].position.y = temp.y;
verts[0].color = color;
verts[1].position.x = temp.x + temp.w;
verts[1].position.y = temp.y;
verts[1].color = color;
verts[2].position.x = temp.x + temp.w;
verts[2].position.y = temp.y + temp.h;
verts[2].color = color;
SDL_RenderGeometry(renderer, NULL, verts, 3, NULL, 0);
verts[1].position.x = temp.x;
verts[1].position.y = temp.y + temp.h;
verts[1].color = color;
SDL_RenderGeometry(renderer, NULL, verts, 3, NULL, 0);
}
SDL_RenderTexture(renderer, sprite, NULL, &temp);
temp.x = viewport.w - sprite_w - 1;
temp.y = 1.0f;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderTexture(renderer, sprite, NULL, &temp);
temp.x = 1.0f;
temp.y = viewport.h - sprite_h - 1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderTexture(renderer, sprite, NULL, &temp);
temp.x = viewport.w - sprite_w - 1;
temp.y = viewport.h - sprite_h - 1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderTexture(renderer, sprite, NULL, &temp);
/* Test diagonal lines */
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderLine(renderer, sprite_w, sprite_h,
viewport.w - sprite_w - 2, viewport.h - sprite_h - 2);
SDL_RenderLine(renderer, viewport.w - sprite_w - 2, sprite_h,
sprite_w, viewport.h - sprite_h - 2);
/* Conditionally move the sprites, bounce at the wall */
if (iterations == -1 || iterations > 0) {
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
velocity = &velocities[i];
position->x += velocity->x;
if ((position->x < 0) || (position->x >= (viewport.w - sprite_w))) {
velocity->x = -velocity->x;
position->x += velocity->x;
}
position->y += velocity->y;
if ((position->y < 0) || (position->y >= (viewport.h - sprite_h))) {
velocity->y = -velocity->y;
position->y += velocity->y;
}
}
/* Countdown sprite-move iterations and disable color changes at iteration end - used for visual tests. */
if (iterations > 0) {
iterations--;
if (iterations == 0) {
cycle_alpha = false;
cycle_color = false;
}
}
}
/* Draw sprites */
if (use_rendergeometry == 0) {
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
/* Blit the sprite onto the screen */
SDL_RenderTexture(renderer, sprite, NULL, position);
}
} else if (use_rendergeometry == 1) {
/*
* 0--1
* | /|
* |/ |
* 3--2
*
* Draw sprite2 as triangles that can be recombined as rect by software renderer
*/
SDL_Vertex *verts = (SDL_Vertex *)SDL_malloc(num_sprites * sizeof(SDL_Vertex) * 6);
SDL_Vertex *verts2 = verts;
if (verts) {
SDL_FColor color;
SDL_GetTextureColorModFloat(sprite, &color.r, &color.g, &color.b);
SDL_GetTextureAlphaModFloat(sprite, &color.a);
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
/* 0 */
verts->position.x = position->x;
verts->position.y = position->y;
verts->color = color;
verts->tex_coord.x = 0.0f;
verts->tex_coord.y = 0.0f;
verts++;
/* 1 */
verts->position.x = position->x + position->w;
verts->position.y = position->y;
verts->color = color;
verts->tex_coord.x = 1.0f;
verts->tex_coord.y = 0.0f;
verts++;
/* 2 */
verts->position.x = position->x + position->w;
verts->position.y = position->y + position->h;
verts->color = color;
verts->tex_coord.x = 1.0f;
verts->tex_coord.y = 1.0f;
verts++;
/* 0 */
verts->position.x = position->x;
verts->position.y = position->y;
verts->color = color;
verts->tex_coord.x = 0.0f;
verts->tex_coord.y = 0.0f;
verts++;
/* 2 */
verts->position.x = position->x + position->w;
verts->position.y = position->y + position->h;
verts->color = color;
verts->tex_coord.x = 1.0f;
verts->tex_coord.y = 1.0f;
verts++;
/* 3 */
verts->position.x = position->x;
verts->position.y = position->y + position->h;
verts->color = color;
verts->tex_coord.x = 0.0f;
verts->tex_coord.y = 1.0f;
verts++;
}
/* Blit sprites as triangles onto the screen */
SDL_RenderGeometry(renderer, sprite, verts2, num_sprites * 6, NULL, 0);
SDL_free(verts2);
}
} else if (use_rendergeometry == 2) {
/* 0-----1
* |\ A /|
* | \ / |
* |D 2 B|
* | / \ |
* |/ C \|
* 3-----4
*
* Draw sprite2 as triangles that can *not* be recombined as rect by software renderer
* Use an 'indices' array
*/
SDL_Vertex *verts = (SDL_Vertex *)SDL_malloc(num_sprites * sizeof(SDL_Vertex) * 5);
SDL_Vertex *verts2 = verts;
int *indices = (int *)SDL_malloc(num_sprites * sizeof(int) * 4 * 3);
int *indices2 = indices;
if (verts && indices) {
int pos = 0;
SDL_FColor color;
SDL_GetTextureColorModFloat(sprite, &color.r, &color.g, &color.b);
SDL_GetTextureAlphaModFloat(sprite, &color.a);
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
/* 0 */
verts->position.x = position->x;
verts->position.y = position->y;
verts->color = color;
verts->tex_coord.x = 0.0f;
verts->tex_coord.y = 0.0f;
verts++;
/* 1 */
verts->position.x = position->x + position->w;
verts->position.y = position->y;
verts->color = color;
verts->tex_coord.x = 1.0f;
verts->tex_coord.y = 0.0f;
verts++;
/* 2 */
verts->position.x = position->x + position->w / 2.0f;
verts->position.y = position->y + position->h / 2.0f;
verts->color = color;
verts->tex_coord.x = 0.5f;
verts->tex_coord.y = 0.5f;
verts++;
/* 3 */
verts->position.x = position->x;
verts->position.y = position->y + position->h;
verts->color = color;
verts->tex_coord.x = 0.0f;
verts->tex_coord.y = 1.0f;
verts++;
/* 4 */
verts->position.x = position->x + position->w;
verts->position.y = position->y + position->h;
verts->color = color;
verts->tex_coord.x = 1.0f;
verts->tex_coord.y = 1.0f;
verts++;
/* A */
*indices++ = pos + 0;
*indices++ = pos + 1;
*indices++ = pos + 2;
/* B */
*indices++ = pos + 1;
*indices++ = pos + 2;
*indices++ = pos + 4;
/* C */
*indices++ = pos + 3;
*indices++ = pos + 2;
*indices++ = pos + 4;
/* D */
*indices++ = pos + 3;
*indices++ = pos + 2;
*indices++ = pos + 0;
pos += 5;
}
}
/* Blit sprites as triangles onto the screen */
SDL_RenderGeometry(renderer, sprite, verts2, num_sprites * 5, indices2, num_sprites * 4 * 3);
SDL_free(verts2);
SDL_free(indices2);
}
/* Update the screen! */
SDL_RenderPresent(renderer);
}
SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
SDL_Rect safe_area;
int i;
Uint64 seed;
/* Initialize parameters */
num_sprites = NUM_SPRITES;
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return SDL_APP_FAILURE;
}
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed == 0) {
consumed = -1;
if (SDL_strcasecmp(argv[i], "--blend") == 0) {
if (argv[i + 1]) {
if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
blendMode = SDL_BLENDMODE_NONE;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
blendMode = SDL_BLENDMODE_BLEND;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "blend_premultiplied") == 0) {
blendMode = SDL_BLENDMODE_BLEND_PREMULTIPLIED;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
blendMode = SDL_BLENDMODE_ADD;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "add_premultiplied") == 0) {
blendMode = SDL_BLENDMODE_ADD_PREMULTIPLIED;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
blendMode = SDL_BLENDMODE_MOD;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "mul") == 0) {
blendMode = SDL_BLENDMODE_MUL;
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "sub") == 0) {
blendMode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_SUBTRACT, SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_SUBTRACT);
consumed = 2;
}
}
} else if (SDL_strcasecmp(argv[i], "--iterations") == 0) {
if (argv[i + 1]) {
iterations = SDL_atoi(argv[i + 1]);
if (iterations < -1) {
iterations = -1;
}
consumed = 2;
}
} else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) {
cycle_color = true;
consumed = 1;
} else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
cycle_alpha = true;
consumed = 1;
} else if (SDL_strcasecmp(argv[i], "--suspend-when-occluded") == 0) {
suspend_when_occluded = true;
consumed = 1;
} else if (SDL_strcasecmp(argv[i], "--use-rendergeometry") == 0) {
if (argv[i + 1]) {
if (SDL_strcasecmp(argv[i + 1], "mode1") == 0) {
/* Draw sprite2 as triangles that can be recombined as rect by software renderer */
use_rendergeometry = 1;
} else if (SDL_strcasecmp(argv[i + 1], "mode2") == 0) {
/* Draw sprite2 as triangles that can *not* be recombined as rect by software renderer
* Use an 'indices' array */
use_rendergeometry = 2;
} else {
return SDL_APP_FAILURE;
}
}
consumed = 2;
} else if (SDL_isdigit(*argv[i])) {
num_sprites = SDL_atoi(argv[i]);
consumed = 1;
} else if (argv[i][0] != '-') {
icon = argv[i];
consumed = 1;
}
}
if (consumed < 0) {
static const char *options[] = {
"[--blend none|blend|blend_premultiplied|add|add_premultiplied|mod|mul|sub]",
"[--cyclecolor]",
"[--cyclealpha]",
"[--suspend-when-occluded]",
"[--iterations N]",
"[--use-rendergeometry mode1|mode2]",
"[num_sprites]",
"[icon.png]",
NULL
};
SDLTest_CommonLogUsage(state, argv[0], options);
return SDL_APP_FAILURE;
}
i += consumed;
}
if (!SDLTest_CommonInit(state)) {
return SDL_APP_FAILURE;
}
/* Create the windows, initialize the renderers, and load the textures */
sprites =
(SDL_Texture **)SDL_calloc(state->num_windows, sizeof(*sprites));
if (!sprites) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
return SDL_APP_FAILURE;
}
for (i = 0; i < state->num_windows; ++i) {
SDL_Renderer *renderer = state->renderers[i];
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
}
if (!LoadSprite(icon)) {
return SDL_APP_FAILURE;
}
/* Allocate memory for the sprite info */
positions = (SDL_FRect *)SDL_malloc(num_sprites * sizeof(*positions));
velocities = (SDL_FRect *)SDL_malloc(num_sprites * sizeof(*velocities));
if (!positions || !velocities) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
return SDL_APP_FAILURE;
}
/* Position sprites and set their velocities using the fuzzer */
/* Really we should be using per-window safe area, but this is fine for a simple test */
SDL_GetRenderSafeArea(state->renderers[0], &safe_area);
if (iterations >= 0) {
/* Deterministic seed - used for visual tests */
seed = (Uint64)iterations;
} else {
/* Pseudo-random seed generated from the time */
seed = SDL_GetPerformanceCounter();
}
SDLTest_FuzzerInit(seed);
for (i = 0; i < num_sprites; ++i) {
positions[i].x = (float)SDLTest_RandomIntegerInRange(0, (int)(safe_area.w - sprite_w));
positions[i].y = (float)SDLTest_RandomIntegerInRange(0, (int)(safe_area.h - sprite_h));
positions[i].w = sprite_w;
positions[i].h = sprite_h;
velocities[i].x = 0;
velocities[i].y = 0;
while (velocities[i].x == 0.f && velocities[i].y == 0.f) {
velocities[i].x = (float)SDLTest_RandomIntegerInRange(-MAX_SPEED, MAX_SPEED);
velocities[i].y = (float)SDLTest_RandomIntegerInRange(-MAX_SPEED, MAX_SPEED);
}
}
/* Main render loop in SDL_AppIterate will begin when this function returns. */
frames = 0;
next_fps_check = SDL_GetTicks() + fps_check_delay;
return SDL_APP_CONTINUE;
}
SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
{
if (event->type == SDL_EVENT_RENDER_DEVICE_RESET) {
LoadSprite(icon);
}
return SDLTest_CommonEventMainCallbacks(state, event);
}
SDL_AppResult SDL_AppIterate(void *appstate)
{
Uint64 now;
int i;
int active_windows = 0;
for (i = 0; i < state->num_windows; ++i) {
if (state->windows[i] == NULL ||
(suspend_when_occluded && (SDL_GetWindowFlags(state->windows[i]) & SDL_WINDOW_OCCLUDED))) {
continue;
}
++active_windows;
MoveSprites(state->renderers[i], sprites[i]);
}
/* If all windows are occluded, throttle the event polling to 15hz. */
if (!active_windows) {
SDL_DelayNS(SDL_NS_PER_SECOND / 15);
}
frames++;
now = SDL_GetTicks();
if (now >= next_fps_check) {
/* Print out some timing information */
const Uint64 then = next_fps_check - fps_check_delay;
const double fps = ((double)frames * 1000) / (now - then);
SDL_Log("%2.2f frames per second", fps);
next_fps_check = now + fps_check_delay;
frames = 0;
}
return SDL_APP_CONTINUE;
while (running) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_EVENT_QUIT) running = false;
if (event.type == SDL_EVENT_MOUSE_MOTION) SDL_Log("%f\n", event.motion.x);
}
SDL_RenderPresent(renderer);
}
}