actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

human readable Keymaps.ini

Browse Source
This commit is contained in:
Chris Danford
2005-04-24 02:15:41 +00:00
parent 958642a3b8
commit f46f9d70d7
7 changed files with 422 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files
stepmania/src/GameInput.cpp
+36 -10
View File
@@ -2,25 +2,51 @@
#include "GameInput.h"
#include "RageLog.h"
#include "RageUtil.h"
#include "Game.h"
CString GameInput::toString()
static const CString GameControllerNames[MAX_GAME_CONTROLLERS] = {
"Controller1",
"Controller2",
};
XToString( GameController, MAX_GAME_CONTROLLERS );
StringToX( GameController );
CString GameButtonToString( const Game* pGame, GameButton i )
{
return ssprintf("%d-%d", controller, button );
return pGame->m_szButtonNames[i];
}
bool GameInput::fromString( CString s )
{
CStringArray a;
split( s, "-", a);
GameButton StringToGameButton( const Game* pGame, const CString& s )
{
for( int i=0; i<pGame->m_iButtonsPerController; i++ )
{
if( s == GameButtonToString(pGame,(GameButton)i) )
return (GameButton)i;
}
return GAME_BUTTON_INVALID;
}
if( a.size() != 2 ) {
MakeInvalid();
CString GameInput::toString( const Game* pGame )
{
return GameControllerToString(controller) + CString("_") + GameButtonToString(pGame,button);
}
bool GameInput::fromString( const Game* pGame, CString s )
{
char szController[32] = "";
char szButton[32] = "";
if( 2 != sscanf( s, "%31[^_]_%31[^_]", szController, szButton ) )
{
controller = GAME_CONTROLLER_INVALID;
return false;
}
controller = (GameController)atoi( a[0] );
button = (GameButton)atoi( a[1] );
controller = StringToGameController( szController );
button = StringToGameButton( pGame, szButton );
return true;
};
stepmania/src/GameInput.h
+7 -2
View File
@@ -5,6 +5,8 @@
#include "EnumHelper.h"
class Game;
enum GameController
{
GAME_CONTROLLER_1 = 0, // left controller
@@ -15,6 +17,9 @@ enum GameController
#define FOREACH_GameController( gc ) FOREACH_ENUM( GameController, MAX_GAME_CONTROLLERS, gc )
typedef int GameButton;
CString GameButtonToString( GameButton i );
GameButton StringToGameButton( const Game* pGame, const CString& s );
const GameButton MAX_GAME_BUTTONS = 20;
const GameButton GAME_BUTTON_INVALID = MAX_GAME_BUTTONS+1;
#define FOREACH_GameButton( gb ) FOREACH_ENUM( GameButton, MAX_GAME_BUTTONS, gb )
@@ -236,8 +241,8 @@ struct GameInput
inline bool IsValid() const { return controller != GAME_CONTROLLER_INVALID; };
inline void MakeInvalid() { controller = GAME_CONTROLLER_INVALID; button = GAME_BUTTON_INVALID; };
CString toString();
bool fromString( CString s );
CString toString( const Game* pGame );
bool fromString( const Game* pGame, CString s );
};
#endif
stepmania/src/InputFilter.cpp
+6 -6
View File
@@ -67,10 +67,10 @@ void InputFilter::ButtonPressed( DeviceInput di, bool Down )
}
/* Release all buttons on the given device. */
void InputFilter::ResetDevice( InputDevice dev )
void InputFilter::ResetDevice( InputDevice device )
{
for( int button = 0; button < NUM_DEVICE_BUTTONS[dev]; ++button )
ButtonPressed( DeviceInput(dev, button), false );
for( int button = 0; button < GetNumDeviceButtons(device); ++button )
ButtonPressed( DeviceInput(device, button), false );
}
void InputFilter::Update(float fDeltaTime)
@@ -97,11 +97,11 @@ void InputFilter::Update(float fDeltaTime)
// taking 4% of the CPU on a P3-666.
DeviceInput di( (InputDevice)0,0,1.0f,now);
for( int d=0; d<NUM_INPUT_DEVICES; d++ ) // foreach InputDevice
FOREACH_InputDevice( d )
{
di.device = (InputDevice)d;
di.device = d;
for( int b=0; b < NUM_DEVICE_BUTTONS[d]; b++ ) // foreach button
for( int b=0; b < GetNumDeviceButtons(d); b++ ) // foreach button
{
ButtonState &bs = m_ButtonState[d][b];
di.button = b;
stepmania/src/InputMapper.cpp
+14 -10
View File
@@ -395,7 +395,9 @@ void InputMapper::ReadMappingsFromDisk()
if( !ini.ReadFile( KEYMAPS_PATH ) )
LOG->Trace( "Couldn't open mapping file \"%s\": %s.", KEYMAPS_PATH, ini.GetError().c_str() );
const XNode *Key = ini.GetChild( GAMESTATE->GetCurrentGame()->m_szName );
const Game *pGame = GAMESTATE->GetCurrentGame();
const XNode *Key = ini.GetChild( pGame->m_szName );
if( Key )
{
@@ -405,7 +407,7 @@ void InputMapper::ReadMappingsFromDisk()
const CString &value = i->m_sValue;
GameInput GameI;
GameI.fromString( name );
GameI.fromString( pGame, name );
CStringArray sDeviceInputStrings;
split( value, ",", sDeviceInputStrings, false );
@@ -429,16 +431,18 @@ void InputMapper::SaveMappingsToDisk()
IniFile ini;
ini.ReadFile( KEYMAPS_PATH );
const Game* pGame = GAMESTATE->GetCurrentGame();
// erase the key so that we overwrite everything for this game
ini.DeleteKey( GAMESTATE->GetCurrentGame()->m_szName );
ini.DeleteKey( pGame->m_szName );
// iterate over our input map and write all mappings to the ini file
FOREACH_GameController(i)
FOREACH_GameController( i )
{
for( int j=0; j<MAX_GAME_BUTTONS; j++ )
for( int j=0; j<pGame->m_iButtonsPerController; j++ )
{
GameInput GameI( (GameController)i, (GameButton)j );
CString sNameString = GameI.toString();
GameInput GameI( i, (GameButton)j );
CString sNameString = GameI.toString( pGame );
vector<CString> asValues;
for( int button = 0; button < NUM_GAME_TO_DEVICE_SLOTS; ++button )
@@ -447,7 +451,7 @@ void InputMapper::SaveMappingsToDisk()
asValues.erase( asValues.begin()+asValues.size()-1 );
CString sValueString = join( ",", asValues );
ini.SetValue( GAMESTATE->GetCurrentGame()->m_szName, sNameString, sValueString );
ini.SetValue( pGame->m_szName, sNameString, sValueString );
}
}
@@ -514,9 +518,9 @@ bool InputMapper::IsMapped( GameInput GameI )
void InputMapper::UpdateTempDItoGI()
{
// clear out m_tempDItoGI
for( int d=0; d<NUM_INPUT_DEVICES; d++ )
FOREACH_InputDevice( d )
{
for( int b=0; b<NUM_DEVICE_BUTTONS[d]; b++ )
for( int b=0; b<GetNumDeviceButtons(d); b++ )
{
m_tempDItoGI[d][b].MakeInvalid();
}
stepmania/src/RageInputDevice.cpp
+266 -207
View File
@@ -6,253 +6,312 @@
#include "global.h"
#include "RageInputDevice.h"
#include "RageUtil.h"
#include "EnumHelper.h"
static const char *PumpButtonNames[] = {
"UL", "UR", "MID", "DL", "DR", "Esc",
"P2 UL", "P2 UR", "P2 MID", "P2 DL", "P2 DR"
CString RageKeySymToString( RageKeySym key )
{
if( key >= 33 && key < 127 &&
!(key >= 'A' && key <= 'Z' ) )
{
/* All printable ASCII except for uppercase alpha characters line up. */
return ssprintf( "%c", key );
}
if( key >= KEY_OTHER_0 && key < KEY_LAST_OTHER )
{
return ssprintf( "unk %i", key-KEY_OTHER_0 );
}
switch( key )
{
case KEY_SPACE: return "space";
case KEY_DEL: return "delete";
case KEY_BACK: return "backspace";
case KEY_TAB: return "tab";
case KEY_ENTER: return "enter";
case KEY_PAUSE: return "pause";
case KEY_ESC: return "escape";
case KEY_F1: return "F1";
case KEY_F2: return "F2";
case KEY_F3: return "F3";
case KEY_F4: return "F4";
case KEY_F5: return "F5";
case KEY_F6: return "F6";
case KEY_F7: return "F7";
case KEY_F8: return "F8";
case KEY_F9: return "F9";
case KEY_F10: return "F10";
case KEY_F11: return "F11";
case KEY_F12: return "F12";
case KEY_F13: return "F13";
case KEY_F14: return "F14";
case KEY_F15: return "F15";
case KEY_F16: return "F16";
case KEY_LCTRL: return "left ctrl";
case KEY_RCTRL: return "right ctrl";
case KEY_LSHIFT: return "left shift";
case KEY_RSHIFT: return "right shift";
case KEY_LALT: return "left alt";
case KEY_RALT: return "right alt";
case KEY_LMETA: return "left meta";
case KEY_RMETA: return "right meta";
case KEY_LSUPER: return "left wnd";
case KEY_RSUPER: return "right wnd";
case KEY_MENU: return "menu";
case KEY_NUMLOCK: return "num lock";
case KEY_SCRLLOCK: return "scroll lock";
case KEY_CAPSLOCK: return "caps lock";
case KEY_PRTSC: return "prtsc";
case KEY_UP: return "up";
case KEY_DOWN: return "down";
case KEY_LEFT: return "left";
case KEY_RIGHT: return "right";
case KEY_INSERT: return "insert";
case KEY_HOME: return "home";
case KEY_END: return "end";
case KEY_PGUP: return "pgup";
case KEY_PGDN: return "pgdn";
case KEY_KP_C0: return "KP 0";
case KEY_KP_C1: return "KP 1";
case KEY_KP_C2: return "KP 2";
case KEY_KP_C3: return "KP 3";
case KEY_KP_C4: return "KP 4";
case KEY_KP_C5: return "KP 5";
case KEY_KP_C6: return "KP 6";
case KEY_KP_C7: return "KP 7";
case KEY_KP_C8: return "KP 8";
case KEY_KP_C9: return "KP 9";
case KEY_KP_SLASH: return "KP /";
case KEY_KP_ASTERISK: return "KP *";
case KEY_KP_HYPHEN: return "KP -";
case KEY_KP_PLUS: return "KP +";
case KEY_KP_PERIOD: return "KP .";
case KEY_KP_EQUAL: return "KP =";
case KEY_KP_ENTER: return "KP enter";
default: return "unknown";
}
}
RageKeySym StringToRageKeySym( const CString& s )
{
for( int i=0; i<NUM_KEYS; i++ )
{
if( RageKeySymToString((RageKeySym)i) == s )
return (RageKeySym)i;
}
return KEY_INVALID;
}
static const CString InputDeviceNames[NUM_INPUT_DEVICES] = {
"Key",
"Joy1",
"Joy2",
"Joy3",
"Joy4",
"Joy5",
"Joy6",
"Joy7",
"Joy8",
"Joy9",
"Joy10",
"Joy11",
"Joy12",
"Joy13",
"Joy14",
"Joy15",
"Joy16",
"Pump1",
"Pump2",
"Para1",
};
XToString( InputDevice, NUM_INPUT_DEVICES );
StringToX( InputDevice );
int DeviceInput::NumButtons(InputDevice device)
static const CString JoystickButtonNames[NUM_JOYSTICK_BUTTONS] = {
"Left",
"Right",
"Up",
"Down",
"Left2",
"Right2",
"Up2",
"Down2",
"Z-Up",
"Z-Down",
"R-Up",
"R-Down",
"R-Left",
"R-Right",
"ZR-Up",
"ZR-Down",
"H-Left",
"H-Right",
"H-Up",
"H-Down",
"Aux1",
"Aux2",
"Aux3",
"Aux4",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20",
"21",
"22",
"23",
"24",
"25",
"26",
"27",
"28",
"29",
"30",
"31",
"32",
};
XToString( JoystickButton, NUM_JOYSTICK_BUTTONS );
StringToX( JoystickButton );
static const CString PumpPadButtonNames[NUM_PUMP_PAD_BUTTONS] = {
"UL",
"UR",
"MID",
"DL",
"DR",
"Esc",
"P2 UL",
"P2 UR",
"P2 MID",
"P2 DL",
"P2 DR"
};
XToString( PumpPadButton, NUM_PUMP_PAD_BUTTONS );
StringToX( PumpPadButton );
static const CString ParaPadButtonNames[NUM_PARA_PAD_BUTTONS] = {
"L",
"UL",
"U",
"UR",
"R",
"SELECT",
"START",
"MENU_LEFT",
"MENU_RIGHT",
};
XToString( ParaPadButton, NUM_PARA_PAD_BUTTONS );
StringToX( ParaPadButton );
CString DeviceButtonToString( InputDevice device, DeviceButton i )
{
switch( device )
{
case DEVICE_KEYBOARD:
return NUM_KEYBOARD_BUTTONS;
case DEVICE_KEYBOARD: return RageKeySymToString( (RageKeySym)i );
case DEVICE_JOY1:
case DEVICE_JOY2:
case DEVICE_JOY3:
case DEVICE_JOY4:
case DEVICE_JOY5:
case DEVICE_JOY6:
return NUM_JOYSTICK_BUTTONS;
case DEVICE_JOY7:
case DEVICE_JOY8:
case DEVICE_JOY9:
case DEVICE_JOY10:
case DEVICE_JOY11:
case DEVICE_JOY12:
case DEVICE_JOY13:
case DEVICE_JOY14:
case DEVICE_JOY15:
case DEVICE_JOY16: return JoystickButtonToString( (JoystickButton)i );
case DEVICE_PUMP1:
case DEVICE_PUMP2:
return NUM_PUMP_PAD_BUTTONS;
default:
ASSERT(0); // invalid device
case DEVICE_PUMP2: return PumpPadButtonToString( (PumpPadButton)i );
case DEVICE_PARA1: return ParaPadButtonToString( (ParaPadButton)i );
case DEVICE_NONE: return "";
default: ASSERT(0); return "";
}
return -1; /* quiet compiler */
}
CString DeviceInput::GetDescription()
DeviceButton StringToDeviceButton( InputDevice device, const CString& s )
{
CString sReturn;
switch( device )
{
case DEVICE_NONE: // blank
ASSERT( false ); // called GetDescription on a blank DeviceInput!
break;
case DEVICE_JOY1: // joystick
case DEVICE_KEYBOARD: return (DeviceButton)StringToRageKeySym( s );
case DEVICE_JOY1:
case DEVICE_JOY2:
case DEVICE_JOY3:
case DEVICE_JOY4:
case DEVICE_JOY5:
case DEVICE_JOY6:
sReturn = ssprintf("Joy%d ", device - DEVICE_JOY1 + 1 );
switch( button )
{
case JOY_LEFT: sReturn += "Left"; break;
case JOY_RIGHT: sReturn += "Right"; break;
case JOY_UP: sReturn += "Up"; break;
case JOY_DOWN: sReturn += "Down"; break;
case JOY_LEFT_2: sReturn += "Left2"; break;
case JOY_RIGHT_2: sReturn += "Right2"; break;
case JOY_UP_2: sReturn += "Up2"; break;
case JOY_DOWN_2: sReturn += "Down2"; break;
case JOY_Z_UP: sReturn += "Z-Up"; break;
case JOY_Z_DOWN: sReturn += "Z-Down"; break;
case JOY_ROT_UP: sReturn += "R-Up"; break;
case JOY_ROT_DOWN:sReturn += "R-Down"; break;
case JOY_ROT_LEFT: sReturn += "R-Left"; break;
case JOY_ROT_RIGHT:sReturn += "R-Right"; break;
case JOY_ROT_Z_UP: sReturn += "ZR-Up"; break;
case JOY_ROT_Z_DOWN:sReturn += "ZR-Down"; break;
case JOY_HAT_LEFT: sReturn += "H-Left"; break;
case JOY_HAT_RIGHT: sReturn += "H-Right"; break;
case JOY_HAT_UP: sReturn += "H-Up"; break;
case JOY_HAT_DOWN: sReturn += "H-Down"; break;
case JOY_AUX_1: sReturn += "Aux1"; break;
case JOY_AUX_2: sReturn += "Aux2"; break;
case JOY_AUX_3: sReturn += "Aux3"; break;
case JOY_AUX_4: sReturn += "Aux4"; break;
case JOY_1: sReturn += "1"; break;
case JOY_2: sReturn += "2"; break;
case JOY_3: sReturn += "3"; break;
case JOY_4: sReturn += "4"; break;
case JOY_5: sReturn += "5"; break;
case JOY_6: sReturn += "6"; break;
case JOY_7: sReturn += "7"; break;
case JOY_8: sReturn += "8"; break;
case JOY_9: sReturn += "9"; break;
case JOY_10: sReturn += "10"; break;
case JOY_11: sReturn += "11"; break;
case JOY_12: sReturn += "12"; break;
case JOY_13: sReturn += "13"; break;
case JOY_14: sReturn += "14"; break;
case JOY_15: sReturn += "15"; break;
case JOY_16: sReturn += "16"; break;
case JOY_17: sReturn += "17"; break;
case JOY_18: sReturn += "18"; break;
case JOY_19: sReturn += "19"; break;
case JOY_20: sReturn += "20"; break;
case JOY_21: sReturn += "21"; break;
case JOY_22: sReturn += "22"; break;
case JOY_23: sReturn += "23"; break;
case JOY_24: sReturn += "24"; break;
case JOY_25: sReturn += "25"; break;
case JOY_26: sReturn += "26"; break;
case JOY_27: sReturn += "27"; break;
case JOY_28: sReturn += "28"; break;
case JOY_29: sReturn += "29"; break;
case JOY_30: sReturn += "30"; break;
case JOY_31: sReturn += "31"; break;
case JOY_32: sReturn += "32"; break;
}
break;
case DEVICE_JOY7:
case DEVICE_JOY8:
case DEVICE_JOY9:
case DEVICE_JOY10:
case DEVICE_JOY11:
case DEVICE_JOY12:
case DEVICE_JOY13:
case DEVICE_JOY14:
case DEVICE_JOY15:
case DEVICE_JOY16: return (DeviceButton)StringToJoystickButton( s );
case DEVICE_PUMP1:
case DEVICE_PUMP2:
/* There is almost always only one Pump device, even if there are
* two pads, so only enumerate the second and higher. */
if(device == DEVICE_PUMP1)
sReturn = ssprintf("PIU ");
else
sReturn = ssprintf("PIU#%d ", device - DEVICE_PUMP1 + 1 );
if(button < NUM_PUMP_PAD_BUTTONS)
sReturn += PumpButtonNames[button];
else
/* This can happen if the INI is corrupt and has an invalid
* button number. Crashing with an assertion failure because
* we got something unexpected is no good. */
sReturn += "???";
break;
case DEVICE_KEYBOARD: // keyboard
sReturn = "Key ";
if( button >= 33 && button < 127 &&
!(button >= 'A' && button <= 'Z' ) )
{
/* All printable ASCII except for uppercase alpha characters line up. */
sReturn += ssprintf( "%c", button );
break;
}
if( button >= KEY_OTHER_0 && button < KEY_LAST_OTHER )
{
sReturn += ssprintf( "unk %i", button-KEY_OTHER_0 );
break;
}
switch( button )
{
case KEY_SPACE: sReturn += "space"; break;
case KEY_DEL: sReturn += "delete"; break;
case KEY_BACK: sReturn += "backspace"; break;
case KEY_TAB: sReturn += "tab"; break;
case KEY_ENTER: sReturn += "enter"; break;
case KEY_PAUSE: sReturn += "pause"; break;
case KEY_ESC: sReturn += "escape"; break;
case KEY_F1: sReturn += "F1"; break;
case KEY_F2: sReturn += "F2"; break;
case KEY_F3: sReturn += "F3"; break;
case KEY_F4: sReturn += "F4"; break;
case KEY_F5: sReturn += "F5"; break;
case KEY_F6: sReturn += "F6"; break;
case KEY_F7: sReturn += "F7"; break;
case KEY_F8: sReturn += "F8"; break;
case KEY_F9: sReturn += "F9"; break;
case KEY_F10: sReturn += "F10"; break;
case KEY_F11: sReturn += "F11"; break;
case KEY_F12: sReturn += "F12"; break;
case KEY_F13: sReturn += "F13"; break;
case KEY_F14: sReturn += "F14"; break;
case KEY_F15: sReturn += "F15"; break;
case KEY_F16: sReturn += "F16"; break;
case KEY_LCTRL: sReturn += "left ctrl"; break;
case KEY_RCTRL: sReturn += "right ctrl"; break;
case KEY_LSHIFT: sReturn += "left shift"; break;
case KEY_RSHIFT: sReturn += "right shift"; break;
case KEY_LALT: sReturn += "left alt"; break;
case KEY_RALT: sReturn += "right alt"; break;
case KEY_LMETA: sReturn += "left meta"; break;
case KEY_RMETA: sReturn += "right meta"; break;
case KEY_LSUPER: sReturn += "left wnd"; break;
case KEY_RSUPER: sReturn += "right wnd"; break;
case KEY_MENU: sReturn += "menu"; break;
case KEY_NUMLOCK: sReturn += "num lock"; break;
case KEY_SCRLLOCK: sReturn += "scroll lock"; break;
case KEY_CAPSLOCK: sReturn += "caps lock"; break;
case KEY_PRTSC: sReturn += "prtsc"; break;
case KEY_UP: sReturn += "up"; break;
case KEY_DOWN: sReturn += "down"; break;
case KEY_LEFT: sReturn += "left"; break;
case KEY_RIGHT: sReturn += "right"; break;
case KEY_INSERT: sReturn += "insert"; break;
case KEY_HOME: sReturn += "home"; break;
case KEY_END: sReturn += "end"; break;
case KEY_PGUP: sReturn += "pgup"; break;
case KEY_PGDN: sReturn += "pgdn"; break;
case KEY_KP_C0: sReturn += "KP 0"; break;
case KEY_KP_C1: sReturn += "KP 1"; break;
case KEY_KP_C2: sReturn += "KP 2"; break;
case KEY_KP_C3: sReturn += "KP 3"; break;
case KEY_KP_C4: sReturn += "KP 4"; break;
case KEY_KP_C5: sReturn += "KP 5"; break;
case KEY_KP_C6: sReturn += "KP 6"; break;
case KEY_KP_C7: sReturn += "KP 7"; break;
case KEY_KP_C8: sReturn += "KP 8"; break;
case KEY_KP_C9: sReturn += "KP 9"; break;
case KEY_KP_SLASH: sReturn += "KP /"; break;
case KEY_KP_ASTERISK: sReturn += "KP *"; break;
case KEY_KP_HYPHEN: sReturn += "KP -"; break;
case KEY_KP_PLUS: sReturn += "KP +"; break;
case KEY_KP_PERIOD: sReturn += "KP ."; break;
case KEY_KP_EQUAL: sReturn += "KP ="; break;
case KEY_KP_ENTER: sReturn += "KP enter"; break;
default: sReturn += "unknown"; break;
}
break;
default:
ASSERT(0); // what device is this?
case DEVICE_PUMP2: return (DeviceButton)StringToPumpPadButton( s );
case DEVICE_PARA1: return (DeviceButton)StringToParaPadButton( s );
case DEVICE_NONE: return DEVICE_BUTTON_INVALID;
default: ASSERT(0); return DEVICE_BUTTON_INVALID;
}
return sReturn;
}
CString DeviceInput::toString()
{
if( device == DEVICE_NONE )
return "";
else
return ssprintf("%d-%d", device, button );
CString s = InputDeviceToString(device) + "_" + DeviceButtonToString(device,button);
return s;
}
bool DeviceInput::fromString( const CString &s )
{
CStringArray a;
split( s, "-", a);
{
char szDevice[32] = "";
char szButton[32] = "";
if( a.size() != 2 ) {
if( 2 != sscanf( s, "%31[^_]_%31[^_]", szDevice, szButton ) )
{
device = DEVICE_NONE;
return false;
}
device = (InputDevice)atoi( a[0] );
button = atoi( a[1] );
device = StringToInputDevice( szDevice );
button = StringToDeviceButton( device, szButton );
return true;
}
stepmania/src/RageInputDevice.h
+89 -54
View File
@@ -3,6 +3,40 @@
#define RAGE_INPUT_DEVICE_H
#include "RageTimer.h"
#include "EnumHelper.h"
const int NUM_JOYSTICKS = 16;
const int NUM_PUMPS = 2;
const int NUM_PARAS = 2;
enum InputDevice {
DEVICE_KEYBOARD = 0,
DEVICE_JOY1,
DEVICE_JOY2,
DEVICE_JOY3,
DEVICE_JOY4,
DEVICE_JOY5,
DEVICE_JOY6,
DEVICE_JOY7,
DEVICE_JOY8,
DEVICE_JOY9,
DEVICE_JOY10,
DEVICE_JOY11,
DEVICE_JOY12,
DEVICE_JOY13,
DEVICE_JOY14,
DEVICE_JOY15,
DEVICE_JOY16,
DEVICE_PUMP1,
DEVICE_PUMP2,
DEVICE_PARA1,
NUM_INPUT_DEVICES, // leave this at the end
DEVICE_NONE // means this is NULL
};
#define FOREACH_InputDevice( i ) FOREACH_ENUM( InputDevice, NUM_INPUT_DEVICES, i )
const CString& InputDeviceToString( InputDevice i );
InputDevice StringToInputDevice( const CString& s );
/* Only raw, unshifted keys go in this table; this doesn't include internationalized
* keyboards, only keys that we might actually want to test for programmatically. Any
@@ -183,36 +217,9 @@ enum RageKeySym
NUM_KEYS,
KEY_INVALID
};
CString RageKeySymToString( RageKeySym i );
RageKeySym StringToRageKeySym( const CString& s );
const int NUM_KEYBOARD_BUTTONS = NUM_KEYS;
const int NUM_JOYSTICKS = 16;
const int NUM_PUMPS = 2;
const int NUM_PARAS = 2;
enum InputDevice {
DEVICE_KEYBOARD = 0,
DEVICE_JOY1,
DEVICE_JOY2,
DEVICE_JOY3,
DEVICE_JOY4,
DEVICE_JOY5,
DEVICE_JOY6,
DEVICE_JOY7,
DEVICE_JOY8,
DEVICE_JOY9,
DEVICE_JOY10,
DEVICE_JOY11,
DEVICE_JOY12,
DEVICE_JOY13,
DEVICE_JOY14,
DEVICE_JOY15,
DEVICE_JOY16,
DEVICE_PUMP1,
DEVICE_PUMP2,
DEVICE_PARA,
NUM_INPUT_DEVICES, // leave this at the end
DEVICE_NONE // means this is NULL
};
/* Joystick inputs. We try to have enough input names so any input on a reasonable
* joystick has an obvious mapping, but keep it generic and don't try to handle odd
@@ -238,10 +245,15 @@ enum JoystickButton
JOY_11, JOY_12, JOY_13, JOY_14, JOY_15, JOY_16, JOY_17, JOY_18, JOY_19, JOY_20,
JOY_21, JOY_22, JOY_23, JOY_24, JOY_25, JOY_26, JOY_27, JOY_28, JOY_29, JOY_30,
JOY_31, JOY_32,
NUM_JOYSTICK_BUTTONS // leave this at the end
};
enum PumpButton {
NUM_JOYSTICK_BUTTONS,
JOYSTICK_BUTTON_INVALID
};
const CString& JoystickButtonToString( JoystickButton i );
JoystickButton StringToJoystickButton( const CString& s );
enum PumpPadButton {
PUMP_UL,
PUMP_UR,
PUMP_MID,
@@ -256,10 +268,15 @@ enum PumpButton {
PUMP_2P_MID,
PUMP_2P_DL,
PUMP_2P_DR,
NUM_PUMP_PAD_BUTTONS // leave this at the end
};
enum ParaButton {
NUM_PUMP_PAD_BUTTONS,
PUMP_PAD_BUTTON_INVALID
};
const CString& PumpPadButtonToString( PumpPadButton i );
PumpPadButton StringToPumpPadButton( const CString& s );
enum ParaPadButton {
PARA_L,
PARA_UL,
PARA_U,
@@ -269,31 +286,53 @@ enum ParaButton {
PARA_START,
PARA_MENU_LEFT,
PARA_MENU_RIGHT,
NUM_PARA_PAD_BUTTONS // leave this at the end
NUM_PARA_PAD_BUTTONS,
PARA_PAD_BUTTON_INVALID
};
const CString& ParaPadButtonToString( ParaPadButton i );
ParaPadButton StringToParaPadButton( const CString& s );
const int NUM_DEVICE_BUTTONS[NUM_INPUT_DEVICES] =
typedef int DeviceButton;
//CString DeviceButtonToString( InputDevice device, DeviceButton i );
//DeviceButton StringToDeviceButton( InputDevice device, const CString& s );
inline int GetNumDeviceButtons( InputDevice device )
{
NUM_KEYBOARD_BUTTONS, // DEVICE_KEYBOARD
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY1
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY2
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY3
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY4
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY5
NUM_JOYSTICK_BUTTONS, // DEVICE_JOY6
NUM_PUMP_PAD_BUTTONS, // DEVICE_PUMP1
NUM_PUMP_PAD_BUTTONS, // DEVICE_PUMP2
NUM_PARA_PAD_BUTTONS, // DEVICE_PARA
switch( device )
{
case DEVICE_KEYBOARD: return NUM_KEYS;
case DEVICE_JOY1:
case DEVICE_JOY2:
case DEVICE_JOY3:
case DEVICE_JOY4:
case DEVICE_JOY5:
case DEVICE_JOY6:
case DEVICE_JOY7:
case DEVICE_JOY8:
case DEVICE_JOY9:
case DEVICE_JOY10:
case DEVICE_JOY11:
case DEVICE_JOY12:
case DEVICE_JOY13:
case DEVICE_JOY14:
case DEVICE_JOY15:
case DEVICE_JOY16: return NUM_JOYSTICK_BUTTONS;
case DEVICE_PUMP1:
case DEVICE_PUMP2: return NUM_PUMP_PAD_BUTTONS;
case DEVICE_PARA1: return NUM_PARA_PAD_BUTTONS;
default: ASSERT(0); return 0;
}
};
const int MAX_DEVICE_BUTTONS = NUM_KEYBOARD_BUTTONS;
const int MAX_DEVICE_BUTTONS = NUM_KEYS;
const DeviceButton DEVICE_BUTTON_INVALID = MAX_DEVICE_BUTTONS+1;
struct DeviceInput
{
public:
InputDevice device;
int button;
DeviceButton button;
/* This is usually 0 or 1. Analog joystick inputs can set this to a percentage (0..1).
* This should be 0 for analog axes within the dead zone. */
@@ -312,8 +351,6 @@ public:
* compare level or ts. */
return device == other.device && button == other.button;
};
CString GetDescription();
CString toString();
bool fromString( const CString &s );
@@ -324,8 +361,6 @@ public:
char ToChar() const;
bool IsJoystick() const { return DEVICE_JOY1 <= device && device < DEVICE_JOY1+NUM_JOYSTICKS; }
static int NumButtons(InputDevice device);
};
#endif
stepmania/src/ScreenTestInput.cpp
+4 -4
View File
@@ -48,17 +48,17 @@ void ScreenTestInput::Update( float fDeltaTime )
DeviceInput di;
for( int d=0; d<NUM_INPUT_DEVICES; d++ )
FOREACH_InputDevice( d )
{
for( int b=0; b<NUM_DEVICE_BUTTONS[d]; b++ )
for( int b=0; b<GetNumDeviceButtons(d); b++ )
{
di.device = (InputDevice)d;
di.device = d;
di.button = b;
if( INPUTFILTER->IsBeingPressed(di) )
{
CString sTemp;
sTemp += di.GetDescription();
sTemp += di.toString();
GameInput gi;
if( INPUTMAPPER->DeviceToGame(di,gi) )