testgamecontroller.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDL.h"

Include dependency graph for testgamecontroller.c:

Go to the source code of this file.

Macros
#define	SCREEN_WIDTH   512
#define	SCREEN_HEIGHT   320

Functions
static void	UpdateWindowTitle ()
static int	FindController (SDL_JoystickID controller_id)
static void	AddController (int device_index, SDL_bool verbose)
static void	SetController (SDL_JoystickID controller)
static void	DelController (SDL_JoystickID controller)
static SDL_Texture *	LoadTexture (SDL_Renderer *renderer, const char *file, SDL_bool transparent)
static Uint16	ConvertAxisToRumble (Sint16 axis)
void	loop (void *arg)
int	main (int argc, char *argv[])

Variables
struct {
int   x
int   y
}	button_positions []
struct {
int   x
int   y
double   angle
}	axis_positions []
SDL_Window *	window = NULL
SDL_Renderer *	screen = NULL
SDL_bool	retval = SDL_FALSE
SDL_bool	done = SDL_FALSE
SDL_bool	set_LED = SDL_FALSE
SDL_Texture *	background_front
SDL_Texture *	background_back
SDL_Texture *	button
SDL_Texture *	axis
SDL_GameController *	gamecontroller
SDL_GameController **	gamecontrollers
int	num_controllers = 0

Macro Definition Documentation

SCREEN_HEIGHT

#define SCREEN_HEIGHT   320

Definition at line 28 of file testgamecontroller.c.

SCREEN_WIDTH

#define SCREEN_WIDTH   512

Definition at line 27 of file testgamecontroller.c.

Function Documentation

AddController()

static void AddController ( int  device_index, SDL_bool  verbose  )

static

Definition at line 117 of file testgamecontroller.c.

{
    SDL_JoystickID controller_id = SDL_JoystickGetDeviceInstanceID(device_index);
    SDL_GameController *controller;
    SDL_GameController **controllers;
 
    controller_id = SDL_JoystickGetDeviceInstanceID(device_index);
    if (controller_id < 0) {
        SDL_Log("Couldn't get controller ID: %s\n", SDL_GetError());
        return;
    }
 
    if (FindController(controller_id) >= 0) {
        /* We already have this controller */
        return;
    }
 
    controller = SDL_GameControllerOpen(device_index);
    if (!controller) {
        SDL_Log("Couldn't open controller: %s\n", SDL_GetError());
        return;
    }
 
    controllers = (SDL_GameController **)SDL_realloc(gamecontrollers, (num_controllers + 1) * sizeof(*controllers));
    if (!controllers) {
        SDL_GameControllerClose(controller);
        return;
    }
 
    controllers[num_controllers++] = controller;
    gamecontrollers = controllers;
    gamecontroller = controller;
 
    if (verbose) {
        const char *name = SDL_GameControllerName(gamecontroller);
        SDL_Log("Opened game controller %s\n", name);
    }
 
    if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_ACCEL)) {
        if (verbose) {
            SDL_Log("Enabling accelerometer\n");
        }
        SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_ACCEL, SDL_TRUE);
    }
 
    if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_GYRO)) {
        if (verbose) {
            SDL_Log("Enabling gyro\n");
        }
        SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_GYRO, SDL_TRUE);
    }
 
    UpdateWindowTitle();
}

References sort_controllers::controllers, FindController(), gamecontroller, gamecontrollers, num_controllers, SDL_GameControllerClose, SDL_GameControllerHasSensor, SDL_GameControllerName, SDL_GameControllerOpen, SDL_GameControllerSetSensorEnabled, SDL_GetError, SDL_JoystickGetDeviceInstanceID, SDL_Log, SDL_realloc, SDL_SENSOR_ACCEL, SDL_SENSOR_GYRO, SDL_TRUE, and UpdateWindowTitle().

Referenced by loop(), and main().

ConvertAxisToRumble()

static Uint16 ConvertAxisToRumble ( Sint16  axis )

static

Definition at line 237 of file testgamecontroller.c.

{
    /* Only start rumbling if the axis is past the halfway point */
    const Sint16 half_axis = (Sint16)SDL_ceil(SDL_JOYSTICK_AXIS_MAX / 2.0f);
    if (axis > half_axis) {
        return (Uint16)(axis - half_axis) * 4;
    } else {
        return 0;
    }
}

References axis, SDL_ceil, and SDL_JOYSTICK_AXIS_MAX.

Referenced by loop().

DelController()

static void DelController ( SDL_JoystickID  controller )

static

Definition at line 186 of file testgamecontroller.c.

{
    int i = FindController(controller);
 
    if (i < 0) {
        return;
    }
 
    SDL_GameControllerClose(gamecontrollers[i]);
 
    --num_controllers;
    if (i < num_controllers) {
        SDL_memcpy(&gamecontrollers[i], &gamecontrollers[i+1], (num_controllers - i) * sizeof(*gamecontrollers));
    }
 
    if (num_controllers > 0) {
        gamecontroller = gamecontrollers[0];
    } else {
        gamecontroller = NULL;
    }
    UpdateWindowTitle();
}

References FindController(), gamecontroller, gamecontrollers, i, NULL, num_controllers, SDL_GameControllerClose, SDL_memcpy, and UpdateWindowTitle().

Referenced by loop().

FindController()

static int FindController ( SDL_JoystickID  controller_id )

static

Definition at line 105 of file testgamecontroller.c.

{
    int i;
 
    for (i = 0; i < num_controllers; ++i) {
        if (controller_id == SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontrollers[i]))) {
            return i;
        }
    }
    return -1;
}

References gamecontrollers, i, num_controllers, SDL_GameControllerGetJoystick, and SDL_JoystickInstanceID.

Referenced by AddController(), DelController(), and SetController().

LoadTexture()

static SDL_Texture* LoadTexture ( SDL_Renderer *  renderer, const char *  file, SDL_bool  transparent  )

static

Definition at line 210 of file testgamecontroller.c.

{
    SDL_Surface *temp = NULL;
    SDL_Texture *texture = NULL;
 
    temp = SDL_LoadBMP(file);
    if (temp == NULL) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
    } else {
        /* Set transparent pixel as the pixel at (0,0) */
        if (transparent) {
            if (temp->format->BytesPerPixel == 1) {
                SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels);
            }
        }
 
        texture = SDL_CreateTextureFromSurface(renderer, temp);
        if (!texture) {
            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
        }
    }
    if (temp) {
        SDL_FreeSurface(temp);
    }
    return texture;
}

References SDL_PixelFormat::BytesPerPixel, SDL_Surface::format, NULL, SDL_Surface::pixels, renderer, SDL_CreateTextureFromSurface, SDL_FreeSurface, SDL_GetError, SDL_LoadBMP, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_SetColorKey, and SDL_TRUE.

Referenced by main().

loop()

void loop

(

void *

arg

)

Definition at line 249 of file testgamecontroller.c.

{
    SDL_Event event;
    int i;
    SDL_bool showing_front = SDL_TRUE;
 
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
        case SDL_CONTROLLERDEVICEADDED:
            SDL_Log("Game controller device %d added.\n", (int) SDL_JoystickGetDeviceInstanceID(event.cdevice.which));
            AddController(event.cdevice.which, SDL_TRUE);
            break;
 
        case SDL_CONTROLLERDEVICEREMOVED:
            SDL_Log("Game controller device %d removed.\n", (int) event.cdevice.which);
            DelController(event.cdevice.which);
            break;
 
        case SDL_CONTROLLERTOUCHPADDOWN:
        case SDL_CONTROLLERTOUCHPADMOTION:
        case SDL_CONTROLLERTOUCHPADUP:
            SDL_Log("Controller touchpad %d finger %d %s %.2f, %.2f, %.2f\n",
                event.ctouchpad.touchpad,
                event.ctouchpad.finger,
                (event.type == SDL_CONTROLLERTOUCHPADDOWN ? "pressed at" :
                (event.type == SDL_CONTROLLERTOUCHPADUP ? "released at" :
                "moved to")),
                event.ctouchpad.x,
                event.ctouchpad.y,
                event.ctouchpad.pressure);
            break;
 
        case SDL_CONTROLLERSENSORUPDATE:
            SDL_Log("Controller sensor %s: %.2f, %.2f, %.2f\n",
                event.csensor.sensor == SDL_SENSOR_ACCEL ? "accelerometer" :
                event.csensor.sensor == SDL_SENSOR_GYRO ? "gyro" : "unknown",
                event.csensor.data[0],
                event.csensor.data[1],
                event.csensor.data[2]);
            break;
 
        case SDL_CONTROLLERAXISMOTION:
            if (event.caxis.value <= (-SDL_JOYSTICK_AXIS_MAX / 2) || event.caxis.value >= (SDL_JOYSTICK_AXIS_MAX / 2)) {
                SetController(event.caxis.which);
            }
            SDL_Log("Controller axis %s changed to %d\n", SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)event.caxis.axis), event.caxis.value);
            break;
 
        case SDL_CONTROLLERBUTTONDOWN:
        case SDL_CONTROLLERBUTTONUP:
            if (event.type == SDL_CONTROLLERBUTTONDOWN) {
                SetController(event.cbutton.which);
            }
            SDL_Log("Controller button %s %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button), event.cbutton.state ? "pressed" : "released");
            break;
 
        case SDL_KEYDOWN:
            if (event.key.keysym.sym != SDLK_ESCAPE) {
                break;
            }
            /* Fall through to signal quit */
        case SDL_QUIT:
            done = SDL_TRUE;
            break;
        default:
            break;
        }
    }
 
    if (gamecontroller) {
        /* Show the back of the controller if the paddles are being held */
        for (i = SDL_CONTROLLER_BUTTON_PADDLE1; i <= SDL_CONTROLLER_BUTTON_PADDLE4; ++i) {
            if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
                showing_front = SDL_FALSE;
                break;
            }
        }
    }
 
    /* blank screen, set up for drawing this frame. */
    SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
    SDL_RenderClear(screen);
    SDL_RenderCopy(screen, showing_front ? background_front : background_back, NULL, NULL);
 
    if (gamecontroller) {
        /* Update visual controller state */
        for (i = 0; i < SDL_CONTROLLER_BUTTON_TOUCHPAD; ++i) {
            if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
                SDL_bool on_front = (i < SDL_CONTROLLER_BUTTON_PADDLE1 || i > SDL_CONTROLLER_BUTTON_PADDLE4);
                if (on_front == showing_front) {
                    const SDL_Rect dst = { button_positions[i].x, button_positions[i].y, 50, 50 };
                    SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, SDL_FLIP_NONE);
                }
            }
        }
 
        if (showing_front) {
            for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; ++i) {
                const Sint16 deadzone = 8000;  /* !!! FIXME: real deadzone */
                const Sint16 value = SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i));
                if (value < -deadzone) {
                    const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
                    const double angle = axis_positions[i].angle;
                    SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                } else if (value > deadzone) {
                    const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
                    const double angle = axis_positions[i].angle + 180.0;
                    SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                }
            }
        }
 
        /* Update LED based on left thumbstick position */
        {
            Sint16 x = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTX);
            Sint16 y = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTY);
 
            if (!set_LED) {
                set_LED = (x < -8000 || x > 8000 || y > 8000);
            }
            if (set_LED) {
                Uint8 r, g, b;
 
                if (x < 0) {
                    r = (Uint8)(((int)(~x) * 255) / 32767);
                    b = 0;
                } else {
                    r = 0;
                    b = (Uint8)(((int)(x) * 255) / 32767);
                }
                if (y > 0) {
                    g = (Uint8)(((int)(y) * 255) / 32767);
                } else {
                    g = 0;
                }
 
                SDL_GameControllerSetLED(gamecontroller, r, g, b);
            }
        }
 
        /* Update rumble based on trigger state */
        {
            Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERLEFT);
            Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT);
            Uint16 low_frequency_rumble = ConvertAxisToRumble(left);
            Uint16 high_frequency_rumble = ConvertAxisToRumble(right);
            SDL_GameControllerRumble(gamecontroller, low_frequency_rumble, high_frequency_rumble, 250);
        }
 
        /* Update trigger rumble based on thumbstick state */
        {
            Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTY);
            Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_RIGHTY);
            Uint16 left_rumble = ConvertAxisToRumble(~left);
            Uint16 right_rumble = ConvertAxisToRumble(~right);
 
            SDL_GameControllerRumbleTriggers(gamecontroller, left_rumble, right_rumble, 250);
        }
    }
 
    SDL_RenderPresent(screen);
 
#ifdef __EMSCRIPTEN__
    if (done) {
        emscripten_cancel_main_loop();
    }
#endif
}

References AddController(), axis, axis_positions, background_back, background_front, button, button_positions, ConvertAxisToRumble(), DelController(), done, gamecontroller, i, NULL, screen, SDL_ALPHA_OPAQUE, SDL_CONTROLLER_AXIS_LEFTX, SDL_CONTROLLER_AXIS_LEFTY, SDL_CONTROLLER_AXIS_MAX, SDL_CONTROLLER_AXIS_RIGHTY, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_CONTROLLER_BUTTON_PADDLE1, SDL_CONTROLLER_BUTTON_PADDLE4, SDL_CONTROLLER_BUTTON_TOUCHPAD, SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_CONTROLLERSENSORUPDATE, SDL_CONTROLLERTOUCHPADDOWN, SDL_CONTROLLERTOUCHPADMOTION, SDL_CONTROLLERTOUCHPADUP, SDL_FALSE, SDL_FLIP_NONE, SDL_GameControllerGetAxis, SDL_GameControllerGetButton, SDL_GameControllerGetStringForAxis, SDL_GameControllerGetStringForButton, SDL_GameControllerRumble, SDL_GameControllerRumbleTriggers, SDL_GameControllerSetLED, SDL_JOYSTICK_AXIS_MAX, SDL_JoystickGetDeviceInstanceID, SDL_KEYDOWN, SDL_Log, SDL_PollEvent, SDL_PRESSED, SDL_QUIT, SDL_RenderClear, SDL_RenderCopy, SDL_RenderCopyEx, SDL_RenderPresent, SDL_SENSOR_ACCEL, SDL_SENSOR_GYRO, SDL_SetRenderDrawColor, SDL_TRUE, SDLK_ESCAPE, set_LED, SetController(), x, and y.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 419 of file testgamecontroller.c.

{
    int i;
    int controller_count = 0;
    int controller_index = 0;
    char guid[64];
 
    SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0");
    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
    SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
 
    /* Enable standard application logging */
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
    /* Initialize SDL (Note: video is required to start event loop) */
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER ) < 0) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
        return 1;
    }
    
    SDL_GameControllerAddMappingsFromFile("gamecontrollerdb.txt");
 
    /* Print information about the mappings */
    if (argv[1] && SDL_strcmp(argv[1], "--mappings") == 0) {
        SDL_Log("Supported mappings:\n");
        for (i = 0; i < SDL_GameControllerNumMappings(); ++i) {
            char *mapping = SDL_GameControllerMappingForIndex(i);
            if (mapping) {
                SDL_Log("\t%s\n", mapping);
                SDL_free(mapping);
            }
        }
        SDL_Log("\n");
    }
 
    /* Print information about the controller */
    for (i = 0; i < SDL_NumJoysticks(); ++i) {
        const char *name;
        const char *description;
 
        SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(i),
                                  guid, sizeof (guid));
 
        if (SDL_IsGameController(i)) {
            controller_count++;
            name = SDL_GameControllerNameForIndex(i);
            switch (SDL_GameControllerTypeForIndex(i)) {
            case SDL_CONTROLLER_TYPE_XBOX360:
                description = "XBox 360 Controller";
                break;
            case SDL_CONTROLLER_TYPE_XBOXONE:
                description = "XBox One Controller";
                break;
            case SDL_CONTROLLER_TYPE_PS3:
                description = "PS3 Controller";
                break;
            case SDL_CONTROLLER_TYPE_PS4:
                description = "PS4 Controller";
                break;
            case SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO:
                description = "Nintendo Switch Pro Controller";
                break;
            case SDL_CONTROLLER_TYPE_VIRTUAL:
                description = "Virtual Game Controller";
                break;
            default:
                description = "Game Controller";
                break;
            }
            AddController(i, SDL_FALSE);
        } else {
            name = SDL_JoystickNameForIndex(i);
            description = "Joystick";
        }
        SDL_Log("%s %d: %s (guid %s, VID 0x%.4x, PID 0x%.4x, player index = %d)\n",
            description, i, name ? name : "Unknown", guid,
            SDL_JoystickGetDeviceVendor(i), SDL_JoystickGetDeviceProduct(i), SDL_JoystickGetDevicePlayerIndex(i));
    }
    SDL_Log("There are %d game controller(s) attached (%d joystick(s))\n", controller_count, SDL_NumJoysticks());
 
    /* Create a window to display controller state */
    window = SDL_CreateWindow("Game Controller Test", SDL_WINDOWPOS_CENTERED,
                              SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
                              SCREEN_HEIGHT, 0);
    if (window == NULL) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
        return 2;
    }
 
    screen = SDL_CreateRenderer(window, -1, 0);
    if (screen == NULL) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
        SDL_DestroyWindow(window);
        return 2;
    }
 
    SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
    SDL_RenderClear(screen);
    SDL_RenderPresent(screen);
 
    /* scale for platforms that don't give you the window size you asked for. */
    SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
 
    background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
    background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE);
    button = LoadTexture(screen, "button.bmp", SDL_TRUE);
    axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
 
    if (!background_front || !background_back || !button || !axis) {
        SDL_DestroyRenderer(screen);
        SDL_DestroyWindow(window);
        return 2;
    }
    SDL_SetTextureColorMod(button, 10, 255, 21);
    SDL_SetTextureColorMod(axis, 10, 255, 21);
 
    /* !!! FIXME: */
    /*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
 
    if (argv[1] && *argv[1] != '-') {
        controller_index = SDL_atoi(argv[1]);
    }
    if (controller_index < num_controllers) {
        gamecontroller = gamecontrollers[controller_index];
    } else {
        gamecontroller = NULL;
    }
    UpdateWindowTitle();
 
    /* Loop, getting controller events! */
#ifdef __EMSCRIPTEN__
    emscripten_set_main_loop_arg(loop, NULL, 0, 1);
#else
    while (!done) {
        loop(NULL);
    }
#endif
 
    SDL_DestroyRenderer(screen);
    SDL_DestroyWindow(window);
    SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
 
    return 0;
}

References AddController(), axis, background_back, background_front, button, done, gamecontroller, gamecontrollers, i, LoadTexture(), loop(), NULL, num_controllers, screen, SCREEN_HEIGHT, SCREEN_WIDTH, SDL_ALPHA_OPAQUE, SDL_atoi, SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO, SDL_CONTROLLER_TYPE_PS3, SDL_CONTROLLER_TYPE_PS4, SDL_CONTROLLER_TYPE_VIRTUAL, SDL_CONTROLLER_TYPE_XBOX360, SDL_CONTROLLER_TYPE_XBOXONE, SDL_CreateRenderer, SDL_CreateWindow, SDL_DestroyRenderer, SDL_DestroyWindow, SDL_FALSE, SDL_free, SDL_GameControllerAddMappingsFromFile, SDL_GameControllerMappingForIndex, SDL_GameControllerNameForIndex, SDL_GameControllerNumMappings, SDL_GameControllerTypeForIndex, SDL_GetError, SDL_HINT_ACCELEROMETER_AS_JOYSTICK, SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, SDL_Init, SDL_INIT_GAMECONTROLLER, SDL_INIT_JOYSTICK, SDL_INIT_VIDEO, SDL_IsGameController, SDL_JoystickGetDeviceGUID, SDL_JoystickGetDevicePlayerIndex, SDL_JoystickGetDeviceProduct, SDL_JoystickGetDeviceVendor, SDL_JoystickGetGUIDString, SDL_JoystickNameForIndex, SDL_Log, SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, SDL_LogError, SDL_LogSetPriority, SDL_NumJoysticks, SDL_QuitSubSystem, SDL_RenderClear, SDL_RenderPresent, SDL_RenderSetLogicalSize, SDL_SetHint, SDL_SetRenderDrawColor, SDL_SetTextureColorMod, SDL_strcmp, SDL_TRUE, SDL_WINDOWPOS_CENTERED, and UpdateWindowTitle().

SetController()

static void SetController ( SDL_JoystickID  controller )

static

Definition at line 172 of file testgamecontroller.c.

{
    int i = FindController(controller);
 
    if (i < 0) {
        return;
    }
 
    if (gamecontroller != gamecontrollers[i]) {
        gamecontroller = gamecontrollers[i];
        UpdateWindowTitle();
    }
}

References FindController(), gamecontroller, gamecontrollers, i, and UpdateWindowTitle().

Referenced by loop().

UpdateWindowTitle()

static void UpdateWindowTitle ( )

static

Definition at line 74 of file testgamecontroller.c.

{
    if (!window) {
        return;
    }
 
    if (gamecontroller) {
        const char *name = SDL_GameControllerName(gamecontroller);
        const char *serial = SDL_GameControllerGetSerial(gamecontroller);
        const char *basetitle = "Game Controller Test: ";
        const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + (serial ? 3 + SDL_strlen(serial) : 0) + 1;
        char *title = (char *)SDL_malloc(titlelen);
 
        retval = SDL_FALSE;
        done = SDL_FALSE;
 
        if (title) {
            SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
            if (serial) {
                SDL_strlcat(title, " (", titlelen);
                SDL_strlcat(title, serial, titlelen);
                SDL_strlcat(title, ")", titlelen);
            }
            SDL_SetWindowTitle(window, title);
            SDL_free(title);
        }
    } else {
        SDL_SetWindowTitle(window, "Waiting for controller...");
    }
}

References done, gamecontroller, retval, SDL_FALSE, SDL_free, SDL_GameControllerGetSerial, SDL_GameControllerName, SDL_malloc, SDL_SetWindowTitle, SDL_snprintf, SDL_strlcat, and SDL_strlen.

Referenced by AddController(), DelController(), main(), and SetController().

Variable Documentation

angle

double angle

Definition at line 55 of file testgamecontroller.c.

axis

SDL_Texture * axis

Definition at line 69 of file testgamecontroller.c.

Referenced by ControllerAxisName(), ConvertAxisToRumble(), HandleJoystickAxis(), loop(), main(), RecenterGameController(), SDL_GameControllerGetAxis(), SDL_GameControllerGetBindForAxis(), SDL_GameControllerGetStringForAxis(), SDL_GameControllerGetStringForButton(), SDL_GameControllerHasAxis(), SDL_JoystickGetAxis(), SDL_JoystickGetAxisInitialState(), SDL_JoystickSetVirtualAxis(), SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerParseElement(), SDL_PrivateJoystickAxis(), and WatchJoystick().

const { ... } axis_positions[]

Initial value:

= {
    {74,  153, 270.0},  
    {74,  153,   0.0},  
    {306, 231, 270.0},  
    {306, 231,   0.0},  
    {91,  -20,   0.0},  
    {375, -20,   0.0},  
}

Referenced by loop().

background_back

SDL_Texture * background_back

Definition at line 69 of file testgamecontroller.c.

Referenced by loop(), main(), and WatchJoystick().

background_front

SDL_Texture* background_front

Definition at line 69 of file testgamecontroller.c.

Referenced by loop(), main(), and WatchJoystick().

button

SDL_Texture * button

Definition at line 69 of file testgamecontroller.c.

Referenced by SDL_BApp::_HandleMouseButton(), SDL_BWin::_SendMouseButton(), button_messagebox(), ControllerButtonName(), GetMouseClickState(), HandleJoystickButton(), loop(), main(), RecenterGameController(), SDL_GameControllerGetBindForButton(), SDL_GameControllerGetButton(), SDL_GameControllerHasButton(), SDL_JoystickGetButton(), SDL_JoystickSetVirtualButton(), SDL_PrivateGameControllerButton(), SDL_PrivateGameControllerParseElement(), SDL_PrivateJoystickButton(), SDL_PrivateSendMouseButton(), SDL_SendMouseButton(), SDL_SendMouseButtonClicks(), SDL_ShowSimpleMessageBox(), and WatchJoystick().

const { ... } button_positions[]

Initial value:

= {
    {387, 167},  
    {431, 132},  
    {342, 132},  
    {389, 101},  
    {174, 132},  
    {232, 128},  
    {289, 132},  
    {75,  154},  
    {305, 230},  
    {77,  40},   
    {396, 36},   
    {154, 188},  
    {154, 249},  
    {116, 217},  
    {186, 217},  
    {232, 174},  
    {132, 135},  
    {330, 135},  
    {132, 175},  
    {330, 175},  
}

Referenced by loop().

done

SDL_bool done = SDL_FALSE

Definition at line 67 of file testgamecontroller.c.

Referenced by loop(), main(), and UpdateWindowTitle().

gamecontroller

SDL_GameController* gamecontroller

Definition at line 70 of file testgamecontroller.c.

Referenced by AddController(), DelController(), HandleJoystickAxis(), HandleJoystickButton(), HandleJoystickHat(), loop(), main(), RecenterGameController(), ResetOutput(), SDL_GameControllerClose(), SDL_GameControllerFromInstanceID(), SDL_GameControllerGetAttached(), SDL_GameControllerGetAxis(), SDL_GameControllerGetBindForAxis(), SDL_GameControllerGetBindForButton(), SDL_GameControllerGetButton(), SDL_GameControllerGetJoystick(), SDL_GameControllerGetNumTouchpadFingers(), SDL_GameControllerGetNumTouchpads(), SDL_GameControllerGetPlayerIndex(), SDL_GameControllerGetProduct(), SDL_GameControllerGetProductVersion(), SDL_GameControllerGetSensorData(), SDL_GameControllerGetSerial(), SDL_GameControllerGetTouchpadFinger(), SDL_GameControllerGetType(), SDL_GameControllerGetVendor(), SDL_GameControllerHasAxis(), SDL_GameControllerHasButton(), SDL_GameControllerHasLED(), SDL_GameControllerHasSensor(), SDL_GameControllerIsSensorEnabled(), SDL_GameControllerMapping(), SDL_GameControllerName(), SDL_GameControllerOpen(), SDL_GameControllerRumble(), SDL_GameControllerRumbleTriggers(), SDL_GameControllerSetLED(), SDL_GameControllerSetPlayerIndex(), SDL_GameControllerSetSensorEnabled(), SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerButton(), SDL_PrivateGameControllerParseControllerConfigString(), SDL_PrivateGameControllerParseElement(), SDL_PrivateLoadButtonMapping(), SetController(), and UpdateWindowTitle().

gamecontrollers

SDL_GameController** gamecontrollers

Definition at line 71 of file testgamecontroller.c.

Referenced by AddController(), DelController(), FindController(), main(), and SetController().

num_controllers

int num_controllers = 0

Definition at line 72 of file testgamecontroller.c.

Referenced by AddController(), DelController(), FindController(), and main().

retval

SDL_bool retval = SDL_FALSE

Definition at line 66 of file testgamecontroller.c.

Referenced by add_audio_device(), AllocateRenderCommand(), build_locales_from_csv_string(), FcitxCreateInputContext(), FlushRenderCommands(), get_sdlapi_entry(), IMA_ADPCM_DecodeBlockData(), main(), PrepQueueCmdDraw(), QueueCmdCopy(), QueueCmdCopyEx(), QueueCmdDrawLines(), QueueCmdDrawPoints(), QueueCmdFillRects(), QueueCmdSetClipRect(), QueueCmdSetDrawColor(), QueueCmdSetViewport(), render(), RenderDrawLinesWithRects(), RenderDrawLinesWithRectsF(), RenderDrawPointsWithRects(), RenderDrawPointsWithRectsF(), SDL_AtomicCAS(), SDL_AtomicCASPtr(), SDL_BuildAudioTypeCVTFromFloat(), SDL_BuildAudioTypeCVTToFloat(), SDL_CondBroadcast(), SDL_CondSignal(), SDL_CondWaitTimeout(), SDL_GetAudioDeviceName(), SDL_GetNumAudioDevices(), SDL_GetPowerInfo(), SDL_GetQueuedAudioSize(), SDL_GL_LoadLibrary(), SDL_GL_MakeCurrent(), SDL_GL_SetAttribute(), SDL_JoystickGetBall(), SDL_NewAudioStream(), SDL_RenderClear(), SDL_RenderCopyExF(), SDL_RenderCopyF(), SDL_RenderDrawLines(), SDL_RenderDrawLinesF(), SDL_RenderDrawPoints(), SDL_RenderDrawPointsF(), SDL_RenderFillRects(), SDL_RenderFillRectsF(), SDL_RenderSetClipRect(), SDL_RenderSetViewport(), SDL_ResampleAudioStream(), SDL_ReserveSpaceInDataQueue(), SDL_SemPost(), SDL_SemTryWait(), SDL_SemWait(), SDL_SemWaitTimeout(), SDL_SetWindowOpacity(), SDL_ShowMessageBox(), SDL_SIMDAlloc(), SDL_SIMDRealloc(), SDL_snprintf(), SDL_TryLockMutex(), SDL_utf8strlen(), SDL_vsscanf(), SDL_Vulkan_LoadLibrary(), SW_RenderCopyEx(), TestWaitTimeout(), and UpdateWindowTitle().

screen

SDL_Renderer* screen = NULL

Definition at line 65 of file testgamecontroller.c.

Referenced by drawCircle(), drawKnob(), drawLine(), DrawScreen(), loop(), main(), setpix(), and WatchJoystick().

set_LED

SDL_bool set_LED = SDL_FALSE

Definition at line 68 of file testgamecontroller.c.

Referenced by loop().

window

SDL_Window* window = NULL

Definition at line 64 of file testgamecontroller.c.

x

int x

Definition at line 31 of file testgamecontroller.c.

Referenced by loop().

y

int y

Definition at line 31 of file testgamecontroller.c.

Referenced by loop().