//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: // //===========================================================================// #include "platform.h" #if !defined( _GAMECONSOLE ) && !defined( PLATFORM_POSIX ) #include #include #include "xbox/xboxstubs.h" #elif defined( _X360 ) #include "xbox/xbox_win32stubs.h" #undef unlink #elif defined( _PS3 ) #include "ps3/ps3_core.h" #include #endif // WIN32 #if defined( _OSX ) #include "posix_stubs.h" #endif #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" static ButtonCode_t s_pVirtualKeyToButtonCode[256]; static ButtonCode_t s_pSKeytoButtonCode[SK_MAX_KEYS]; #if defined( PLATFORM_WINDOWS ) || defined( _GAMECONSOLE ) || defined( _OSX ) static ButtonCode_t s_pXKeyTrans[XK_MAX_KEYS]; #endif static int s_pButtonCodeToVirtual[BUTTON_CODE_LAST]; #if defined ( _GAMECONSOLE ) #define JOYSTICK_NAMES_BUTTONS( x ) \ "A_BUTTON",\ "B_BUTTON",\ "X_BUTTON",\ "Y_BUTTON",\ "L_SHOULDER",\ "R_SHOULDER",\ "BACK",\ "START",\ "STICK1",\ "STICK2",\ "JOY11",\ "FIREMODE_1",\ "FIREMODE_2",\ "FIREMODE_3",\ "RELOAD",\ "TRIGGER",\ "PUMP_ACTION",\ "ROLL_RIGHT",\ "ROLL_LEFT",\ "JOY20",\ "JOY21",\ "JOY22",\ "JOY23",\ "JOY24",\ "JOY25",\ "JOY26",\ "JOY27",\ "JOY28",\ "JOY29",\ "JOY30",\ "JOY31",\ "JOY32" #define JOYSTICK_NAMES_POV( x ) \ "UP",\ "RIGHT",\ "DOWN",\ "LEFT" #define JOYSTICK_NAMES_AXIS( x ) \ "S1_RIGHT",\ "S1_LEFT",\ "S1_DOWN",\ "S1_UP",\ "L_TRIGGER",\ "R_TRIGGER",\ "S2_RIGHT",\ "S2_LEFT",\ "S2_DOWN",\ "S2_UP",\ "V AXIS POS",\ "V AXIS NEG" #else #define JOYSTICK_NAMES_BUTTONS( x ) \ "JOY1", \ "JOY2", \ "JOY3", \ "JOY4", \ "JOY5", \ "JOY6", \ "JOY7", \ "JOY8", \ "JOY9", \ "JOY10", \ "JOY11", \ "JOY12", \ "JOY13", \ "JOY14", \ "JOY15", \ "JOY16", \ "JOY17", \ "JOY18", \ "JOY19", \ "JOY20", \ "JOY21", \ "JOY22", \ "JOY23", \ "JOY24", \ "JOY25", \ "JOY26", \ "JOY27", \ "JOY28", \ "JOY29", \ "JOY30", \ "JOY31", \ "JOY32" #define JOYSTICK_NAMES_POV( x ) \ "POV_UP",\ "POV_RIGHT",\ "POV_DOWN",\ "POV_LEFT" #define JOYSTICK_NAMES_AXIS( x ) \ "X AXIS POS",\ "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" #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" #if defined( _PS3 ) static const char *s_pPS3ButtonCodeName[ ] = { "", // KEY_NONE "KEY_0", // KEY_0, "KEY_1", // KEY_1, "KEY_2", // KEY_2, "KEY_3", // KEY_3, "KEY_4", // KEY_4, "KEY_5", // KEY_5, "KEY_6", // KEY_6, "KEY_7", // KEY_7, "KEY_8", // KEY_8, "KEY_9", // KEY_9, "KEY_A", // KEY_A, "KEY_B", // KEY_B, "KEY_C", // KEY_C, "KEY_D", // KEY_D, "KEY_E", // KEY_E, "KEY_F", // KEY_F, "KEY_G", // KEY_G, "KEY_H", // KEY_H, "KEY_I", // KEY_I, "KEY_J", // KEY_J, "KEY_K", // KEY_K, "KEY_L", // KEY_L, "KEY_M", // KEY_M, "KEY_N", // KEY_N, "KEY_O", // KEY_O, "KEY_P", // KEY_P, "KEY_Q", // KEY_Q, "KEY_R", // KEY_R, "KEY_S", // KEY_S, "KEY_T", // KEY_T, "KEY_U", // KEY_U, "KEY_V", // KEY_V, "KEY_W", // KEY_W, "KEY_X", // KEY_X, "KEY_Y", // KEY_Y, "KEY_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, "LBRACKET", // KEY_LBRACKET, "RBRACKET", // KEY_RBRACKET, "SEMICOLON", // KEY_SEMICOLON, "APOSTROPHE", // KEY_APOSTROPHE, "BACKQUOTE", // KEY_BACKQUOTE, "COMMA", // KEY_COMMA, "PERIOD", // KEY_PERIOD, "SLASH", // KEY_SLASH, "BACKSLASH", // KEY_BACKSLASH, "MINUS", // KEY_MINUS, "EQUAL", // 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 JOYSTICK_NAMES_BUTTONS( 0 ), JOYSTICK_NAMES_BUTTONS( 1 ), JOYSTICK_NAMES_BUTTONS( 2 ), JOYSTICK_NAMES_BUTTONS( 3 ), JOYSTICK_NAMES_BUTTONS( 4 ), JOYSTICK_NAMES_BUTTONS( 5 ), JOYSTICK_NAMES_BUTTONS( 6 ), JOYSTICK_NAMES_POV( 0 ), JOYSTICK_NAMES_POV( 1 ), JOYSTICK_NAMES_POV( 2 ), JOYSTICK_NAMES_POV( 3 ), JOYSTICK_NAMES_POV( 4 ), JOYSTICK_NAMES_POV( 5 ), JOYSTICK_NAMES_POV( 6 ), JOYSTICK_NAMES_AXIS( 0 ), JOYSTICK_NAMES_AXIS( 1 ), JOYSTICK_NAMES_AXIS( 2 ), JOYSTICK_NAMES_AXIS( 3 ), JOYSTICK_NAMES_AXIS( 4 ), JOYSTICK_NAMES_AXIS( 5 ), JOYSTICK_NAMES_AXIS( 6 ), }; #endif 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, #if defined(OSX) "COMMAND", // KEY_LWIN "COMMAND", // KEY_RWIN #else "LWIN", // KEY_LWIN, "RWIN", // KEY_RWIN, #endif "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 JOYSTICK_NAMES_BUTTONS( 0 ), JOYSTICK_NAMES_BUTTONS( 1 ), JOYSTICK_NAMES_BUTTONS( 2 ), JOYSTICK_NAMES_BUTTONS( 3 ), #ifdef _PS3 JOYSTICK_NAMES_BUTTONS( 4 ), JOYSTICK_NAMES_BUTTONS( 5 ), JOYSTICK_NAMES_BUTTONS( 6 ), #endif JOYSTICK_NAMES_POV( 0 ), JOYSTICK_NAMES_POV( 1 ), JOYSTICK_NAMES_POV( 2 ), JOYSTICK_NAMES_POV( 3 ), #ifdef _PS3 JOYSTICK_NAMES_POV( 4 ), JOYSTICK_NAMES_POV( 5 ), JOYSTICK_NAMES_POV( 6 ), #endif JOYSTICK_NAMES_AXIS( 0 ), JOYSTICK_NAMES_AXIS( 1 ), JOYSTICK_NAMES_AXIS( 2 ), JOYSTICK_NAMES_AXIS( 3 ), #ifdef _PS3 JOYSTICK_NAMES_AXIS( 4 ), JOYSTICK_NAMES_AXIS( 5 ), JOYSTICK_NAMES_AXIS( 6 ), #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_BUTTONS( 8 ), SCONTROLLERBUTTONS_BUTTONS( 9 ), SCONTROLLERBUTTONS_BUTTONS( 10 ), SCONTROLLERBUTTONS_BUTTONS( 11 ), SCONTROLLERBUTTONS_BUTTONS( 12 ), SCONTROLLERBUTTONS_BUTTONS( 13 ), SCONTROLLERBUTTONS_BUTTONS( 14 ), SCONTROLLERBUTTONS_BUTTONS( 15 ), 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_AXIS( 8 ), SCONTROLLERBUTTONS_AXIS( 9 ), SCONTROLLERBUTTONS_AXIS( 10 ), SCONTROLLERBUTTONS_AXIS( 11 ), SCONTROLLERBUTTONS_AXIS( 12 ), SCONTROLLERBUTTONS_AXIS( 13 ), SCONTROLLERBUTTONS_AXIS( 14 ), SCONTROLLERBUTTONS_AXIS( 15 ), }; #define JOYSTICK_ANALOG( x ) \ "X AXIS",\ "Y AXIS",\ "Z AXIS",\ "R AXIS",\ "U AXIS",\ "V AXIS" 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, JOYSTICK_ANALOG( 0 ), JOYSTICK_ANALOG( 1 ), JOYSTICK_ANALOG( 2 ), JOYSTICK_ANALOG( 3 ), #ifdef _PS3 JOYSTICK_ANALOG( 4 ), JOYSTICK_ANALOG( 5 ), JOYSTICK_ANALOG( 6 ), #endif }; #if !defined ( _GAMECONSOLE ) #define XCONTROLLERBUTTONS_BUTTONS( x ) \ "A_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" #define XCONTROLLERBUTTONS_POV( x ) \ "UP",\ "RIGHT",\ "DOWN",\ "LEFT" #define XCONTROLLERBUTTONS_AXIS( x ) \ "S1_RIGHT",\ "S1_LEFT",\ "S1_DOWN",\ "S1_UP",\ "L_TRIGGER",\ "R_TRIGGER",\ "S2_RIGHT",\ "S2_LEFT",\ "S2_DOWN",\ "S2_UP",\ "V AXIS POS",\ "V AXIS NEG" static const char *s_pXControllerButtonCodeNames[ ] = { XCONTROLLERBUTTONS_BUTTONS( 0 ), XCONTROLLERBUTTONS_BUTTONS( 1 ), XCONTROLLERBUTTONS_BUTTONS( 2 ), XCONTROLLERBUTTONS_BUTTONS( 3 ), #ifdef _PS3 XCONTROLLERBUTTONS_BUTTONS( 4 ), XCONTROLLERBUTTONS_BUTTONS( 5 ), XCONTROLLERBUTTONS_BUTTONS( 6 ), #endif XCONTROLLERBUTTONS_POV( 0 ), XCONTROLLERBUTTONS_POV( 1 ), XCONTROLLERBUTTONS_POV( 2 ), XCONTROLLERBUTTONS_POV( 3 ), #ifdef _PS3 XCONTROLLERBUTTONS_POV( 4 ), XCONTROLLERBUTTONS_POV( 5 ), XCONTROLLERBUTTONS_POV( 6 ), #endif XCONTROLLERBUTTONS_AXIS( 0 ), XCONTROLLERBUTTONS_AXIS( 1 ), XCONTROLLERBUTTONS_AXIS( 2 ), XCONTROLLERBUTTONS_AXIS( 3 ), #ifdef _PS3 XCONTROLLERBUTTONS_AXIS( 4 ), XCONTROLLERBUTTONS_AXIS( 5 ), XCONTROLLERBUTTONS_AXIS( 6 ), #endif }; static const char *s_pSControllerButtonCodeNames[ ] = { 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 ), }; #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() { #if defined( _PS3 ) COMPILE_TIME_ASSERT( sizeof(s_pPS3ButtonCodeName) / sizeof( const char * ) == BUTTON_CODE_LAST ); #endif COMPILE_TIME_ASSERT( sizeof(s_pButtonCodeName) / sizeof( const char * ) == BUTTON_CODE_LAST ); COMPILE_TIME_ASSERT( sizeof(s_pAnalogCodeName) / sizeof( const char * ) == ANALOG_CODE_LAST ); // For debugging, spews entire mapping #if 0 for ( int i = 0; i < BUTTON_CODE_LAST; ++i ) { Msg( "code %d == %s\n", i, s_pButtonCodeName[ i ] ); } #endif // set virtual key translation table memset( s_pVirtualKeyToButtonCode, KEY_NONE, sizeof(s_pVirtualKeyToButtonCode) ); #if defined ( _PS3 ) s_pVirtualKeyToButtonCode[CELL_KEYC_0] =KEY_0; s_pVirtualKeyToButtonCode[CELL_KEYC_1] =KEY_1; s_pVirtualKeyToButtonCode[CELL_KEYC_2] =KEY_2; s_pVirtualKeyToButtonCode[CELL_KEYC_3] =KEY_3; s_pVirtualKeyToButtonCode[CELL_KEYC_4] =KEY_4; s_pVirtualKeyToButtonCode[CELL_KEYC_5] =KEY_5; s_pVirtualKeyToButtonCode[CELL_KEYC_6] =KEY_6; s_pVirtualKeyToButtonCode[CELL_KEYC_7] =KEY_7; s_pVirtualKeyToButtonCode[CELL_KEYC_8] =KEY_8; s_pVirtualKeyToButtonCode[CELL_KEYC_9] =KEY_9; s_pVirtualKeyToButtonCode[CELL_KEYC_A] =KEY_A; s_pVirtualKeyToButtonCode[CELL_KEYC_B] =KEY_B; s_pVirtualKeyToButtonCode[CELL_KEYC_C] =KEY_C; s_pVirtualKeyToButtonCode[CELL_KEYC_D] =KEY_D; s_pVirtualKeyToButtonCode[CELL_KEYC_E] =KEY_E; s_pVirtualKeyToButtonCode[CELL_KEYC_F] =KEY_F; s_pVirtualKeyToButtonCode[CELL_KEYC_G] =KEY_G; s_pVirtualKeyToButtonCode[CELL_KEYC_H] =KEY_H; s_pVirtualKeyToButtonCode[CELL_KEYC_I] =KEY_I; s_pVirtualKeyToButtonCode[CELL_KEYC_J] =KEY_J; s_pVirtualKeyToButtonCode[CELL_KEYC_K] =KEY_K; s_pVirtualKeyToButtonCode[CELL_KEYC_L] =KEY_L; s_pVirtualKeyToButtonCode[CELL_KEYC_M] =KEY_M; s_pVirtualKeyToButtonCode[CELL_KEYC_N] =KEY_N; s_pVirtualKeyToButtonCode[CELL_KEYC_O] =KEY_O; s_pVirtualKeyToButtonCode[CELL_KEYC_P] =KEY_P; s_pVirtualKeyToButtonCode[CELL_KEYC_Q] =KEY_Q; s_pVirtualKeyToButtonCode[CELL_KEYC_R] =KEY_R; s_pVirtualKeyToButtonCode[CELL_KEYC_S] =KEY_S; s_pVirtualKeyToButtonCode[CELL_KEYC_T] =KEY_T; s_pVirtualKeyToButtonCode[CELL_KEYC_U] =KEY_U; s_pVirtualKeyToButtonCode[CELL_KEYC_V] =KEY_V; s_pVirtualKeyToButtonCode[CELL_KEYC_W] =KEY_W; s_pVirtualKeyToButtonCode[CELL_KEYC_X] =KEY_X; s_pVirtualKeyToButtonCode[CELL_KEYC_Y] =KEY_Y; s_pVirtualKeyToButtonCode[CELL_KEYC_Z] =KEY_Z; #else 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; #endif #if defined ( _PS3 ) s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_0] =KEY_PAD_0; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_1] =KEY_PAD_1; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_2] =KEY_PAD_2; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_3] =KEY_PAD_3; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_4] =KEY_PAD_4; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_5] =KEY_PAD_5; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_6] =KEY_PAD_6; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_7] =KEY_PAD_7; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_8] =KEY_PAD_8; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_9] =KEY_PAD_9; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_SLASH] =KEY_PAD_DIVIDE; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_ASTERISK] =KEY_PAD_MULTIPLY; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_MINUS] =KEY_PAD_MINUS; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_PLUS] =KEY_PAD_PLUS; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_ENTER] =KEY_PAD_ENTER; s_pVirtualKeyToButtonCode[CELL_KEYC_KPAD_PERIOD] =KEY_PAD_DECIMAL; #elif !defined( PLATFORM_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 #if defined ( _PS3 ) s_pVirtualKeyToButtonCode[CELL_KEYC_LEFT_BRACKET_101] =KEY_LBRACKET; s_pVirtualKeyToButtonCode[CELL_KEYC_RIGHT_BRACKET_101] =KEY_RBRACKET; s_pVirtualKeyToButtonCode[CELL_KEYC_SEMICOLON] =KEY_SEMICOLON; s_pVirtualKeyToButtonCode[CELL_KEYC_QUOTATION_101] =KEY_APOSTROPHE; s_pVirtualKeyToButtonCode[CELL_KEYC_106_KANJI] =KEY_BACKQUOTE; s_pVirtualKeyToButtonCode[CELL_KEYC_COMMA] =KEY_COMMA; s_pVirtualKeyToButtonCode[CELL_KEYC_PERIOD] =KEY_PERIOD; s_pVirtualKeyToButtonCode[CELL_KEYC_SLASH] =KEY_SLASH; s_pVirtualKeyToButtonCode[CELL_KEYC_BACKSLASH_101] =KEY_BACKSLASH; s_pVirtualKeyToButtonCode[CELL_KEYC_MINUS] =KEY_MINUS; s_pVirtualKeyToButtonCode[CELL_KEYC_EQUAL_101] =KEY_EQUAL; #else 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; #endif #if defined ( _PS3 ) s_pVirtualKeyToButtonCode[CELL_KEYC_ENTER] =KEY_ENTER; s_pVirtualKeyToButtonCode[CELL_KEYC_SPACE] =KEY_SPACE; s_pVirtualKeyToButtonCode[CELL_KEYC_BS] =KEY_BACKSPACE; s_pVirtualKeyToButtonCode[CELL_KEYC_TAB] =KEY_TAB; s_pVirtualKeyToButtonCode[CELL_KEYC_CAPS_LOCK] =KEY_CAPSLOCK; s_pVirtualKeyToButtonCode[CELL_KEYC_NUM_LOCK] =KEY_NUMLOCK; s_pVirtualKeyToButtonCode[CELL_KEYC_ESC] =KEY_ESCAPE; s_pVirtualKeyToButtonCode[CELL_KEYC_SCROLL_LOCK] =KEY_SCROLLLOCK; s_pVirtualKeyToButtonCode[CELL_KEYC_INSERT] =KEY_INSERT; s_pVirtualKeyToButtonCode[CELL_KEYC_DELETE] =KEY_DELETE; s_pVirtualKeyToButtonCode[CELL_KEYC_HOME] =KEY_HOME; s_pVirtualKeyToButtonCode[CELL_KEYC_END] =KEY_END; s_pVirtualKeyToButtonCode[CELL_KEYC_PAGE_UP] =KEY_PAGEUP; s_pVirtualKeyToButtonCode[CELL_KEYC_PAGE_DOWN] =KEY_PAGEDOWN; s_pVirtualKeyToButtonCode[CELL_KEYC_PAUSE] =KEY_BREAK; s_pVirtualKeyToButtonCode[CELL_KEYC_APPLICATION] =KEY_APP; s_pVirtualKeyToButtonCode[CELL_KEYC_UP_ARROW] =KEY_UP; s_pVirtualKeyToButtonCode[CELL_KEYC_LEFT_ARROW] =KEY_LEFT; s_pVirtualKeyToButtonCode[CELL_KEYC_DOWN_ARROW] =KEY_DOWN; s_pVirtualKeyToButtonCode[CELL_KEYC_RIGHT_ARROW] =KEY_RIGHT; s_pVirtualKeyToButtonCode[CELL_KEYC_F1] =KEY_F1; s_pVirtualKeyToButtonCode[CELL_KEYC_F2] =KEY_F2; s_pVirtualKeyToButtonCode[CELL_KEYC_F3] =KEY_F3; s_pVirtualKeyToButtonCode[CELL_KEYC_F4] =KEY_F4; s_pVirtualKeyToButtonCode[CELL_KEYC_F5] =KEY_F5; s_pVirtualKeyToButtonCode[CELL_KEYC_F6] =KEY_F6; s_pVirtualKeyToButtonCode[CELL_KEYC_F7] =KEY_F7; s_pVirtualKeyToButtonCode[CELL_KEYC_F8] =KEY_F8; s_pVirtualKeyToButtonCode[CELL_KEYC_F9] =KEY_F9; s_pVirtualKeyToButtonCode[CELL_KEYC_F10] =KEY_F10; s_pVirtualKeyToButtonCode[CELL_KEYC_F11] =KEY_F11; s_pVirtualKeyToButtonCode[CELL_KEYC_F12] =KEY_F12; #elif !defined( PLATFORM_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( PLATFORM_POSIX ) || defined( _GAMECONSOLE ) || defined( _OSX ) 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; s_pXKeyTrans[XK_BUTTON_INACTIVE_START] = KEY_XBUTTON_INACTIVE_START; s_pXKeyTrans[XK_BUTTON_FIREMODE_SELECTOR_1] = KEY_XBUTTON_FIREMODE_SELECTOR_1; s_pXKeyTrans[XK_BUTTON_FIREMODE_SELECTOR_2] = KEY_XBUTTON_FIREMODE_SELECTOR_2; s_pXKeyTrans[XK_BUTTON_FIREMODE_SELECTOR_3] = KEY_XBUTTON_FIREMODE_SELECTOR_3; s_pXKeyTrans[XK_BUTTON_RELOAD] = KEY_XBUTTON_RELOAD; s_pXKeyTrans[XK_BUTTON_TRIGGER] = KEY_XBUTTON_TRIGGER; s_pXKeyTrans[XK_BUTTON_PUMP_ACTION] = KEY_XBUTTON_PUMP_ACTION; s_pXKeyTrans[XK_XBUTTON_ROLL_RIGHT] = KEY_XBUTTON_ROLL_RIGHT; s_pXKeyTrans[XK_XBUTTON_ROLL_LEFT] = KEY_XBUTTON_ROLL_LEFT; #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; } 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( PLATFORM_POSIX ) || defined( _GAMECONSOLE ) || defined( _OSX ) 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 // PLATFORM_POSIX return KEY_NONE; #endif // PLATFORM_POSIX } 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 } // Convert back + forth between ButtonCode/AnalogCode + strings const char *ButtonCode_ButtonCodeToString( ButtonCode_t code, bool bXController ) { #if !defined ( _GAMECONSOLE ) if ( bXController ) { if ( IsJoystickButtonCode( code ) ) { int offset = ( code - JOYSTICK_FIRST_BUTTON ) % JOYSTICK_MAX_BUTTON_COUNT; return s_pXControllerButtonCodeNames[ offset ]; } if ( IsJoystickPOVCode( code ) ) { int offset = ( code - JOYSTICK_FIRST_POV_BUTTON ) % JOYSTICK_POV_BUTTON_COUNT; return s_pXControllerButtonCodeNames[ MAX_JOYSTICKS * JOYSTICK_MAX_BUTTON_COUNT + offset ]; } if ( IsJoystickAxisCode( code ) ) { int offset = ( code - JOYSTICK_FIRST_AXIS_BUTTON ) % JOYSTICK_AXIS_BUTTON_COUNT; return s_pXControllerButtonCodeNames[ MAX_JOYSTICKS * ( JOYSTICK_POV_BUTTON_COUNT + JOYSTICK_MAX_BUTTON_COUNT ) + offset ]; } } #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; } #if defined(OSX) // map "l_win" to the LWIN key on OSX (it appears in the table as "command" ) if ( !Q_stricmp( pString, "lwin" ) ) #else // map "COMMAND" to the LWIN key on non-OSX if ( !Q_stricmp( pString, "command" ) ) #endif { return KEY_LWIN; } #if defined( _PS3 ) // For PS3, we want to check against specific PS3 button code names. for ( int i = 0; i < BUTTON_CODE_LAST; ++i ) { if ( !Q_stricmp( s_pPS3ButtonCodeName[i], pString ) ) return (ButtonCode_t)i; } #endif for ( int i = 0; i < BUTTON_CODE_LAST; ++i ) { if ( !Q_stricmp( s_pButtonCodeName[i], pString ) ) return (ButtonCode_t)i; } #if !defined ( _GAMECONSOLE ) 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; } 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( _GAMECONSOLE ) && !defined( PLATFORM_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(); }