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), mMouseCenterX(0), 
00035           mMouseCenterY(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         warpMouse=useMouse;
00157 
00158         // Get the center and put the mouse there
00159         unsigned int width, height, depth;
00160         int left, top;
00161         pWindow->getMetrics(width, height, depth, left, top);
00162 
00163         mMouseX = mMouseCenterX = width / 2;
00164         mMouseY = mMouseCenterY = height / 2;
00165 
00166         if(warpMouse)
00167           SDL_WarpMouse(mMouseCenterX, mMouseCenterY);
00168     }
00169 
00170     void SDLInput::capture()
00171     {
00172         // Wait until we're visible again
00173         if (!_visible)
00174         {
00175             SDL_Event event;
00176             while (SDL_WaitEvent(&event))
00177             {
00178                 if (event.type == SDL_ACTIVEEVENT && event.active.gain == 1)
00179                 {
00180                     break;
00181                 }
00182             }
00183         }
00184 
00185         if (mUseBufferedKeys)
00186         {
00187             processBufferedKeyboard();
00188         }
00189 
00190         if (mUseBufferedMouse)
00191         {
00192             processBufferedMouse();
00193         }
00194 
00195         SDL_PumpEvents();
00196 
00197         if (!mUseBufferedKeys)
00198         {
00199             // Get Keyboard state
00200             mKeyboardBuffer = SDL_GetKeyState(NULL);
00201         }
00202 
00203         // NB buffered keyboard not yet supported!
00204         // TODO
00205         if (!mUseBufferedMouse)
00206         {
00207             mMouseKeys = 0;
00208 
00209             // Get mouse info
00210             if( SDL_GetAppState() & SDL_APPMOUSEFOCUS )
00211             {
00212                 mMouseKeys = SDL_GetMouseState( &mMouseX, &mMouseY );
00213             }
00214 
00215             mMouseState.Xabs = mMouseX;
00216             mMouseState.Yabs = mMouseY;
00217             mMouseState.Zabs = 0;
00218 
00219             mMouseState.Xrel = mMouseX - mMouseCenterX;
00220             mMouseState.Yrel = mMouseY - mMouseCenterY;
00221             mMouseState.Zrel = 0;
00222 
00223             mMouseState.Buttons = 0;
00224 
00225             for(int i = 0; i < 3; i++ )
00226                 if( mMouseKeys & SDL_BUTTON( i ) )
00227                     mMouseState.Buttons |= ( 1 << i );
00228 
00229             // XXX Fix me up
00230             // Game controller state
00231         }
00232         if(warpMouse)
00233           SDL_WarpMouse( mMouseCenterX, mMouseCenterY );
00234     }
00235 
00236     bool SDLInput::isKeyDown(KeyCode kc) const
00237     {
00238         switch(kc)
00239         {
00240         case KC_ESCAPE:
00241             return mKeyboardBuffer[SDLK_ESCAPE];
00242         case KC_1:
00243             return mKeyboardBuffer[SDLK_1];
00244         case KC_2:
00245             return mKeyboardBuffer[SDLK_2];
00246         case KC_3:
00247             return mKeyboardBuffer[SDLK_3];
00248         case KC_4:
00249             return mKeyboardBuffer[SDLK_4];
00250         case KC_5:
00251             return mKeyboardBuffer[SDLK_5];
00252         case KC_6:
00253             return mKeyboardBuffer[SDLK_6];
00254         case KC_7:
00255             return mKeyboardBuffer[SDLK_7];
00256         case KC_8:
00257             return mKeyboardBuffer[SDLK_8];
00258         case KC_9:
00259             return mKeyboardBuffer[SDLK_9];
00260         case KC_0:
00261             return mKeyboardBuffer[SDLK_0];
00262         case KC_MINUS:  /* - on main keyboard */
00263             return mKeyboardBuffer[SDLK_MINUS];
00264         case KC_EQUALS:
00265             return mKeyboardBuffer[SDLK_EQUALS];
00266         case KC_BACK:  /* backspace */
00267             return mKeyboardBuffer[SDLK_BACKSPACE];
00268         case KC_TAB:
00269             return mKeyboardBuffer[SDLK_TAB];
00270         case KC_Q:
00271             return mKeyboardBuffer[SDLK_q];
00272         case KC_W:
00273             return mKeyboardBuffer[SDLK_w];
00274         case KC_E:
00275             return mKeyboardBuffer[SDLK_e];
00276         case KC_R:
00277             return mKeyboardBuffer[SDLK_r];
00278         case KC_T:
00279             return mKeyboardBuffer[SDLK_t];
00280         case KC_Y:
00281             return mKeyboardBuffer[SDLK_y];
00282         case KC_U:
00283             return mKeyboardBuffer[SDLK_u];
00284         case KC_I:
00285             return mKeyboardBuffer[SDLK_i];
00286         case KC_O:
00287             return mKeyboardBuffer[SDLK_o];
00288         case KC_P:
00289             return mKeyboardBuffer[SDLK_p];
00290         case KC_LBRACKET:
00291         case KC_RBRACKET:
00292             break;
00293         case KC_RETURN: /* Enter on main keyboard */
00294             return mKeyboardBuffer[SDLK_RETURN];
00295         case KC_LCONTROL:
00296             return mKeyboardBuffer[SDLK_LCTRL];
00297         case KC_A:
00298             return mKeyboardBuffer[SDLK_a];
00299         case KC_S:
00300             return mKeyboardBuffer[SDLK_s];
00301         case KC_D:
00302             return mKeyboardBuffer[SDLK_d];
00303         case KC_F:
00304             return mKeyboardBuffer[SDLK_f];
00305         case KC_G:
00306             return mKeyboardBuffer[SDLK_g];
00307         case KC_H:
00308             return mKeyboardBuffer[SDLK_h];
00309         case KC_J:
00310             return mKeyboardBuffer[SDLK_j];
00311         case KC_K:
00312             return mKeyboardBuffer[SDLK_k];
00313         case KC_L:
00314             return mKeyboardBuffer[SDLK_l];
00315         case KC_SEMICOLON:
00316             return mKeyboardBuffer[SDLK_SEMICOLON];
00317         case KC_APOSTROPHE:
00318             return mKeyboardBuffer[SDLK_QUOTE];
00319         case KC_GRAVE:  /* accent grave */
00320             return mKeyboardBuffer[SDLK_BACKQUOTE];
00321         case KC_LSHIFT:
00322             return mKeyboardBuffer[SDLK_LSHIFT];
00323         case KC_BACKSLASH:
00324             return mKeyboardBuffer[SDLK_BACKSLASH];
00325         case KC_Z:
00326             return mKeyboardBuffer[SDLK_z];
00327         case KC_X:
00328             return mKeyboardBuffer[SDLK_x];
00329         case KC_C:
00330             return mKeyboardBuffer[SDLK_c];
00331         case KC_V:
00332             return mKeyboardBuffer[SDLK_v];
00333         case KC_B:
00334             return mKeyboardBuffer[SDLK_b];
00335         case KC_N:
00336             return mKeyboardBuffer[SDLK_n];
00337         case KC_M:
00338             return mKeyboardBuffer[SDLK_m];
00339         case KC_COMMA:
00340             return mKeyboardBuffer[SDLK_COMMA];
00341         case KC_PERIOD: /* . on main keyboard */
00342             return mKeyboardBuffer[SDLK_PERIOD];
00343         case KC_SLASH: /* '/' on main keyboard */
00344             break;
00345         case KC_RSHIFT:
00346             return mKeyboardBuffer[SDLK_RSHIFT];
00347         case KC_MULTIPLY: /* * on numeric keypad */
00348             return mKeyboardBuffer[SDLK_KP_MULTIPLY];
00349         case KC_LMENU: /* left Alt */
00350             return mKeyboardBuffer[SDLK_LALT];
00351         case KC_SPACE:
00352             return mKeyboardBuffer[SDLK_SPACE];
00353         case KC_CAPITAL:
00354             return mKeyboardBuffer[SDLK_CAPSLOCK];
00355         case KC_F1:
00356             return mKeyboardBuffer[SDLK_F1];
00357         case KC_F2:
00358             return mKeyboardBuffer[SDLK_F2];
00359         case KC_F3:
00360             return mKeyboardBuffer[SDLK_F3];
00361         case KC_F4:
00362             return mKeyboardBuffer[SDLK_F4];
00363         case KC_F5:
00364             return mKeyboardBuffer[SDLK_F5];
00365         case KC_F6:
00366             return mKeyboardBuffer[SDLK_F6];
00367         case KC_F7:
00368             return mKeyboardBuffer[SDLK_F7];
00369         case KC_F8:
00370             return mKeyboardBuffer[SDLK_F8];
00371         case KC_F9:
00372             return mKeyboardBuffer[SDLK_F9];
00373         case KC_F10:
00374             return mKeyboardBuffer[SDLK_F10];
00375         case KC_NUMLOCK:
00376             return mKeyboardBuffer[SDLK_NUMLOCK];
00377         case KC_SCROLL: /* Scroll Lock */
00378             return mKeyboardBuffer[SDLK_SCROLLOCK];
00379         case KC_NUMPAD7:
00380             return mKeyboardBuffer[SDLK_KP7];
00381         case KC_NUMPAD8:
00382             return mKeyboardBuffer[SDLK_KP8];
00383         case KC_NUMPAD9:
00384             return mKeyboardBuffer[SDLK_KP9];
00385         case KC_SUBTRACT: /* - on numeric keypad */
00386             return mKeyboardBuffer[SDLK_KP_MINUS];
00387         case KC_NUMPAD4:
00388             return mKeyboardBuffer[SDLK_KP4];
00389         case KC_NUMPAD5:
00390             return mKeyboardBuffer[SDLK_KP5];
00391         case KC_NUMPAD6:
00392             return mKeyboardBuffer[SDLK_KP6];
00393         case KC_ADD: /* + on numeric keypad */
00394             return mKeyboardBuffer[SDLK_KP_PLUS];
00395         case KC_NUMPAD1:
00396             return mKeyboardBuffer[SDLK_KP1];
00397         case KC_NUMPAD2:
00398             return mKeyboardBuffer[SDLK_KP2];
00399         case KC_NUMPAD3:
00400             return mKeyboardBuffer[SDLK_KP3];
00401         case KC_NUMPAD0:
00402             return mKeyboardBuffer[SDLK_KP0];
00403         case KC_DECIMAL:  /* . on numeric keypad */
00404             return mKeyboardBuffer[SDLK_KP_PERIOD];
00405         case KC_OEM_102:  /* < > | on UK/Germany keyboards */
00406             break;
00407         case KC_F11:
00408             return mKeyboardBuffer[SDLK_F11];
00409         case KC_F12:
00410             return mKeyboardBuffer[SDLK_F12];
00411         case KC_F13: /* (NEC PC98) */
00412             return mKeyboardBuffer[SDLK_F13];
00413         case KC_F14: /* (NEC PC98) */
00414             return mKeyboardBuffer[SDLK_F14];
00415         case KC_F15: /* (NEC PC98) */
00416             return mKeyboardBuffer[SDLK_F15];
00417         case KC_KANA: /* (Japanese keyboard) */
00418         case KC_ABNT_C1: /* / ? on Portugese (Brazilian) keyboards */
00419         case KC_CONVERT: /* (Japanese keyboard) */
00420         case KC_NOCONVERT: /* (Japanese keyboard) */
00421         case KC_YEN: /* (Japanese keyboard) */
00422         case KC_ABNT_C2: /* Numpad . on Portugese (Brazilian) keyboards */
00423             break;
00424         case KC_NUMPADEQUALS: /* = on numeric keypad (NEC PC98) */
00425             return mKeyboardBuffer[SDLK_KP_EQUALS];
00426         case KC_PREVTRACK: /* Previous Track (KC_CIRCUMFLEX on Japanese keyboard) */
00427         case KC_AT: /* (NEC PC98) */
00428         case KC_COLON: /* (NEC PC98) */
00429             return mKeyboardBuffer[SDLK_COLON];
00430         case KC_UNDERLINE: /* (NEC PC98) */
00431         case KC_KANJI: /* (Japanese keyboard)            */
00432         case KC_STOP: /* (NEC PC98) */
00433         case KC_AX:  /*  (Japan AX) */
00434         case KC_UNLABELED:  /* (J3100) */
00435         case KC_NEXTTRACK:  /* Next Track */
00436         case KC_NUMPADENTER:  /* Enter on numeric keypad */
00437         case KC_RCONTROL:
00438         case KC_MUTE:  /* Mute */
00439         case KC_CALCULATOR:  /* Calculator */
00440         case KC_PLAYPAUSE:  /* Play / Pause */
00441         case KC_MEDIASTOP:  /* Media Stop */
00442         case KC_VOLUMEDOWN:  /* Volume - */
00443         case KC_VOLUMEUP:  /* Volume + */
00444         case KC_WEBHOME:  /* Web home */
00445         case KC_NUMPADCOMMA:  /* , on numeric keypad (NEC PC98) */
00446             break;
00447         case KC_DIVIDE:  /* / on numeric keypad */
00448             return mKeyboardBuffer[SDLK_KP_DIVIDE];
00449         case KC_SYSRQ:
00450             return mKeyboardBuffer[SDLK_SYSREQ] | mKeyboardBuffer[SDLK_PRINT];
00451         case KC_RMENU:  /* right Alt */
00452             return mKeyboardBuffer[SDLK_RALT];
00453         case KC_PAUSE:  /* Pause */
00454             break;
00455         case KC_HOME:  /* Home on arrow keypad */
00456             return mKeyboardBuffer[SDLK_HOME];
00457         case KC_UP:  /* UpArrow on arrow keypad */
00458             return mKeyboardBuffer[SDLK_UP];
00459         case KC_PGUP:  /* PgUp on arrow keypad */
00460             return mKeyboardBuffer[SDLK_PAGEUP];
00461         case KC_LEFT:  /* LeftArrow on arrow keypad */
00462             return mKeyboardBuffer[SDLK_LEFT];
00463         case KC_RIGHT:  /* RightArrow on arrow keypad */
00464             return mKeyboardBuffer[SDLK_RIGHT];
00465         case KC_END:  /* End on arrow keypad */
00466             return mKeyboardBuffer[SDLK_END];
00467         case KC_DOWN:  /* DownArrow on arrow keypad */
00468             return mKeyboardBuffer[SDLK_DOWN];
00469         case KC_PGDOWN:  /* PgDn on arrow keypad */
00470             return mKeyboardBuffer[SDLK_PAGEDOWN];
00471         case KC_INSERT:  /* Insert on arrow keypad */
00472             return mKeyboardBuffer[SDLK_INSERT];
00473         case KC_DELETE:  /* Delete on arrow keypad */
00474             return mKeyboardBuffer[SDLK_DELETE];
00475         case KC_LWIN:  /* Left Windows key */
00476             return mKeyboardBuffer[SDLK_LSUPER];
00477         case KC_RWIN:  /* Right Windows key */
00478             return mKeyboardBuffer[SDLK_RSUPER];
00479         case KC_APPS:  /* AppMenu key */
00480         case KC_POWER:  /* System Power */
00481         case KC_SLEEP:  /* System Sleep */
00482         case KC_WAKE:  /* System Wake */
00483         case KC_WEBSEARCH:  /* Web Search */
00484         case KC_WEBFAVORITES:  /* Web Favorites */
00485         case KC_WEBREFRESH:  /* Web Refresh */
00486         case KC_WEBSTOP:  /* Web Stop */
00487         case KC_WEBFORWARD:  /* Web Forward */
00488         case KC_WEBBACK:  /* Web Back */
00489         case KC_MYCOMPUTER:  /* My Computer */
00490         case KC_MAIL:  /* Mail */
00491         case KC_MEDIASELECT:  /* Media Select */
00492             break;
00493         default:
00494             break;
00495         };
00496 
00497         return 0;
00498     }
00499 
00500     long SDLInput::getMouseRelX() const
00501     {
00502         return mMouseX - mMouseCenterX;
00503     }
00504 
00505     long SDLInput::getMouseRelY() const
00506     {
00507         return mMouseY - mMouseCenterY;
00508     }
00509 
00510     long SDLInput::getMouseRelZ() const
00511     {
00512         return 0;
00513     }
00514 
00515     long SDLInput::getMouseAbsX() const
00516     {
00517         return mMouseX;
00518     }
00519 
00520     long SDLInput::getMouseAbsY() const
00521     {
00522         return mMouseY;
00523     }
00524 
00525     long SDLInput::getMouseAbsZ() const
00526     {
00527         return 0;
00528     }
00529 
00530     bool SDLInput::getMouseButton( uchar button ) const
00531     {
00532         return mMouseState.isButtonDown( button );
00533     }
00534 
00535     void SDLInput::processBufferedKeyboard()
00536     {
00537         // XXX Arbitrarily picked 16 
00538         SDL_Event events[16];
00539 
00540         int count = SDL_PeepEvents(events, 16, SDL_GETEVENT,
00541                 (SDL_KEYDOWNMASK | SDL_KEYUPMASK));
00542         if (!count)
00543         {
00544             return;
00545         }
00546 
00547         for (int i = 0; i < count; i++)
00548         {
00549             bool down = false;
00550             if (events[i].type == SDL_KEYDOWN)
00551                 down = true;
00552             keyChanged(_key_map[events[i].key.keysym.sym], down);
00553         }
00554     }
00555 
00556     void SDLInput::processBufferedMouse()
00557     {
00558         // XXX Arbitrarily picked 16 
00559         SDL_Event events[16];
00560 
00561         int count = SDL_PeepEvents(events, 16, SDL_GETEVENT,
00562                 (SDL_MOUSEMOTIONMASK | SDL_MOUSEBUTTONDOWNMASK |
00563                  SDL_MOUSEBUTTONUPMASK | SDL_ACTIVEEVENTMASK));
00564         if (!count)
00565         {
00566             return;
00567         }
00568 
00569         bool Xset, Yset, Zset;
00570         Xset = Yset = Zset = false;
00571         for (int i = 0; i < count; i++)
00572         {
00573             int button_mask = -1;
00574             bool button_down = false;
00575             switch (events[i].type)
00576             {
00577             case SDL_ACTIVEEVENT:
00578                 _visible = events[i].active.gain ? true : false;
00579                 break;
00580             case SDL_MOUSEMOTION:
00581                 if (events[i].motion.x == mMouseCenterX && 
00582                         events[i].motion.y == mMouseCenterY)
00583                 {
00584                     // it moved to the center, probably a warp, ignore it
00585                     continue;
00586                 }
00587 
00588                 if (events[i].motion.xrel)
00589                 {
00590                     if (Xset)
00591                     {
00592                         mouseMoved();
00593                     }
00594                     mCursor->addToX(events[i].motion.xrel * mScale);
00595                     Xset = true;
00596                 }
00597                 if (events[i].motion.yrel)
00598                 {
00599                     if (Yset)
00600                     {
00601                         mouseMoved();
00602                     }
00603                     mCursor->addToY(events[i].motion.yrel * mScale);
00604                     Yset = true;
00605                 }
00606                 break;
00607             case SDL_MOUSEBUTTONDOWN:
00608                 button_down = true;
00609             case SDL_MOUSEBUTTONUP:
00610                 switch(events[i].button.button)
00611                 {
00612                 case SDL_BUTTON_LEFT:
00613                     button_mask = InputEvent::BUTTON0_MASK;
00614                     break;
00615                 case SDL_BUTTON_RIGHT:
00616                     button_mask = InputEvent::BUTTON1_MASK;
00617                     break;
00618                 case SDL_BUTTON_MIDDLE:
00619                     button_mask = InputEvent::BUTTON2_MASK;
00620                     break;
00621                 };
00622                 triggerMouseButton(button_mask, button_down);
00623                 break;
00624             };
00625             
00626             if (Xset && Yset)
00627             {
00628                 mouseMoved();
00629                 Xset = Yset = false;
00630             }
00631         }
00632 
00633         if (Xset || Yset)
00634         {
00635             mouseMoved();
00636         }
00637                     
00638     }
00639 
00640     void SDLInput::getMouseState( MouseState& state ) const
00641     {
00642         memcpy( &state, &mMouseState, sizeof( MouseState ) );
00643     }
00644 
00645 }

Copyright © 2002-2003 by The OGRE Team
Last modified Wed Jan 21 00:10:27 2004