test/controllermap.c
changeset 8043 74fcbf6987ba
child 8046 e7c89b29932a
equal deleted inserted replaced
8042:7863121cb7d5 8043:74fcbf6987ba
       
     1 /*
       
     2   Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
       
     3 
       
     4   This software is provided 'as-is', without any express or implied
       
     5   warranty.  In no event will the authors be held liable for any damages
       
     6   arising from the use of this software.
       
     7 
       
     8   Permission is granted to anyone to use this software for any purpose,
       
     9   including commercial applications, and to alter it and redistribute it
       
    10   freely.
       
    11 */
       
    12 
       
    13 /* Game controller mapping generator */
       
    14 /* Gabriel Jacobo <gabomdq@gmail.com> */
       
    15 
       
    16 #include <stdio.h>
       
    17 #include <stdlib.h>
       
    18 #include <string.h>
       
    19 
       
    20 #include "SDL.h"
       
    21 
       
    22 #ifndef SDL_JOYSTICK_DISABLED
       
    23 
       
    24 #ifdef __IPHONEOS__
       
    25 #define SCREEN_WIDTH    320
       
    26 #define SCREEN_HEIGHT   480
       
    27 #else
       
    28 #define SCREEN_WIDTH    512
       
    29 #define SCREEN_HEIGHT   317
       
    30 #endif
       
    31 
       
    32 #define MAP_WIDTH 512
       
    33 #define MAP_HEIGHT 317
       
    34 
       
    35 #define MARKER_BUTTON 1
       
    36 #define MARKER_AXIS 2
       
    37 
       
    38 typedef struct MappingStep
       
    39 {
       
    40     int x, y;
       
    41     double angle;
       
    42     int marker;
       
    43     char *field;
       
    44     int axis, button, hat, hat_value;
       
    45     char mapping[4096];
       
    46 }MappingStep;
       
    47 
       
    48 
       
    49 SDL_Texture *
       
    50 LoadTexture(SDL_Renderer *renderer, char *file, SDL_bool transparent)
       
    51 {
       
    52     SDL_Surface *temp;
       
    53     SDL_Texture *texture;
       
    54 
       
    55     /* Load the sprite image */
       
    56     temp = SDL_LoadBMP(file);
       
    57     if (temp == NULL) {
       
    58         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
       
    59         return NULL;
       
    60     }
       
    61 
       
    62     /* Set transparent pixel as the pixel at (0,0) */
       
    63     if (transparent) {
       
    64         if (temp->format->palette) {
       
    65             SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
       
    66         } else {
       
    67             switch (temp->format->BitsPerPixel) {
       
    68             case 15:
       
    69                 SDL_SetColorKey(temp, SDL_TRUE,
       
    70                                 (*(Uint16 *) temp->pixels) & 0x00007FFF);
       
    71                 break;
       
    72             case 16:
       
    73                 SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
       
    74                 break;
       
    75             case 24:
       
    76                 SDL_SetColorKey(temp, SDL_TRUE,
       
    77                                 (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
       
    78                 break;
       
    79             case 32:
       
    80                 SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
       
    81                 break;
       
    82             }
       
    83         }
       
    84     }
       
    85 
       
    86     /* Create textures from the image */
       
    87     texture = SDL_CreateTextureFromSurface(renderer, temp);
       
    88     if (!texture) {
       
    89         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
       
    90         SDL_FreeSurface(temp);
       
    91         return NULL;
       
    92     }
       
    93     SDL_FreeSurface(temp);
       
    94 
       
    95     /* We're ready to roll. :) */
       
    96     return texture;
       
    97 }
       
    98 
       
    99 static void
       
   100 DrawRect(SDL_Renderer *r, const int x, const int y, const int w, const int h)
       
   101 {
       
   102     const SDL_Rect area = { x, y, w, h };
       
   103     SDL_RenderFillRect(r, &area);
       
   104 }
       
   105 
       
   106 static SDL_bool
       
   107 WatchJoystick(SDL_Joystick * joystick)
       
   108 {
       
   109     SDL_Window *window = NULL;
       
   110     SDL_Renderer *screen = NULL;
       
   111     SDL_Texture *target, *background, *button, *axis, *marker;
       
   112     const char *name = NULL;
       
   113     SDL_bool retval = SDL_FALSE;
       
   114     SDL_bool done = SDL_FALSE, next=SDL_FALSE;
       
   115     SDL_Event event;
       
   116     SDL_Rect dst;
       
   117     int i, s, _s;
       
   118     Uint8 alpha=200, alpha_step = -1;
       
   119     Uint32 alpha_ticks;
       
   120     char mapping[4096], temp[4096];
       
   121     MappingStep *step;
       
   122     MappingStep steps[] = {
       
   123         {342, 132,  0.0,  MARKER_BUTTON, "x", -1, -1, -1, -1, ""},
       
   124         {387, 167,  0.0,  MARKER_BUTTON, "a", -1, -1, -1, -1, ""},
       
   125         {431, 132,  0.0,  MARKER_BUTTON, "b", -1, -1, -1, -1, ""},
       
   126         {389, 101,  0.0,  MARKER_BUTTON, "y", -1, -1, -1, -1, ""},
       
   127         {174, 132,  0.0,  MARKER_BUTTON, "back", -1, -1, -1, -1, ""},
       
   128         {233, 132,  0.0,  MARKER_BUTTON, "guide", -1, -1, -1, -1, ""},
       
   129         {289, 132,  0.0,  MARKER_BUTTON, "start", -1, -1, -1, -1, ""},        
       
   130         {116, 217,  0.0,  MARKER_BUTTON, "dpleft", -1, -1, -1, -1, ""},
       
   131         {154, 249,  0.0,  MARKER_BUTTON, "dpdown", -1, -1, -1, -1, ""},
       
   132         {186, 217,  0.0,  MARKER_BUTTON, "dpright", -1, -1, -1, -1, ""},
       
   133         {154, 188,  0.0,  MARKER_BUTTON, "dpup", -1, -1, -1, -1, ""},
       
   134         {77,  40,   0.0,  MARKER_BUTTON, "leftshoulder", -1, -1, -1, -1, ""},
       
   135         {91, 0,    0.0,  MARKER_BUTTON, "lefttrigger", -1, -1, -1, -1, ""},
       
   136         {396, 36,   0.0,  MARKER_BUTTON, "rightshoulder", -1, -1, -1, -1, ""},
       
   137         {375, 0,    0.0,  MARKER_BUTTON, "righttrigger", -1, -1, -1, -1, ""},
       
   138         {75,  154,  0.0,  MARKER_BUTTON, "leftstick", -1, -1, -1, -1, ""},
       
   139         {305, 230,  0.0,  MARKER_BUTTON, "rightstick", -1, -1, -1, -1, ""},
       
   140         {75,  154,  0.0,  MARKER_AXIS,   "leftx", -1, -1, -1, -1, ""},
       
   141         {75,  154,  90.0, MARKER_AXIS,   "lefty", -1, -1, -1, -1, ""},        
       
   142         {305, 230,  0.0,  MARKER_AXIS,   "rightx", -1, -1, -1, -1, ""},
       
   143         {305, 230,  90.0, MARKER_AXIS,   "righty", -1, -1, -1, -1, ""},
       
   144     };
       
   145 
       
   146     /* Create a window to display joystick axis position */
       
   147     window = SDL_CreateWindow("Joystick Test", SDL_WINDOWPOS_CENTERED,
       
   148                               SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
       
   149                               SCREEN_HEIGHT, 0);
       
   150     if (window == NULL) {
       
   151         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
       
   152         return SDL_FALSE;
       
   153     }
       
   154 
       
   155     screen = SDL_CreateRenderer(window, -1, 0);
       
   156     if (screen == NULL) {
       
   157         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
       
   158         SDL_DestroyWindow(window);
       
   159         return SDL_FALSE;
       
   160     }
       
   161     
       
   162     target = SDL_CreateTexture(screen, SDL_PIXELFORMAT_RGB888, SDL_TEXTUREACCESS_TARGET, MAP_WIDTH, MAP_HEIGHT);
       
   163     background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
       
   164     button = LoadTexture(screen, "button.bmp", SDL_TRUE);
       
   165     axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
       
   166     SDL_RaiseWindow(window);
       
   167 
       
   168     /* Print info about the joystick we are watching */
       
   169     name = SDL_JoystickName(joystick);
       
   170     SDL_Log("Watching joystick %d: (%s)\n", SDL_JoystickInstanceID(joystick),
       
   171            name ? name : "Unknown Joystick");
       
   172     SDL_Log("Joystick has %d axes, %d hats, %d balls, and %d buttons\n",
       
   173            SDL_JoystickNumAxes(joystick), SDL_JoystickNumHats(joystick),
       
   174            SDL_JoystickNumBalls(joystick), SDL_JoystickNumButtons(joystick));
       
   175     
       
   176     SDL_Log("\n\n\
       
   177     ====================================================================================\n\
       
   178     Press the buttons on your controller when indicated\n\
       
   179     (Your controller may look different than the picture)\n\
       
   180     If you want to correct a mistake, press backspace or the back button on your device\n\
       
   181     To exit, press ESC\n\
       
   182     ====================================================================================\n");
       
   183     
       
   184     /* Initialize mapping with GUID and name */
       
   185     SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joystick), temp, SDL_arraysize(temp));
       
   186     SDL_snprintf(mapping, SDL_arraysize(mapping), "%s,%s,platform:%s,",
       
   187         temp, name ? name : "Unknown Joystick", SDL_GetPlatform());
       
   188 
       
   189     /* Loop, getting joystick events! */
       
   190     for(s=0; s<SDL_arraysize(steps) && !done;) {
       
   191         /* blank screen, set up for drawing this frame. */
       
   192         step = &steps[s];
       
   193         SDL_strlcpy(step->mapping, mapping, SDL_arraysize(step->mapping));
       
   194         step->axis = -1;
       
   195         step->button = -1;
       
   196         step->hat = -1;
       
   197         step->hat_value = -1;
       
   198         SDL_SetClipboardText("TESTING TESTING 123");
       
   199         
       
   200         switch(step->marker) {
       
   201             case MARKER_AXIS:
       
   202                 marker = axis;
       
   203                 break;
       
   204             case MARKER_BUTTON:
       
   205                 marker = button;
       
   206                 break;
       
   207             default:
       
   208                 break;
       
   209         }
       
   210         
       
   211         dst.x = step->x;
       
   212         dst.y = step->y;
       
   213         SDL_QueryTexture(marker, NULL, NULL, &dst.w, &dst.h);
       
   214         next=SDL_FALSE;
       
   215         
       
   216         while (!done && !next) {
       
   217             if (SDL_GetTicks() - alpha_ticks > 5) {
       
   218                 alpha_ticks = SDL_GetTicks();
       
   219                 alpha += alpha_step;
       
   220                 if (alpha == 255) {
       
   221                     alpha_step = -1;
       
   222                 }
       
   223                 if (alpha < 128) {
       
   224                     alpha_step = 1;
       
   225                 }
       
   226             }
       
   227             
       
   228             SDL_SetRenderTarget(screen, target);
       
   229             SDL_RenderCopy(screen, background, NULL, NULL);
       
   230             SDL_SetTextureAlphaMod(marker, alpha);
       
   231             SDL_SetTextureColorMod(marker, 10, 255, 21);
       
   232             SDL_RenderCopyEx(screen, marker, NULL, &dst, step->angle, NULL, 0);
       
   233             SDL_SetRenderTarget(screen, NULL);
       
   234             SDL_RenderCopy(screen, target, NULL, NULL);
       
   235             SDL_RenderPresent(screen);
       
   236             
       
   237             if (SDL_PollEvent(&event)) {
       
   238                 switch (event.type) {
       
   239                 case SDL_JOYAXISMOTION:
       
   240                     if (event.jaxis.value > 20000 || event.jaxis.value < -20000) {
       
   241                         for (_s = 0; _s < s; _s++) {
       
   242                             if (steps[_s].axis == event.jaxis.axis) {
       
   243                                 break;
       
   244                             }
       
   245                         }
       
   246                         if (_s == s) {
       
   247                             step->axis = event.jaxis.axis;
       
   248                             SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
       
   249                             SDL_snprintf(temp, SDL_arraysize(temp), ":a%u,", event.jaxis.axis);
       
   250                             SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
       
   251                             s++;
       
   252                             next=SDL_TRUE;
       
   253                         }
       
   254                     }
       
   255                     
       
   256                     break;
       
   257                 case SDL_JOYHATMOTION:
       
   258                         for (_s = 0; _s < s; _s++) {
       
   259                             if (steps[_s].hat == event.jhat.hat && steps[_s].hat_value == event.jhat.value) {
       
   260                                 break;
       
   261                             }
       
   262                         }
       
   263                         if (_s == s) {
       
   264                             step->hat = event.jhat.hat;
       
   265                             step->hat_value = event.jhat.value;
       
   266                             SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
       
   267                             SDL_snprintf(temp, SDL_arraysize(temp), ":h%u.%u,", event.jhat.hat, event.jhat.value );
       
   268                             SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
       
   269                             s++;
       
   270                             next=SDL_TRUE;
       
   271                         }
       
   272                     break;
       
   273                 case SDL_JOYBALLMOTION:
       
   274                     break;
       
   275                 case SDL_JOYBUTTONUP:
       
   276                     for (_s = 0; _s < s; _s++) {
       
   277                         if (steps[_s].button == event.jbutton.button) {
       
   278                             break;
       
   279                         }
       
   280                     }
       
   281                     if (_s == s) {
       
   282                         step->button = event.jbutton.button;
       
   283                         SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
       
   284                         SDL_snprintf(temp, SDL_arraysize(temp), ":b%u,", event.jbutton.button);
       
   285                         SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
       
   286                         s++;
       
   287                         next=SDL_TRUE;
       
   288                     }
       
   289                     break;
       
   290                 case SDL_KEYDOWN:
       
   291                     if (event.key.keysym.sym == SDLK_BACKSPACE || event.key.keysym.sym == SDLK_AC_BACK) {
       
   292                         /* Undo! */
       
   293                         if (s > 0) {
       
   294                             SDL_strlcpy(mapping, step->mapping, SDL_arraysize(step->mapping));
       
   295                             s--;
       
   296                             next = SDL_TRUE;
       
   297                         }
       
   298                         break;
       
   299                     }
       
   300                     if ((event.key.keysym.sym != SDLK_ESCAPE)) {
       
   301                         break;
       
   302                     }
       
   303                     /* Fall through to signal quit */
       
   304                 case SDL_FINGERDOWN:
       
   305                 case SDL_MOUSEBUTTONDOWN:
       
   306                 case SDL_QUIT:
       
   307                     done = SDL_TRUE;
       
   308                     break;
       
   309                 default:
       
   310                     break;
       
   311                 }
       
   312             }
       
   313         }
       
   314 
       
   315     }
       
   316 
       
   317     if (s == SDL_arraysize(steps) ) {
       
   318         SDL_Log("Mapping:\n\n%s\n\n", mapping);
       
   319         /* Print to stdout as well so the user can cat the output somewhere */
       
   320         printf("%s\n", mapping);
       
   321     }
       
   322     
       
   323     while(SDL_PollEvent(&event)) {};
       
   324     
       
   325     SDL_DestroyRenderer(screen);
       
   326     SDL_DestroyWindow(window);
       
   327     return retval;
       
   328 }
       
   329 
       
   330 int
       
   331 main(int argc, char *argv[])
       
   332 {
       
   333     const char *name;
       
   334     int i;
       
   335     SDL_Joystick *joystick;
       
   336 
       
   337     /* Enable standard application logging */
       
   338     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);	
       
   339 
       
   340     /* Initialize SDL (Note: video is required to start event loop) */
       
   341     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
       
   342         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
       
   343         exit(1);
       
   344     }
       
   345 
       
   346     /* Print information about the joysticks */
       
   347     SDL_Log("There are %d joysticks attached\n", SDL_NumJoysticks());
       
   348     for (i = 0; i < SDL_NumJoysticks(); ++i) {
       
   349         name = SDL_JoystickNameForIndex(i);
       
   350         SDL_Log("Joystick %d: %s\n", i, name ? name : "Unknown Joystick");
       
   351         joystick = SDL_JoystickOpen(i);
       
   352         if (joystick == NULL) {
       
   353             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_JoystickOpen(%d) failed: %s\n", i,
       
   354                     SDL_GetError());
       
   355         } else {
       
   356             char guid[64];
       
   357             SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joystick),
       
   358                                       guid, sizeof (guid));
       
   359             SDL_Log("       axes: %d\n", SDL_JoystickNumAxes(joystick));
       
   360             SDL_Log("      balls: %d\n", SDL_JoystickNumBalls(joystick));
       
   361             SDL_Log("       hats: %d\n", SDL_JoystickNumHats(joystick));
       
   362             SDL_Log("    buttons: %d\n", SDL_JoystickNumButtons(joystick));
       
   363             SDL_Log("instance id: %d\n", SDL_JoystickInstanceID(joystick));
       
   364             SDL_Log("       guid: %s\n", guid);
       
   365             SDL_JoystickClose(joystick);
       
   366         }
       
   367     }
       
   368 
       
   369 #ifdef ANDROID
       
   370     if (SDL_NumJoysticks() > 0) {
       
   371 #else
       
   372     if (argv[1]) {
       
   373 #endif
       
   374         SDL_bool reportederror = SDL_FALSE;
       
   375         SDL_bool keepGoing = SDL_TRUE;
       
   376         SDL_Event event;
       
   377 #ifdef ANDROID
       
   378         joystick = SDL_JoystickOpen(0);
       
   379 #else
       
   380         joystick = SDL_JoystickOpen(atoi(argv[1]));
       
   381 #endif
       
   382         while ( keepGoing ) {
       
   383             if (joystick == NULL) {
       
   384                 if ( !reportederror ) {
       
   385                     SDL_Log("Couldn't open joystick %d: %s\n", atoi(argv[1]), SDL_GetError());
       
   386                     keepGoing = SDL_FALSE;
       
   387                     reportederror = SDL_TRUE;
       
   388                 }
       
   389             } else {
       
   390                 reportederror = SDL_FALSE;
       
   391                 keepGoing = WatchJoystick(joystick);
       
   392                 SDL_JoystickClose(joystick);
       
   393             }
       
   394 
       
   395             joystick = NULL;
       
   396             if (keepGoing) {
       
   397                 SDL_Log("Waiting for attach\n");
       
   398             }
       
   399             while (keepGoing) {
       
   400                 SDL_WaitEvent(&event);
       
   401                 if ((event.type == SDL_QUIT) || (event.type == SDL_FINGERDOWN)
       
   402                     || (event.type == SDL_MOUSEBUTTONDOWN)) {
       
   403                     keepGoing = SDL_FALSE;
       
   404                 } else if (event.type == SDL_JOYDEVICEADDED) {
       
   405                     joystick = SDL_JoystickOpen(atoi(argv[1]));
       
   406                     break;
       
   407                 }
       
   408             }
       
   409         }
       
   410     }
       
   411     else {
       
   412         SDL_Log("\n\nUsage: ./controllermap number\nFor example: ./controllermap 0\nOr: ./controllermap 0 >> gamecontrollerdb.txt");
       
   413     }
       
   414     SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
       
   415 
       
   416 #ifdef ANDROID
       
   417     exit(0);
       
   418 #else
       
   419     return 0;
       
   420 #endif
       
   421 }
       
   422 
       
   423 #else
       
   424 
       
   425 int
       
   426 main(int argc, char *argv[])
       
   427 {
       
   428     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL compiled without Joystick support.\n");
       
   429     exit(1);
       
   430 }
       
   431 
       
   432 #endif