2015-06-21 15:33:46 +00:00
|
|
|
/*
|
2020-01-17 04:49:25 +00:00
|
|
|
Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Simple program to test the SDL game controller routines */
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "SDL.h"
|
|
|
|
|
|
|
|
#ifdef __EMSCRIPTEN__
|
|
|
|
#include <emscripten/emscripten.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef SDL_JOYSTICK_DISABLED
|
|
|
|
|
|
|
|
#define SCREEN_WIDTH 512
|
2016-10-13 11:01:25 +00:00
|
|
|
#define SCREEN_HEIGHT 320
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
/* This is indexed by SDL_GameControllerButton. */
|
|
|
|
static const struct { int x; int y; } button_positions[] = {
|
2020-11-07 10:22:15 +00:00
|
|
|
{387, 167}, /* SDL_CONTROLLER_BUTTON_A */
|
|
|
|
{431, 132}, /* SDL_CONTROLLER_BUTTON_B */
|
|
|
|
{342, 132}, /* SDL_CONTROLLER_BUTTON_X */
|
|
|
|
{389, 101}, /* SDL_CONTROLLER_BUTTON_Y */
|
|
|
|
{174, 132}, /* SDL_CONTROLLER_BUTTON_BACK */
|
|
|
|
{232, 128}, /* SDL_CONTROLLER_BUTTON_GUIDE */
|
|
|
|
{289, 132}, /* SDL_CONTROLLER_BUTTON_START */
|
|
|
|
{75, 154}, /* SDL_CONTROLLER_BUTTON_LEFTSTICK */
|
|
|
|
{305, 230}, /* SDL_CONTROLLER_BUTTON_RIGHTSTICK */
|
|
|
|
{77, 40}, /* SDL_CONTROLLER_BUTTON_LEFTSHOULDER */
|
|
|
|
{396, 36}, /* SDL_CONTROLLER_BUTTON_RIGHTSHOULDER */
|
|
|
|
{154, 188}, /* SDL_CONTROLLER_BUTTON_DPAD_UP */
|
|
|
|
{154, 249}, /* SDL_CONTROLLER_BUTTON_DPAD_DOWN */
|
|
|
|
{116, 217}, /* SDL_CONTROLLER_BUTTON_DPAD_LEFT */
|
|
|
|
{186, 217}, /* SDL_CONTROLLER_BUTTON_DPAD_RIGHT */
|
|
|
|
{232, 174}, /* SDL_CONTROLLER_BUTTON_MISC1 */
|
|
|
|
{132, 135}, /* SDL_CONTROLLER_BUTTON_PADDLE1 */
|
|
|
|
{330, 135}, /* SDL_CONTROLLER_BUTTON_PADDLE2 */
|
|
|
|
{132, 175}, /* SDL_CONTROLLER_BUTTON_PADDLE3 */
|
|
|
|
{330, 175}, /* SDL_CONTROLLER_BUTTON_PADDLE4 */
|
2015-06-21 15:33:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* This is indexed by SDL_GameControllerAxis. */
|
|
|
|
static const struct { int x; int y; double angle; } axis_positions[] = {
|
2016-12-27 09:39:07 +00:00
|
|
|
{74, 153, 270.0}, /* LEFTX */
|
2020-11-07 10:22:15 +00:00
|
|
|
{74, 153, 0.0}, /* LEFTY */
|
2016-12-27 09:39:07 +00:00
|
|
|
{306, 231, 270.0}, /* RIGHTX */
|
2020-11-07 10:22:15 +00:00
|
|
|
{306, 231, 0.0}, /* RIGHTY */
|
|
|
|
{91, -20, 0.0}, /* TRIGGERLEFT */
|
|
|
|
{375, -20, 0.0}, /* TRIGGERRIGHT */
|
2015-06-21 15:33:46 +00:00
|
|
|
};
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_Window *window = NULL;
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_Renderer *screen = NULL;
|
|
|
|
SDL_bool retval = SDL_FALSE;
|
|
|
|
SDL_bool done = SDL_FALSE;
|
2020-11-16 18:39:44 +00:00
|
|
|
SDL_bool set_LED = SDL_FALSE;
|
2020-11-07 10:22:15 +00:00
|
|
|
SDL_Texture *background_front, *background_back, *button, *axis;
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_GameController *gamecontroller;
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
static SDL_Texture *
|
2016-09-21 21:06:38 +00:00
|
|
|
LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
|
2015-06-21 15:33:46 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
static void
|
2020-11-17 18:30:20 +00:00
|
|
|
InitGameController()
|
2020-04-19 04:41:37 +00:00
|
|
|
{
|
|
|
|
const char *name = SDL_GameControllerName(gamecontroller);
|
2020-11-17 18:30:20 +00:00
|
|
|
|
|
|
|
SDL_Log("Opened game controller %s\n", name);
|
|
|
|
|
|
|
|
if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_ACCEL)) {
|
|
|
|
SDL_Log("Enabling accelerometer\n");
|
|
|
|
SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_ACCEL, SDL_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_GYRO)) {
|
|
|
|
SDL_Log("Enabling gyro\n");
|
|
|
|
SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_GYRO, SDL_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
UpdateWindowTitle()
|
|
|
|
{
|
|
|
|
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);
|
2020-11-17 01:36:47 +00:00
|
|
|
}
|
2020-11-17 18:30:20 +00:00
|
|
|
} else {
|
|
|
|
SDL_SetWindowTitle(window, "Waiting for controller...");
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-12 02:57:37 +00:00
|
|
|
static Uint16 ConvertAxisToRumble(Sint16 axis)
|
|
|
|
{
|
|
|
|
/* Only start rumbling if the axis is past the halfway point */
|
2020-11-12 15:53:01 +00:00
|
|
|
const Sint16 half_axis = (Sint16)SDL_ceil(SDL_JOYSTICK_AXIS_MAX / 2.0f);
|
2020-11-12 02:57:37 +00:00
|
|
|
if (axis > half_axis) {
|
|
|
|
return (Uint16)(axis - half_axis) * 4;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
void
|
|
|
|
loop(void *arg)
|
|
|
|
{
|
|
|
|
SDL_Event event;
|
|
|
|
int i;
|
2020-11-07 10:22:15 +00:00
|
|
|
SDL_bool showing_front = SDL_TRUE;
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
while (SDL_PollEvent(&event)) {
|
|
|
|
switch (event.type) {
|
2020-04-19 04:41:37 +00:00
|
|
|
case SDL_CONTROLLERDEVICEADDED:
|
|
|
|
SDL_Log("Game controller device %d added.\n", (int) event.cdevice.which);
|
2020-11-25 00:38:49 +00:00
|
|
|
if (gamecontroller) {
|
|
|
|
SDL_GameControllerClose(gamecontroller);
|
|
|
|
}
|
|
|
|
|
|
|
|
gamecontroller = SDL_GameControllerOpen(event.cdevice.which);
|
|
|
|
if (gamecontroller) {
|
|
|
|
InitGameController();
|
|
|
|
} else {
|
|
|
|
SDL_Log("Couldn't open controller: %s\n", SDL_GetError());
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
2020-11-25 00:38:49 +00:00
|
|
|
UpdateWindowTitle();
|
2020-04-19 04:41:37 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SDL_CONTROLLERDEVICEREMOVED:
|
|
|
|
SDL_Log("Game controller device %d removed.\n", (int) event.cdevice.which);
|
|
|
|
if (gamecontroller && event.cdevice.which == SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontroller))) {
|
|
|
|
SDL_GameControllerClose(gamecontroller);
|
|
|
|
gamecontroller = SDL_GameControllerOpen(0);
|
|
|
|
if (gamecontroller) {
|
2020-11-17 18:30:20 +00:00
|
|
|
InitGameController();
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
2020-11-17 18:30:20 +00:00
|
|
|
UpdateWindowTitle();
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2020-11-14 02:01:29 +00:00
|
|
|
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;
|
|
|
|
|
2020-11-17 18:30:20 +00:00
|
|
|
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;
|
|
|
|
|
2016-12-27 09:39:07 +00:00
|
|
|
case SDL_CONTROLLERAXISMOTION:
|
2016-12-28 19:11:29 +00:00
|
|
|
SDL_Log("Controller axis %s changed to %d\n", SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)event.caxis.axis), event.caxis.value);
|
2016-12-27 09:39:07 +00:00
|
|
|
break;
|
2020-11-14 02:01:29 +00:00
|
|
|
|
2016-12-27 09:39:07 +00:00
|
|
|
case SDL_CONTROLLERBUTTONDOWN:
|
|
|
|
case SDL_CONTROLLERBUTTONUP:
|
2016-12-28 19:11:29 +00:00
|
|
|
SDL_Log("Controller button %s %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button), event.cbutton.state ? "pressed" : "released");
|
2016-12-27 09:39:07 +00:00
|
|
|
break;
|
2020-11-14 02:01:29 +00:00
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-07 10:22:15 +00:00
|
|
|
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);
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
if (gamecontroller) {
|
|
|
|
/* Update visual controller state */
|
2020-11-14 02:01:29 +00:00
|
|
|
for (i = 0; i < SDL_CONTROLLER_BUTTON_TOUCHPAD; ++i) {
|
2020-04-19 04:41:37 +00:00
|
|
|
if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
|
2020-11-07 10:22:15 +00:00
|
|
|
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);
|
|
|
|
}
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
|
|
|
|
2020-11-07 10:22:15 +00:00
|
|
|
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);
|
|
|
|
}
|
2020-04-19 04:41:37 +00:00
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 19:07:54 +00:00
|
|
|
/* 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);
|
|
|
|
|
2020-11-16 18:39:44 +00:00
|
|
|
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);
|
|
|
|
}
|
2020-11-05 19:07:54 +00:00
|
|
|
}
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
/* Update rumble based on trigger state */
|
|
|
|
{
|
|
|
|
Uint16 low_frequency_rumble = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERLEFT) * 2;
|
|
|
|
Uint16 high_frequency_rumble = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT) * 2;
|
|
|
|
SDL_GameControllerRumble(gamecontroller, low_frequency_rumble, high_frequency_rumble, 250);
|
|
|
|
}
|
2020-11-12 02:57:37 +00:00
|
|
|
|
|
|
|
/* Update trigger rumble based on thumbstick state */
|
|
|
|
{
|
|
|
|
Sint16 left_y = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTY);
|
|
|
|
Sint16 right_y = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_RIGHTY);
|
|
|
|
Uint16 left_rumble = ConvertAxisToRumble(~left_y);
|
|
|
|
Uint16 right_rumble = ConvertAxisToRumble(~right_y);
|
|
|
|
|
|
|
|
SDL_GameControllerRumbleTriggers(gamecontroller, left_rumble, right_rumble, 250);
|
|
|
|
}
|
2020-02-07 19:45:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_RenderPresent(screen);
|
|
|
|
|
|
|
|
#ifdef __EMSCRIPTEN__
|
|
|
|
if (done) {
|
|
|
|
emscripten_cancel_main_loop();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int nController = 0;
|
|
|
|
char guid[64];
|
|
|
|
|
2020-11-06 23:54:18 +00:00
|
|
|
SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0");
|
2020-11-22 02:01:23 +00:00
|
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
|
2020-11-06 23:54:18 +00:00
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
/* Enable standard application logging */
|
2015-11-25 20:39:28 +00:00
|
|
|
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
|
2015-06-21 15:33:46 +00:00
|
|
|
|
|
|
|
/* 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");
|
|
|
|
|
2016-11-29 14:36:57 +00:00
|
|
|
/* Print information about the mappings */
|
2020-04-19 04:41:37 +00:00
|
|
|
if (argv[1] && SDL_strcmp(argv[1], "--mappings") == 0) {
|
2016-12-09 12:17:10 +00:00
|
|
|
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);
|
|
|
|
}
|
2016-11-29 14:36:57 +00:00
|
|
|
}
|
2016-12-09 12:17:10 +00:00
|
|
|
SDL_Log("\n");
|
2016-11-29 14:36:57 +00:00
|
|
|
}
|
|
|
|
|
2015-06-21 15:33:46 +00:00
|
|
|
/* 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));
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
if ( SDL_IsGameController(i) ) {
|
2015-06-21 15:33:46 +00:00
|
|
|
nController++;
|
|
|
|
name = SDL_GameControllerNameForIndex(i);
|
2019-11-22 21:12:12 +00:00
|
|
|
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;
|
Fixed bug 5028 - Virtual Joysticks (new joystick backend)
David Ludwig
I have created a new driver for SDL's Joystick and Game-Controller subsystem: a Virtual driver. This driver allows one to create a software-based joystick, which to SDL applications will look and react like a real joystick, but whose state can be set programmatically. A primary use case for this is to help enable developers to add touch-screen joysticks to their apps.
The driver comes with a set of new, public APIs, with functions to attach and detach joysticks, set virtual-joystick state, and to determine if a joystick is a virtual-one.
Use of virtual joysticks goes as such:
1. Attach one or more virtual joysticks by calling SDL_JoystickAttachVirtual. If successful, this returns the virtual-device's joystick-index.
2. Open the virtual joysticks (using indicies returned by SDL_JoystickAttachVirtual).
3. Call any of the SDL_JoystickSetVirtual* functions when joystick-state changes. Please note that virtual-joystick state will only get applied on the next call to SDL_JoystickUpdate, or when pumping or polling for SDL events (via SDL_PumpEvents or SDL_PollEvent).
Here is a listing of the new, public APIs, at present and subject to change:
------------------------------------------------------------
/**
* Attaches a new virtual joystick.
* Returns the joystick's device index, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type, int naxes, int nballs, int nbuttons, int nhats);
/**
* Detaches a virtual joystick
* Returns 0 on success, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
/**
* Indicates whether or not a virtual-joystick is at a given device index.
*/
extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
/**
* Set values on an opened, virtual-joystick's controls.
* Returns 0 on success, -1 on error.
*/
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick * joystick, int axis, Sint16 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualBall(SDL_Joystick * joystick, int ball, Sint16 xrel, Sint16 yrel);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick * joystick, int button, Uint8 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick * joystick, int hat, Uint8 value);
------------------------------------------------------------
Miscellaneous notes on the initial patch, which are also subject to change:
1. no test code is present in SDL, yet. This should, perhaps, change. Initial development was done with an ImGui-based app, which potentially is too thick for use in SDL-official. If tests are to be added, what kind of tests? Automated? Graphical?
2. virtual game controllers can be created by calling SDL_JoystickAttachVirtual with a joystick-type of SDL_JOYSTICK_TYPE_GAME_CONTROLLER, with naxes (num axes) set to SDL_CONTROLLER_AXIS_MAX, and with nbuttons (num buttons) set to SDL_CONTROLLER_BUTTON_MAX. When updating their state, values of type SDL_GameControllerAxis or SDL_GameControllerButton can be casted to an int and used for the control-index (in calls to SDL_JoystickSetVirtual* functions).
3. virtual joysticks' guids are mostly all-zeros with the exception of the last two bytes, the first of which is a 'v', to indicate that the guid is a virtual one, and the second of which is a SDL_JoystickType that has been converted into a Uint8.
4. virtual joysticks are ONLY turned into virtual game-controllers if and when their joystick-type is set to SDL_JOYSTICK_TYPE_GAMECONTROLLER. This is controlled by having SDL's default list of game-controllers have a single entry for a virtual game controller (of guid, "00000000000000000000000000007601", which is subject to the guid-encoding described above).
5. regarding having to call SDL_JoystickUpdate, either directly or indirectly via SDL_PumpEvents or SDL_PollEvents, before new virtual-joystick state becomes active (as specified via SDL_JoystickSetVirtual* function-calls), this was done to match behavior found in SDL's other joystick drivers, almost all of which will only update SDL-state during SDL_JoystickUpdate.
6. the initial patch is based off of SDL 2.0.12
7. the virtual joystick subsystem is disabled by default. It should be possible to enable it by building with SDL_JOYSTICK_VIRTUAL=1
Questions, comments, suggestions, or bug reports very welcome!
2020-03-14 02:08:45 +00:00
|
|
|
case SDL_CONTROLLER_TYPE_VIRTUAL:
|
|
|
|
description = "Virtual Game Controller";
|
|
|
|
break;
|
2019-11-22 21:12:12 +00:00
|
|
|
default:
|
|
|
|
description = "Game Controller";
|
|
|
|
break;
|
|
|
|
}
|
2015-06-21 15:33:46 +00:00
|
|
|
} else {
|
|
|
|
name = SDL_JoystickNameForIndex(i);
|
|
|
|
description = "Joystick";
|
|
|
|
}
|
2019-12-21 04:12:03 +00:00
|
|
|
SDL_Log("%s %d: %s (guid %s, VID 0x%.4x, PID 0x%.4x, player index = %d)\n",
|
2016-11-11 02:53:50 +00:00
|
|
|
description, i, name ? name : "Unknown", guid,
|
2019-12-21 04:12:03 +00:00
|
|
|
SDL_JoystickGetDeviceVendor(i), SDL_JoystickGetDeviceProduct(i), SDL_JoystickGetDevicePlayerIndex(i));
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
|
|
|
SDL_Log("There are %d game controller(s) attached (%d joystick(s))\n", nController, SDL_NumJoysticks());
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
2015-11-14 17:35:45 +00:00
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
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;
|
|
|
|
}
|
2015-11-14 17:35:45 +00:00
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
|
|
|
|
SDL_RenderClear(screen);
|
|
|
|
SDL_RenderPresent(screen);
|
2015-06-21 15:33:46 +00:00
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
/* scale for platforms that don't give you the window size you asked for. */
|
|
|
|
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
|
|
|
2020-11-07 10:22:15 +00:00
|
|
|
background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
|
|
|
|
background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE);
|
2020-04-19 04:41:37 +00:00
|
|
|
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
|
|
|
|
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
|
|
|
|
|
2020-11-07 10:22:15 +00:00
|
|
|
if (!background_front || !background_back || !button || !axis) {
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_DestroyRenderer(screen);
|
|
|
|
SDL_DestroyWindow(window);
|
|
|
|
return 2;
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_SetTextureColorMod(button, 10, 255, 21);
|
|
|
|
SDL_SetTextureColorMod(axis, 10, 255, 21);
|
|
|
|
|
|
|
|
/* !!! FIXME: */
|
|
|
|
/*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
|
|
|
|
|
2020-11-23 22:28:30 +00:00
|
|
|
if (argv[1] && *argv[1] != '-') {
|
|
|
|
gamecontroller = SDL_GameControllerOpen(SDL_atoi(argv[1]));
|
|
|
|
}
|
|
|
|
|
2020-11-17 18:30:20 +00:00
|
|
|
UpdateWindowTitle();
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
/* Loop, getting controller events! */
|
|
|
|
#ifdef __EMSCRIPTEN__
|
|
|
|
emscripten_set_main_loop_arg(loop, NULL, 0, 1);
|
|
|
|
#else
|
|
|
|
while (!done) {
|
|
|
|
loop(NULL);
|
|
|
|
}
|
|
|
|
#endif
|
2015-06-21 15:33:46 +00:00
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
SDL_DestroyRenderer(screen);
|
|
|
|
SDL_DestroyWindow(window);
|
2015-06-21 15:33:46 +00:00
|
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
|
|
|
|
|
2020-04-19 04:41:37 +00:00
|
|
|
return 0;
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL compiled without Joystick support.\n");
|
2019-09-10 07:03:20 +00:00
|
|
|
return 1;
|
2015-06-21 15:33:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2016-11-11 02:53:50 +00:00
|
|
|
|
|
|
|
/* vi: set ts=4 sw=4 expandtab: */
|