Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

OgreSDLInput.cpp

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright © 2000-2002 The OGRE Team
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 -----------------------------------------------------------------------------
00024 */
00025 
00026 #include "OgreSDLInput.h"
00027 #include "OgreLogManager.h"
00028 #include "OgreMouseEvent.h"
00029 #include "OgreCursor.h"
00030 
00031 namespace Ogre {
00032     
00033     SDLInput::SDLInput() 
00034         : InputReader(), mMouseX(0), mMouseY(0), mMouseRelativeX(0),
00035           mMouseRelativeY(0), mMouseRelativeZ(0), mScale(0.002), _visible(true)
00036     {
00037         mEventQueue = 0;
00038 
00039         _key_map.insert(InputKeyMap::value_type(SDLK_ESCAPE,KC_ESCAPE));
00040         _key_map.insert(InputKeyMap::value_type(SDLK_1, KC_1));
00041         _key_map.insert(InputKeyMap::value_type(SDLK_2, KC_2));
00042         _key_map.insert(InputKeyMap::value_type(SDLK_3, KC_3));
00043         _key_map.insert(InputKeyMap::value_type(SDLK_4, KC_4));
00044         _key_map.insert(InputKeyMap::value_type(SDLK_5, KC_5));
00045         _key_map.insert(InputKeyMap::value_type(SDLK_6, KC_6));
00046         _key_map.insert(InputKeyMap::value_type(SDLK_7, KC_7));
00047         _key_map.insert(InputKeyMap::value_type(SDLK_8, KC_8));
00048         _key_map.insert(InputKeyMap::value_type(SDLK_9, KC_9));
00049         _key_map.insert(InputKeyMap::value_type(SDLK_0, KC_0));
00050         _key_map.insert(InputKeyMap::value_type(SDLK_MINUS, KC_MINUS));
00051         _key_map.insert(InputKeyMap::value_type(SDLK_EQUALS, KC_EQUALS));
00052         _key_map.insert(InputKeyMap::value_type(SDLK_BACKSPACE, KC_BACK));
00053         _key_map.insert(InputKeyMap::value_type(SDLK_TAB, KC_TAB));
00054         _key_map.insert(InputKeyMap::value_type(SDLK_q, KC_Q));
00055         _key_map.insert(InputKeyMap::value_type(SDLK_w, KC_W));
00056         _key_map.insert(InputKeyMap::value_type(SDLK_e, KC_E));
00057         _key_map.insert(InputKeyMap::value_type(SDLK_r, KC_R));
00058         _key_map.insert(InputKeyMap::value_type(SDLK_t, KC_T));
00059         _key_map.insert(InputKeyMap::value_type(SDLK_y, KC_Y));
00060         _key_map.insert(InputKeyMap::value_type(SDLK_u, KC_U));
00061         _key_map.insert(InputKeyMap::value_type(SDLK_i, KC_I));
00062         _key_map.insert(InputKeyMap::value_type(SDLK_o, KC_O));
00063         _key_map.insert(InputKeyMap::value_type(SDLK_p, KC_P));
00064         _key_map.insert(InputKeyMap::value_type(SDLK_RETURN, KC_RETURN));
00065         _key_map.insert(InputKeyMap::value_type(SDLK_LCTRL, KC_LCONTROL));
00066         _key_map.insert(InputKeyMap::value_type(SDLK_a, KC_A));
00067         _key_map.insert(InputKeyMap::value_type(SDLK_s, KC_S));
00068         _key_map.insert(InputKeyMap::value_type(SDLK_d, KC_D));
00069         _key_map.insert(InputKeyMap::value_type(SDLK_f, KC_F));
00070         _key_map.insert(InputKeyMap::value_type(SDLK_g, KC_G));
00071         _key_map.insert(InputKeyMap::value_type(SDLK_h, KC_H));
00072         _key_map.insert(InputKeyMap::value_type(SDLK_j, KC_J));
00073         _key_map.insert(InputKeyMap::value_type(SDLK_k, KC_K));
00074         _key_map.insert(InputKeyMap::value_type(SDLK_l, KC_L));
00075         _key_map.insert(InputKeyMap::value_type(SDLK_SEMICOLON, KC_SEMICOLON));
00076         _key_map.insert(InputKeyMap::value_type(SDLK_COLON, KC_COLON));
00077         _key_map.insert(InputKeyMap::value_type(SDLK_QUOTE, KC_APOSTROPHE));
00078         _key_map.insert(InputKeyMap::value_type(SDLK_BACKQUOTE, KC_GRAVE));
00079         _key_map.insert(InputKeyMap::value_type(SDLK_LSHIFT, KC_LSHIFT));
00080         _key_map.insert(InputKeyMap::value_type(SDLK_BACKSLASH, KC_BACKSLASH));
00081         _key_map.insert(InputKeyMap::value_type(SDLK_z, KC_Z));
00082         _key_map.insert(InputKeyMap::value_type(SDLK_x, KC_X));
00083         _key_map.insert(InputKeyMap::value_type(SDLK_c, KC_C));
00084         _key_map.insert(InputKeyMap::value_type(SDLK_v, KC_V));
00085         _key_map.insert(InputKeyMap::value_type(SDLK_b, KC_B));
00086         _key_map.insert(InputKeyMap::value_type(SDLK_n, KC_N));
00087         _key_map.insert(InputKeyMap::value_type(SDLK_m, KC_M));
00088         _key_map.insert(InputKeyMap::value_type(SDLK_COMMA, KC_COMMA));
00089         _key_map.insert(InputKeyMap::value_type(SDLK_PERIOD, KC_PERIOD));
00090         _key_map.insert(InputKeyMap::value_type(SDLK_RSHIFT, KC_RSHIFT));
00091         _key_map.insert(InputKeyMap::value_type(SDLK_KP_MULTIPLY, KC_MULTIPLY));
00092         _key_map.insert(InputKeyMap::value_type(SDLK_LALT, KC_LMENU));
00093         _key_map.insert(InputKeyMap::value_type(SDLK_SPACE, KC_SPACE));
00094         _key_map.insert(InputKeyMap::value_type(SDLK_CAPSLOCK, KC_CAPITAL));
00095         _key_map.insert(InputKeyMap::value_type(SDLK_F1, KC_F1));
00096         _key_map.insert(InputKeyMap::value_type(SDLK_F2, KC_F2));
00097         _key_map.insert(InputKeyMap::value_type(SDLK_F3, KC_F3));
00098         _key_map.insert(InputKeyMap::value_type(SDLK_F4, KC_F4));
00099         _key_map.insert(InputKeyMap::value_type(SDLK_F5, KC_F5));
00100         _key_map.insert(InputKeyMap::value_type(SDLK_F6, KC_F6));
00101         _key_map.insert(InputKeyMap::value_type(SDLK_F7, KC_F7));
00102         _key_map.insert(InputKeyMap::value_type(SDLK_F8, KC_F8));
00103         _key_map.insert(InputKeyMap::value_type(SDLK_F9, KC_F9));
00104         _key_map.insert(InputKeyMap::value_type(SDLK_F10, KC_F10));
00105         _key_map.insert(InputKeyMap::value_type(SDLK_NUMLOCK, KC_NUMLOCK));
00106         _key_map.insert(InputKeyMap::value_type(SDLK_SCROLLOCK, KC_SCROLL));
00107         _key_map.insert(InputKeyMap::value_type(SDLK_KP7, KC_NUMPAD7));
00108         _key_map.insert(InputKeyMap::value_type(SDLK_KP8, KC_NUMPAD8));
00109         _key_map.insert(InputKeyMap::value_type(SDLK_KP9, KC_NUMPAD9));
00110         _key_map.insert(InputKeyMap::value_type(SDLK_KP_MINUS, KC_SUBTRACT));
00111         _key_map.insert(InputKeyMap::value_type(SDLK_KP4, KC_NUMPAD4));
00112         _key_map.insert(InputKeyMap::value_type(SDLK_KP5, KC_NUMPAD5));
00113         _key_map.insert(InputKeyMap::value_type(SDLK_KP6, KC_NUMPAD6));
00114         _key_map.insert(InputKeyMap::value_type(SDLK_KP_PLUS, KC_ADD));
00115         _key_map.insert(InputKeyMap::value_type(SDLK_KP1, KC_NUMPAD1));
00116         _key_map.insert(InputKeyMap::value_type(SDLK_KP2, KC_NUMPAD2));
00117         _key_map.insert(InputKeyMap::value_type(SDLK_KP3, KC_NUMPAD3));
00118         _key_map.insert(InputKeyMap::value_type(SDLK_KP0, KC_NUMPAD0));
00119         _key_map.insert(InputKeyMap::value_type(SDLK_KP_PERIOD, KC_DECIMAL));
00120         _key_map.insert(InputKeyMap::value_type(SDLK_F11, KC_F11));
00121         _key_map.insert(InputKeyMap::value_type(SDLK_F12, KC_F12));
00122         _key_map.insert(InputKeyMap::value_type(SDLK_F13, KC_F13));
00123         _key_map.insert(InputKeyMap::value_type(SDLK_F14, KC_F14));
00124         _key_map.insert(InputKeyMap::value_type(SDLK_F15, KC_F15));
00125         _key_map.insert(InputKeyMap::value_type(SDLK_KP_EQUALS, KC_NUMPADEQUALS));
00126         _key_map.insert(InputKeyMap::value_type(SDLK_KP_DIVIDE, KC_DIVIDE));
00127         _key_map.insert(InputKeyMap::value_type(SDLK_SYSREQ, KC_SYSRQ));
00128         _key_map.insert(InputKeyMap::value_type(SDLK_RALT, KC_RMENU));
00129         _key_map.insert(InputKeyMap::value_type(SDLK_HOME, KC_HOME));
00130         _key_map.insert(InputKeyMap::value_type(SDLK_UP, KC_UP));
00131         _key_map.insert(InputKeyMap::value_type(SDLK_PAGEUP, KC_PGUP));
00132         _key_map.insert(InputKeyMap::value_type(SDLK_LEFT, KC_LEFT));
00133         _key_map.insert(InputKeyMap::value_type(SDLK_RIGHT, KC_RIGHT));
00134         _key_map.insert(InputKeyMap::value_type(SDLK_END, KC_END));
00135         _key_map.insert(InputKeyMap::value_type(SDLK_DOWN, KC_DOWN));
00136         _key_map.insert(InputKeyMap::value_type(SDLK_PAGEDOWN, KC_PGDOWN));
00137         _key_map.insert(InputKeyMap::value_type(SDLK_INSERT, KC_INSERT));
00138         _key_map.insert(InputKeyMap::value_type(SDLK_DELETE, KC_DELETE));
00139         _key_map.insert(InputKeyMap::value_type(SDLK_LSUPER, KC_LWIN));
00140         _key_map.insert(InputKeyMap::value_type(SDLK_RSUPER, KC_RWIN));
00141     }
00142 
00143     SDLInput::~SDLInput()
00144     {
00145         SDL_WM_GrabInput(SDL_GRAB_OFF);
00146         SDL_ShowCursor(1);
00147     }
00148 
00149     void SDLInput::initialise(RenderWindow* pWindow, bool useKeyboard, bool useMouse, bool useGameController)
00150     {
00151         if(useMouse) {
00152           // Hide the cursor
00153           SDL_ShowCursor(0);
00154           SDL_WM_GrabInput(SDL_GRAB_ON);
00155         }
00156 
00157         // Get the center and put the mouse there
00158         unsigned int width, height, depth;
00159         int left, top;
00160         pWindow->getMetrics(width, height, depth, left, top);
00161 
00162         mMouseX = width / 2;
00163         mMouseY = height / 2;
00164     }
00165 
00166     void SDLInput::capture()
00167     {
00168         // Wait until we're visible again
00169         if (!_visible)
00170         {
00171             SDL_Event event;
00172             while (SDL_WaitEvent(&event))
00173             {
00174                 if (event.type == SDL_ACTIVEEVENT && event.active.gain == 1)
00175                 {
00176                     break;
00177                 }
00178             }
00179         }
00180 
00181         if (mUseBufferedKeys)
00182         {
00183             processBufferedKeyboard();
00184         }
00185 
00186         if (mUseBufferedMouse)
00187         {
00188             processBufferedMouse();
00189         }
00190 
00191         SDL_PumpEvents();
00192 
00193         if (!mUseBufferedKeys)
00194         {
00195             // Get Keyboard state
00196             mKeyboardBuffer = SDL_GetKeyState(NULL);
00197         }
00198 
00199         // NB buffered keyboard not yet supported!
00200         // TODO
00201         if (!mUseBufferedMouse)
00202         {
00203             mMouseKeys = 0;
00204             mMouseRelativeX = 0, mMouseRelativeY = 0;
00205 
00206             // Get mouse info
00207             if( SDL_GetAppState() & SDL_APPMOUSEFOCUS )
00208             {
00209                 mMouseKeys = SDL_GetMouseState( &mMouseX, &mMouseY );
00210                 SDL_GetRelativeMouseState( &mMouseRelativeX, &mMouseRelativeY );
00211 
00212                 // the value that is added to mMouseRelativeZ when the wheel
00213                 // is moved one step (this value is actually added
00214                 // twice per movement since a wheel movement triggers a
00215                 // MOUSEBUTTONUP and a MOUSEBUTTONDOWN event)
00216                 
00217                 // get mouse wheel movement
00218                 SDL_Event event[16];
00219                 // fetch all mouse related events
00220                 int count = SDL_PeepEvents( event, 16 , SDL_GETEVENT , (SDL_EVENTMASK(SDL_MOUSEMOTION) | SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN) | SDL_EVENTMASK(SDL_MOUSEBUTTONUP)));
00221                 if ( count )
00222                 {
00223                     for (int i = 0; i < count; i++)
00224                     {
00225                         switch (event[i].type)
00226                         {
00227                         case SDL_MOUSEBUTTONDOWN:
00228                         case SDL_MOUSEBUTTONUP:
00229                             switch(event[i].button.button)
00230                             {
00231                             case SDL_BUTTON_WHEELUP:
00232                                 mMouseRelativeZ += mWheelStep;
00233                                 break;
00234                             case SDL_BUTTON_WHEELDOWN:
00235                                 mMouseRelativeZ -= mWheelStep;
00236                                 break;
00237                             }
00238                             break;
00239                         }
00240                     }
00241                 }
00242             }
00243 
00244             mMouseState.Xabs = mMouseX;
00245             mMouseState.Yabs = mMouseY;
00246             mMouseState.Zabs = 0;
00247 
00248             mMouseState.Xrel = mMouseRelativeX;
00249             mMouseState.Yrel = mMouseRelativeY;
00250             mMouseState.Zrel = mMouseRelativeZ;
00251 
00252             mMouseState.Buttons =  (mMouseKeys & SDL_BUTTON_LMASK) ? 1 : 0; // left
00253             mMouseState.Buttons |= (mMouseKeys & SDL_BUTTON_RMASK) ? 2 : 0; // right
00254             mMouseState.Buttons |= (mMouseKeys & SDL_BUTTON_MMASK) ? 4 : 0; // middle 
00255 
00256             // XXX Fix me up
00257             // Game controller state
00258         }
00259     }
00260 
00261     bool SDLInput::isKeyDown(KeyCode kc) const
00262     {
00263         switch(kc)
00264         {
00265         case KC_ESCAPE:
00266             return mKeyboardBuffer[SDLK_ESCAPE];
00267         case KC_1:
00268             return mKeyboardBuffer[SDLK_1];
00269         case KC_2:
00270             return mKeyboardBuffer[SDLK_2];
00271         case KC_3:
00272             return mKeyboardBuffer[SDLK_3];
00273         case KC_4:
00274             return mKeyboardBuffer[SDLK_4];
00275         case KC_5:
00276             return mKeyboardBuffer[SDLK_5];
00277         case KC_6:
00278             return mKeyboardBuffer[SDLK_6];
00279         case KC_7:
00280             return mKeyboardBuffer[SDLK_7];
00281         case KC_8:
00282             return mKeyboardBuffer[SDLK_8];
00283         case KC_9:
00284             return mKeyboardBuffer[SDLK_9];
00285         case KC_0:
00286             return mKeyboardBuffer[SDLK_0];
00287         case KC_MINUS:  /* - on main keyboard */
00288             return mKeyboardBuffer[SDLK_MINUS];
00289         case KC_EQUALS:
00290             return mKeyboardBuffer[SDLK_EQUALS];
00291         case KC_BACK:  /* backspace */
00292             return mKeyboardBuffer[SDLK_BACKSPACE];
00293         case KC_TAB:
00294             return mKeyboardBuffer[SDLK_TAB];
00295         case KC_Q:
00296             return mKeyboardBuffer[SDLK_q];
00297         case KC_W:
00298             return mKeyboardBuffer[SDLK_w];
00299         case KC_E:
00300             return mKeyboardBuffer[SDLK_e];
00301         case KC_R:
00302             return mKeyboardBuffer[SDLK_r];
00303         case KC_T:
00304             return mKeyboardBuffer[SDLK_t];
00305         case KC_Y:
00306             return mKeyboardBuffer[SDLK_y];
00307         case KC_U:
00308             return mKeyboardBuffer[SDLK_u];
00309         case KC_I:
00310             return mKeyboardBuffer[SDLK_i];
00311         case KC_O:
00312             return mKeyboardBuffer[SDLK_o];
00313         case KC_P:
00314             return mKeyboardBuffer[SDLK_p];
00315         case KC_LBRACKET:
00316         case KC_RBRACKET:
00317             break;
00318         case KC_RETURN: /* Enter on main keyboard */
00319             return mKeyboardBuffer[SDLK_RETURN];
00320         case KC_LCONTROL:
00321             return mKeyboardBuffer[SDLK_LCTRL];
00322         case KC_A:
00323             return mKeyboardBuffer[SDLK_a];
00324         case KC_S:
00325             return mKeyboardBuffer[SDLK_s];
00326         case KC_D:
00327             return mKeyboardBuffer[SDLK_d];
00328         case KC_F:
00329             return mKeyboardBuffer[SDLK_f];
00330         case KC_G:
00331             return mKeyboardBuffer[SDLK_g];
00332         case KC_H:
00333             return mKeyboardBuffer[SDLK_h];
00334         case KC_J:
00335             return mKeyboardBuffer[SDLK_j];
00336         case KC_K:
00337             return mKeyboardBuffer[SDLK_k];
00338         case KC_L:
00339             return mKeyboardBuffer[SDLK_l];
00340         case KC_SEMICOLON:
00341             return mKeyboardBuffer[SDLK_SEMICOLON];
00342         case KC_APOSTROPHE:
00343             return mKeyboardBuffer[SDLK_QUOTE];
00344         case KC_GRAVE:  /* accent grave */
00345             return mKeyboardBuffer[SDLK_BACKQUOTE];
00346         case KC_LSHIFT:
00347             return mKeyboardBuffer[SDLK_LSHIFT];
00348         case KC_BACKSLASH:
00349             return mKeyboardBuffer[SDLK_BACKSLASH];
00350         case KC_Z:
00351             return mKeyboardBuffer[SDLK_z];
00352         case KC_X:
00353             return mKeyboardBuffer[SDLK_x];
00354         case KC_C:
00355             return mKeyboardBuffer[SDLK_c];
00356         case KC_V:
00357             return mKeyboardBuffer[SDLK_v];
00358         case KC_B:
00359             return mKeyboardBuffer[SDLK_b];
00360         case KC_N:
00361             return mKeyboardBuffer[SDLK_n];
00362         case KC_M:
00363             return mKeyboardBuffer[SDLK_m];
00364         case KC_COMMA:
00365             return mKeyboardBuffer[SDLK_COMMA];
00366         case KC_PERIOD: /* . on main keyboard */
00367             return mKeyboardBuffer[SDLK_PERIOD];
00368         case KC_SLASH: /* '/' on main keyboard */
00369             break;
00370         case KC_RSHIFT:
00371             return mKeyboardBuffer[SDLK_RSHIFT];
00372         case KC_MULTIPLY: /* * on numeric keypad */
00373             return mKeyboardBuffer[SDLK_KP_MULTIPLY];
00374         case KC_LMENU: /* left Alt */
00375             return mKeyboardBuffer[SDLK_LALT];
00376         case KC_SPACE:
00377             return mKeyboardBuffer[SDLK_SPACE];
00378         case KC_CAPITAL:
00379             return mKeyboardBuffer[SDLK_CAPSLOCK];
00380         case KC_F1:
00381             return mKeyboardBuffer[SDLK_F1];
00382         case KC_F2:
00383             return mKeyboardBuffer[SDLK_F2];
00384         case KC_F3:
00385             return mKeyboardBuffer[SDLK_F3];
00386         case KC_F4:
00387             return mKeyboardBuffer[SDLK_F4];
00388         case KC_F5:
00389             return mKeyboardBuffer[SDLK_F5];
00390         case KC_F6:
00391             return mKeyboardBuffer[SDLK_F6];
00392         case KC_F7:
00393             return mKeyboardBuffer[SDLK_F7];
00394         case KC_F8:
00395             return mKeyboardBuffer[SDLK_F8];
00396         case KC_F9:
00397             return mKeyboardBuffer[SDLK_F9];
00398         case KC_F10:
00399             return mKeyboardBuffer[SDLK_F10];
00400         case KC_NUMLOCK:
00401             return mKeyboardBuffer[SDLK_NUMLOCK];
00402         case KC_SCROLL: /* Scroll Lock */
00403             return mKeyboardBuffer[SDLK_SCROLLOCK];
00404         case KC_NUMPAD7:
00405             return mKeyboardBuffer[SDLK_KP7];
00406         case KC_NUMPAD8:
00407             return mKeyboardBuffer[SDLK_KP8];
00408         case KC_NUMPAD9:
00409             return mKeyboardBuffer[SDLK_KP9];
00410         case KC_SUBTRACT: /* - on numeric keypad */
00411             return mKeyboardBuffer[SDLK_KP_MINUS];
00412         case KC_NUMPAD4:
00413             return mKeyboardBuffer[SDLK_KP4];
00414         case KC_NUMPAD5:
00415             return mKeyboardBuffer[SDLK_KP5];
00416         case KC_NUMPAD6:
00417             return mKeyboardBuffer[SDLK_KP6];
00418         case KC_ADD: /* + on numeric keypad */
00419             return mKeyboardBuffer[SDLK_KP_PLUS];
00420         case KC_NUMPAD1:
00421             return mKeyboardBuffer[SDLK_KP1];
00422         case KC_NUMPAD2:
00423             return mKeyboardBuffer[SDLK_KP2];
00424         case KC_NUMPAD3:
00425             return mKeyboardBuffer[SDLK_KP3];
00426         case KC_NUMPAD0:
00427             return mKeyboardBuffer[SDLK_KP0];
00428         case KC_DECIMAL:  /* . on numeric keypad */
00429             return mKeyboardBuffer[SDLK_KP_PERIOD];
00430         case KC_OEM_102:  /* < > | on UK/Germany keyboards */
00431             break;
00432         case KC_F11:
00433             return mKeyboardBuffer[SDLK_F11];
00434         case KC_F12:
00435             return mKeyboardBuffer[SDLK_F12];
00436         case KC_F13: /* (NEC PC98) */
00437             return mKeyboardBuffer[SDLK_F13];
00438         case KC_F14: /* (NEC PC98) */
00439             return mKeyboardBuffer[SDLK_F14];
00440         case KC_F15: /* (NEC PC98) */
00441             return mKeyboardBuffer[SDLK_F15];
00442         case KC_KANA: /* (Japanese keyboard) */
00443         case KC_ABNT_C1: /* / ? on Portugese (Brazilian) keyboards */
00444         case KC_CONVERT: /* (Japanese keyboard) */
00445         case KC_NOCONVERT: /* (Japanese keyboard) */
00446         case KC_YEN: /* (Japanese keyboard) */
00447         case KC_ABNT_C2: /* Numpad . on Portugese (Brazilian) keyboards */
00448             break;
00449         case KC_NUMPADEQUALS: /* = on numeric keypad (NEC PC98) */
00450             return mKeyboardBuffer[SDLK_KP_EQUALS];
00451         case KC_PREVTRACK: /* Previous Track (KC_CIRCUMFLEX on Japanese keyboard) */
00452         case KC_AT: /* (NEC PC98) */
00453         case KC_COLON: /* (NEC PC98) */
00454             return mKeyboardBuffer[SDLK_COLON];
00455         case KC_UNDERLINE: /* (NEC PC98) */
00456         case KC_KANJI: /* (Japanese keyboard)            */
00457         case KC_STOP: /* (NEC PC98) */
00458         case KC_AX:  /*  (Japan AX) */
00459         case KC_UNLABELED:  /* (J3100) */
00460         case KC_NEXTTRACK:  /* Next Track */
00461         case KC_NUMPADENTER:  /* Enter on numeric keypad */
00462         case KC_RCONTROL:
00463         case KC_MUTE:  /* Mute */
00464         case KC_CALCULATOR:  /* Calculator */
00465         case KC_PLAYPAUSE:  /* Play / Pause */
00466         case KC_MEDIASTOP:  /* Media Stop */
00467         case KC_VOLUMEDOWN:  /* Volume - */
00468         case KC_VOLUMEUP:  /* Volume + */
00469         case KC_WEBHOME:  /* Web home */
00470         case KC_NUMPADCOMMA:  /* , on numeric keypad (NEC PC98) */
00471             break;
00472         case KC_DIVIDE:  /* / on numeric keypad */
00473             return mKeyboardBuffer[SDLK_KP_DIVIDE];
00474         case KC_SYSRQ:
00475             return mKeyboardBuffer[SDLK_SYSREQ] | mKeyboardBuffer[SDLK_PRINT];
00476         case KC_RMENU:  /* right Alt */
00477             return mKeyboardBuffer[SDLK_RALT];
00478         case KC_PAUSE:  /* Pause */
00479             break;
00480         case KC_HOME:  /* Home on arrow keypad */
00481             return mKeyboardBuffer[SDLK_HOME];
00482         case KC_UP:  /* UpArrow on arrow keypad */
00483             return mKeyboardBuffer[SDLK_UP];
00484         case KC_PGUP:  /* PgUp on arrow keypad */
00485             return mKeyboardBuffer[SDLK_PAGEUP];
00486         case KC_LEFT:  /* LeftArrow on arrow keypad */
00487             return mKeyboardBuffer[SDLK_LEFT];
00488         case KC_RIGHT:  /* RightArrow on arrow keypad */
00489             return mKeyboardBuffer[SDLK_RIGHT];
00490         case KC_END:  /* End on arrow keypad */
00491             return mKeyboardBuffer[SDLK_END];
00492         case KC_DOWN:  /* DownArrow on arrow keypad */
00493             return mKeyboardBuffer[SDLK_DOWN];
00494         case KC_PGDOWN:  /* PgDn on arrow keypad */
00495             return mKeyboardBuffer[SDLK_PAGEDOWN];
00496         case KC_INSERT:  /* Insert on arrow keypad */
00497             return mKeyboardBuffer[SDLK_INSERT];
00498         case KC_DELETE:  /* Delete on arrow keypad */
00499             return mKeyboardBuffer[SDLK_DELETE];
00500         case KC_LWIN:  /* Left Windows key */
00501             return mKeyboardBuffer[SDLK_LSUPER];
00502         case KC_RWIN:  /* Right Windows key */
00503             return mKeyboardBuffer[SDLK_RSUPER];
00504         case KC_APPS:  /* AppMenu key */
00505         case KC_POWER:  /* System Power */
00506         case KC_SLEEP:  /* System Sleep */
00507         case KC_WAKE:  /* System Wake */
00508         case KC_WEBSEARCH:  /* Web Search */
00509         case KC_WEBFAVORITES:  /* Web Favorites */
00510         case KC_WEBREFRESH:  /* Web Refresh */
00511         case KC_WEBSTOP:  /* Web Stop */
00512         case KC_WEBFORWARD:  /* Web Forward */
00513         case KC_WEBBACK:  /* Web Back */
00514         case KC_MYCOMPUTER:  /* My Computer */
00515         case KC_MAIL:  /* Mail */
00516         case KC_MEDIASELECT:  /* Media Select */
00517             break;
00518         default:
00519             break;
00520         };
00521 
00522         return 0;
00523     }
00524 
00525     long SDLInput::getMouseRelX() const
00526     {
00527         return mMouseState.Xrel;
00528     }
00529 
00530     long SDLInput::getMouseRelY() const
00531     {
00532         return mMouseState.Yrel;
00533     }
00534 
00535     long SDLInput::getMouseRelZ() const
00536     {
00537         return mMouseState.Zrel;
00538     }
00539 
00540     long SDLInput::getMouseAbsX() const
00541     {
00542         return mMouseX;
00543     }
00544 
00545     long SDLInput::getMouseAbsY() const
00546     {
00547         return mMouseY;
00548     }
00549 
00550     long SDLInput::getMouseAbsZ() const
00551     {
00552         return 0;
00553     }
00554 
00555     bool SDLInput::getMouseButton( uchar button ) const
00556     {
00557         return mMouseState.isButtonDown( button );
00558     }
00559 
00560     void SDLInput::processBufferedKeyboard()
00561     {
00562         // XXX Arbitrarily picked 16 
00563         SDL_Event events[16];
00564 
00565         int count = SDL_PeepEvents(events, 16, SDL_GETEVENT,
00566                 (SDL_KEYDOWNMASK | SDL_KEYUPMASK));
00567         if (!count)
00568         {
00569             return;
00570         }
00571 
00572         for (int i = 0; i < count; i++)
00573         {
00574             bool down = false;
00575             if (events[i].type == SDL_KEYDOWN)
00576                 down = true;
00577             keyChanged(_key_map[events[i].key.keysym.sym], down);
00578         }
00579     }
00580 
00581     void SDLInput::processBufferedMouse()
00582     {
00583         // XXX Arbitrarily picked 16 
00584         SDL_Event events[16];
00585 
00586         // the value that is added to mMouseRelativeZ when the wheel
00587         // is moved one step (this value is actually added
00588         // twice per movement since a wheel movement triggers a
00589         // MOUSEBUTTONUP and a MOUSEBUTTONDOWN event)
00590 
00591         int count = SDL_PeepEvents(events, 16, SDL_GETEVENT,
00592                 (SDL_MOUSEMOTIONMASK | SDL_MOUSEBUTTONDOWNMASK |
00593                  SDL_MOUSEBUTTONUPMASK | SDL_ACTIVEEVENTMASK));
00594         if (!count)
00595         {
00596             return;
00597         }
00598 
00599         bool Xset, Yset, Zset;
00600         Xset = Yset = Zset = false;
00601         for (int i = 0; i < count; i++)
00602         {
00603             int button_mask = -1;
00604             bool button_down = false;
00605             switch (events[i].type)
00606             {
00607             case SDL_ACTIVEEVENT:
00608                 _visible = events[i].active.gain ? true : false;
00609                 break;
00610             case SDL_MOUSEMOTION:
00611                 if (events[i].motion.xrel)
00612                 {
00613                     if (Xset)
00614                     {
00615                         mouseMoved();
00616                     }
00617                     mCursor->addToX(events[i].motion.xrel * mScale);
00618                     Xset = true;
00619                 }
00620                 if (events[i].motion.yrel)
00621                 {
00622                     if (Yset)
00623                     {
00624                         mouseMoved();
00625                     }
00626                     mCursor->addToY(events[i].motion.yrel * mScale);
00627                     Yset = true;
00628                 }
00629                 break;
00630             case SDL_MOUSEBUTTONDOWN:
00631                 button_down = true;
00632             case SDL_MOUSEBUTTONUP:
00633                 switch(events[i].button.button)
00634                 {
00635                 case SDL_BUTTON_LEFT:
00636                     button_mask = InputEvent::BUTTON0_MASK;
00637                     break;
00638                 case SDL_BUTTON_RIGHT:
00639                     button_mask = InputEvent::BUTTON1_MASK;
00640                     break;
00641                 case SDL_BUTTON_MIDDLE:
00642                     button_mask = InputEvent::BUTTON2_MASK;
00643                     break;
00644                 case SDL_BUTTON_WHEELUP:
00645                     mMouseRelativeZ += mWheelStep;
00646                     break;
00647                 case SDL_BUTTON_WHEELDOWN:
00648                     mMouseRelativeZ -= mWheelStep;
00649                     break; 
00650                 };
00651                 triggerMouseButton(button_mask, button_down);
00652                 break;
00653             };
00654             
00655             if (Xset && Yset)
00656             {
00657                 mouseMoved();
00658                 Xset = Yset = false;
00659             }
00660         }
00661 
00662         if (Xset || Yset)
00663         {
00664             mouseMoved();
00665         }
00666                     
00667     }
00668 
00669     void SDLInput::getMouseState( MouseState& state ) const
00670     {
00671         memcpy( &state, &mMouseState, sizeof( MouseState ) );
00672     }
00673 
00674 }

Copyright © 2002-2003 by The OGRE Team
Last modified Fri May 14 23:22:46 2004