create tremded branch

1 files changed, 1336 insertions, 0 deletions

diff --git a/src/sdl/sdl_input.cpp b/src/sdl/sdl_input.cpp
new file mode 100644
index 0000000..1e1056a
--- /dev/null
+++ b/src/sdl/sdl_input.cpp
@@ -0,0 +1,1336 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous 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 3 of the License,
+or (at your option) any later version.
+
+Tremulous 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 Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+
+#ifdef USE_LOCAL_HEADERS
+# include "SDL.h"
+#else
+# include <SDL.h>
+#endif
+
+#include "client/client.h"
+#include "sys/sys_local.h"
+
+static cvar_t *in_keyboardDebug     = NULL;
+
+static SDL_GameController *gamepad = NULL;
+static SDL_Joystick *stick = NULL;
+
+static bool mouseAvailable = false;
+static bool mouseActive = false;
+
+static cvar_t *in_mouse             = NULL;
+static cvar_t *in_nograb;
+
+static cvar_t *in_joystick          = NULL;
+static cvar_t *in_joystickThreshold = NULL;
+static cvar_t *in_joystickNo        = NULL;
+static cvar_t *in_joystickUseAnalog = NULL;
+
+static int vidRestartTime = 0;
+static int in_eventTime = 0;
+
+static SDL_Window *SDL_window = NULL;
+
+#define CTRL(a) ((a)-'a'+1)
+
+/*
+===============
+IN_PrintKey
+===============
+*/
+static void IN_PrintKey( const SDL_Keysym *keysym, keyNum_t key, bool 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 bool 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 )
+	{
+		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;
+
+			if( strlen( token ) == 4 )
+				charCode = Com_HexStrToInt( token );
+
+			if( charCode > 0 )
+			{
+				c->type = consoleKey_s::CHARACTER;
+				c->u.character = charCode;
+			}
+			else
+			{
+				c->type = consoleKey_s::QUAKE_KEY;
+				c->u.key = (keyNum_t)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 = (keyNum_t)0;
+
+	for( i = 0; i < numConsoleKeys; i++ )
+	{
+		consoleKey_t *c = &consoleKeys[ i ];
+
+		switch( c->type )
+		{
+            case consoleKey_s::QUAKE_KEY:
+				if( key && c->u.key == key )
+					return true;
+				break;
+
+            case consoleKey_s::CHARACTER:
+				if( c->u.character == character )
+					return true;
+				break;
+		}
+	}
+
+	return false;
+}
+
+/*
+===============
+IN_TranslateSDLToQ3Key
+===============
+*/
+static keyNum_t IN_TranslateSDLToQ3Key( SDL_Keysym *keysym, bool down )
+{
+	keyNum_t key = (keyNum_t)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 = static_cast<keyNum_t>('0');
+		else
+			key = static_cast<keyNum_t>('1' + keysym->scancode - SDL_SCANCODE_1);
+	}
+	else if( keysym->sym >= SDLK_SPACE && keysym->sym < SDLK_DELETE )
+	{
+		// These happen to match the ASCII chars
+		key = (keyNum_t)keysym->sym;
+	}
+	else
+	{
+		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( !( 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 = static_cast<keyNum_t>(K_WORLD_0 + (int)keysym->scancode);
+                }
+				break;
+		}
+	}
+
+	if( in_keyboardDebug->integer )
+		IN_PrintKey( keysym, key, down );
+
+	if( IN_IsConsoleKey( key, 0 ) )
+	{
+		// Console keys can't be bound or generate characters
+		key = K_CONSOLE;
+	}
+
+	return key;
+}
+
+/*
+===============
+IN_GobbleMotionEvents
+===============
+*/
+static void IN_GobbleMotionEvents( void )
+{
+	SDL_Event dummy[ 1 ];
+	int val = 0;
+
+	// Gobble any mouse motion events
+	SDL_PumpEvents( );
+	while( ( val = SDL_PeepEvents( dummy, 1, SDL_GETEVENT,
+		SDL_MOUSEMOTION, SDL_MOUSEMOTION ) ) > 0 ) { }
+
+	if ( val < 0 )
+		Com_Printf( "IN_GobbleMotionEvents failed: %s\n", SDL_GetError( ) );
+}
+
+/*
+===============
+IN_GetUIMousePosition
+===============
+*/
+static void IN_GetUIMousePosition( int *x, int *y )
+{
+	if( cls.ui )
+	{
+		int pos = VM_Call( cls.ui, UI_MOUSE_POSITION );
+		*x = pos & 0xFFFF;
+		*y = ( pos >> 16 ) & 0xFFFF;
+
+		*x = cls.glconfig.vidWidth * *x / 640;
+		*y = cls.glconfig.vidHeight * *y / 480;
+	}
+	else
+	{
+		*x = cls.glconfig.vidWidth / 2;
+		*y = cls.glconfig.vidHeight / 2;
+	}
+}
+
+/*
+===============
+IN_SetUIMousePosition
+===============
+*/
+static void IN_SetUIMousePosition( int x, int y )
+{
+	if( cls.ui )
+	{
+		x = x * 640 / cls.glconfig.vidWidth;
+		y = y * 480 / cls.glconfig.vidHeight;
+		VM_Call( cls.ui, UI_SET_MOUSE_POSITION, x, y );
+	}
+}
+
+/*
+===============
+IN_ActivateMouse
+===============
+*/
+static void IN_ActivateMouse( void )
+{
+	if (!mouseAvailable || !SDL_WasInit( SDL_INIT_VIDEO ) )
+		return;
+
+	if( !mouseActive )
+	{
+		SDL_SetRelativeMouseMode( SDL_TRUE );
+		SDL_SetWindowGrab( SDL_window, SDL_TRUE );
+
+		IN_GobbleMotionEvents( );
+	}
+
+	// in_nograb makes no sense in fullscreen mode
+	if( !cls.glconfig.isFullscreen )
+	{
+		if( in_nograb->modified || !mouseActive )
+		{
+			if( in_nograb->integer )
+            {
+                SDL_SetRelativeMouseMode( SDL_FALSE  );
+				SDL_SetWindowGrab( SDL_window, SDL_FALSE );
+            }
+			else
+            {
+                SDL_SetRelativeMouseMode( SDL_TRUE  );
+                SDL_SetWindowGrab( SDL_window, SDL_TRUE );
+            }
+			in_nograb->modified = qfalse;
+		}
+	}
+
+	mouseActive = true;
+}
+
+/*
+===============
+IN_DeactivateMouse
+===============
+*/
+static void IN_DeactivateMouse( void )
+{
+	if( !SDL_WasInit( SDL_INIT_VIDEO ) )
+		return;
+
+	// Always show the cursor when the mouse is disabled,
+	// but not when fullscreen
+	if( !cls.glconfig.isFullscreen )
+	{
+		if( ( Key_GetCatcher( ) == KEYCATCH_UI ) &&
+		    SDL_GetWindowFlags( SDL_window ) & SDL_WINDOW_MOUSE_FOCUS )
+			SDL_ShowCursor( 0 );
+		else
+			SDL_ShowCursor( 1 );
+	}
+
+	if( !mouseAvailable )
+		return;
+
+	if( mouseActive )
+	{
+		IN_GobbleMotionEvents( );
+
+		SDL_SetWindowGrab( SDL_window, SDL_FALSE );
+		SDL_SetRelativeMouseMode( SDL_FALSE );
+
+		// Don't warp the mouse unless the cursor is within the window
+		if( SDL_GetWindowFlags( SDL_window ) & SDL_WINDOW_MOUSE_FOCUS && cls.uiInterface != 2 )
+    {
+			int x, y;
+			IN_GetUIMousePosition( &x, &y );
+			SDL_WarpMouseInWindow( SDL_window, x, y );
+    }
+
+		mouseActive = false;
+	}
+}
+
+// We translate axes movement into keypresses
+static 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 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
+{
+	bool 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 );
+
+	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 );
+	if( in_joystickNo->integer < 0 || in_joystickNo->integer >= total )
+		Cvar_Set( "in_joystickNo", "0" );
+
+	in_joystickUseAnalog = Cvar_Get( "in_joystickUseAnalog", "0", CVAR_ARCHIVE );
+
+	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 bool KeyToAxisAndSign(int keynum, int *outAxis, int *outSign)
+{
+	if (!keynum)
+		return false;
+
+	const char* bind = Key_GetBinding(keynum);
+
+	if (!bind || *bind != '+')
+		return false;
+
+	*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];
+	bool translatedAxesSet[MAX_JOYSTICK_AXIS];
+
+	SDL_GameControllerUpdate();
+
+	// check buttons
+	for (i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++)
+	{
+		bool pressed = SDL_GameControllerGetButton(gamepad, (SDL_GameControllerButton)(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] = false;
+		}
+	}
+
+	// check axes
+	for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; i++)
+	{
+		int axis = SDL_GameControllerGetAxis(gamepad, (SDL_GameControllerAxis)(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 };
+
+			bool posAnalog = false, negAnalog = false;
+			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] = true;
+				}
+
+				// 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] = true;
+				}
+
+				// negative/neutral to positive -> keydown
+				if (posAnalog && axis > 0)
+				{
+					translatedAxes[posAxis] = axis * posSign;
+					translatedAxesSet[posAxis] = true;
+				}
+
+				// positive/neutral to negative -> keydown
+				if (negAnalog && axis < 0)
+				{
+					translatedAxes[negAxis] = -axis * negSign;
+					translatedAxesSet[negAxis] = true;
+				}
+			}
+
+			// 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, false, 0, NULL);
+
+			// negative to positive/neutral -> keyup
+			if (!negAnalog && negKey && oldAxis < 0 && axis >= 0)
+				Com_QueueEvent(in_eventTime, SE_KEY, negKey, false, 0, NULL);
+
+			// negative/neutral to positive -> keydown
+			if (!posAnalog && posKey && oldAxis <= 0 && axis > 0)
+				Com_QueueEvent(in_eventTime, SE_KEY, posKey, true, 0, NULL);
+
+			// positive/neutral to negative -> keydown
+			if (!negAnalog && negKey && oldAxis >= 0 && axis < 0)
+				Com_QueueEvent(in_eventTime, SE_KEY, negKey, true, 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;
+
+	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++)
+		{
+			bool 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], false, 0, NULL );
+						break;
+					case SDL_HAT_RIGHT:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], false, 0, NULL );
+						break;
+					case SDL_HAT_DOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], false, 0, NULL );
+						break;
+					case SDL_HAT_LEFT:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], false, 0, NULL );
+						break;
+					case SDL_HAT_RIGHTUP:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 0], false, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], false, 0, NULL );
+						break;
+					case SDL_HAT_RIGHTDOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], false, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], false, 0, NULL );
+						break;
+					case SDL_HAT_LEFTUP:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 0], false, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], false, 0, NULL );
+						break;
+					case SDL_HAT_LEFTDOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], false, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], false, 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], true, 0, NULL );
+						break;
+					case SDL_HAT_RIGHT:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], true, 0, NULL );
+						break;
+					case SDL_HAT_DOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], true, 0, NULL );
+						break;
+					case SDL_HAT_LEFT:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], true, 0, NULL );
+						break;
+					case SDL_HAT_RIGHTUP:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 0], true, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], true, 0, NULL );
+						break;
+					case SDL_HAT_RIGHTDOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], true, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 1], true, 0, NULL );
+						break;
+					case SDL_HAT_LEFTUP:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 0], true, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], true, 0, NULL );
+						break;
+					case SDL_HAT_LEFTDOWN:
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 2], true, 0, NULL );
+						Com_QueueEvent(in_eventTime, SE_KEY, hat_keys[4*i + 3], true, 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], true, 0, NULL );
+			}
+
+			if( !( axes & ( 1 << i ) ) && ( stick_state.oldaxes & ( 1 << i ) ) ) {
+				Com_QueueEvent(in_eventTime, SE_KEY, joy_keys[i], false, 0, NULL );
+			}
+		}
+	}
+
+	/* Save for future generations. */
+	stick_state.oldaxes = axes;
+}
+
+/*
+===============
+IN_ProcessEvents
+===============
+*/
+static void IN_ProcessEvents( void )
+{
+	SDL_Event e;
+	keyNum_t key = (keyNum_t)0;
+	static keyNum_t lastKeyDown = (keyNum_t)0;
+
+	if( !SDL_WasInit( SDL_INIT_VIDEO ) )
+			return;
+
+	while( SDL_PollEvent( &e ) )
+	{
+		switch( e.type )
+		{
+			case SDL_KEYDOWN:
+				if ( e.key.repeat && Key_GetCatcher( ) == 0 )
+					break;
+
+				if( ( key = IN_TranslateSDLToQ3Key( &e.key.keysym, true ) ) )
+					Com_QueueEvent(in_eventTime, SE_KEY, key, true, 0, NULL );
+
+				if( key == K_BACKSPACE )
+					Com_QueueEvent(in_eventTime, SE_CHAR, CTRL('h'), 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, false ) ) )
+					Com_QueueEvent(in_eventTime, SE_KEY, key, false, 0, NULL );
+
+				lastKeyDown = (keyNum_t)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;
+
+						if( ( *c & 0x80 ) == 0 )
+							utf32 = *c++;
+						else if( ( *c & 0xE0 ) == 0xC0 ) // 110x xxxx
+						{
+							utf32 |= ( *c++ & 0x1F ) << 6;
+							utf32 |= ( *c++ & 0x3F );
+						}
+						else if( ( *c & 0xF0 ) == 0xE0 ) // 1110 xxxx
+						{
+							utf32 |= ( *c++ & 0x0F ) << 12;
+							utf32 |= ( *c++ & 0x3F ) << 6;
+							utf32 |= ( *c++ & 0x3F );
+						}
+						else if( ( *c & 0xF8 ) == 0xF0 ) // 1111 0xxx
+						{
+							utf32 |= ( *c++ & 0x07 ) << 18;
+							utf32 |= ( *c++ & 0x3F ) << 12;
+							utf32 |= ( *c++ & 0x3F ) << 6;
+							utf32 |= ( *c++ & 0x3F );
+						}
+						else
+						{
+							Com_DPrintf( "Unrecognised UTF-8 lead byte: 0x%x\n", (unsigned int)*c );
+							c++;
+						}
+
+						if( utf32 != 0 )
+						{
+							if( IN_IsConsoleKey( (keyNum_t)0, utf32 ) )
+							{
+								Com_QueueEvent(in_eventTime, SE_KEY, K_CONSOLE, true, 0, NULL );
+								Com_QueueEvent(in_eventTime, SE_KEY, K_CONSOLE, false, 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 1:   b = K_MOUSE1;     break;
+						case 2:   b = K_MOUSE3;     break;
+						case 3:   b = K_MOUSE2;     break;
+						case 4:   b = K_MOUSE4;     break;
+						case 5:   b = K_MOUSE5;     break;
+						default:  b = K_AUX1 + ( e.button.button - 8 ) % 16; break;
+					}
+					Com_QueueEvent(in_eventTime, SE_KEY, b,
+						( e.type == SDL_MOUSEBUTTONDOWN ? true : false ), 0, NULL );
+				}
+				break;
+
+			case SDL_MOUSEWHEEL:
+				if( e.wheel.y > 0 )
+				{
+					Com_QueueEvent(in_eventTime, SE_KEY, K_MWHEELUP, true, 0, NULL );
+					Com_QueueEvent(in_eventTime, SE_KEY, K_MWHEELUP, false, 0, NULL );
+				}
+				else if( e.wheel.y < 0 )
+				{
+					Com_QueueEvent(in_eventTime, SE_KEY, K_MWHEELDOWN, true, 0, NULL );
+					Com_QueueEvent(in_eventTime, SE_KEY, K_MWHEELDOWN, false, 0, NULL );
+				}
+				break;
+
+			case SDL_CONTROLLERDEVICEADDED:
+			case SDL_CONTROLLERDEVICEREMOVED:
+				if (in_joystick->integer)
+					IN_InitJoystick();
+				break;
+
+			case SDL_QUIT:
+				Cbuf_ExecuteText(EXEC_NOW, "quit \"Closed window\"\n");
+				break;
+
+			case SDL_WINDOWEVENT:
+				switch( e.window.event )
+				{
+					case SDL_WINDOWEVENT_RESIZED:
+						{
+							int width, height;
+
+							width = e.window.data1;
+							height = e.window.data2;
+
+                            // ignore this event on fullscreen
+                            if ( cls.glconfig.isFullscreen )
+                                break;
+
+							// check if size actually changed
+							if( cls.glconfig.vidWidth == width && cls.glconfig.vidHeight == height )
+							{
+								break;
+							}
+
+							Cvar_SetValue( "r_width", width );
+							Cvar_SetValue( "r_height", height );
+
+							// Wait until user stops dragging for 1 second, so
+							// we aren't constantly recreating the GL context while
+							// he tries to drag...
+							vidRestartTime = Sys_Milliseconds( ) + 1000;
+						}
+						break;
+
+					case SDL_WINDOWEVENT_MINIMIZED:    Cvar_SetValue( "com_minimized", 1 ); break;
+					case SDL_WINDOWEVENT_RESTORED:
+					case SDL_WINDOWEVENT_MAXIMIZED:    Cvar_SetValue( "com_minimized", 0 ); break;
+					case SDL_WINDOWEVENT_FOCUS_LOST:   Cvar_SetValue( "com_unfocused", 1 ); break;
+					case SDL_WINDOWEVENT_FOCUS_GAINED: Cvar_SetValue( "com_unfocused", 0 ); break;
+				}
+				break;
+
+			default:
+				break;
+		}
+	}
+}
+
+/*
+===============
+IN_Frame
+===============
+*/
+void IN_Frame( void )
+{
+	bool loading;
+	bool cursorShowing;
+	int x, y;
+
+	IN_JoyMove( );
+
+	// If not DISCONNECTED (main menu) or ACTIVE (in game), we're loading
+	loading = ( clc.state != CA_DISCONNECTED && clc.state != CA_ACTIVE );
+	cursorShowing = Key_GetCatcher( ) & KEYCATCH_UI;
+
+	if( !cls.glconfig.isFullscreen && ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) )
+	{
+		// Console is down in windowed mode
+		IN_DeactivateMouse( );
+	}
+	else if( !cls.glconfig.isFullscreen && loading )
+	{
+		// Loading in windowed mode
+		IN_DeactivateMouse( );
+	}
+	else if( !cls.glconfig.isFullscreen && cursorShowing && cls.uiInterface != 2 )
+	{
+		// Use WM cursor when not fullscreen
+		IN_DeactivateMouse( );
+	}
+	else if( !( SDL_GetWindowFlags( SDL_window ) & SDL_WINDOW_INPUT_FOCUS ) )
+	{
+		// Window not got focus
+		IN_DeactivateMouse( );
+	}
+	else
+		IN_ActivateMouse( );
+
+	if( !mouseActive && cls.uiInterface != 2 )
+	{
+		SDL_GetMouseState( &x, &y );
+		IN_SetUIMousePosition( x, y );
+	}
+
+	IN_ProcessEvents( );
+
+    // Set event time for next frame to earliest possible time an event could happen
+    in_eventTime = Sys_Milliseconds();
+
+	// In case we had to delay actual restart of video system
+	if( ( vidRestartTime != 0 ) && ( vidRestartTime < Sys_Milliseconds( ) ) )
+	{
+		vidRestartTime = 0;
+		Cbuf_AddText( "vid_restart\n" );
+	}
+}
+
+/*
+===============
+IN_Init
+===============
+*/
+void IN_Init( void *windowData )
+{
+	int appState;
+
+	if( !SDL_WasInit( SDL_INIT_VIDEO ) )
+	{
+		Com_Error( ERR_FATAL, "IN_Init called before SDL_Init( SDL_INIT_VIDEO )" );
+		return;
+	}
+
+	SDL_window = (SDL_Window *)windowData;
+
+	Com_DPrintf( "\n------- Input Initialization -------\n" );
+
+	in_keyboardDebug = Cvar_Get( "in_keyboardDebug", "0", CVAR_ARCHIVE );
+
+	// mouse variables
+	in_mouse = Cvar_Get( "in_mouse", "1", CVAR_ARCHIVE );
+	in_nograb = Cvar_Get( "in_nograb", "0", CVAR_ARCHIVE );
+
+	in_joystick = Cvar_Get( "in_joystick", "0", CVAR_ARCHIVE|CVAR_LATCH );
+	in_joystickThreshold = Cvar_Get( "joy_threshold", "0.15", CVAR_ARCHIVE );
+
+	SDL_StartTextInput( );
+
+	mouseAvailable = ( in_mouse->value != 0 );
+	IN_DeactivateMouse( );
+
+	appState = SDL_GetWindowFlags( SDL_window );
+	Cvar_SetValue( "com_unfocused",	!( appState & SDL_WINDOW_INPUT_FOCUS ) );
+	Cvar_SetValue( "com_minimized", appState & SDL_WINDOW_MINIMIZED );
+
+	IN_InitJoystick( );
+	Com_DPrintf( "------------------------------------\n" );
+}
+
+/*
+===============
+IN_Shutdown
+===============
+*/
+void IN_Shutdown( void )
+{
+	SDL_StopTextInput( );
+
+	IN_DeactivateMouse( );
+	mouseAvailable = false;
+
+	IN_ShutdownJoystick( );
+
+	SDL_window = NULL;
+}
+
+/*
+===============
+IN_Restart
+===============
+*/
+void IN_Restart( void )
+{
+	IN_ShutdownJoystick( );
+	IN_Init( SDL_window );
+}