/* =========================================================================== Copyright (C) 1999-2005 Id Software, Inc. This file is part of Quake III Arena source code. Quake III Arena source code 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. Quake III Arena source code 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. You should have received a copy of the GNU General Public License along with Quake III Arena source code; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA =========================================================================== */ #ifdef USE_LOCAL_HEADERS # include "SDL.h" #else # include #endif #include "../client/client.h" #include "sdl_glw.h" static cvar_t *in_keyboardDebug; static cvar_t *in_forceCharset; #ifdef USE_JOYSTICK static SDL_GameController *gamepad; static SDL_Joystick *stick = NULL; #endif static qboolean mouseAvailable = qfalse; static qboolean mouseActive = qfalse; static cvar_t *in_mouse; #ifdef USE_JOYSTICK static cvar_t *in_joystick; static cvar_t *in_joystickThreshold; static cvar_t *in_joystickNo; static cvar_t *in_joystickUseAnalog; static cvar_t *j_pitch; static cvar_t *j_yaw; static cvar_t *j_forward; static cvar_t *j_side; static cvar_t *j_up; static cvar_t *j_pitch_axis; static cvar_t *j_yaw_axis; static cvar_t *j_forward_axis; static cvar_t *j_side_axis; static cvar_t *j_up_axis; #endif #define Com_QueueEvent Sys_QueEvent static cvar_t *cl_consoleKeys; static int in_eventTime = 0; static qboolean mouse_focus; #define CTRL(a) ((a)-'a'+1) /* =============== IN_PrintKey =============== */ static void IN_PrintKey( const SDL_Keysym *keysym, keyNum_t key, qboolean down ) { if( down ) Com_Printf( "+ " ); else Com_Printf( " " ); Com_Printf( "Scancode: 0x%02x(%s) Sym: 0x%02x(%s)", keysym->scancode, SDL_GetScancodeName( keysym->scancode ), keysym->sym, SDL_GetKeyName( keysym->sym ) ); if( keysym->mod & KMOD_LSHIFT ) Com_Printf( " KMOD_LSHIFT" ); if( keysym->mod & KMOD_RSHIFT ) Com_Printf( " KMOD_RSHIFT" ); if( keysym->mod & KMOD_LCTRL ) Com_Printf( " KMOD_LCTRL" ); if( keysym->mod & KMOD_RCTRL ) Com_Printf( " KMOD_RCTRL" ); if( keysym->mod & KMOD_LALT ) Com_Printf( " KMOD_LALT" ); if( keysym->mod & KMOD_RALT ) Com_Printf( " KMOD_RALT" ); if( keysym->mod & KMOD_LGUI ) Com_Printf( " KMOD_LGUI" ); if( keysym->mod & KMOD_RGUI ) Com_Printf( " KMOD_RGUI" ); if( keysym->mod & KMOD_NUM ) Com_Printf( " KMOD_NUM" ); if( keysym->mod & KMOD_CAPS ) Com_Printf( " KMOD_CAPS" ); if( keysym->mod & KMOD_MODE ) Com_Printf( " KMOD_MODE" ); if( keysym->mod & KMOD_RESERVED ) Com_Printf( " KMOD_RESERVED" ); Com_Printf( " Q:0x%02x(%s)\n", key, Key_KeynumToString( key ) ); } #define MAX_CONSOLE_KEYS 16 /* =============== IN_IsConsoleKey TODO: If the SDL_Scancode situation improves, use it instead of both of these methods =============== */ static qboolean IN_IsConsoleKey( keyNum_t key, int character ) { typedef struct consoleKey_s { enum { QUAKE_KEY, CHARACTER } type; union { keyNum_t key; int character; } u; } consoleKey_t; static consoleKey_t consoleKeys[ MAX_CONSOLE_KEYS ]; static int numConsoleKeys = 0; int i; // Only parse the variable when it changes if ( cl_consoleKeys->modified ) { const char *text_p, *token; cl_consoleKeys->modified = qfalse; text_p = cl_consoleKeys->string; numConsoleKeys = 0; while( numConsoleKeys < MAX_CONSOLE_KEYS ) { consoleKey_t *c = &consoleKeys[ numConsoleKeys ]; int charCode = 0; token = COM_Parse( &text_p ); if( !token[ 0 ] ) break; charCode = Com_HexStrToInt( token ); if( charCode > 0 ) { c->type = CHARACTER; c->u.character = charCode; } else { c->type = QUAKE_KEY; c->u.key = Key_StringToKeynum( token ); // 0 isn't a key if ( c->u.key <= 0 ) continue; } numConsoleKeys++; } } // If the character is the same as the key, prefer the character if ( key == character ) key = 0; for ( i = 0; i < numConsoleKeys; i++ ) { consoleKey_t *c = &consoleKeys[ i ]; switch ( c->type ) { case QUAKE_KEY: if( key && c->u.key == key ) return qtrue; break; case CHARACTER: if( c->u.character == character ) return qtrue; break; } } return qfalse; } /* =============== IN_TranslateSDLToQ3Key =============== */ static keyNum_t IN_TranslateSDLToQ3Key( SDL_Keysym *keysym, qboolean down ) { keyNum_t key = 0; if ( keysym->scancode >= SDL_SCANCODE_1 && keysym->scancode <= SDL_SCANCODE_0 ) { // Always map the number keys as such even if they actually map // to other characters (eg, "1" is "&" on an AZERTY keyboard). // This is required for SDL before 2.0.6, except on Windows // which already had this behavior. if( keysym->scancode == SDL_SCANCODE_0 ) key = '0'; else key = '1' + keysym->scancode - SDL_SCANCODE_1; } else if ( in_forceCharset->integer > 0 ) { if ( keysym->scancode >= SDL_SCANCODE_A && keysym->scancode <= SDL_SCANCODE_Z ) { key = 'a' + keysym->scancode - SDL_SCANCODE_A; } else { switch ( keysym->scancode ) { case SDL_SCANCODE_MINUS: key = '-'; break; case SDL_SCANCODE_EQUALS: key = '='; break; case SDL_SCANCODE_LEFTBRACKET: key = '['; break; case SDL_SCANCODE_RIGHTBRACKET: key = ']'; break; case SDL_SCANCODE_NONUSBACKSLASH: case SDL_SCANCODE_BACKSLASH: key = '\\'; break; case SDL_SCANCODE_SEMICOLON: key = ';'; break; case SDL_SCANCODE_APOSTROPHE: key = '\''; break; case SDL_SCANCODE_COMMA: key = ','; break; case SDL_SCANCODE_PERIOD: key = '.'; break; case SDL_SCANCODE_SLASH: key = '/'; break; default: /* key = 0 */ break; } } } if( !key && keysym->sym >= SDLK_SPACE && keysym->sym < SDLK_DELETE ) { // These happen to match the ASCII chars key = (int)keysym->sym; } else if( !key ) { switch( keysym->sym ) { case SDLK_PAGEUP: key = K_PGUP; break; case SDLK_KP_9: key = K_KP_PGUP; break; case SDLK_PAGEDOWN: key = K_PGDN; break; case SDLK_KP_3: key = K_KP_PGDN; break; case SDLK_KP_7: key = K_KP_HOME; break; case SDLK_HOME: key = K_HOME; break; case SDLK_KP_1: key = K_KP_END; break; case SDLK_END: key = K_END; break; case SDLK_KP_4: key = K_KP_LEFTARROW; break; case SDLK_LEFT: key = K_LEFTARROW; break; case SDLK_KP_6: key = K_KP_RIGHTARROW; break; case SDLK_RIGHT: key = K_RIGHTARROW; break; case SDLK_KP_2: key = K_KP_DOWNARROW; break; case SDLK_DOWN: key = K_DOWNARROW; break; case SDLK_KP_8: key = K_KP_UPARROW; break; case SDLK_UP: key = K_UPARROW; break; case SDLK_ESCAPE: key = K_ESCAPE; break; case SDLK_KP_ENTER: key = K_KP_ENTER; break; case SDLK_RETURN: key = K_ENTER; break; case SDLK_TAB: key = K_TAB; break; case SDLK_F1: key = K_F1; break; case SDLK_F2: key = K_F2; break; case SDLK_F3: key = K_F3; break; case SDLK_F4: key = K_F4; break; case SDLK_F5: key = K_F5; break; case SDLK_F6: key = K_F6; break; case SDLK_F7: key = K_F7; break; case SDLK_F8: key = K_F8; break; case SDLK_F9: key = K_F9; break; case SDLK_F10: key = K_F10; break; case SDLK_F11: key = K_F11; break; case SDLK_F12: key = K_F12; break; case SDLK_F13: key = K_F13; break; case SDLK_F14: key = K_F14; break; case SDLK_F15: key = K_F15; break; case SDLK_BACKSPACE: key = K_BACKSPACE; break; case SDLK_KP_PERIOD: key = K_KP_DEL; break; case SDLK_DELETE: key = K_DEL; break; case SDLK_PAUSE: key = K_PAUSE; break; case SDLK_LSHIFT: case SDLK_RSHIFT: key = K_SHIFT; break; case SDLK_LCTRL: case SDLK_RCTRL: key = K_CTRL; break; #ifdef __APPLE__ case SDLK_RGUI: case SDLK_LGUI: key = K_COMMAND; break; #else case SDLK_RGUI: case SDLK_LGUI: key = K_SUPER; break; #endif case SDLK_RALT: case SDLK_LALT: key = K_ALT; break; case SDLK_KP_5: key = K_KP_5; break; case SDLK_INSERT: key = K_INS; break; case SDLK_KP_0: key = K_KP_INS; break; case SDLK_KP_MULTIPLY: key = '*'; /*K_KP_STAR;*/ break; case SDLK_KP_PLUS: key = K_KP_PLUS; break; case SDLK_KP_MINUS: key = K_KP_MINUS; break; case SDLK_KP_DIVIDE: key = K_KP_SLASH; break; case SDLK_MODE: key = K_MODE; break; case SDLK_HELP: key = K_HELP; break; case SDLK_PRINTSCREEN: key = K_PRINT; break; case SDLK_SYSREQ: key = K_SYSREQ; break; case SDLK_MENU: key = K_MENU; break; case SDLK_APPLICATION: key = K_MENU; break; case SDLK_POWER: key = K_POWER; break; case SDLK_UNDO: key = K_UNDO; break; case SDLK_SCROLLLOCK: key = K_SCROLLOCK; break; case SDLK_NUMLOCKCLEAR: key = K_KP_NUMLOCK; break; case SDLK_CAPSLOCK: key = K_CAPSLOCK; break; default: #if 1 key = 0; #else if( !( keysym->sym & SDLK_SCANCODE_MASK ) && keysym->scancode <= 95 ) { // Map Unicode characters to 95 world keys using the key's scan code. // FIXME: There aren't enough world keys to cover all the scancodes. // Maybe create a map of scancode to quake key at start up and on // key map change; allocate world key numbers as needed similar // to SDL 1.2. key = K_WORLD_0 + (int)keysym->scancode; } #endif break; } } if ( in_keyboardDebug->integer ) IN_PrintKey( keysym, key, down ); if ( keysym->scancode == SDL_SCANCODE_GRAVE ) { //SDL_Keycode translated = SDL_GetKeyFromScancode( SDL_SCANCODE_GRAVE ); //if ( translated == SDLK_CARET ) { // Console keys can't be bound or generate characters key = K_CONSOLE; } } else if ( IN_IsConsoleKey( key, 0 ) ) { // Console keys can't be bound or generate characters key = K_CONSOLE; } return key; } /* =============== IN_GobbleMotionEvents =============== */ static void IN_GobbleMouseEvents( void ) { SDL_Event dummy[ 1 ]; int val = 0; // Gobble any mouse events SDL_PumpEvents(); while( ( val = SDL_PeepEvents( dummy, ARRAY_LEN( dummy ), SDL_GETEVENT, SDL_MOUSEMOTION, SDL_MOUSEWHEEL ) ) > 0 ) { } if ( val < 0 ) Com_Printf( "%s failed: %s\n", __func__, SDL_GetError() ); } //#define DEBUG_EVENTS /* =============== IN_ActivateMouse =============== */ static void IN_ActivateMouse( void ) { if ( !mouseAvailable ) return; if ( !mouseActive ) { IN_GobbleMouseEvents(); SDL_SetRelativeMouseMode( in_mouse->integer == 1 ? SDL_TRUE : SDL_FALSE ); SDL_SetWindowGrab( SDL_window, SDL_TRUE ); if ( glw_state.isFullscreen ) SDL_ShowCursor( SDL_FALSE ); SDL_WarpMouseInWindow( SDL_window, glw_state.window_width / 2, glw_state.window_height / 2 ); #ifdef DEBUG_EVENTS Com_Printf( "%4i %s\n", Sys_Milliseconds(), __func__ ); #endif } // in_nograb makes no sense in fullscreen mode if ( !glw_state.isFullscreen ) { if ( in_nograb->modified || !mouseActive ) { if ( in_nograb->integer ) { SDL_SetRelativeMouseMode( SDL_FALSE ); SDL_SetWindowGrab( SDL_window, SDL_FALSE ); } else { SDL_SetRelativeMouseMode( in_mouse->integer == 1 ? SDL_TRUE : SDL_FALSE ); SDL_SetWindowGrab( SDL_window, SDL_TRUE ); } in_nograb->modified = qfalse; } } mouseActive = qtrue; } /* =============== IN_DeactivateMouse =============== */ static void IN_DeactivateMouse( void ) { if ( !mouseAvailable ) return; if ( mouseActive ) { #ifdef DEBUG_EVENTS Com_Printf( "%4i %s\n", Sys_Milliseconds(), __func__ ); #endif IN_GobbleMouseEvents(); SDL_SetWindowGrab( SDL_window, SDL_FALSE ); SDL_SetRelativeMouseMode( SDL_FALSE ); if ( gw_active ) SDL_WarpMouseInWindow( SDL_window, glw_state.window_width / 2, glw_state.window_height / 2 ); else { if ( glw_state.isFullscreen ) SDL_ShowCursor( SDL_TRUE ); SDL_WarpMouseGlobal( glw_state.desktop_width / 2, glw_state.desktop_height / 2 ); } mouseActive = qfalse; } // Always show the cursor when the mouse is disabled, // but not when fullscreen if ( !glw_state.isFullscreen ) SDL_ShowCursor( SDL_TRUE ); } #ifdef USE_JOYSTICK // We translate axes movement into keypresses static const int joy_keys[16] = { K_LEFTARROW, K_RIGHTARROW, K_UPARROW, K_DOWNARROW, K_JOY17, K_JOY18, K_JOY19, K_JOY20, K_JOY21, K_JOY22, K_JOY23, K_JOY24, K_JOY25, K_JOY26, K_JOY27, K_JOY28 }; // translate hat events into keypresses // the 4 highest buttons are used for the first hat ... static const int hat_keys[16] = { K_JOY29, K_JOY30, K_JOY31, K_JOY32, K_JOY25, K_JOY26, K_JOY27, K_JOY28, K_JOY21, K_JOY22, K_JOY23, K_JOY24, K_JOY17, K_JOY18, K_JOY19, K_JOY20 }; struct { qboolean buttons[SDL_CONTROLLER_BUTTON_MAX + 1]; // +1 because old max was 16, current SDL_CONTROLLER_BUTTON_MAX is 15 unsigned int oldaxes; int oldaaxes[MAX_JOYSTICK_AXIS]; unsigned int oldhats; } stick_state; /* =============== IN_InitJoystick =============== */ static void IN_InitJoystick( void ) { int i = 0; int total = 0; char buf[16384] = ""; if (gamepad) SDL_GameControllerClose(gamepad); if (stick != NULL) SDL_JoystickClose(stick); stick = NULL; gamepad = NULL; memset(&stick_state, '\0', sizeof (stick_state)); // SDL 2.0.4 requires SDL_INIT_JOYSTICK to be initialized separately from // SDL_INIT_GAMECONTROLLER for SDL_JoystickOpen() to work correctly, // despite https://wiki.libsdl.org/SDL_Init (retrieved 2016-08-16) // indicating SDL_INIT_JOYSTICK should be initialized automatically. if (!SDL_WasInit(SDL_INIT_JOYSTICK)) { Com_DPrintf("Calling SDL_Init(SDL_INIT_JOYSTICK)...\n"); if (SDL_Init(SDL_INIT_JOYSTICK) != 0) { Com_DPrintf("SDL_Init(SDL_INIT_JOYSTICK) failed: %s\n", SDL_GetError()); return; } Com_DPrintf("SDL_Init(SDL_INIT_JOYSTICK) passed.\n"); } if (!SDL_WasInit(SDL_INIT_GAMECONTROLLER)) { Com_DPrintf("Calling SDL_Init(SDL_INIT_GAMECONTROLLER)...\n"); if (SDL_Init(SDL_INIT_GAMECONTROLLER) != 0) { Com_DPrintf("SDL_Init(SDL_INIT_GAMECONTROLLER) failed: %s\n", SDL_GetError()); return; } Com_DPrintf("SDL_Init(SDL_INIT_GAMECONTROLLER) passed.\n"); } total = SDL_NumJoysticks(); Com_DPrintf("%d possible joysticks\n", total); // Print list and build cvar to allow ui to select joystick. for (i = 0; i < total; i++) { Q_strcat(buf, sizeof(buf), SDL_JoystickNameForIndex(i)); Q_strcat(buf, sizeof(buf), "\n"); } Cvar_Get( "in_availableJoysticks", buf, CVAR_ROM ); Cvar_SetDescription( in_availableJoysticks, "List of available joysticks." ); if( !in_joystick->integer ) { Com_DPrintf( "Joystick is not active.\n" ); SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER); return; } in_joystickNo = Cvar_Get( "in_joystickNo", "0", CVAR_ARCHIVE ); Cvar_SetDescription( in_joystickNo, "Select which joystick to use." ); if( in_joystickNo->integer < 0 || in_joystickNo->integer >= total ) Cvar_Set( "in_joystickNo", "0" ); in_joystickUseAnalog = Cvar_Get( "in_joystickUseAnalog", "0", CVAR_ARCHIVE ); Cvar_SetDescription( in_joystickUseAnalog, "Do not translate joystick axis events to keyboard commands." ); stick = SDL_JoystickOpen( in_joystickNo->integer ); if (stick == NULL) { Com_DPrintf( "No joystick opened: %s\n", SDL_GetError() ); return; } if (SDL_IsGameController(in_joystickNo->integer)) gamepad = SDL_GameControllerOpen(in_joystickNo->integer); Com_DPrintf( "Joystick %d opened\n", in_joystickNo->integer ); Com_DPrintf( "Name: %s\n", SDL_JoystickNameForIndex(in_joystickNo->integer) ); Com_DPrintf( "Axes: %d\n", SDL_JoystickNumAxes(stick) ); Com_DPrintf( "Hats: %d\n", SDL_JoystickNumHats(stick) ); Com_DPrintf( "Buttons: %d\n", SDL_JoystickNumButtons(stick) ); Com_DPrintf( "Balls: %d\n", SDL_JoystickNumBalls(stick) ); Com_DPrintf( "Use Analog: %s\n", in_joystickUseAnalog->integer ? "Yes" : "No" ); Com_DPrintf( "Is gamepad: %s\n", gamepad ? "Yes" : "No" ); SDL_JoystickEventState(SDL_QUERY); SDL_GameControllerEventState(SDL_QUERY); } /* =============== IN_ShutdownJoystick =============== */ static void IN_ShutdownJoystick( void ) { if ( !SDL_WasInit( SDL_INIT_GAMECONTROLLER ) ) return; if ( !SDL_WasInit( SDL_INIT_JOYSTICK ) ) return; if (gamepad) { SDL_GameControllerClose(gamepad); gamepad = NULL; } if (stick) { SDL_JoystickClose(stick); stick = NULL; } SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER); SDL_QuitSubSystem(SDL_INIT_JOYSTICK); } static qboolean KeyToAxisAndSign(int keynum, int *outAxis, int *outSign) { const char *bind; if (!keynum) return qfalse; bind = Key_GetBinding(keynum); if (!bind || *bind != '+') return qfalse; *outSign = 0; if (Q_stricmp(bind, "+forward") == 0) { *outAxis = j_forward_axis->integer; *outSign = j_forward->value > 0.0f ? 1 : -1; } else if (Q_stricmp(bind, "+back") == 0) { *outAxis = j_forward_axis->integer; *outSign = j_forward->value > 0.0f ? -1 : 1; } else if (Q_stricmp(bind, "+moveleft") == 0) { *outAxis = j_side_axis->integer; *outSign = j_side->value > 0.0f ? -1 : 1; } else if (Q_stricmp(bind, "+moveright") == 0) { *outAxis = j_side_axis->integer; *outSign = j_side->value > 0.0f ? 1 : -1; } else if (Q_stricmp(bind, "+lookup") == 0) { *outAxis = j_pitch_axis->integer; *outSign = j_pitch->value > 0.0f ? -1 : 1; } else if (Q_stricmp(bind, "+lookdown") == 0) { *outAxis = j_pitch_axis->integer; *outSign = j_pitch->value > 0.0f ? 1 : -1; } else if (Q_stricmp(bind, "+left") == 0) { *outAxis = j_yaw_axis->integer; *outSign = j_yaw->value > 0.0f ? 1 : -1; } else if (Q_stricmp(bind, "+right") == 0) { *outAxis = j_yaw_axis->integer; *outSign = j_yaw->value > 0.0f ? -1 : 1; } else if (Q_stricmp(bind, "+moveup") == 0) { *outAxis = j_up_axis->integer; *outSign = j_up->value > 0.0f ? 1 : -1; } else if (Q_stricmp(bind, "+movedown") == 0) { *outAxis = j_up_axis->integer; *outSign = j_up->value > 0.0f ? -1 : 1; } return *outSign != 0; } /* =============== IN_GamepadMove =============== */ static void IN_GamepadMove( void ) { int i; int translatedAxes[MAX_JOYSTICK_AXIS]; qboolean translatedAxesSet[MAX_JOYSTICK_AXIS]; SDL_GameControllerUpdate(); // check buttons for (i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++) { qboolean pressed = SDL_GameControllerGetButton(gamepad, SDL_CONTROLLER_BUTTON_A + i); if (pressed != stick_state.buttons[i]) { Com_QueueEvent(in_eventTime, SE_KEY, K_PAD0_A + i, pressed, 0, NULL); stick_state.buttons[i] = pressed; } } // must defer translated axes until all real axes are processed // must be done this way to prevent a later mapped axis from zeroing out a previous one if (in_joystickUseAnalog->integer) { for (i = 0; i < MAX_JOYSTICK_AXIS; i++) { translatedAxes[i] = 0; translatedAxesSet[i] = qfalse; } } // check axes for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; i++) { int axis = SDL_GameControllerGetAxis(gamepad, SDL_CONTROLLER_AXIS_LEFTX + i); int oldAxis = stick_state.oldaaxes[i]; // Smoothly ramp from dead zone to maximum value float f = ((float)abs(axis) / 32767.0f - in_joystickThreshold->value) / (1.0f - in_joystickThreshold->value); if (f < 0.0f) f = 0.0f; axis = (int)(32767 * ((axis < 0) ? -f : f)); if (axis != oldAxis) { const int negMap[SDL_CONTROLLER_AXIS_MAX] = { K_PAD0_LEFTSTICK_LEFT, K_PAD0_LEFTSTICK_UP, K_PAD0_RIGHTSTICK_LEFT, K_PAD0_RIGHTSTICK_UP, 0, 0 }; const int posMap[SDL_CONTROLLER_AXIS_MAX] = { K_PAD0_LEFTSTICK_RIGHT, K_PAD0_LEFTSTICK_DOWN, K_PAD0_RIGHTSTICK_RIGHT, K_PAD0_RIGHTSTICK_DOWN, K_PAD0_LEFTTRIGGER, K_PAD0_RIGHTTRIGGER }; qboolean posAnalog = qfalse, negAnalog = qfalse; int negKey = negMap[i]; int posKey = posMap[i]; if (in_joystickUseAnalog->integer) { int posAxis = 0, posSign = 0, negAxis = 0, negSign = 0; // get axes and axes signs for keys if available posAnalog = KeyToAxisAndSign(posKey, &posAxis, &posSign); negAnalog = KeyToAxisAndSign(negKey, &negAxis, &negSign); // positive to negative/neutral -> keyup if axis hasn't yet been set if (posAnalog && !translatedAxesSet[posAxis] && oldAxis > 0 && axis <= 0) { translatedAxes[posAxis] = 0; translatedAxesSet[posAxis] = qtrue; } // negative to positive/neutral -> keyup if axis hasn't yet been set if (negAnalog && !translatedAxesSet[negAxis] && oldAxis < 0 && axis >= 0) { translatedAxes[negAxis] = 0; translatedAxesSet[negAxis] = qtrue; } // negative/neutral to positive -> keydown if (posAnalog && axis > 0) { translatedAxes[posAxis] = axis * posSign; translatedAxesSet[posAxis] = qtrue; } // positive/neutral to negative -> keydown if (negAnalog && axis < 0) { translatedAxes[negAxis] = -axis * negSign; translatedAxesSet[negAxis] = qtrue; } } // keyups first so they get overridden by keydowns later // positive to negative/neutral -> keyup if (!posAnalog && posKey && oldAxis > 0 && axis <= 0) Com_QueueEvent(in_eventTime, SE_KEY, posKey, qfalse, 0, NULL); // negative to positive/neutral -> keyup if (!negAnalog && negKey && oldAxis < 0 && axis >= 0) Com_QueueEvent(in_eventTime, SE_KEY, negKey, qfalse, 0, NULL); // negative/neutral to positive -> keydown if (!posAnalog && posKey && oldAxis <= 0 && axis > 0) Com_QueueEvent(in_eventTime, SE_KEY, posKey, qtrue, 0, NULL); // positive/neutral to negative -> keydown if (!negAnalog && negKey && oldAxis >= 0 && axis < 0) Com_QueueEvent(in_eventTime, SE_KEY, negKey, qtrue, 0, NULL); stick_state.oldaaxes[i] = axis; } } // set translated axes if (in_joystickUseAnalog->integer) { for (i = 0; i < MAX_JOYSTICK_AXIS; i++) { if (translatedAxesSet[i]) Com_QueueEvent(in_eventTime, SE_JOYSTICK_AXIS, i, translatedAxes[i], 0, NULL); } } } /* =============== IN_JoyMove =============== */ static void IN_JoyMove( void ) { unsigned int axes = 0; unsigned int hats = 0; int total = 0; int i = 0; in_eventTime = Sys_Milliseconds(); if (gamepad) { IN_GamepadMove(); return; } if (!stick) return; SDL_JoystickUpdate(); // update the ball state. total = SDL_JoystickNumBalls(stick); if (total > 0) { int balldx = 0; int balldy = 0; for (i = 0; i < total; i++) { int dx = 0; int dy = 0; SDL_JoystickGetBall(stick, i, &dx, &dy); balldx += dx; balldy += dy; } if (balldx || balldy) { // !!! FIXME: is this good for stick balls, or just mice? // Scale like the mouse input... if (abs(balldx) > 1) balldx *= 2; if (abs(balldy) > 1) balldy *= 2; Com_QueueEvent( in_eventTime, SE_MOUSE, balldx, balldy, 0, NULL ); } } // now query the stick buttons... total = SDL_JoystickNumButtons(stick); if (total > 0) { if (total > ARRAY_LEN(stick_state.buttons)) total = ARRAY_LEN(stick_state.buttons); for (i = 0; i < total; i++) { qboolean pressed = (SDL_JoystickGetButton(stick, i) != 0); if (pressed != stick_state.buttons[i]) { Com_QueueEvent( in_eventTime, SE_KEY, K_JOY1 + i, pressed, 0, NULL ); stick_state.buttons[i] = pressed; } } } // look at the hats... total = SDL_JoystickNumHats(stick); if (total > 0) { if (total > 4) total = 4; for (i = 0; i < total; i++) { ((Uint8 *)&hats)[i] = SDL_JoystickGetHat(stick, i); } } // update hat state if (hats != stick_state.oldhats) { for( i = 0; i < 4; i++ ) { if( ((Uint8 *)&hats)[i] != ((Uint8 *)&stick_state.oldhats)[i] ) { // release event switch( ((Uint8 *)&stick_state.oldhats)[i] ) { case SDL_HAT_UP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qfalse, 0, NULL ); break; case SDL_HAT_RIGHT: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qfalse, 0, NULL ); break; case SDL_HAT_DOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qfalse, 0, NULL ); break; case SDL_HAT_LEFT: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qfalse, 0, NULL ); break; case SDL_HAT_RIGHTUP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qfalse, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qfalse, 0, NULL ); break; case SDL_HAT_RIGHTDOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qfalse, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qfalse, 0, NULL ); break; case SDL_HAT_LEFTUP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qfalse, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qfalse, 0, NULL ); break; case SDL_HAT_LEFTDOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qfalse, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qfalse, 0, NULL ); break; default: break; } // press event switch( ((Uint8 *)&hats)[i] ) { case SDL_HAT_UP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qtrue, 0, NULL ); break; case SDL_HAT_RIGHT: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qtrue, 0, NULL ); break; case SDL_HAT_DOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qtrue, 0, NULL ); break; case SDL_HAT_LEFT: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qtrue, 0, NULL ); break; case SDL_HAT_RIGHTUP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qtrue, 0, NULL ); break; case SDL_HAT_RIGHTDOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 1], qtrue, 0, NULL ); break; case SDL_HAT_LEFTUP: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 0], qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qtrue, 0, NULL ); break; case SDL_HAT_LEFTDOWN: Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 2], qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, hat_keys[4*i + 3], qtrue, 0, NULL ); break; default: break; } } } } // save hat state stick_state.oldhats = hats; // finally, look at the axes... total = SDL_JoystickNumAxes(stick); if (total > 0) { if (in_joystickUseAnalog->integer) { if (total > MAX_JOYSTICK_AXIS) total = MAX_JOYSTICK_AXIS; for (i = 0; i < total; i++) { Sint16 axis = SDL_JoystickGetAxis(stick, i); float f = ( (float) abs(axis) ) / 32767.0f; if( f < in_joystickThreshold->value ) axis = 0; if ( axis != stick_state.oldaaxes[i] ) { Com_QueueEvent( in_eventTime, SE_JOYSTICK_AXIS, i, axis, 0, NULL ); stick_state.oldaaxes[i] = axis; } } } else { if (total > 16) total = 16; for (i = 0; i < total; i++) { Sint16 axis = SDL_JoystickGetAxis(stick, i); float f = ( (float) axis ) / 32767.0f; if( f < -in_joystickThreshold->value ) { axes |= ( 1 << ( i * 2 ) ); } else if( f > in_joystickThreshold->value ) { axes |= ( 1 << ( ( i * 2 ) + 1 ) ); } } } } /* Time to update axes state based on old vs. new. */ if (axes != stick_state.oldaxes) { for( i = 0; i < 16; i++ ) { if( ( axes & ( 1 << i ) ) && !( stick_state.oldaxes & ( 1 << i ) ) ) { Com_QueueEvent( in_eventTime, SE_KEY, joy_keys[i], qtrue, 0, NULL ); } if( !( axes & ( 1 << i ) ) && ( stick_state.oldaxes & ( 1 << i ) ) ) { Com_QueueEvent( in_eventTime, SE_KEY, joy_keys[i], qfalse, 0, NULL ); } } } /* Save for future generations. */ stick_state.oldaxes = axes; } #endif // USE_JOYSTICK #ifdef DEBUG_EVENTS static const char *eventName( SDL_WindowEventID event ) { static char buf[32]; switch ( event ) { case SDL_WINDOWEVENT_NONE: return "NONE"; case SDL_WINDOWEVENT_SHOWN: return "SHOWN"; case SDL_WINDOWEVENT_HIDDEN: return "HIDDEN"; case SDL_WINDOWEVENT_EXPOSED: return "EXPOSED"; case SDL_WINDOWEVENT_MOVED: return "MOVED"; case SDL_WINDOWEVENT_RESIZED: return "RESIZED"; case SDL_WINDOWEVENT_SIZE_CHANGED: return "SIZE_CHANGED"; case SDL_WINDOWEVENT_MINIMIZED: return "MINIMIZED"; case SDL_WINDOWEVENT_MAXIMIZED: return "MAXIMIZED"; case SDL_WINDOWEVENT_RESTORED: return "RESTORED"; case SDL_WINDOWEVENT_ENTER: return "ENTER"; case SDL_WINDOWEVENT_LEAVE: return "LEAVE"; case SDL_WINDOWEVENT_FOCUS_GAINED: return "FOCUS_GAINED"; case SDL_WINDOWEVENT_FOCUS_LOST: return "FOCUS_LOST"; case SDL_WINDOWEVENT_CLOSE: return "CLOSE"; case SDL_WINDOWEVENT_TAKE_FOCUS: return "TAKE_FOCUS"; case SDL_WINDOWEVENT_HIT_TEST: return "HIT_TEST"; default: sprintf( buf, "EVENT#%i", event ); return buf; } } #endif /* =============== HandleEvents =============== */ //static void IN_ProcessEvents( void ) void HandleEvents( void ) { SDL_Event e; keyNum_t key = 0; static keyNum_t lastKeyDown = 0; if ( !SDL_WasInit( SDL_INIT_VIDEO ) ) return; in_eventTime = Sys_Milliseconds(); while ( SDL_PollEvent( &e ) ) { switch( e.type ) { case SDL_KEYDOWN: if ( e.key.repeat && Key_GetCatcher() == 0 ) break; key = IN_TranslateSDLToQ3Key( &e.key.keysym, qtrue ); if ( key == K_ENTER && keys[K_ALT].down ) { Cvar_SetIntegerValue( "r_fullscreen", glw_state.isFullscreen ? 0 : 1 ); Cbuf_AddText( "vid_restart\n" ); break; } if ( key ) { Com_QueueEvent( in_eventTime, SE_KEY, key, qtrue, 0, NULL ); if ( key == K_BACKSPACE ) Com_QueueEvent( in_eventTime, SE_CHAR, CTRL('h'), 0, 0, NULL ); else if ( key == K_ESCAPE ) Com_QueueEvent( in_eventTime, SE_CHAR, key, 0, 0, NULL ); else if( keys[K_CTRL].down && key >= 'a' && key <= 'z' ) Com_QueueEvent( in_eventTime, SE_CHAR, CTRL(key), 0, 0, NULL ); } lastKeyDown = key; break; case SDL_KEYUP: if( ( key = IN_TranslateSDLToQ3Key( &e.key.keysym, qfalse ) ) ) Com_QueueEvent( in_eventTime, SE_KEY, key, qfalse, 0, NULL ); lastKeyDown = 0; break; case SDL_TEXTINPUT: if( lastKeyDown != K_CONSOLE ) { char *c = e.text.text; // Quick and dirty UTF-8 to UTF-32 conversion while( *c ) { int utf32 = 0; unsigned char cur_char = *c; if (cur_char >> 7 == 0) { utf32 = cur_char; c++; } else if (cur_char >> 5 == 0b110) { utf32 |= (cur_char & 0b11111) << 6; utf32 |= (*(c + 1)) & 0b111111; c += 2; } else if (cur_char >> 4 == 0b1110) { utf32 |= (cur_char & 0b1111) << 12; utf32 |= ((*(c + 1)) & 0b111111) << 6; utf32 |= (*(c + 2)) & 0b111111; c += 3; } else if (cur_char >> 3 == 0b11110) { utf32 |= (cur_char & 0b111) << 18; utf32 |= ((*(c + 1)) & 0b111111) << 12; utf32 |= ((*(c + 2)) & 0b111111) << 6; utf32 |= (*(c + 3)) & 0b111111; c += 4; } else { Com_DPrintf("Unrecognised UTF-8 character: 0x%x\n", (unsigned int)*c); c++; } if( utf32 != 0 ) { if( IN_IsConsoleKey( 0, utf32 ) ) { Com_QueueEvent( in_eventTime, SE_KEY, K_CONSOLE, qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, K_CONSOLE, qfalse, 0, NULL ); } else Com_QueueEvent( in_eventTime, SE_CHAR, utf32, 0, 0, NULL ); } } } break; case SDL_MOUSEMOTION: if( mouseActive ) { if( !e.motion.xrel && !e.motion.yrel ) break; Com_QueueEvent( in_eventTime, SE_MOUSE, e.motion.xrel, e.motion.yrel, 0, NULL ); } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { int b; switch( e.button.button ) { case SDL_BUTTON_LEFT: b = K_MOUSE1; break; case SDL_BUTTON_MIDDLE: b = K_MOUSE3; break; case SDL_BUTTON_RIGHT: b = K_MOUSE2; break; case SDL_BUTTON_X1: b = K_MOUSE4; break; case SDL_BUTTON_X2: b = K_MOUSE5; break; default: b = K_AUX1 + ( e.button.button - SDL_BUTTON_X2 + 1 ) % 16; break; } Com_QueueEvent( in_eventTime, SE_KEY, b, ( e.type == SDL_MOUSEBUTTONDOWN ? qtrue : qfalse ), 0, NULL ); } break; case SDL_MOUSEWHEEL: if( e.wheel.y > 0 ) { Com_QueueEvent( in_eventTime, SE_KEY, K_MWHEELUP, qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, K_MWHEELUP, qfalse, 0, NULL ); } else if( e.wheel.y < 0 ) { Com_QueueEvent( in_eventTime, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL ); Com_QueueEvent( in_eventTime, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL ); } break; #ifdef USE_JOYSTICK case SDL_CONTROLLERDEVICEADDED: case SDL_CONTROLLERDEVICEREMOVED: if ( in_joystick->integer ) IN_InitJoystick(); break; #endif case SDL_QUIT: Cbuf_ExecuteText( EXEC_NOW, "quit Closed window\n" ); break; case SDL_WINDOWEVENT: #ifdef DEBUG_EVENTS Com_Printf( "%4i %s\n", e.window.timestamp, eventName( e.window.event ) ); #endif switch ( e.window.event ) { case SDL_WINDOWEVENT_MOVED: if ( gw_active && !gw_minimized && !glw_state.isFullscreen ) { Cvar_SetIntegerValue( "vid_xpos", e.window.data1 ); Cvar_SetIntegerValue( "vid_ypos", e.window.data2 ); } break; // window states: case SDL_WINDOWEVENT_HIDDEN: case SDL_WINDOWEVENT_MINIMIZED: gw_active = qfalse; gw_minimized = qtrue; break; case SDL_WINDOWEVENT_SHOWN: case SDL_WINDOWEVENT_RESTORED: case SDL_WINDOWEVENT_MAXIMIZED: gw_minimized = qfalse; break; // keyboard focus: case SDL_WINDOWEVENT_FOCUS_LOST: lastKeyDown = 0; Key_ClearStates(); gw_active = qfalse; break; case SDL_WINDOWEVENT_FOCUS_GAINED: lastKeyDown = 0; Key_ClearStates(); gw_active = qtrue; gw_minimized = qfalse; if ( re.SetColorMappings ) { re.SetColorMappings(); } break; // mouse focus: case SDL_WINDOWEVENT_ENTER: mouse_focus = qtrue; break; case SDL_WINDOWEVENT_LEAVE: if ( glw_state.isFullscreen ) mouse_focus = qfalse; break; } break; default: break; } } } /* =============== IN_Minimize Minimize the game so that user is back at the desktop =============== */ static void IN_Minimize( void ) { SDL_MinimizeWindow( SDL_window ); } /* =============== IN_Frame =============== */ void IN_Frame( void ) { #ifdef USE_JOYSTICK IN_JoyMove(); #endif if ( Key_GetCatcher() & KEYCATCH_CONSOLE ) { // temporarily deactivate if not in the game and // running on the desktop with multimonitor configuration if ( !glw_state.isFullscreen || glw_state.monitorCount > 1 ) { IN_DeactivateMouse(); return; } } if ( !gw_active || !mouse_focus || in_nograb->integer ) { IN_DeactivateMouse(); return; } IN_ActivateMouse(); //IN_ProcessEvents(); //HandleEvents(); // Set event time for next frame to earliest possible time an event could happen //in_eventTime = Sys_Milliseconds(); } /* =============== IN_Restart =============== */ static void IN_Restart( void ) { #ifdef USE_JOYSTICK IN_ShutdownJoystick(); #endif IN_Shutdown(); IN_Init(); } /* =============== IN_Init =============== */ void IN_Init( void ) { if ( !SDL_WasInit( SDL_INIT_VIDEO ) ) { Com_Error( ERR_FATAL, "IN_Init called before SDL_Init( SDL_INIT_VIDEO )" ); return; } Com_DPrintf( "\n------- Input Initialization -------\n" ); in_keyboardDebug = Cvar_Get( "in_keyboardDebug", "0", CVAR_ARCHIVE ); Cvar_SetDescription( in_keyboardDebug, "Print keyboard debug info." ); in_forceCharset = Cvar_Get( "in_forceCharset", "1", CVAR_ARCHIVE_ND ); Cvar_SetDescription( in_forceCharset, "Try to translate non-ASCII chars in keyboard input or force EN/US keyboard layout." ); // mouse variables in_mouse = Cvar_Get( "in_mouse", "1", CVAR_ARCHIVE ); Cvar_CheckRange( in_mouse, "-1", "1", CV_INTEGER ); Cvar_SetDescription( in_mouse, "Mouse data input source:\n" \ " 0 - disable mouse input\n" \ " 1 - di/raw mouse\n" \ " -1 - win32 mouse" ); #ifdef USE_JOYSTICK in_joystick = Cvar_Get( "in_joystick", "0", CVAR_ARCHIVE|CVAR_LATCH ); Cvar_SetDescription( in_joystick, "Whether or not joystick support is on." ); in_joystickThreshold = Cvar_Get( "joy_threshold", "0.15", CVAR_ARCHIVE ); Cvar_SetDescription( in_joystickThreshold, "Threshold of joystick moving distance." ); j_pitch = Cvar_Get( "j_pitch", "0.022", CVAR_ARCHIVE_ND ); Cvar_SetDescription( j_pitch, "Joystick pitch rotation speed/direction." ); j_yaw = Cvar_Get( "j_yaw", "-0.022", CVAR_ARCHIVE_ND ); Cvar_SetDescription( j_yaw, "Joystick yaw rotation speed/direction." ); j_forward = Cvar_Get( "j_forward", "-0.25", CVAR_ARCHIVE_ND ); Cvar_SetDescription( j_forward, "Joystick forward movement speed/direction." ); j_side = Cvar_Get( "j_side", "0.25", CVAR_ARCHIVE_ND ); Cvar_SetDescription( j_side, "Joystick side movement speed/direction." ); j_up = Cvar_Get( "j_up", "0", CVAR_ARCHIVE_ND ); Cvar_SetDescription( j_up, "Joystick up movement speed/direction." ); j_pitch_axis = Cvar_Get( "j_pitch_axis", "3", CVAR_ARCHIVE_ND ); Cvar_CheckRange( j_pitch_axis, "0", va("%i",MAX_JOYSTICK_AXIS-1), CV_INTEGER ); Cvar_SetDescription( j_pitch_axis, "Selects which joystick axis controls pitch." ); j_yaw_axis = Cvar_Get( "j_yaw_axis", "2", CVAR_ARCHIVE_ND ); Cvar_CheckRange( j_yaw_axis, "0", va("%i",MAX_JOYSTICK_AXIS-1), CV_INTEGER ); Cvar_SetDescription( j_yaw_axis, "Selects which joystick axis controls yaw." ); j_forward_axis = Cvar_Get( "j_forward_axis", "1", CVAR_ARCHIVE_ND ); Cvar_CheckRange( j_forward_axis, "0", va("%i",MAX_JOYSTICK_AXIS-1), CV_INTEGER ); Cvar_SetDescription( j_forward_axis, "Selects which joystick axis controls forward/back." ); j_side_axis = Cvar_Get( "j_side_axis", "0", CVAR_ARCHIVE_ND ); Cvar_CheckRange( j_side_axis, "0", va("%i",MAX_JOYSTICK_AXIS-1), CV_INTEGER ); Cvar_SetDescription( j_side_axis, "Selects which joystick axis controls left/right." ); j_up_axis = Cvar_Get( "j_up_axis", "4", CVAR_ARCHIVE_ND ); Cvar_CheckRange( j_up_axis, "0", va("%i",MAX_JOYSTICK_AXIS-1), CV_INTEGER ); Cvar_SetDescription( j_up_axis, "Selects which joystick axis controls up/down." ); #endif // ~ and `, as keys and characters cl_consoleKeys = Cvar_Get( "cl_consoleKeys", "~ ` 0x7e 0x60", CVAR_ARCHIVE ); Cvar_SetDescription( cl_consoleKeys, "Space delimited list of key names or characters that toggle the console." ); mouseAvailable = ( in_mouse->value != 0 ) ? qtrue : qfalse; SDL_StartTextInput(); //IN_DeactivateMouse(); #ifdef USE_JOYSTICK IN_InitJoystick(); #endif Cmd_AddCommand( "minimize", IN_Minimize ); Cmd_AddCommand( "in_restart", IN_Restart ); Com_DPrintf( "------------------------------------\n" ); } /* =============== IN_Shutdown =============== */ void IN_Shutdown( void ) { SDL_StopTextInput(); IN_DeactivateMouse(); mouseAvailable = qfalse; #ifdef USE_JOYSTICK IN_ShutdownJoystick(); #endif Cmd_RemoveCommand( "minimize" ); Cmd_RemoveCommand( "in_restart" ); }