tf2/tf2_src/inputsystem/key_translation.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//===========================================================================//


#if defined( WIN32 ) 
#if !defined( _X360 )
#include <wtypes.h>
#include <winuser.h>
#include "xbox/xboxstubs.h"
#else
#include "xbox/xbox_win32stubs.h"
#endif
#endif // WIN32

#include "key_translation.h"
#include "tier1/convar.h"
#include "tier1/strtools.h"
#include "tier0/dbg.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#if defined(__clang__)
	#pragma GCC diagnostic ignored "-Wchar-subscripts"
#endif

static ButtonCode_t s_pVirtualKeyToButtonCode[256];

static ButtonCode_t s_pSKeytoButtonCode[SK_MAX_KEYS];

#if !defined( POSIX )
static ButtonCode_t s_pXKeyTrans[XK_MAX_KEYS];
#endif

#define SCONTROLLERBUTTONS_BUTTONS( x ) \
	"SC_A",\
	"SC_B",\
	"SC_X",\
	"SC_Y",\
	"SC_DPAD_UP",\
	"SC_DPAD_RIGHT",\
	"SC_DPAD_DOWN",\
	"SC_DPAD_LEFT",\
	"SC_LEFT_BUMPER",\
	"SC_RIGHT_BUMPER",\
	"SC_LEFT_TRIGGER",\
	"SC_RIGHT_TRIGGER",\
	"SC_LEFT_GRIP",\
	"SC_RIGHT_GRIP",\
	"SC_LEFT_PAD_TOUCH",\
	"SC_RIGHT_PAD_TOUCH",\
	"SC_LEFT_PAD_CLICK",\
	"SC_RIGHT_PAD_CLICK",\
	"SC_LPAD_UP",\
	"SC_LPAD_RIGHT",\
	"SC_LPAD_DOWN",\
	"SC_LPAD_LEFT",\
	"SC_RPAD_UP",\
	"SC_RPAD_RIGHT",\
	"SC_RPAD_DOWN",\
	"SC_RPAD_LEFT",\
	"SC_SELECT",\
	"SC_START",\
	"SC_STEAM",\
	"SC_NULL"

#define SCONTROLLERBUTTONS_AXIS( x ) \
	"SC_LPAD_AXIS_RIGHT",\
	"SC_LPAD_AXIS_LEFT",\
	"SC_LPAD_AXIS_DOWN",\
	"SC_LPAD_AXIS_UP",\
	"SC_AXIS_L_TRIGGER",\
	"SC_AXIS_R_TRIGGER",\
	"SC_RPAD_AXIS_RIGHT",\
	"SC_RPAD_AXIS_LEFT",\
	"SC_RPAD_AXIS_DOWN",\
	"SC_RPAD_AXIS_UP",\
	"SC_GYRO_AXIS_PITCH_POSITIVE",\
	"SC_GYRO_AXIS_PITCH_NEGATIVE",\
	"SC_GYRO_AXIS_ROLL_POSITIVE",\
	"SC_GYRO_AXIS_ROLL_NEGATIVE",\
	"SC_GYRO_AXIS_YAW_POSITIVE",\
	"SC_GYRO_AXIS_YAW_NEGATIVE"

#define SCONTROLLERBUTTONS_VBUTTONS( x ) \
	"SC_F1",\
	"SC_F2",\
	"SC_F3",\
	"SC_F4",\
	"SC_F5",\
	"SC_F6",\
	"SC_F7",\
	"SC_F8",\
	"SC_F9",\
	"SC_F10",\
	"SC_F11",\
	"SC_F12"

static int s_pButtonCodeToVirtual[BUTTON_CODE_LAST];

static const char *s_pButtonCodeName[ ] =
{
	"",				// KEY_NONE
	"0",			// KEY_0,
	"1",			// KEY_1,
	"2",			// KEY_2,
	"3",			// KEY_3,
	"4",			// KEY_4,
	"5",			// KEY_5,
	"6",			// KEY_6,
	"7",			// KEY_7,
	"8",			// KEY_8,
	"9",			// KEY_9,
	"a",			// KEY_A,
	"b",			// KEY_B,
	"c",			// KEY_C,
	"d",			// KEY_D,
	"e",			// KEY_E,
	"f",			// KEY_F,
	"g",			// KEY_G,
	"h",			// KEY_H,
	"i",			// KEY_I,
	"j",			// KEY_J,
	"k",			// KEY_K,
	"l",			// KEY_L,
	"m",			// KEY_M,
	"n",			// KEY_N,
	"o",			// KEY_O,
	"p",			// KEY_P,
	"q",			// KEY_Q,
	"r",			// KEY_R,
	"s",			// KEY_S,
	"t",			// KEY_T,
	"u",			// KEY_U,
	"v",			// KEY_V,
	"w",			// KEY_W,
	"x",			// KEY_X,
	"y",			// KEY_Y,
	"z",			// KEY_Z,
	"KP_INS",		// KEY_PAD_0,
	"KP_END",		// KEY_PAD_1,
	"KP_DOWNARROW",	// KEY_PAD_2,
	"KP_PGDN",		// KEY_PAD_3,
	"KP_LEFTARROW",	// KEY_PAD_4,
	"KP_5",			// KEY_PAD_5,
	"KP_RIGHTARROW",// KEY_PAD_6,
	"KP_HOME",		// KEY_PAD_7,
	"KP_UPARROW",	// KEY_PAD_8,
	"KP_PGUP",		// KEY_PAD_9,
	"KP_SLASH",		// KEY_PAD_DIVIDE,
	"KP_MULTIPLY",	// KEY_PAD_MULTIPLY,
	"KP_MINUS",		// KEY_PAD_MINUS,
	"KP_PLUS",		// KEY_PAD_PLUS,
	"KP_ENTER",		// KEY_PAD_ENTER,
	"KP_DEL",		// KEY_PAD_DECIMAL,
	"[",			// KEY_LBRACKET,
	"]",			// KEY_RBRACKET,
	"SEMICOLON",	// KEY_SEMICOLON,
	"'",			// KEY_APOSTROPHE,
	"`",			// KEY_BACKQUOTE,
	",",			// KEY_COMMA,
	".",			// KEY_PERIOD,
	"/",			// KEY_SLASH,
	"\\",			// KEY_BACKSLASH,
	"-",			// KEY_MINUS,
	"=",			// KEY_EQUAL,
	"ENTER",		// KEY_ENTER,
	"SPACE",		// KEY_SPACE,
	"BACKSPACE",	// KEY_BACKSPACE,
	"TAB",			// KEY_TAB,
	"CAPSLOCK",		// KEY_CAPSLOCK,
	"NUMLOCK",		// KEY_NUMLOCK,
	"ESCAPE",		// KEY_ESCAPE,
	"SCROLLLOCK",	// KEY_SCROLLLOCK,
	"INS",			// KEY_INSERT,
	"DEL",			// KEY_DELETE,
	"HOME",			// KEY_HOME,
	"END",			// KEY_END,
	"PGUP",			// KEY_PAGEUP,
	"PGDN",			// KEY_PAGEDOWN,
	"PAUSE",		// KEY_BREAK,
	"SHIFT",		// KEY_LSHIFT,
	"RSHIFT",		// KEY_RSHIFT,
	"ALT",			// KEY_LALT,
	"RALT",			// KEY_RALT,
	"CTRL",			// KEY_LCONTROL,
	"RCTRL",		// KEY_RCONTROL,
	"LWIN",			// KEY_LWIN,
	"RWIN",			// KEY_RWIN,
	"APP",			// KEY_APP,
	"UPARROW",		// KEY_UP,
	"LEFTARROW",	// KEY_LEFT,
	"DOWNARROW",	// KEY_DOWN,
	"RIGHTARROW",	// KEY_RIGHT,
	"F1",			// KEY_F1,
	"F2",			// KEY_F2,
	"F3",			// KEY_F3,
	"F4",			// KEY_F4,
	"F5",			// KEY_F5,
	"F6",			// KEY_F6,
	"F7",			// KEY_F7,
	"F8",			// KEY_F8,
	"F9",			// KEY_F9,
	"F10",			// KEY_F10,
	"F11",			// KEY_F11,
	"F12",			// KEY_F12,

	// FIXME: CAPSLOCK/NUMLOCK/SCROLLLOCK all appear above. What are these for?!
	// They only appear in CInputWin32::UpdateToggleButtonState in vgui2
	"CAPSLOCKTOGGLE",	// KEY_CAPSLOCKTOGGLE,
	"NUMLOCKTOGGLE",	// KEY_NUMLOCKTOGGLE,
	"SCROLLLOCKTOGGLE", // KEY_SCROLLLOCKTOGGLE,

	// Mouse
	"MOUSE1",		// MOUSE_LEFT,
	"MOUSE2",		// MOUSE_RIGHT,
	"MOUSE3",		// MOUSE_MIDDLE,
	"MOUSE4",		// MOUSE_4,
	"MOUSE5",		// MOUSE_5,

	"MWHEELUP",		// MOUSE_WHEEL_UP
	"MWHEELDOWN",	// MOUSE_WHEEL_DOWN

#if defined ( _X360 ) || defined ( _LINUX )
	"A_BUTTON",		// JOYSTICK_FIRST_BUTTON		
	"B_BUTTON",		
	"X_BUTTON",		
	"Y_BUTTON",		
	"L_SHOULDER",		
	"R_SHOULDER",		
	"BACK",		
	"START",
	"STICK1",		
	"STICK2",		
#else
	"JOY1",			// JOYSTICK_FIRST_BUTTON
	"JOY2",		
	"JOY3",		
	"JOY4",		
	"JOY5",		
	"JOY6",		
	"JOY7",		
	"JOY8",		
	"JOY9",		
	"JOY10",
#endif

	"JOY11",		
	"JOY12",		
	"JOY13",		
	"JOY14",		
	"JOY15",		
	"JOY16",		
	"JOY17",	
	"JOY18",		
	"JOY19",		
	"JOY20",	
	"JOY21",	
	"JOY22",	
	"JOY23",		
	"JOY24",		
	"JOY25",		
	"JOY26",		
	"JOY27",	
	"JOY28",	
	"JOY29",	
	"JOY30",		
	"JOY31",		
	"JOY32",		// JOYSTICK_LAST_BUTTON

#if defined ( _X360 )
	"UP",			// JOYSTICK_FIRST_POV_BUTTON
	"RIGHT",		
	"DOWN",		
	"LEFT",			// JOYSTICK_LAST_POV_BUTTON

	"S1_RIGHT",		// JOYSTICK_FIRST_AXIS_BUTTON
	"S1_LEFT",		
	"S1_DOWN",
	"S1_UP",		
	"L_TRIGGER",		
	"R_TRIGGER",
	"S2_RIGHT",
	"S2_LEFT",		
	"S2_DOWN",
	"S2_UP",		// JOYSTICK_LAST_AXIS_BUTTON
	"V AXIS POS",
	"V AXIS NEG",		
#else
	"POV_UP",		// JOYSTICK_FIRST_POV_BUTTON
	"POV_RIGHT",		
	"POV_DOWN",		
	"POV_LEFT",		// JOYSTICK_LAST_POV_BUTTON

	"X AXIS POS",	// JOYSTICK_FIRST_AXIS_BUTTON
	"X AXIS NEG",		
	"Y AXIS POS",
	"Y AXIS NEG",		
	"Z AXIS POS",
	"Z AXIS NEG",		
	"R AXIS POS",
	"R AXIS NEG",		
	"U AXIS POS",
	"U AXIS NEG",		
	"V AXIS POS",
	"V AXIS NEG",	// JOYSTICK_LAST_AXIS_BUTTON
	"FALCON_NULL", // NVNT temp Fix for unaligned joystick enumeration
	"FALCON_1",	// NOVINT_FIRST
	"FALCON_2",
	"FALCON_3",
	"FALCON_4",
	"FALCON2_1",
	"FALCON2_2",
	"FALCON2_3",
	"FALCON2_4", // NOVINT_LAST
#endif

	SCONTROLLERBUTTONS_BUTTONS( 0 ),
	SCONTROLLERBUTTONS_BUTTONS( 1 ),
	SCONTROLLERBUTTONS_BUTTONS( 2 ),
	SCONTROLLERBUTTONS_BUTTONS( 3 ),
	SCONTROLLERBUTTONS_BUTTONS( 4 ),
	SCONTROLLERBUTTONS_BUTTONS( 5 ),
	SCONTROLLERBUTTONS_BUTTONS( 6 ),
	SCONTROLLERBUTTONS_BUTTONS( 7 ),

	SCONTROLLERBUTTONS_AXIS( 0 ),
	SCONTROLLERBUTTONS_AXIS( 1 ),
	SCONTROLLERBUTTONS_AXIS( 2 ),
	SCONTROLLERBUTTONS_AXIS( 3 ),
	SCONTROLLERBUTTONS_AXIS( 4 ),
	SCONTROLLERBUTTONS_AXIS( 5 ),
	SCONTROLLERBUTTONS_AXIS( 6 ),
	SCONTROLLERBUTTONS_AXIS( 7 ),

	SCONTROLLERBUTTONS_VBUTTONS( 0 ),
	SCONTROLLERBUTTONS_VBUTTONS( 1 ),
	SCONTROLLERBUTTONS_VBUTTONS( 2 ),
	SCONTROLLERBUTTONS_VBUTTONS( 3 ),
	SCONTROLLERBUTTONS_VBUTTONS( 4 ),
	SCONTROLLERBUTTONS_VBUTTONS( 5 ),
	SCONTROLLERBUTTONS_VBUTTONS( 6 ),
	SCONTROLLERBUTTONS_VBUTTONS( 7 ),
};

static const char *s_pAnalogCodeName[ ] =
{
	"MOUSE_X",		// MOUSE_X = 0,
	"MOUSE_Y",		// MOUSE_Y,
	"MOUSE_XY",		// MOUSE_XY,		// Invoked when either x or y changes
	"MOUSE_WHEEL",	// MOUSE_WHEEL,

	"X AXIS",		// JOY_AXIS_X
	"Y AXIS",		// JOY_AXIS_Y
	"Z AXIS",		// JOY_AXIS_Z
	"R AXIS",		// JOY_AXIS_R
	"U AXIS",		// JOY_AXIS_U
	"V AXIS",		// JOY_AXIS_V
};

#if !defined ( _X360 )
static const char *s_pXControllerButtonCodeNames[ ] =
{
	"A_BUTTON",		// JOYSTICK_FIRST_BUTTON		
	"B_BUTTON",		
	"X_BUTTON",		
	"Y_BUTTON",		
	"L_SHOULDER",		
	"R_SHOULDER",		
	"BACK",		
	"START",
	"STICK1",		
	"STICK2",		
	"JOY11",		
	"JOY12",		
	"JOY13",		
	"JOY14",		
	"JOY15",		
	"JOY16",		
	"JOY17",	
	"JOY18",		
	"JOY19",		
	"JOY20",	
	"JOY21",	
	"JOY22",	
	"JOY23",		
	"JOY24",		
	"JOY25",		
	"JOY26",		
	"JOY27",	
	"JOY28",	
	"JOY29",	
	"JOY30",		
	"JOY31",		
	"JOY32",		// JOYSTICK_LAST_BUTTON

	"UP",			// JOYSTICK_FIRST_POV_BUTTON
	"RIGHT",		
	"DOWN",		
	"LEFT",			// JOYSTICK_LAST_POV_BUTTON

	"S1_RIGHT",		// JOYSTICK_FIRST_AXIS_BUTTON
	"S1_LEFT",		
	"S1_DOWN",
	"S1_UP",		
	"L_TRIGGER",		
	"R_TRIGGER",
	"S2_RIGHT",
	"S2_LEFT",		
	"S2_DOWN",
	"S2_UP",		// JOYSTICK_LAST_AXIS_BUTTON
	"V AXIS POS",
	"V AXIS NEG",		
};
#endif

// this maps non-translated keyboard scan codes to engine key codes
// Google for 'Keyboard Scan Code Specification'
static ButtonCode_t s_pScanToButtonCode_QWERTY[128] = 
{ 
	//	0				1				2				3				4				5				6				7 
	//	8				9				A				B				C				D				E				F 
	KEY_NONE,		KEY_ESCAPE,		KEY_1,			KEY_2,			KEY_3,			KEY_4,			KEY_5,			KEY_6,			// 0
	KEY_7,			KEY_8,			KEY_9,			KEY_0,			KEY_MINUS,		KEY_EQUAL,		KEY_BACKSPACE,	KEY_TAB,		// 0 

	KEY_Q,			KEY_W,			KEY_E,			KEY_R,			KEY_T,			KEY_Y,			KEY_U,			KEY_I,			// 1
	KEY_O,			KEY_P,			KEY_LBRACKET,	KEY_RBRACKET,	KEY_ENTER,		KEY_LCONTROL,	KEY_A,			KEY_S,			// 1 

	KEY_D,			KEY_F,			KEY_G,			KEY_H,			KEY_J,			KEY_K,			KEY_L,			KEY_SEMICOLON,	// 2 
	KEY_APOSTROPHE,	KEY_BACKQUOTE,	KEY_LSHIFT,		KEY_BACKSLASH,	KEY_Z,			KEY_X,			KEY_C,			KEY_V,			// 2 

	KEY_B,			KEY_N,			KEY_M,			KEY_COMMA,		KEY_PERIOD,		KEY_SLASH,		KEY_RSHIFT,		KEY_PAD_MULTIPLY,// 3
	KEY_LALT,		KEY_SPACE,		KEY_CAPSLOCK,	KEY_F1,			KEY_F2,			KEY_F3,			KEY_F4,			KEY_F5,			// 3 

	KEY_F6,			KEY_F7,			KEY_F8,			KEY_F9,			KEY_F10,		KEY_NUMLOCK,	KEY_SCROLLLOCK,	KEY_HOME,		// 4
	KEY_UP,			KEY_PAGEUP,		KEY_PAD_MINUS,	KEY_LEFT,		KEY_PAD_5,		KEY_RIGHT,		KEY_PAD_PLUS,	KEY_END,		// 4 

	KEY_DOWN,		KEY_PAGEDOWN,	KEY_INSERT,		KEY_DELETE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_F11,		// 5
	KEY_F12,		KEY_BREAK,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		// 5

	KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		// 6
	KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		// 6 

	KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		// 7
	KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE,		KEY_NONE		// 7 
};

static ButtonCode_t s_pScanToButtonCode[128];


void ButtonCode_InitKeyTranslationTable()
{
	COMPILE_TIME_ASSERT( sizeof(s_pButtonCodeName) / sizeof( const char * ) == BUTTON_CODE_LAST );
	COMPILE_TIME_ASSERT( sizeof(s_pAnalogCodeName) / sizeof( const char * ) == ANALOG_CODE_LAST );

	// set virtual key translation table
	memset( s_pVirtualKeyToButtonCode, KEY_NONE, sizeof(s_pVirtualKeyToButtonCode) );

	s_pVirtualKeyToButtonCode['0']			=KEY_0;
	s_pVirtualKeyToButtonCode['1']			=KEY_1;
	s_pVirtualKeyToButtonCode['2']			=KEY_2;
	s_pVirtualKeyToButtonCode['3']			=KEY_3;
	s_pVirtualKeyToButtonCode['4']			=KEY_4;
	s_pVirtualKeyToButtonCode['5']			=KEY_5;
	s_pVirtualKeyToButtonCode['6']			=KEY_6;
	s_pVirtualKeyToButtonCode['7']			=KEY_7;
	s_pVirtualKeyToButtonCode['8']			=KEY_8;
	s_pVirtualKeyToButtonCode['9']			=KEY_9;
	s_pVirtualKeyToButtonCode['A']			=KEY_A;
	s_pVirtualKeyToButtonCode['B'] 			=KEY_B;
	s_pVirtualKeyToButtonCode['C'] 			=KEY_C;
	s_pVirtualKeyToButtonCode['D'] 			=KEY_D;
	s_pVirtualKeyToButtonCode['E']			=KEY_E;
	s_pVirtualKeyToButtonCode['F']			=KEY_F;
	s_pVirtualKeyToButtonCode['G']			=KEY_G;
	s_pVirtualKeyToButtonCode['H'] 			=KEY_H;
	s_pVirtualKeyToButtonCode['I']			=KEY_I;
	s_pVirtualKeyToButtonCode['J']			=KEY_J;
	s_pVirtualKeyToButtonCode['K']			=KEY_K;
	s_pVirtualKeyToButtonCode['L']			=KEY_L;
	s_pVirtualKeyToButtonCode['M']			=KEY_M;
	s_pVirtualKeyToButtonCode['N']			=KEY_N;
	s_pVirtualKeyToButtonCode['O']			=KEY_O;
	s_pVirtualKeyToButtonCode['P']			=KEY_P;
	s_pVirtualKeyToButtonCode['Q']			=KEY_Q;
	s_pVirtualKeyToButtonCode['R']			=KEY_R;
	s_pVirtualKeyToButtonCode['S']			=KEY_S;
	s_pVirtualKeyToButtonCode['T']			=KEY_T;
	s_pVirtualKeyToButtonCode['U']			=KEY_U;
	s_pVirtualKeyToButtonCode['V']			=KEY_V;
	s_pVirtualKeyToButtonCode['W']			=KEY_W;
	s_pVirtualKeyToButtonCode['X']			=KEY_X;
	s_pVirtualKeyToButtonCode['Y']			=KEY_Y;
	s_pVirtualKeyToButtonCode['Z']			=KEY_Z;
#if !defined( POSIX )
	s_pVirtualKeyToButtonCode[VK_NUMPAD0]	=KEY_PAD_0;
	s_pVirtualKeyToButtonCode[VK_NUMPAD1]	=KEY_PAD_1;
	s_pVirtualKeyToButtonCode[VK_NUMPAD2]	=KEY_PAD_2;
	s_pVirtualKeyToButtonCode[VK_NUMPAD3]	=KEY_PAD_3;
	s_pVirtualKeyToButtonCode[VK_NUMPAD4]	=KEY_PAD_4;
	s_pVirtualKeyToButtonCode[VK_NUMPAD5]	=KEY_PAD_5;
	s_pVirtualKeyToButtonCode[VK_NUMPAD6]	=KEY_PAD_6;
	s_pVirtualKeyToButtonCode[VK_NUMPAD7]	=KEY_PAD_7;
	s_pVirtualKeyToButtonCode[VK_NUMPAD8]	=KEY_PAD_8;
	s_pVirtualKeyToButtonCode[VK_NUMPAD9]	=KEY_PAD_9;
	s_pVirtualKeyToButtonCode[VK_DIVIDE]	=KEY_PAD_DIVIDE;
	s_pVirtualKeyToButtonCode[VK_MULTIPLY]	=KEY_PAD_MULTIPLY;
	s_pVirtualKeyToButtonCode[VK_SUBTRACT]	=KEY_PAD_MINUS;
	s_pVirtualKeyToButtonCode[VK_ADD]		=KEY_PAD_PLUS;
	s_pVirtualKeyToButtonCode[VK_RETURN]	=KEY_PAD_ENTER;
	s_pVirtualKeyToButtonCode[VK_DECIMAL]	=KEY_PAD_DECIMAL;
#endif
	s_pVirtualKeyToButtonCode[0xdb]			=KEY_LBRACKET;
	s_pVirtualKeyToButtonCode[0xdd]			=KEY_RBRACKET;
	s_pVirtualKeyToButtonCode[0xba]			=KEY_SEMICOLON;
	s_pVirtualKeyToButtonCode[0xde]			=KEY_APOSTROPHE;
	s_pVirtualKeyToButtonCode[0xc0]			=KEY_BACKQUOTE;
	s_pVirtualKeyToButtonCode[0xbc]			=KEY_COMMA;
	s_pVirtualKeyToButtonCode[0xbe]			=KEY_PERIOD;
	s_pVirtualKeyToButtonCode[0xbf]			=KEY_SLASH;
	s_pVirtualKeyToButtonCode[0xdc]			=KEY_BACKSLASH;
	s_pVirtualKeyToButtonCode[0xbd]			=KEY_MINUS;
	s_pVirtualKeyToButtonCode[0xbb]			=KEY_EQUAL;
#if !defined( POSIX )
	s_pVirtualKeyToButtonCode[VK_RETURN]	=KEY_ENTER;
	s_pVirtualKeyToButtonCode[VK_SPACE]		=KEY_SPACE;
	s_pVirtualKeyToButtonCode[VK_BACK]		=KEY_BACKSPACE;
	s_pVirtualKeyToButtonCode[VK_TAB]		=KEY_TAB;
	s_pVirtualKeyToButtonCode[VK_CAPITAL]	=KEY_CAPSLOCK;
	s_pVirtualKeyToButtonCode[VK_NUMLOCK]	=KEY_NUMLOCK;
	s_pVirtualKeyToButtonCode[VK_ESCAPE]	=KEY_ESCAPE;
	s_pVirtualKeyToButtonCode[VK_SCROLL]	=KEY_SCROLLLOCK;
	s_pVirtualKeyToButtonCode[VK_INSERT]	=KEY_INSERT;
	s_pVirtualKeyToButtonCode[VK_DELETE]	=KEY_DELETE;
	s_pVirtualKeyToButtonCode[VK_HOME]		=KEY_HOME;
	s_pVirtualKeyToButtonCode[VK_END]		=KEY_END;
	s_pVirtualKeyToButtonCode[VK_PRIOR]		=KEY_PAGEUP;
	s_pVirtualKeyToButtonCode[VK_NEXT]		=KEY_PAGEDOWN;
	s_pVirtualKeyToButtonCode[VK_PAUSE]		=KEY_BREAK;
	s_pVirtualKeyToButtonCode[VK_SHIFT]		=KEY_RSHIFT;
	s_pVirtualKeyToButtonCode[VK_SHIFT]		=KEY_LSHIFT;	// SHIFT -> left SHIFT
	s_pVirtualKeyToButtonCode[VK_MENU]		=KEY_RALT;
	s_pVirtualKeyToButtonCode[VK_MENU]		=KEY_LALT;		// ALT -> left ALT
	s_pVirtualKeyToButtonCode[VK_CONTROL]	=KEY_RCONTROL;
	s_pVirtualKeyToButtonCode[VK_CONTROL]	=KEY_LCONTROL;	// CTRL -> left CTRL
	s_pVirtualKeyToButtonCode[VK_LWIN]		=KEY_LWIN;
	s_pVirtualKeyToButtonCode[VK_RWIN]		=KEY_RWIN;
	s_pVirtualKeyToButtonCode[VK_APPS]		=KEY_APP;
	s_pVirtualKeyToButtonCode[VK_UP]		=KEY_UP;
	s_pVirtualKeyToButtonCode[VK_LEFT]		=KEY_LEFT;
	s_pVirtualKeyToButtonCode[VK_DOWN]		=KEY_DOWN;
	s_pVirtualKeyToButtonCode[VK_RIGHT]		=KEY_RIGHT;	
	s_pVirtualKeyToButtonCode[VK_F1]		=KEY_F1;
	s_pVirtualKeyToButtonCode[VK_F2]		=KEY_F2;
	s_pVirtualKeyToButtonCode[VK_F3]		=KEY_F3;
	s_pVirtualKeyToButtonCode[VK_F4]		=KEY_F4;
	s_pVirtualKeyToButtonCode[VK_F5]		=KEY_F5;
	s_pVirtualKeyToButtonCode[VK_F6]		=KEY_F6;
	s_pVirtualKeyToButtonCode[VK_F7]		=KEY_F7;
	s_pVirtualKeyToButtonCode[VK_F8]		=KEY_F8;
	s_pVirtualKeyToButtonCode[VK_F9]		=KEY_F9;
	s_pVirtualKeyToButtonCode[VK_F10]		=KEY_F10;
	s_pVirtualKeyToButtonCode[VK_F11]		=KEY_F11;
	s_pVirtualKeyToButtonCode[VK_F12]		=KEY_F12;
#endif

	// init the xkey translation table
#if !defined( POSIX )
	s_pXKeyTrans[XK_NULL]					= KEY_NONE;
	s_pXKeyTrans[XK_BUTTON_UP]				= KEY_XBUTTON_UP;
	s_pXKeyTrans[XK_BUTTON_DOWN]			= KEY_XBUTTON_DOWN;
	s_pXKeyTrans[XK_BUTTON_LEFT]			= KEY_XBUTTON_LEFT;
	s_pXKeyTrans[XK_BUTTON_RIGHT]			= KEY_XBUTTON_RIGHT;
	s_pXKeyTrans[XK_BUTTON_START]			= KEY_XBUTTON_START;
	s_pXKeyTrans[XK_BUTTON_BACK]			= KEY_XBUTTON_BACK;
	s_pXKeyTrans[XK_BUTTON_STICK1]			= KEY_XBUTTON_STICK1;
	s_pXKeyTrans[XK_BUTTON_STICK2]			= KEY_XBUTTON_STICK2;
	s_pXKeyTrans[XK_BUTTON_A]				= KEY_XBUTTON_A;
	s_pXKeyTrans[XK_BUTTON_B]				= KEY_XBUTTON_B;
	s_pXKeyTrans[XK_BUTTON_X]				= KEY_XBUTTON_X;
	s_pXKeyTrans[XK_BUTTON_Y]				= KEY_XBUTTON_Y;
	s_pXKeyTrans[XK_BUTTON_LEFT_SHOULDER]   = KEY_XBUTTON_LEFT_SHOULDER;
	s_pXKeyTrans[XK_BUTTON_RIGHT_SHOULDER]	= KEY_XBUTTON_RIGHT_SHOULDER;
	s_pXKeyTrans[XK_BUTTON_LTRIGGER]		= KEY_XBUTTON_LTRIGGER;
	s_pXKeyTrans[XK_BUTTON_RTRIGGER]		= KEY_XBUTTON_RTRIGGER;
	s_pXKeyTrans[XK_STICK1_UP]				= KEY_XSTICK1_UP;
	s_pXKeyTrans[XK_STICK1_DOWN]			= KEY_XSTICK1_DOWN;
	s_pXKeyTrans[XK_STICK1_LEFT]			= KEY_XSTICK1_LEFT;
	s_pXKeyTrans[XK_STICK1_RIGHT]			= KEY_XSTICK1_RIGHT;
	s_pXKeyTrans[XK_STICK2_UP]				= KEY_XSTICK2_UP;
	s_pXKeyTrans[XK_STICK2_DOWN]			= KEY_XSTICK2_DOWN;
	s_pXKeyTrans[XK_STICK2_LEFT]			= KEY_XSTICK2_LEFT;
	s_pXKeyTrans[XK_STICK2_RIGHT]			= KEY_XSTICK2_RIGHT;
#endif // PLATFORM_POSIX

	// create reverse table engine to virtual
	for ( int i = 0; i < ARRAYSIZE( s_pVirtualKeyToButtonCode ); i++ )
	{
		s_pButtonCodeToVirtual[ s_pVirtualKeyToButtonCode[i] ] = i;
	}

	s_pButtonCodeToVirtual[0] = 0;

	s_pSKeytoButtonCode[SK_NULL] = KEY_NONE;
	s_pSKeytoButtonCode[SK_BUTTON_A] = STEAMCONTROLLER_A;
	s_pSKeytoButtonCode[SK_BUTTON_B] = STEAMCONTROLLER_B;
	s_pSKeytoButtonCode[SK_BUTTON_X] = STEAMCONTROLLER_X;
	s_pSKeytoButtonCode[SK_BUTTON_Y] = STEAMCONTROLLER_Y;
	s_pSKeytoButtonCode[SK_BUTTON_UP] = STEAMCONTROLLER_DPAD_UP;
	s_pSKeytoButtonCode[SK_BUTTON_RIGHT] = STEAMCONTROLLER_DPAD_RIGHT;
	s_pSKeytoButtonCode[SK_BUTTON_DOWN] = STEAMCONTROLLER_DPAD_DOWN;
	s_pSKeytoButtonCode[SK_BUTTON_LEFT] = STEAMCONTROLLER_DPAD_LEFT;
	s_pSKeytoButtonCode[SK_BUTTON_LEFT_BUMPER] = STEAMCONTROLLER_LEFT_BUMPER;
	s_pSKeytoButtonCode[SK_BUTTON_RIGHT_BUMPER] = STEAMCONTROLLER_RIGHT_BUMPER;
	s_pSKeytoButtonCode[SK_BUTTON_LEFT_TRIGGER] = STEAMCONTROLLER_LEFT_TRIGGER;
	s_pSKeytoButtonCode[SK_BUTTON_RIGHT_TRIGGER] = STEAMCONTROLLER_RIGHT_TRIGGER;
	s_pSKeytoButtonCode[SK_BUTTON_LEFT_GRIP] = STEAMCONTROLLER_LEFT_GRIP;
	s_pSKeytoButtonCode[SK_BUTTON_RIGHT_GRIP] = STEAMCONTROLLER_RIGHT_GRIP;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_TOUCH] = STEAMCONTROLLER_LEFT_PAD_FINGERDOWN;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_TOUCH] = STEAMCONTROLLER_RIGHT_PAD_FINGERDOWN;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_CLICK] = STEAMCONTROLLER_LEFT_PAD_CLICK;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_CLICK] = STEAMCONTROLLER_RIGHT_PAD_CLICK;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_UP] = STEAMCONTROLLER_LEFT_PAD_UP;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_RIGHT] = STEAMCONTROLLER_LEFT_PAD_RIGHT;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_DOWN] = STEAMCONTROLLER_LEFT_PAD_DOWN;
	s_pSKeytoButtonCode[SK_BUTTON_LPAD_LEFT] = STEAMCONTROLLER_LEFT_PAD_LEFT;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_UP] = STEAMCONTROLLER_RIGHT_PAD_UP;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_RIGHT] = STEAMCONTROLLER_RIGHT_PAD_RIGHT;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_DOWN] = STEAMCONTROLLER_RIGHT_PAD_DOWN;
	s_pSKeytoButtonCode[SK_BUTTON_RPAD_LEFT] = STEAMCONTROLLER_RIGHT_PAD_LEFT;
	s_pSKeytoButtonCode[SK_BUTTON_SELECT] = STEAMCONTROLLER_SELECT;
	s_pSKeytoButtonCode[SK_BUTTON_START] = STEAMCONTROLLER_START;
	s_pSKeytoButtonCode[SK_BUTTON_STEAM] = STEAMCONTROLLER_STEAM;
	s_pSKeytoButtonCode[SK_BUTTON_INACTIVE_START] = STEAMCONTROLLER_INACTIVE_START;

	// These are fake ("virtual") steam controller buttons that don't physically exist, but we can manufacture to make internal routing
	// to old school UI (which is expecting button code rather than actions) without clashing with other butt
	s_pSKeytoButtonCode[SK_VBUTTON_F1] = STEAMCONTROLLER_F1;
	s_pSKeytoButtonCode[SK_VBUTTON_F2] = STEAMCONTROLLER_F2;
	s_pSKeytoButtonCode[SK_VBUTTON_F3] = STEAMCONTROLLER_F3;
	s_pSKeytoButtonCode[SK_VBUTTON_F4] = STEAMCONTROLLER_F4;
	s_pSKeytoButtonCode[SK_VBUTTON_F5] = STEAMCONTROLLER_F5;
	s_pSKeytoButtonCode[SK_VBUTTON_F6] = STEAMCONTROLLER_F6;
	s_pSKeytoButtonCode[SK_VBUTTON_F7] = STEAMCONTROLLER_F7;
	s_pSKeytoButtonCode[SK_VBUTTON_F8] = STEAMCONTROLLER_F8;
	s_pSKeytoButtonCode[SK_VBUTTON_F9] = STEAMCONTROLLER_F9;
	s_pSKeytoButtonCode[SK_VBUTTON_F10] = STEAMCONTROLLER_F10;
	s_pSKeytoButtonCode[SK_VBUTTON_F11] = STEAMCONTROLLER_F11;
	s_pSKeytoButtonCode[SK_VBUTTON_F12] = STEAMCONTROLLER_F12;
}

ButtonCode_t ButtonCode_VirtualKeyToButtonCode( int keyCode )
{
	if ( keyCode < 0 || keyCode >= sizeof( s_pVirtualKeyToButtonCode ) / sizeof( s_pVirtualKeyToButtonCode[0] ) )
	{
		Assert( false );
		return KEY_NONE;
	}
	return s_pVirtualKeyToButtonCode[keyCode];
}

int ButtonCode_ButtonCodeToVirtualKey( ButtonCode_t code )
{
	return s_pButtonCodeToVirtual[code];
}

ButtonCode_t ButtonCode_XKeyToButtonCode( int nPort, int keyCode )
{
#if !defined( POSIX )
	if ( keyCode < 0 || keyCode >= sizeof( s_pXKeyTrans ) / sizeof( s_pXKeyTrans[0] ) )
	{
		Assert( false );
		return KEY_NONE;
	}

	ButtonCode_t code = s_pXKeyTrans[keyCode];
	if ( IsJoystickButtonCode( code ) )
	{
		int nOffset = code - JOYSTICK_FIRST_BUTTON;
		return JOYSTICK_BUTTON( nPort, nOffset );
	}
	
	if ( IsJoystickPOVCode( code ) )
	{
		int nOffset = code - JOYSTICK_FIRST_POV_BUTTON;
		return JOYSTICK_POV_BUTTON( nPort, nOffset );
	}
	
	if ( IsJoystickAxisCode( code ) )
	{
		int nOffset = code - JOYSTICK_FIRST_AXIS_BUTTON;
		return JOYSTICK_AXIS_BUTTON( nPort, nOffset );
	}

	return code;
#else // POSIX
	return KEY_NONE;
#endif // POSIX
}

// Convert back + forth between ButtonCode/AnalogCode + strings
const char *ButtonCode_ButtonCodeToString( ButtonCode_t code, bool bXController )
{
#if !defined ( _X360 )
	if ( bXController && code >= JOYSTICK_FIRST_BUTTON && code <= JOYSTICK_LAST_AXIS_BUTTON )
		return s_pXControllerButtonCodeNames[ code - JOYSTICK_FIRST_BUTTON ];
#endif

	return s_pButtonCodeName[ code ];
}

const char *AnalogCode_AnalogCodeToString( AnalogCode_t code )
{
	return s_pAnalogCodeName[ code ];
}

ButtonCode_t ButtonCode_StringToButtonCode( const char *pString, bool bXController )
{
	if ( !pString || !pString[0] )
		return BUTTON_CODE_INVALID;

	// Backward compat for screwed up previous joystick button names
	if ( !Q_strnicmp( pString, "aux", 3 ) )
	{
		int nIndex = atoi( &pString[3] );
		if ( nIndex < 29 )
			return JOYSTICK_BUTTON( 0, nIndex );
		if ( ( nIndex >= 29 ) && ( nIndex <= 32 ) )
			return JOYSTICK_POV_BUTTON( 0, nIndex - 29 );
		return BUTTON_CODE_INVALID;
	}

	for ( int i = 0; i < BUTTON_CODE_LAST; ++i )
	{
		if ( !Q_stricmp( s_pButtonCodeName[i], pString ) )
			return (ButtonCode_t)i;
	}

#if !defined ( _X360 )
	if ( bXController )
	{
		for ( int i = 0; i < ARRAYSIZE(s_pXControllerButtonCodeNames); ++i )
		{
			if ( !Q_stricmp( s_pXControllerButtonCodeNames[i], pString ) )
				return (ButtonCode_t)(JOYSTICK_FIRST_BUTTON + i);
		}
	}
#endif

	return BUTTON_CODE_INVALID;
}

ButtonCode_t ButtonCode_SKeyToButtonCode( int nPort, int keyCode )
{
#if !defined( _GAMECONSOLE )
	if ( keyCode < 0 || keyCode >= sizeof( s_pSKeytoButtonCode ) / sizeof( s_pSKeytoButtonCode[0] ) )
	{
		Assert( false );
		return KEY_NONE;
	}

	ButtonCode_t code = s_pSKeytoButtonCode[keyCode];
	// 	if ( IsSteamControllerCode( code ) )
	// 	{
	// 		// Need Per Controller Offset here.
	// 		return code;
	// 	}

	if ( IsSteamControllerButtonCode( code ) )
	{
		int nOffset = code - STEAMCONTROLLER_FIRST_BUTTON;
		return STEAMCONTROLLER_BUTTON( nPort, nOffset );
	}

	if ( IsSteamControllerAxisCode( code ) )
	{
		int nOffset = code - STEAMCONTROLLER_FIRST_AXIS_BUTTON;
		return STEAMCONTROLLER_AXIS_BUTTON( nPort, nOffset );
	}

	return code;
#else // _GAMECONSOLE
	return KEY_NONE;
#endif // _GAMECONSOLE
}

AnalogCode_t AnalogCode_StringToAnalogCode( const char *pString )
{
	if ( !pString || !pString[0] )
		return ANALOG_CODE_INVALID;

	for ( int i = 0; i < ANALOG_CODE_LAST; ++i )
	{
		if ( !Q_stricmp( s_pAnalogCodeName[i], pString ) )
			return (AnalogCode_t)i;
	}

	return ANALOG_CODE_INVALID;
}

ButtonCode_t ButtonCode_ScanCodeToButtonCode( int lParam )
{
	int nScanCode = ( lParam >> 16 ) & 0xFF;
	if ( nScanCode > 127 )
		return KEY_NONE;

	ButtonCode_t result = s_pScanToButtonCode[nScanCode];

	bool bIsExtended = ( lParam & ( 1 << 24 ) ) != 0;
	if ( !bIsExtended )
	{
		switch ( result )
		{
		case KEY_HOME:
			return KEY_PAD_7;
		case KEY_UP:
			return KEY_PAD_8;
		case KEY_PAGEUP:
			return KEY_PAD_9;
		case KEY_LEFT:
			return KEY_PAD_4;
		case KEY_RIGHT:
			return KEY_PAD_6;
		case KEY_END:
			return KEY_PAD_1;
		case KEY_DOWN:
			return KEY_PAD_2;
		case KEY_PAGEDOWN:
			return KEY_PAD_3;
		case KEY_INSERT:
			return KEY_PAD_0;
		case KEY_DELETE:
			return KEY_PAD_DECIMAL;
		default:
			break;
		}
	}
	else
	{
		switch ( result )
		{
		case KEY_ENTER:
			return KEY_PAD_ENTER;
		case KEY_LALT:
			return KEY_RALT;
		case KEY_LCONTROL:
			return KEY_RCONTROL;
		case KEY_SLASH:
			return KEY_PAD_DIVIDE;
		case KEY_CAPSLOCK:
			return KEY_PAD_PLUS;
		}
	}

	return result;
}


//-----------------------------------------------------------------------------
// Update scan codes for foreign keyboards
//-----------------------------------------------------------------------------
void ButtonCode_UpdateScanCodeLayout( )
{
	// reset the keyboard
	memcpy( s_pScanToButtonCode, s_pScanToButtonCode_QWERTY, sizeof(s_pScanToButtonCode) );

#if !defined( _X360 ) && !defined( POSIX )
	// fix up keyboard layout for other languages
	HKL currentKb = ::GetKeyboardLayout( 0 );
	HKL englishKb = ::LoadKeyboardLayout("00000409", 0);

	if (englishKb && englishKb != currentKb)
	{
		for ( int i = 0; i < ARRAYSIZE(s_pScanToButtonCode); i++ )
		{
			// take the english/QWERTY
			ButtonCode_t code = s_pScanToButtonCode_QWERTY[ i ];

			// only remap printable keys
			if ( code != KEY_NONE && code != KEY_BACKQUOTE && ( IsAlphaNumeric( code ) || IsPunctuation( code ) ) )
			{
				// get it's virtual key based on the old layout
				int vk = ::MapVirtualKeyEx( i, 1, englishKb );

				// turn in into a scancode on the new layout
				int newScanCode = ::MapVirtualKeyEx( vk, 0, currentKb );

				// strip off any high bits
				newScanCode &= 0x0000007F;

				// set in the new layout
				s_pScanToButtonCode[newScanCode] = code;
			}
		}
	}

	s_pScanToButtonCode[0] = KEY_NONE;
#endif
}


//-----------------------------------------------------------------------------
// Purpose: Updates the current keyboard layout
//-----------------------------------------------------------------------------
CON_COMMAND( key_updatelayout, "Updates game keyboard layout to current windows keyboard setting." )
{
	ButtonCode_UpdateScanCodeLayout();
}