#include "core/Utilites.h" #include const Ogre::String CreateAutoName(const Ogre::String prefix) { static int enumerator = 0; return prefix + Ogre::StringConverter::toString( enumerator++ ); } struct KeyName { Ogre::String name; OIS::KeyCode key; }; KeyName key_names[] = { { "Enter", OIS::KC_RETURN }, { "Escape", OIS::KC_ESCAPE }, { "Space", OIS::KC_SPACE }, { "LShift", OIS::KC_LSHIFT }, { "RShift", OIS::KC_RSHIFT }, { "LCtrl", OIS::KC_LCONTROL }, { "RCtrl", OIS::KC_RCONTROL }, { "LAlt", OIS::KC_LMENU }, { "RAlt", OIS::KC_RMENU }, { "0", OIS::KC_0 }, { "1", OIS::KC_1 }, { "2", OIS::KC_2 }, { "3", OIS::KC_3 }, { "4", OIS::KC_4 }, { "5", OIS::KC_5 }, { "6", OIS::KC_6 }, { "7", OIS::KC_7 }, { "8", OIS::KC_8 }, { "9", OIS::KC_9 }, { "A", OIS::KC_A }, { "B", OIS::KC_B }, { "C", OIS::KC_C }, { "D", OIS::KC_D }, { "E", OIS::KC_E }, { "F", OIS::KC_F }, { "G", OIS::KC_G }, { "H", OIS::KC_H }, { "I", OIS::KC_I }, { "J", OIS::KC_J }, { "K", OIS::KC_K }, { "L", OIS::KC_L }, { "M", OIS::KC_M }, { "N", OIS::KC_N }, { "O", OIS::KC_O }, { "P", OIS::KC_P }, { "Q", OIS::KC_Q }, { "R", OIS::KC_R }, { "S", OIS::KC_S }, { "T", OIS::KC_T }, { "U", OIS::KC_U }, { "V", OIS::KC_V }, { "W", OIS::KC_W }, { "X", OIS::KC_X }, { "Y", OIS::KC_Y }, { "Z", OIS::KC_Z }, { "Left", OIS::KC_LEFT }, { "Up", OIS::KC_UP }, { "Down", OIS::KC_DOWN }, { "Right", OIS::KC_RIGHT }, { "Num0", OIS::KC_NUMPAD0 }, { "Num1", OIS::KC_NUMPAD1 }, { "Num2", OIS::KC_NUMPAD2 }, { "Num3", OIS::KC_NUMPAD3 }, { "Num4", OIS::KC_NUMPAD4 }, { "Num5", OIS::KC_NUMPAD5 }, { "Num6", OIS::KC_NUMPAD6 }, { "Num7", OIS::KC_NUMPAD7 }, { "Num8", OIS::KC_NUMPAD8 }, { "Num9", OIS::KC_NUMPAD9 }, { "NumLock", OIS::KC_NUMLOCK }, { "NumDiv", OIS::KC_DIVIDE }, { "NumMult", OIS::KC_MULTIPLY }, { "NumSub", OIS::KC_SUBTRACT }, { "NumAdd", OIS::KC_ADD }, { "NumEnter", OIS::KC_NUMPADENTER }, { "NumDec", OIS::KC_DECIMAL }, { "F1", OIS::KC_F1 }, { "F2", OIS::KC_F2 }, { "F3", OIS::KC_F3 }, { "F4", OIS::KC_F4 }, { "F5", OIS::KC_F5 }, { "F6", OIS::KC_F6 }, { "F7", OIS::KC_F7 }, { "F8", OIS::KC_F8 }, { "F9", OIS::KC_F9 }, { "F10", OIS::KC_F10 }, { "F11", OIS::KC_F11 }, { "F12", OIS::KC_F12 }, { "UNASSIGNED", OIS::KC_UNASSIGNED }, }; Ogre::String KeyToString( OIS::KeyCode key ) { // find string by key for( KeyName* kn = key_names; kn->name != "UNASSIGNED"; ++kn ) { if( kn->key == key ) { return kn->name; } } return "UNASSIGNED"; } OIS::KeyCode StringToKey( const Ogre::String& str ) { if( str == "" ) { return OIS::KC_UNASSIGNED; } // find key by string for( KeyName* kn = key_names; kn->name != "UNASSIGNED"; ++kn ) { if( kn->name == str ) { return kn->key; } } return OIS::KC_UNASSIGNED; } Ogre::StringVector StringTokenise( const Ogre::String& str, const Ogre::String& delimiters, const Ogre::String& delimiters_preserve, const Ogre::String& quote, const Ogre::String& esc ) { Ogre::StringVector ret; Ogre::String::size_type pos = 0; // the current position (char) in the string char ch = 0; // buffer for the current character char delimiter = 0; // the buffer for the delimiter char which // will be added to the tokens if the delimiter // is preserved char current_quote = 0; // the char of the current open quote bool quoted = false; // indicator if there is an open quote Ogre::String token; // string buffer for the token bool token_complete = false; // indicates if the current token is // read to be added to the result vector Ogre::String::size_type len = str.length(); // length of the input-string // for every char in the input-string while( len > pos ) { // get the character of the string and reset the delimiter buffer ch = str.at( pos ); delimiter = 0; // assume ch isn't a delimiter bool add_char = true; // check ... // ... if the delimiter is an escaped character bool escaped = false; // indicates if the next char is protected if( esc.empty() == false ) // check if esc-chars are provided { if( esc.find_first_of( ch ) != std::string::npos ) { // get the escaped char ++pos; if( pos < len ) // if there are more chars left { // get the next one ch = str.at( pos ); // add the escaped character to the token add_char = true; } else // cannot get any more characters { // don't add the esc-char add_char = false; } // ignore the remaining delimiter checks escaped = true; } } // ... if the delimiter is a quote if( quote.empty() == false && escaped == false ) { // if quote chars are provided and the char isn't protected if( quote.find_first_of( ch ) != std::string::npos ) { // if not quoted, set state to open quote and set // the quote character if( quoted == false ) { quoted = true; current_quote = ch; // don't add the quote-char to the token add_char = false; } else // if quote is open already { // check if it is the matching character to close it if( current_quote == ch ) { // close quote and reset the quote character quoted = false; current_quote = 0; // don't add the quote-char to the token add_char = false; } } } } // if the delimiter isn't preserved if( delimiters.empty() == false && escaped == false && quoted == false ) { // if a delimiter is provided and the char isn't protected by // quote or escape char if( delimiters.find_first_of( ch ) != std::string::npos ) { // if ch is a delimiter and the token string isn't empty // the token is complete if( token.empty() == false ) { token_complete = true; } // don't add the delimiter to the token add_char = false; } } // if the delimiter is preserved - add it as a token bool add_delimiter = false; if( delimiters_preserve.empty() == false && escaped == false && quoted == false ) { // if a delimiter which will be preserved is provided and the // char isn't protected by quote or escape char if( delimiters_preserve.find_first_of( ch ) != std::string::npos ) { // if ch is a delimiter and the token string isn't empty the token is complete if( token.empty() == false ) { token_complete = true; } // don't add the delimiter to the token add_char = false; // add the delimiter delimiter = ch; add_delimiter = true; } } // add the character to the token if( add_char == true ) { // add the current char token.push_back( ch ); } // add the token if it is complete if( token_complete == true && token.empty() == false ) { // add the token string ret.push_back( token ); // clear the contents token.clear(); // build the next token token_complete = false; } // add the delimiter if( add_delimiter == true ) { // the next token is the delimiter Ogre::String delim_token; delim_token.push_back( delimiter ); ret.push_back( delim_token ); } // repeat for the next character ++pos; } // add the final token if( token.empty() == false ) { ret.push_back( token ); } return ret; }