diff options
| -rw-r--r-- | src/setup/Makefile.am | 1 | ||||
| -rw-r--r-- | src/setup/joystick.c | 410 | ||||
| -rw-r--r-- | src/setup/txt_joyaxis.c | 527 | ||||
| -rw-r--r-- | src/setup/txt_joyaxis.h | 90 |
4 files changed, 672 insertions, 356 deletions
diff --git a/src/setup/Makefile.am b/src/setup/Makefile.am index 27de0add..1a1e1ccb 100644 --- a/src/setup/Makefile.am +++ b/src/setup/Makefile.am @@ -18,6 +18,7 @@ SOURCE_FILES = \ multiplayer.c multiplayer.h \ sound.c sound.h \ execute.c execute.h \ + txt_joyaxis.c txt_joyaxis.h \ txt_joybinput.c txt_joybinput.h \ txt_keyinput.c txt_keyinput.h \ txt_mouseinput.c txt_mouseinput.h diff --git a/src/setup/joystick.c b/src/setup/joystick.c index 1b2a00f3..41bde51c 100644 --- a/src/setup/joystick.c +++ b/src/setup/joystick.c @@ -25,19 +25,9 @@ #include "execute.h" #include "joystick.h" #include "mode.h" +#include "txt_joyaxis.h" #include "txt_joybinput.h" -typedef enum -{ - CALIBRATE_CENTER, - CALIBRATE_LEFT, - CALIBRATE_UP, - - // These are only used when defining button axes: - CALIBRATE_RIGHT, - CALIBRATE_DOWN, -} calibration_stage_t; - typedef struct { char *name; // Config file name @@ -69,15 +59,6 @@ int joystick_index = -1; static int calibrate_button = -1; -// "Bad" joystick axes. Sometimes an axis can be stuck or "bad". An -// example I found is that if you unplug the nunchuck extension from -// a Wii remote, the axes from the nunchuck can be stuck at one of -// the maximum values. These have to be ignored, so when we ask the -// user to center the joystick, we look for bad axes that are not -// close to zero. - -static boolean *bad_axis = NULL; - // Which joystick axis to use for horizontal movement, and whether to // invert the direction: @@ -101,14 +82,14 @@ int joystick_physical_buttons[NUM_VIRTUAL_BUTTONS] = { }; static txt_button_t *joystick_button; +static txt_joystick_axis_t *x_axis_widget; +static txt_joystick_axis_t *y_axis_widget; // // Calibration // static txt_window_t *calibration_window; -static txt_label_t *calibration_label; -static calibration_stage_t calibrate_stage; static SDL_Joystick **all_joysticks = NULL; // Known controllers. @@ -468,262 +449,13 @@ static void CloseAllJoysticks(void) all_joysticks = NULL; } -static void SetCalibrationLabel(void) -{ - char *message = "???"; - - switch (calibrate_stage) - { - case CALIBRATE_CENTER: - message = "Move the D-pad or joystick to the\n" - "center, and press a button."; - break; - case CALIBRATE_UP: - message = "Push the D-pad or joystick up,\n" - "and press the button."; - break; - case CALIBRATE_LEFT: - message = "Push the D-pad or joystick to the\n" - "left, and press the button."; - break; - case CALIBRATE_DOWN: - message = "Push the D-pad or joystick down,\n" - "and press the button."; - break; - case CALIBRATE_RIGHT: - message = "Push the D-pad or joystick to the\n" - "right, and press the button."; - break; - } - - TXT_SetLabel(calibration_label, message); -} - -// Search all axes on joystick being configured; find a button that is -// pressed (other than the calibrate button). Returns the button number. - -static int FindPressedAxisButton(void) -{ - SDL_Joystick *joystick; - int i; - - joystick = all_joysticks[joystick_index]; - - for (i = 0; i < SDL_JoystickNumButtons(joystick); ++i) - { - if (i == calibrate_button) - { - continue; - } - - if (SDL_JoystickGetButton(joystick, i)) - { - return i; - } - } - - return -1; -} - -// Look for a hat that isn't centered. Returns the encoded hat axis. - -static int FindUncenteredHat(int *axis_invert) -{ - SDL_Joystick *joystick; - int i, hatval; - - joystick = all_joysticks[joystick_index]; - - for (i = 0; i < SDL_JoystickNumHats(joystick); ++i) - { - hatval = SDL_JoystickGetHat(joystick, i); - - switch (hatval) - { - case SDL_HAT_LEFT: - case SDL_HAT_RIGHT: - *axis_invert = hatval != SDL_HAT_LEFT; - return CREATE_HAT_AXIS(i, HAT_AXIS_HORIZONTAL); - - case SDL_HAT_UP: - case SDL_HAT_DOWN: - *axis_invert = hatval != SDL_HAT_UP; - return CREATE_HAT_AXIS(i, HAT_AXIS_VERTICAL); - - // If the hat is centered, or is not pointing in a - // definite direction, then ignore it. We don't accept - // the hat being pointed to the upper-left for example, - // because it's ambiguous. - case SDL_HAT_CENTERED: - default: - break; - } - } - - // None found. - return -1; -} - -static boolean CalibrateAxis(int *axis_index, int *axis_invert) -{ - SDL_Joystick *joystick; - int best_axis; - int best_value; - int best_invert; - Sint16 axis_value; - int i; - - joystick = all_joysticks[joystick_index]; - - // Check all axes to find which axis has the largest value. We test - // for one axis at a time, so eg. when we prompt to push the joystick - // left, whichever axis has the largest value is the left axis. - - best_axis = 0; - best_value = 0; - best_invert = 0; - - for (i=0; i<SDL_JoystickNumAxes(joystick); ++i) - { - if (bad_axis[i]) - { - continue; - } - - axis_value = SDL_JoystickGetAxis(joystick, i); - - if (abs(axis_value) > best_value) - { - best_value = abs(axis_value); - best_invert = axis_value > 0; - best_axis = i; - } - } - - // Did we find one axis that had a significant value? - - if (best_value > 32768 / 4) - { - // Save the best values we have found - - *axis_index = best_axis; - *axis_invert = best_invert; - return true; - } - - // Otherwise, maybe this is a "button axis", like the PS3 SIXAXIS - // controller that exposes the D-pad as four individual buttons. - // Search for a button. - - i = FindPressedAxisButton(); - - if (i >= 0) - { - *axis_index = CREATE_BUTTON_AXIS(i, 0); - *axis_invert = 0; - return true; - } - - // Maybe it's a D-pad that is presented as a hat. This sounds weird - // but gamepads like this really do exist; an example is the - // Nyko AIRFLO Ex. - - i = FindUncenteredHat(axis_invert); - - if (i >= 0) - { - *axis_index = i; - return true; - } - - // User pressed the button without pushing the joystick anywhere. - return false; -} - -static boolean SetButtonAxisPositive(int *axis_index) +static void CalibrateXAxis(void) { - int button; - - button = FindPressedAxisButton(); - - if (button >= 0) - { - *axis_index |= CREATE_BUTTON_AXIS(0, button); - return true; - } - - return false; -} - -static int NextCalibrateStage(void) -{ - switch (calibrate_stage) - { - case CALIBRATE_CENTER: - return CALIBRATE_LEFT; - - // After pushing to the left, there are two possibilities: - // either it is a button axis, in which case we need to find - // the other button, or we can just move on to the next axis. - case CALIBRATE_LEFT: - if (IS_BUTTON_AXIS(joystick_x_axis)) - { - return CALIBRATE_RIGHT; - } - else - { - return CALIBRATE_UP; - } - - case CALIBRATE_RIGHT: - return CALIBRATE_UP; - - case CALIBRATE_UP: - if (IS_BUTTON_AXIS(joystick_y_axis)) - { - return CALIBRATE_DOWN; - } - else - { - // Finished. - return CALIBRATE_CENTER; - } - - case CALIBRATE_DOWN: - // Finished. - return CALIBRATE_CENTER; - } -} - -static void IdentifyBadAxes(void) -{ - SDL_Joystick *joystick; - int i, val; - - free(bad_axis); - - joystick = all_joysticks[joystick_index]; - bad_axis = calloc(SDL_JoystickNumAxes(joystick), sizeof(boolean)); - - // Look for uncentered axes. - - for (i = 0; i < SDL_JoystickNumAxes(joystick); ++i) - { - val = SDL_JoystickGetAxis(joystick, i); - - bad_axis[i] = abs(val) > (32768 / 5); - - if (bad_axis[i]) - { - printf("Ignoring uncentered joystick axis #%i: %i\n", i, val); - } - } + TXT_ConfigureJoystickAxis(x_axis_widget, calibrate_button, NULL); } static int CalibrationEventCallback(SDL_Event *event, void *user_data) { - boolean advance; - if (event->type != SDL_JOYBUTTONDOWN) { return 0; @@ -732,75 +464,28 @@ static int CalibrationEventCallback(SDL_Event *event, void *user_data) // At this point, we have a button press. // In the first "center" stage, we're just trying to work out which // joystick is being configured and which button the user is pressing. - if (calibrate_stage == CALIBRATE_CENTER) - { - joystick_index = event->jbutton.which; - calibrate_button = event->jbutton.button; - IdentifyBadAxes(); + joystick_index = event->jbutton.which; + calibrate_button = event->jbutton.button; - // If the joystick is a known one, auto-load default - // config for it. - if (IsKnownJoystick(joystick_index)) - { - LoadKnownConfiguration(); - usejoystick = 1; - TXT_CloseWindow(calibration_window); - } - else - { - // Advance to next stage. - calibrate_stage = CALIBRATE_LEFT; - SetCalibrationLabel(); - } - - return 1; + // If the joystick is a known one, auto-load default + // config for it. Otherwise, proceed with calibration. + if (IsKnownJoystick(joystick_index)) + { + LoadKnownConfiguration(); + usejoystick = 1; + TXT_CloseWindow(calibration_window); } - - // In subsequent stages, the user is asked to push in a specific - // direction and press the button. They must push the same button - // as they did before; this is necessary to support button axes. - if (event->jbutton.which == joystick_index - && event->jbutton.button == calibrate_button) + else { - switch (calibrate_stage) - { - default: - case CALIBRATE_LEFT: - advance = CalibrateAxis(&joystick_x_axis, &joystick_x_invert); - break; - - case CALIBRATE_RIGHT: - advance = SetButtonAxisPositive(&joystick_x_axis); - break; - - case CALIBRATE_UP: - advance = CalibrateAxis(&joystick_y_axis, &joystick_y_invert); - break; - - case CALIBRATE_DOWN: - advance = SetButtonAxisPositive(&joystick_y_axis); - break; - } - - // Advance to the next calibration stage? + TXT_CloseWindow(calibration_window); - if (advance) - { - calibrate_stage = NextCalibrateStage(); - SetCalibrationLabel(); - - // Finished? - if (calibrate_stage == CALIBRATE_CENTER) - { - usejoystick = 1; - TXT_CloseWindow(calibration_window); - } - - return 1; - } + // Calibrate joystick axes: Y axis first, then X axis once + // completed. + TXT_ConfigureJoystickAxis(y_axis_widget, calibrate_button, + CalibrateXAxis); } - return 0; + return 1; } static void NoJoystick(void) @@ -823,8 +508,6 @@ static void CalibrateWindowClosed(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused) static void CalibrateJoystick(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) { - calibrate_stage = CALIBRATE_CENTER; - // Try to open all available joysticks. If none are opened successfully, // bomb out with an error. @@ -837,10 +520,9 @@ static void CalibrateJoystick(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) calibration_window = TXT_NewWindow("Gamepad/Joystick calibration"); TXT_AddWidgets(calibration_window, - TXT_NewLabel("Please follow the following instructions\n" - "in order to calibrate your controller."), TXT_NewStrut(0, 1), - calibration_label = TXT_NewLabel("zzz"), + TXT_NewLabel("Center the D-pad or joystick,\n" + "and press a button."), TXT_NewStrut(0, 1), NULL); @@ -849,7 +531,6 @@ static void CalibrateJoystick(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) TXT_NewWindowAbortAction(calibration_window)); TXT_SetWindowAction(calibration_window, TXT_HORIZ_RIGHT, NULL); - TXT_SetWidgetAlign(calibration_label, TXT_HORIZ_CENTER); TXT_SDL_SetEventCallback(CalibrationEventCallback, NULL); TXT_SignalConnect(calibration_window, "closed", CalibrateWindowClosed, NULL); @@ -857,9 +538,6 @@ static void CalibrateJoystick(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) // Start calibration joystick_index = -1; - calibrate_stage = CALIBRATE_CENTER; - - SetCalibrationLabel(); } // @@ -888,10 +566,10 @@ static void AddJoystickControl(txt_table_t *table, char *label, int *var) void ConfigJoystick(void) { txt_window_t *window; - txt_table_t *button_table; + txt_table_t *button_table, *axis_table; txt_table_t *joystick_table; - if (!joystick_initted) + if (!joystick_initted) { joystick_initted = SDL_Init(SDL_INIT_JOYSTICK) >= 0; } @@ -901,8 +579,27 @@ void ConfigJoystick(void) TXT_AddWidgets(window, TXT_NewCheckBox("Enable gamepad/joystick", &usejoystick), joystick_table = TXT_NewTable(2), + TXT_NewSeparator("Axes"), + axis_table = TXT_NewTable(2), TXT_NewSeparator("Buttons"), - button_table = TXT_NewTable(2), + button_table = TXT_NewTable(4), + NULL); + + TXT_SetColumnWidths(axis_table, 20, 15); + + TXT_AddWidgets(axis_table, + TXT_NewLabel("Forward/backward"), + y_axis_widget = TXT_NewJoystickAxis(&joystick_y_axis, + &joystick_y_invert, + JOYSTICK_AXIS_VERTICAL), + TXT_NewLabel("Turn left/right"), + x_axis_widget = TXT_NewJoystickAxis(&joystick_x_axis, + &joystick_x_invert, + JOYSTICK_AXIS_HORIZONTAL), + TXT_NewLabel("Strafe left/right"), + TXT_NewJoystickAxis(&joystick_strafe_axis, + &joystick_strafe_invert, + JOYSTICK_AXIS_HORIZONTAL), NULL); TXT_SetColumnWidths(joystick_table, 20, 15); @@ -912,10 +609,18 @@ void ConfigJoystick(void) joystick_button = TXT_NewButton("zzzz"), NULL); - TXT_SetColumnWidths(button_table, 20, 15); + TXT_SetColumnWidths(button_table, 16, 12, 14, 11); AddJoystickControl(button_table, "Fire/Attack", &joybfire); + AddJoystickControl(button_table, "Strafe Left", &joybstrafeleft); + AddJoystickControl(button_table, "Use", &joybuse); + AddJoystickControl(button_table, "Strafe Right", &joybstraferight); + + AddJoystickControl(button_table, "Previous weapon", &joybprevweapon); + AddJoystickControl(button_table, "Strafe", &joybstrafe); + + AddJoystickControl(button_table, "Next weapon", &joybnextweapon); // High values of joybspeed are used to activate the "always run mode" // trick in Vanilla Doom. If this has been enabled, not only is the @@ -926,13 +631,6 @@ void ConfigJoystick(void) AddJoystickControl(button_table, "Speed", &joybspeed); } - AddJoystickControl(button_table, "Strafe", &joybstrafe); - - AddJoystickControl(button_table, "Strafe Left", &joybstrafeleft); - AddJoystickControl(button_table, "Strafe Right", &joybstraferight); - AddJoystickControl(button_table, "Previous weapon", &joybprevweapon); - AddJoystickControl(button_table, "Next weapon", &joybnextweapon); - if (gamemission == hexen || gamemission == strife) { AddJoystickControl(button_table, "Jump", &joybjump); diff --git a/src/setup/txt_joyaxis.c b/src/setup/txt_joyaxis.c new file mode 100644 index 00000000..927c0473 --- /dev/null +++ b/src/setup/txt_joyaxis.c @@ -0,0 +1,527 @@ +// +// Copyright(C) 2014 Simon Howard +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "SDL.h" + +#include "joystick.h" +#include "i_joystick.h" +#include "i_system.h" +#include "m_controls.h" +#include "m_misc.h" + +#include "textscreen.h" +#include "txt_gui.h" +#include "txt_io.h" +#include "txt_joyaxis.h" + +#define JOYSTICK_AXIS_WIDTH 24 + +static char *CalibrationLabel(txt_joystick_axis_t *joystick_axis) +{ + switch (joystick_axis->config_stage) + { + case CONFIG_CENTER: + return "Center the D-pad or joystick,\n" + "and press a button."; + + case CONFIG_STAGE1: + if (joystick_axis->dir == JOYSTICK_AXIS_VERTICAL) + { + return "Push the D-pad or joystick up,\n" + "and press the button."; + } + else + { + return "Push the D-pad or joystick to the\n" + "left, and press the button."; + } + + case CONFIG_STAGE2: + if (joystick_axis->dir == JOYSTICK_AXIS_VERTICAL) + { + return "Push the D-pad or joystick down,\n" + "and press the button."; + } + else + { + return "Push the D-pad or joystick to the\n" + "right, and press the button."; + } + } +} + +static void SetCalibrationLabel(txt_joystick_axis_t *joystick_axis) +{ + TXT_SetLabel(joystick_axis->config_label, CalibrationLabel(joystick_axis)); +} + +// Search all axes on joystick being configured; find a button that is +// pressed (other than the calibrate button). Returns the button number. + +static int FindPressedAxisButton(txt_joystick_axis_t *joystick_axis) +{ + int i; + + for (i = 0; i < SDL_JoystickNumButtons(joystick_axis->joystick); ++i) + { + if (i == joystick_axis->config_button) + { + continue; + } + + if (SDL_JoystickGetButton(joystick_axis->joystick, i)) + { + return i; + } + } + + return -1; +} + +// Look for a hat that isn't centered. Returns the encoded hat axis. + +static int FindUncenteredHat(SDL_Joystick *joystick, int *axis_invert) +{ + int i, hatval; + + for (i = 0; i < SDL_JoystickNumHats(joystick); ++i) + { + hatval = SDL_JoystickGetHat(joystick, i); + + switch (hatval) + { + case SDL_HAT_LEFT: + case SDL_HAT_RIGHT: + *axis_invert = hatval != SDL_HAT_LEFT; + return CREATE_HAT_AXIS(i, HAT_AXIS_HORIZONTAL); + + case SDL_HAT_UP: + case SDL_HAT_DOWN: + *axis_invert = hatval != SDL_HAT_UP; + return CREATE_HAT_AXIS(i, HAT_AXIS_VERTICAL); + + // If the hat is centered, or is not pointing in a + // definite direction, then ignore it. We don't accept + // the hat being pointed to the upper-left for example, + // because it's ambiguous. + case SDL_HAT_CENTERED: + default: + break; + } + } + + // None found. + return -1; +} + +static boolean CalibrateAxis(txt_joystick_axis_t *joystick_axis) +{ + int best_axis; + int best_value; + int best_invert; + Sint16 axis_value; + int i; + + // Check all axes to find which axis has the largest value. We test + // for one axis at a time, so eg. when we prompt to push the joystick + // left, whichever axis has the largest value is the left axis. + + best_axis = 0; + best_value = 0; + best_invert = 0; + + for (i = 0; i < SDL_JoystickNumAxes(joystick_axis->joystick); ++i) + { + //if (bad_axis[i]) + //{ + // continue; + //} + + axis_value = SDL_JoystickGetAxis(joystick_axis->joystick, i); + + if (abs(axis_value) > best_value) + { + best_value = abs(axis_value); + best_invert = axis_value > 0; + best_axis = i; + } + } + + // Did we find one axis that had a significant value? + + if (best_value > 32768 / 4) + { + // Save the best values we have found + + *joystick_axis->axis = best_axis; + *joystick_axis->invert = best_invert; + return true; + } + + // Otherwise, maybe this is a "button axis", like the PS3 SIXAXIS + // controller that exposes the D-pad as four individual buttons. + // Search for a button. + + i = FindPressedAxisButton(joystick_axis); + + if (i >= 0) + { + *joystick_axis->axis = CREATE_BUTTON_AXIS(i, 0); + *joystick_axis->invert = 0; + return true; + } + + // Maybe it's a D-pad that is presented as a hat. This sounds weird + // but gamepads like this really do exist; an example is the + // Nyko AIRFLO Ex. + + i = FindUncenteredHat(joystick_axis->joystick, joystick_axis->invert); + + if (i >= 0) + { + *joystick_axis->axis = i; + return true; + } + + // User pressed the button without pushing the joystick anywhere. + return false; +} + +static boolean SetButtonAxisPositive(txt_joystick_axis_t *joystick_axis) +{ + int button; + + button = FindPressedAxisButton(joystick_axis); + + if (button >= 0) + { + *joystick_axis->axis |= CREATE_BUTTON_AXIS(0, button); + return true; + } + + return false; +} + +static void IdentifyBadAxes(txt_joystick_axis_t *joystick_axis) +{ + int i, val; + + free(joystick_axis->bad_axis); + + joystick_axis->bad_axis + = calloc(SDL_JoystickNumAxes(joystick_axis->joystick), + sizeof(boolean)); + + // Look for uncentered axes. + + for (i = 0; i < SDL_JoystickNumAxes(joystick_axis->joystick); ++i) + { + val = SDL_JoystickGetAxis(joystick_axis->joystick, i); + + joystick_axis->bad_axis[i] = abs(val) > (32768 / 5); + + if (joystick_axis->bad_axis[i]) + { + printf("Ignoring uncentered joystick axis #%i: %i\n", i, val); + } + } +} + +static int NextCalibrateStage(txt_joystick_axis_t *joystick_axis) +{ + switch (joystick_axis->config_stage) + { + case CONFIG_CENTER: + return CONFIG_STAGE1; + + // After pushing to the left, there are two possibilities: + // either it is a button axis, in which case we need to find + // the other button, or we can just move on to the next axis. + case CONFIG_STAGE1: + if (IS_BUTTON_AXIS(*joystick_axis->axis)) + { + return CONFIG_STAGE2; + } + else + { + return CONFIG_CENTER; + } + + case CONFIG_STAGE2: + return CONFIG_CENTER; + } +} + +static int EventCallback(SDL_Event *event, TXT_UNCAST_ARG(joystick_axis)) +{ + TXT_CAST_ARG(txt_joystick_axis_t, joystick_axis); + boolean advance; + + if (event->type != SDL_JOYBUTTONDOWN) + { + return 0; + } + + // At this point, we have a button press. + // In the first "center" stage, we're just trying to work out which + // joystick is being configured and which button the user is pressing. + if (joystick_axis->config_stage == CONFIG_CENTER) + { + joystick_index = event->jbutton.which; + joystick_axis->config_button = event->jbutton.button; + IdentifyBadAxes(joystick_axis); + + // Advance to next stage. + joystick_axis->config_stage = CONFIG_STAGE1; + SetCalibrationLabel(joystick_axis); + + return 1; + } + + // In subsequent stages, the user is asked to push in a specific + // direction and press the button. They must push the same button + // as they did before; this is necessary to support button axes. + if (event->jbutton.which == joystick_index + && event->jbutton.button == joystick_axis->config_button) + { + switch (joystick_axis->config_stage) + { + default: + case CONFIG_STAGE1: + advance = CalibrateAxis(joystick_axis); + break; + + case CONFIG_STAGE2: + advance = SetButtonAxisPositive(joystick_axis); + break; + } + + // Advance to the next calibration stage? + + if (advance) + { + joystick_axis->config_stage = NextCalibrateStage(joystick_axis); + SetCalibrationLabel(joystick_axis); + + // Finished? + if (joystick_axis->config_stage == CONFIG_CENTER) + { + TXT_CloseWindow(joystick_axis->config_window); + + if (joystick_axis->callback != NULL) + { + joystick_axis->callback(); + } + } + + return 1; + } + } + + return 0; +} + +static void CalibrateWindowClosed(TXT_UNCAST_ARG(widget), + TXT_UNCAST_ARG(joystick_axis)) +{ + TXT_CAST_ARG(txt_joystick_axis_t, joystick_axis); + + free(joystick_axis->bad_axis); + joystick_axis->bad_axis = NULL; + + SDL_JoystickClose(joystick_axis->joystick); + SDL_JoystickEventState(SDL_DISABLE); + SDL_QuitSubSystem(SDL_INIT_JOYSTICK); + TXT_SDL_SetEventCallback(NULL, NULL); +} + +void TXT_ConfigureJoystickAxis(txt_joystick_axis_t *joystick_axis, + int using_button, + txt_joystick_axis_callback_t callback) +{ + // Open the joystick first. + if (SDL_Init(SDL_INIT_JOYSTICK) < 0) + { + return; + } + + joystick_axis->joystick = SDL_JoystickOpen(joystick_index); + if (joystick_axis->joystick == NULL) + { + // TODO: OpenErrorWindow(); + return; + } + + SDL_JoystickEventState(SDL_ENABLE); + + // Build the prompt window. + + joystick_axis->config_window + = TXT_NewWindow("Gamepad/Joystick calibration"); + TXT_AddWidgets(joystick_axis->config_window, + TXT_NewStrut(0, 1), + joystick_axis->config_label = TXT_NewLabel(""), + TXT_NewStrut(0, 1), + NULL); + + TXT_SetWindowAction(joystick_axis->config_window, TXT_HORIZ_LEFT, NULL); + TXT_SetWindowAction(joystick_axis->config_window, TXT_HORIZ_CENTER, + TXT_NewWindowAbortAction(joystick_axis->config_window)); + TXT_SetWindowAction(joystick_axis->config_window, TXT_HORIZ_RIGHT, NULL); + TXT_SetWidgetAlign(joystick_axis->config_window, TXT_HORIZ_CENTER); + + if (using_button >= 0) + { + joystick_axis->config_stage = CONFIG_STAGE1; + joystick_axis->config_button = using_button; + IdentifyBadAxes(joystick_axis); + } + else + { + joystick_axis->config_stage = CONFIG_CENTER; + } + + SetCalibrationLabel(joystick_axis); + + // Close the joystick and shut down joystick subsystem when the window + // is closed. + TXT_SignalConnect(joystick_axis->config_window, "closed", + CalibrateWindowClosed, joystick_axis); + + TXT_SDL_SetEventCallback(EventCallback, joystick_axis); + + // When successfully calibrated, invoke this callback: + joystick_axis->callback = callback; +} + +static void TXT_JoystickAxisSizeCalc(TXT_UNCAST_ARG(joystick_axis)) +{ + TXT_CAST_ARG(txt_joystick_axis_t, joystick_axis); + + // All joystickinputs are the same size. + + joystick_axis->widget.w = JOYSTICK_AXIS_WIDTH; + joystick_axis->widget.h = 1; +} + +static void TXT_JoystickAxisDrawer(TXT_UNCAST_ARG(joystick_axis)) +{ + TXT_CAST_ARG(txt_joystick_axis_t, joystick_axis); + char buf[JOYSTICK_AXIS_WIDTH + 1]; + int i; + + if (*joystick_axis->axis < 0) + { + M_StringCopy(buf, "(None)", sizeof(buf)); + } + else if (IS_BUTTON_AXIS(*joystick_axis->axis)) + { + int neg, pos; + + neg = BUTTON_AXIS_NEG(*joystick_axis->axis); + pos = BUTTON_AXIS_POS(*joystick_axis->axis); + M_snprintf(buf, sizeof(buf), "BUTTONS #%i+#%i", neg, pos); + } + else if (IS_HAT_AXIS(*joystick_axis->axis)) + { + int hat, dir; + + hat = HAT_AXIS_HAT(*joystick_axis->axis); + dir = HAT_AXIS_DIRECTION(*joystick_axis->axis); + + M_snprintf(buf, sizeof(buf), "HAT #%i (%s)", hat, + dir == HAT_AXIS_HORIZONTAL ? "horizontal" : "vertical"); + } + else + { + M_snprintf(buf, sizeof(buf), "AXIS #%i", *joystick_axis->axis); + } + + TXT_SetWidgetBG(joystick_axis); + TXT_FGColor(TXT_COLOR_BRIGHT_WHITE); + + TXT_DrawString(buf); + + for (i=strlen(buf); i<JOYSTICK_AXIS_WIDTH; ++i) + { + TXT_DrawString(" "); + } +} + +static void TXT_JoystickAxisDestructor(TXT_UNCAST_ARG(joystick_axis)) +{ +} + +static int TXT_JoystickAxisKeyPress(TXT_UNCAST_ARG(joystick_axis), int key) +{ + TXT_CAST_ARG(txt_joystick_axis_t, joystick_axis); + + if (key == KEY_ENTER) + { + TXT_ConfigureJoystickAxis(joystick_axis, -1, NULL); + return 1; + } + + if (key == KEY_BACKSPACE || key == KEY_DEL) + { + *joystick_axis->axis = -1; + } + + return 0; +} + +static void TXT_JoystickAxisMousePress(TXT_UNCAST_ARG(widget), + int x, int y, int b) +{ + TXT_CAST_ARG(txt_joystick_axis_t, widget); + + // Clicking is like pressing enter + + if (b == TXT_MOUSE_LEFT) + { + TXT_JoystickAxisKeyPress(widget, KEY_ENTER); + } +} + +txt_widget_class_t txt_joystick_axis_class = +{ + TXT_AlwaysSelectable, + TXT_JoystickAxisSizeCalc, + TXT_JoystickAxisDrawer, + TXT_JoystickAxisKeyPress, + TXT_JoystickAxisDestructor, + TXT_JoystickAxisMousePress, + NULL, +}; + +txt_joystick_axis_t *TXT_NewJoystickAxis(int *axis, int *invert, + txt_joystick_axis_direction_t dir) +{ + txt_joystick_axis_t *joystick_axis; + + joystick_axis = malloc(sizeof(txt_joystick_axis_t)); + + TXT_InitWidget(joystick_axis, &txt_joystick_axis_class); + joystick_axis->axis = axis; + joystick_axis->invert = invert; + joystick_axis->dir = dir; + joystick_axis->bad_axis = NULL; + + return joystick_axis; +} + diff --git a/src/setup/txt_joyaxis.h b/src/setup/txt_joyaxis.h new file mode 100644 index 00000000..1f41d0e8 --- /dev/null +++ b/src/setup/txt_joyaxis.h @@ -0,0 +1,90 @@ +// +// Copyright(C) 2005-2014 Simon Howard +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// + +#ifndef TXT_JOY_AXIS_H +#define TXT_JOY_AXIS_H + +typedef struct txt_joystick_axis_s txt_joystick_axis_t; + +typedef enum +{ + JOYSTICK_AXIS_HORIZONTAL, + JOYSTICK_AXIS_VERTICAL, +} txt_joystick_axis_direction_t; + +typedef enum +{ + CONFIG_CENTER, // "Center the joystick and press a button..." + CONFIG_STAGE1, // "Top or left and press a button..." + CONFIG_STAGE2, // [Optional] "Bottom or right and press a button..." +} txt_joystick_axis_stage_t; + +// Callback invoked when calibration is completed. +typedef void (*txt_joystick_axis_callback_t)(void); + +#include "txt_widget.h" +#include "txt_window.h" + +#include "SDL.h" + +// +// A joystick axis. +// + +struct txt_joystick_axis_s +{ + txt_widget_t widget; + int *axis, *invert; + txt_joystick_axis_direction_t dir; + + // Only used when configuring: + + // Configuration prompt window and label. + txt_window_t *config_window; + txt_label_t *config_label; + + // SDL joystick handle for reading joystick state. + SDL_Joystick *joystick; + + // "Bad" joystick axes. Sometimes an axis can be stuck or "bad". An + // example I found is that if you unplug the nunchuck extension from + // a Wii remote, the axes from the nunchuck can be stuck at one of + // the maximum values. These have to be ignored, so when we ask the + // user to center the joystick, we look for bad axes that are not + // close to zero. + boolean *bad_axis; + + // Stage we have reached in configuring joystick axis. + txt_joystick_axis_stage_t config_stage; + + // Button to press to advance to next stage. + int config_button; + + // Callback invoked when the axis is calibrated. + txt_joystick_axis_callback_t callback; +}; + +txt_joystick_axis_t *TXT_NewJoystickAxis(int *axis, int *invert, + txt_joystick_axis_direction_t dir); + +// Configure a joystick axis widget. +// axis: The axis widget to configure. +// using_button: If non-negative, use this joystick button as the button +// to expect from the user. Otherwise, ask. +void TXT_ConfigureJoystickAxis(txt_joystick_axis_t *axis, int using_button, + txt_joystick_axis_callback_t callback); + +#endif /* #ifndef TXT_JOY_AXIS_H */ + + |