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 mMouseGrabbed = false; 00038 mGrabMouse = false; 00039 mMouseLeft = false; 00040 mGrabMode = GRAB_NONE; 00041 mEventQueue = 0; 00042 00043 _key_map.insert(InputKeyMap::value_type(SDLK_ESCAPE,KC_ESCAPE)); 00044 _key_map.insert(InputKeyMap::value_type(SDLK_1, KC_1)); 00045 _key_map.insert(InputKeyMap::value_type(SDLK_2, KC_2)); 00046 _key_map.insert(InputKeyMap::value_type(SDLK_3, KC_3)); 00047 _key_map.insert(InputKeyMap::value_type(SDLK_4, KC_4)); 00048 _key_map.insert(InputKeyMap::value_type(SDLK_5, KC_5)); 00049 _key_map.insert(InputKeyMap::value_type(SDLK_6, KC_6)); 00050 _key_map.insert(InputKeyMap::value_type(SDLK_7, KC_7)); 00051 _key_map.insert(InputKeyMap::value_type(SDLK_8, KC_8)); 00052 _key_map.insert(InputKeyMap::value_type(SDLK_9, KC_9)); 00053 _key_map.insert(InputKeyMap::value_type(SDLK_0, KC_0)); 00054 _key_map.insert(InputKeyMap::value_type(SDLK_MINUS, KC_MINUS)); 00055 _key_map.insert(InputKeyMap::value_type(SDLK_EQUALS, KC_EQUALS)); 00056 _key_map.insert(InputKeyMap::value_type(SDLK_BACKSPACE, KC_BACK)); 00057 _key_map.insert(InputKeyMap::value_type(SDLK_TAB, KC_TAB)); 00058 _key_map.insert(InputKeyMap::value_type(SDLK_q, KC_Q)); 00059 _key_map.insert(InputKeyMap::value_type(SDLK_w, KC_W)); 00060 _key_map.insert(InputKeyMap::value_type(SDLK_e, KC_E)); 00061 _key_map.insert(InputKeyMap::value_type(SDLK_r, KC_R)); 00062 _key_map.insert(InputKeyMap::value_type(SDLK_t, KC_T)); 00063 _key_map.insert(InputKeyMap::value_type(SDLK_y, KC_Y)); 00064 _key_map.insert(InputKeyMap::value_type(SDLK_u, KC_U)); 00065 _key_map.insert(InputKeyMap::value_type(SDLK_i, KC_I)); 00066 _key_map.insert(InputKeyMap::value_type(SDLK_o, KC_O)); 00067 _key_map.insert(InputKeyMap::value_type(SDLK_p, KC_P)); 00068 _key_map.insert(InputKeyMap::value_type(SDLK_RETURN, KC_RETURN)); 00069 _key_map.insert(InputKeyMap::value_type(SDLK_LCTRL, KC_LCONTROL)); 00070 _key_map.insert(InputKeyMap::value_type(SDLK_a, KC_A)); 00071 _key_map.insert(InputKeyMap::value_type(SDLK_s, KC_S)); 00072 _key_map.insert(InputKeyMap::value_type(SDLK_d, KC_D)); 00073 _key_map.insert(InputKeyMap::value_type(SDLK_f, KC_F)); 00074 _key_map.insert(InputKeyMap::value_type(SDLK_g, KC_G)); 00075 _key_map.insert(InputKeyMap::value_type(SDLK_h, KC_H)); 00076 _key_map.insert(InputKeyMap::value_type(SDLK_j, KC_J)); 00077 _key_map.insert(InputKeyMap::value_type(SDLK_k, KC_K)); 00078 _key_map.insert(InputKeyMap::value_type(SDLK_l, KC_L)); 00079 _key_map.insert(InputKeyMap::value_type(SDLK_SEMICOLON, KC_SEMICOLON)); 00080 _key_map.insert(InputKeyMap::value_type(SDLK_COLON, KC_COLON)); 00081 _key_map.insert(InputKeyMap::value_type(SDLK_QUOTE, KC_APOSTROPHE)); 00082 _key_map.insert(InputKeyMap::value_type(SDLK_BACKQUOTE, KC_GRAVE)); 00083 _key_map.insert(InputKeyMap::value_type(SDLK_LSHIFT, KC_LSHIFT)); 00084 _key_map.insert(InputKeyMap::value_type(SDLK_BACKSLASH, KC_BACKSLASH)); 00085 _key_map.insert(InputKeyMap::value_type(SDLK_z, KC_Z)); 00086 _key_map.insert(InputKeyMap::value_type(SDLK_x, KC_X)); 00087 _key_map.insert(InputKeyMap::value_type(SDLK_c, KC_C)); 00088 _key_map.insert(InputKeyMap::value_type(SDLK_v, KC_V)); 00089 _key_map.insert(InputKeyMap::value_type(SDLK_b, KC_B)); 00090 _key_map.insert(InputKeyMap::value_type(SDLK_n, KC_N)); 00091 _key_map.insert(InputKeyMap::value_type(SDLK_m, KC_M)); 00092 _key_map.insert(InputKeyMap::value_type(SDLK_COMMA, KC_COMMA)); 00093 _key_map.insert(InputKeyMap::value_type(SDLK_PERIOD, KC_PERIOD)); 00094 _key_map.insert(InputKeyMap::value_type(SDLK_RSHIFT, KC_RSHIFT)); 00095 _key_map.insert(InputKeyMap::value_type(SDLK_KP_MULTIPLY, KC_MULTIPLY)); 00096 _key_map.insert(InputKeyMap::value_type(SDLK_LALT, KC_LMENU)); 00097 _key_map.insert(InputKeyMap::value_type(SDLK_SPACE, KC_SPACE)); 00098 _key_map.insert(InputKeyMap::value_type(SDLK_CAPSLOCK, KC_CAPITAL)); 00099 _key_map.insert(InputKeyMap::value_type(SDLK_F1, KC_F1)); 00100 _key_map.insert(InputKeyMap::value_type(SDLK_F2, KC_F2)); 00101 _key_map.insert(InputKeyMap::value_type(SDLK_F3, KC_F3)); 00102 _key_map.insert(InputKeyMap::value_type(SDLK_F4, KC_F4)); 00103 _key_map.insert(InputKeyMap::value_type(SDLK_F5, KC_F5)); 00104 _key_map.insert(InputKeyMap::value_type(SDLK_F6, KC_F6)); 00105 _key_map.insert(InputKeyMap::value_type(SDLK_F7, KC_F7)); 00106 _key_map.insert(InputKeyMap::value_type(SDLK_F8, KC_F8)); 00107 _key_map.insert(InputKeyMap::value_type(SDLK_F9, KC_F9)); 00108 _key_map.insert(InputKeyMap::value_type(SDLK_F10, KC_F10)); 00109 _key_map.insert(InputKeyMap::value_type(SDLK_NUMLOCK, KC_NUMLOCK)); 00110 _key_map.insert(InputKeyMap::value_type(SDLK_SCROLLOCK, KC_SCROLL)); 00111 _key_map.insert(InputKeyMap::value_type(SDLK_KP7, KC_NUMPAD7)); 00112 _key_map.insert(InputKeyMap::value_type(SDLK_KP8, KC_NUMPAD8)); 00113 _key_map.insert(InputKeyMap::value_type(SDLK_KP9, KC_NUMPAD9)); 00114 _key_map.insert(InputKeyMap::value_type(SDLK_KP_MINUS, KC_SUBTRACT)); 00115 _key_map.insert(InputKeyMap::value_type(SDLK_KP4, KC_NUMPAD4)); 00116 _key_map.insert(InputKeyMap::value_type(SDLK_KP5, KC_NUMPAD5)); 00117 _key_map.insert(InputKeyMap::value_type(SDLK_KP6, KC_NUMPAD6)); 00118 _key_map.insert(InputKeyMap::value_type(SDLK_KP_PLUS, KC_ADD)); 00119 _key_map.insert(InputKeyMap::value_type(SDLK_KP1, KC_NUMPAD1)); 00120 _key_map.insert(InputKeyMap::value_type(SDLK_KP2, KC_NUMPAD2)); 00121 _key_map.insert(InputKeyMap::value_type(SDLK_KP3, KC_NUMPAD3)); 00122 _key_map.insert(InputKeyMap::value_type(SDLK_KP0, KC_NUMPAD0)); 00123 _key_map.insert(InputKeyMap::value_type(SDLK_KP_PERIOD, KC_DECIMAL)); 00124 _key_map.insert(InputKeyMap::value_type(SDLK_F11, KC_F11)); 00125 _key_map.insert(InputKeyMap::value_type(SDLK_F12, KC_F12)); 00126 _key_map.insert(InputKeyMap::value_type(SDLK_F13, KC_F13)); 00127 _key_map.insert(InputKeyMap::value_type(SDLK_F14, KC_F14)); 00128 _key_map.insert(InputKeyMap::value_type(SDLK_F15, KC_F15)); 00129 _key_map.insert(InputKeyMap::value_type(SDLK_KP_EQUALS, KC_NUMPADEQUALS)); 00130 _key_map.insert(InputKeyMap::value_type(SDLK_KP_DIVIDE, KC_DIVIDE)); 00131 _key_map.insert(InputKeyMap::value_type(SDLK_SYSREQ, KC_SYSRQ)); 00132 _key_map.insert(InputKeyMap::value_type(SDLK_RALT, KC_RMENU)); 00133 _key_map.insert(InputKeyMap::value_type(SDLK_HOME, KC_HOME)); 00134 _key_map.insert(InputKeyMap::value_type(SDLK_UP, KC_UP)); 00135 _key_map.insert(InputKeyMap::value_type(SDLK_PAGEUP, KC_PGUP)); 00136 _key_map.insert(InputKeyMap::value_type(SDLK_LEFT, KC_LEFT)); 00137 _key_map.insert(InputKeyMap::value_type(SDLK_RIGHT, KC_RIGHT)); 00138 _key_map.insert(InputKeyMap::value_type(SDLK_END, KC_END)); 00139 _key_map.insert(InputKeyMap::value_type(SDLK_DOWN, KC_DOWN)); 00140 _key_map.insert(InputKeyMap::value_type(SDLK_PAGEDOWN, KC_PGDOWN)); 00141 _key_map.insert(InputKeyMap::value_type(SDLK_INSERT, KC_INSERT)); 00142 _key_map.insert(InputKeyMap::value_type(SDLK_DELETE, KC_DELETE)); 00143 _key_map.insert(InputKeyMap::value_type(SDLK_LSUPER, KC_LWIN)); 00144 _key_map.insert(InputKeyMap::value_type(SDLK_RSUPER, KC_RWIN)); 00145 } 00146 00147 SDLInput::~SDLInput() 00148 { 00149 if ( mUseMouse ) 00150 { 00151 SDL_WM_GrabInput(SDL_GRAB_OFF); 00152 SDL_ShowCursor(1); 00153 } 00154 } 00155 00156 void SDLInput::initialise(RenderWindow* pWindow, bool useKeyboard, bool useMouse, bool useGameController) 00157 { 00158 mUseMouse = useMouse; 00159 if ( useMouse ) 00160 { 00161 mGrabMode = GRAB_MOUSE_CLICK; 00162 00163 // is the mouse pointer over the app window? 00164 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) 00165 { 00166 _grabMouse(); 00167 } 00168 else 00169 { 00170 // no, so we have to wait until the app gets 00171 // the mouse focus 00172 mGrabMouse = true; 00173 mMouseLeft = true; 00174 } 00175 // Get the center and put the mouse there 00176 unsigned int width, height, depth; 00177 int left, top; 00178 pWindow->getMetrics(width, height, depth, left, top); 00179 00180 mMouseX = width / 2; 00181 mMouseY = height / 2; 00182 } 00183 else 00184 { 00185 mGrabMode = GRAB_NONE; 00186 } 00187 } 00188 00189 void SDLInput::_releaseMouse() 00190 { 00191 SDL_WM_GrabInput(SDL_GRAB_OFF); 00192 SDL_ShowCursor(1); 00193 mMouseGrabbed = false; 00194 mMouseLeft = false; 00195 mGrabMouse = true; 00196 } 00197 00198 void SDLInput::_grabMouse() 00199 { 00200 SDL_ShowCursor(0); 00201 SDL_WM_GrabInput(SDL_GRAB_ON); 00202 mMouseGrabbed = true; 00203 mGrabMouse = false; 00204 } 00205 00206 void SDLInput::capture() 00207 { 00208 SDL_Event event[16]; 00209 00210 // Wait until we're visible again 00211 // and throw away all SDL_Events 00212 if (!_visible) 00213 { 00214 SDL_Event event; 00215 while (SDL_WaitEvent(&event)) 00216 { 00217 if (event.type == SDL_ACTIVEEVENT && event.active.gain == 1) 00218 { 00219 break; 00220 } 00221 } 00222 } 00223 00224 SDL_PumpEvents(); 00225 00226 // look for SDL "system" events 00227 int count = SDL_PeepEvents( event, 16 , SDL_GETEVENT 00228 , SDL_EVENTMASK(SDL_ACTIVEEVENT) 00229 | SDL_EVENTMASK(SDL_VIDEORESIZE) 00230 | SDL_EVENTMASK(SDL_VIDEOEXPOSE) 00231 | SDL_EVENTMASK(SDL_SYSWMEVENT) 00232 ); 00233 if ( count ) 00234 { 00235 for (int i = 0; i < count; i++) 00236 { 00237 switch (event[i].type) 00238 { 00239 case SDL_ACTIVEEVENT: 00240 if ( mGrabMouse && (mGrabMode == GRAB_MOUSE_OVER ) ) 00241 { 00242 if ( event[i].active.gain ) 00243 { 00244 if ( mMouseLeft ) 00245 { 00246 // mouse is over the application window 00247 _grabMouse(); 00248 } 00249 } 00250 else 00251 { 00252 mMouseLeft = true; 00253 } 00254 } 00255 break; 00256 case SDL_VIDEORESIZE: 00257 case SDL_VIDEOEXPOSE: 00258 case SDL_SYSWMEVENT: 00259 break; 00260 } 00261 } 00262 } 00263 00264 // Keyboard input 00265 if (mUseBufferedKeys) 00266 { 00267 processBufferedKeyboard(); 00268 } 00269 // check for ALT + TAB to mimic windoze behaviour (useful to get the mouse 00270 // pointer back ;-) 00271 00272 // we have to call GetKeyState() even if buffered keyboard input is selected 00273 mKeyboardBuffer = SDL_GetKeyState(NULL); 00274 if ( mKeyboardBuffer[SDLK_LALT] && mKeyboardBuffer[SDLK_TAB] ) 00275 { 00276 _releaseMouse(); 00277 } 00278 00279 00280 if (mUseBufferedMouse) 00281 { 00282 processBufferedMouse(); 00283 } 00284 else 00285 { 00286 mMouseKeys = 0; 00287 mMouseRelativeX = 0; mMouseRelativeY = 0; mMouseRelativeZ = 0; 00288 00289 // Get mouse info 00290 if( 1 ) // SDL_GetAppState() & SDL_APPMOUSEFOCUS ) 00291 { 00292 mMouseKeys = SDL_GetMouseState( &mMouseX, &mMouseY ); 00293 SDL_GetRelativeMouseState( &mMouseRelativeX, &mMouseRelativeY ); 00294 00295 00296 // get mouse wheel movement 00297 // fetch all mouse wheel related events 00298 int count = SDL_PeepEvents( event, 16 , SDL_GETEVENT 00299 ,(SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN) 00300 | SDL_EVENTMASK(SDL_MOUSEBUTTONUP) 00301 | SDL_EVENTMASK(SDL_MOUSEMOTION) 00302 )); 00303 if ( count ) 00304 { 00305 for (int i = 0; i < count; i++) 00306 { 00307 switch (event[i].type) 00308 { 00309 case SDL_MOUSEBUTTONDOWN: 00310 case SDL_MOUSEBUTTONUP: 00311 // grab the mouse if the user presses a mouse button 00312 if ( !mMouseGrabbed && mGrabMouse && ( mGrabMode == GRAB_MOUSE_CLICK ) ) 00313 { 00314 _grabMouse(); 00315 } 00316 switch(event[i].button.button) 00317 { 00318 case SDL_BUTTON_WHEELUP: 00319 mMouseRelativeZ += mWheelStep; 00320 break; 00321 case SDL_BUTTON_WHEELDOWN: 00322 mMouseRelativeZ -= mWheelStep; 00323 break; 00324 } 00325 break; 00326 } 00327 } 00328 } 00329 } 00330 00331 mMouseState.Xabs = mMouseX; 00332 mMouseState.Yabs = mMouseY; 00333 mMouseState.Zabs = 0; 00334 00335 mMouseState.Xrel = mMouseRelativeX; 00336 mMouseState.Yrel = mMouseRelativeY; 00337 mMouseState.Zrel = mMouseRelativeZ; 00338 00339 mMouseState.Buttons = (mMouseKeys & SDL_BUTTON_LMASK) ? 1 : 0; // left 00340 mMouseState.Buttons |= (mMouseKeys & SDL_BUTTON_RMASK) ? 2 : 0; // right 00341 mMouseState.Buttons |= (mMouseKeys & SDL_BUTTON_MMASK) ? 4 : 0; // middle 00342 00343 } 00344 00345 // XXX Fix me up 00346 // Game controller state 00347 } 00348 00349 bool SDLInput::isKeyDownImmediate(KeyCode kc) const 00350 { 00351 switch(kc) 00352 { 00353 case KC_ESCAPE: 00354 return mKeyboardBuffer[SDLK_ESCAPE]; 00355 case KC_1: 00356 return mKeyboardBuffer[SDLK_1]; 00357 case KC_2: 00358 return mKeyboardBuffer[SDLK_2]; 00359 case KC_3: 00360 return mKeyboardBuffer[SDLK_3]; 00361 case KC_4: 00362 return mKeyboardBuffer[SDLK_4]; 00363 case KC_5: 00364 return mKeyboardBuffer[SDLK_5]; 00365 case KC_6: 00366 return mKeyboardBuffer[SDLK_6]; 00367 case KC_7: 00368 return mKeyboardBuffer[SDLK_7]; 00369 case KC_8: 00370 return mKeyboardBuffer[SDLK_8]; 00371 case KC_9: 00372 return mKeyboardBuffer[SDLK_9]; 00373 case KC_0: 00374 return mKeyboardBuffer[SDLK_0]; 00375 case KC_MINUS: /* - on main keyboard */ 00376 return mKeyboardBuffer[SDLK_MINUS]; 00377 case KC_EQUALS: 00378 return mKeyboardBuffer[SDLK_EQUALS]; 00379 case KC_BACK: /* backspace */ 00380 return mKeyboardBuffer[SDLK_BACKSPACE]; 00381 case KC_TAB: 00382 return mKeyboardBuffer[SDLK_TAB]; 00383 case KC_Q: 00384 return mKeyboardBuffer[SDLK_q]; 00385 case KC_W: 00386 return mKeyboardBuffer[SDLK_w]; 00387 case KC_E: 00388 return mKeyboardBuffer[SDLK_e]; 00389 case KC_R: 00390 return mKeyboardBuffer[SDLK_r]; 00391 case KC_T: 00392 return mKeyboardBuffer[SDLK_t]; 00393 case KC_Y: 00394 return mKeyboardBuffer[SDLK_y]; 00395 case KC_U: 00396 return mKeyboardBuffer[SDLK_u]; 00397 case KC_I: 00398 return mKeyboardBuffer[SDLK_i]; 00399 case KC_O: 00400 return mKeyboardBuffer[SDLK_o]; 00401 case KC_P: 00402 return mKeyboardBuffer[SDLK_p]; 00403 case KC_LBRACKET: 00404 case KC_RBRACKET: 00405 break; 00406 case KC_RETURN: /* Enter on main keyboard */ 00407 return mKeyboardBuffer[SDLK_RETURN]; 00408 case KC_LCONTROL: 00409 return mKeyboardBuffer[SDLK_LCTRL]; 00410 case KC_A: 00411 return mKeyboardBuffer[SDLK_a]; 00412 case KC_S: 00413 return mKeyboardBuffer[SDLK_s]; 00414 case KC_D: 00415 return mKeyboardBuffer[SDLK_d]; 00416 case KC_F: 00417 return mKeyboardBuffer[SDLK_f]; 00418 case KC_G: 00419 return mKeyboardBuffer[SDLK_g]; 00420 case KC_H: 00421 return mKeyboardBuffer[SDLK_h]; 00422 case KC_J: 00423 return mKeyboardBuffer[SDLK_j]; 00424 case KC_K: 00425 return mKeyboardBuffer[SDLK_k]; 00426 case KC_L: 00427 return mKeyboardBuffer[SDLK_l]; 00428 case KC_SEMICOLON: 00429 return mKeyboardBuffer[SDLK_SEMICOLON]; 00430 case KC_APOSTROPHE: 00431 return mKeyboardBuffer[SDLK_QUOTE]; 00432 case KC_GRAVE: /* accent grave */ 00433 return mKeyboardBuffer[SDLK_BACKQUOTE]; 00434 case KC_LSHIFT: 00435 return mKeyboardBuffer[SDLK_LSHIFT]; 00436 case KC_BACKSLASH: 00437 return mKeyboardBuffer[SDLK_BACKSLASH]; 00438 case KC_Z: 00439 return mKeyboardBuffer[SDLK_z]; 00440 case KC_X: 00441 return mKeyboardBuffer[SDLK_x]; 00442 case KC_C: 00443 return mKeyboardBuffer[SDLK_c]; 00444 case KC_V: 00445 return mKeyboardBuffer[SDLK_v]; 00446 case KC_B: 00447 return mKeyboardBuffer[SDLK_b]; 00448 case KC_N: 00449 return mKeyboardBuffer[SDLK_n]; 00450 case KC_M: 00451 return mKeyboardBuffer[SDLK_m]; 00452 case KC_COMMA: 00453 return mKeyboardBuffer[SDLK_COMMA]; 00454 case KC_PERIOD: /* . on main keyboard */ 00455 return mKeyboardBuffer[SDLK_PERIOD]; 00456 case KC_SLASH: /* '/' on main keyboard */ 00457 break; 00458 case KC_RSHIFT: 00459 return mKeyboardBuffer[SDLK_RSHIFT]; 00460 case KC_MULTIPLY: /* * on numeric keypad */ 00461 return mKeyboardBuffer[SDLK_KP_MULTIPLY]; 00462 case KC_LMENU: /* left Alt */ 00463 return mKeyboardBuffer[SDLK_LALT]; 00464 case KC_SPACE: 00465 return mKeyboardBuffer[SDLK_SPACE]; 00466 case KC_CAPITAL: 00467 return mKeyboardBuffer[SDLK_CAPSLOCK]; 00468 case KC_F1: 00469 return mKeyboardBuffer[SDLK_F1]; 00470 case KC_F2: 00471 return mKeyboardBuffer[SDLK_F2]; 00472 case KC_F3: 00473 return mKeyboardBuffer[SDLK_F3]; 00474 case KC_F4: 00475 return mKeyboardBuffer[SDLK_F4]; 00476 case KC_F5: 00477 return mKeyboardBuffer[SDLK_F5]; 00478 case KC_F6: 00479 return mKeyboardBuffer[SDLK_F6]; 00480 case KC_F7: 00481 return mKeyboardBuffer[SDLK_F7]; 00482 case KC_F8: 00483 return mKeyboardBuffer[SDLK_F8]; 00484 case KC_F9: 00485 return mKeyboardBuffer[SDLK_F9]; 00486 case KC_F10: 00487 return mKeyboardBuffer[SDLK_F10]; 00488 case KC_NUMLOCK: 00489 return mKeyboardBuffer[SDLK_NUMLOCK]; 00490 case KC_SCROLL: /* Scroll Lock */ 00491 return mKeyboardBuffer[SDLK_SCROLLOCK]; 00492 case KC_NUMPAD7: 00493 return mKeyboardBuffer[SDLK_KP7]; 00494 case KC_NUMPAD8: 00495 return mKeyboardBuffer[SDLK_KP8]; 00496 case KC_NUMPAD9: 00497 return mKeyboardBuffer[SDLK_KP9]; 00498 case KC_SUBTRACT: /* - on numeric keypad */ 00499 return mKeyboardBuffer[SDLK_KP_MINUS]; 00500 case KC_NUMPAD4: 00501 return mKeyboardBuffer[SDLK_KP4]; 00502 case KC_NUMPAD5: 00503 return mKeyboardBuffer[SDLK_KP5]; 00504 case KC_NUMPAD6: 00505 return mKeyboardBuffer[SDLK_KP6]; 00506 case KC_ADD: /* + on numeric keypad */ 00507 return mKeyboardBuffer[SDLK_KP_PLUS]; 00508 case KC_NUMPAD1: 00509 return mKeyboardBuffer[SDLK_KP1]; 00510 case KC_NUMPAD2: 00511 return mKeyboardBuffer[SDLK_KP2]; 00512 case KC_NUMPAD3: 00513 return mKeyboardBuffer[SDLK_KP3]; 00514 case KC_NUMPAD0: 00515 return mKeyboardBuffer[SDLK_KP0]; 00516 case KC_DECIMAL: /* . on numeric keypad */ 00517 return mKeyboardBuffer[SDLK_KP_PERIOD]; 00518 case KC_OEM_102: /* < > | on UK/Germany keyboards */ 00519 break; 00520 case KC_F11: 00521 return mKeyboardBuffer[SDLK_F11]; 00522 case KC_F12: 00523 return mKeyboardBuffer[SDLK_F12]; 00524 case KC_F13: /* (NEC PC98) */ 00525 return mKeyboardBuffer[SDLK_F13]; 00526 case KC_F14: /* (NEC PC98) */ 00527 return mKeyboardBuffer[SDLK_F14]; 00528 case KC_F15: /* (NEC PC98) */ 00529 return mKeyboardBuffer[SDLK_F15]; 00530 case KC_KANA: /* (Japanese keyboard) */ 00531 case KC_ABNT_C1: /* / ? on Portugese (Brazilian) keyboards */ 00532 case KC_CONVERT: /* (Japanese keyboard) */ 00533 case KC_NOCONVERT: /* (Japanese keyboard) */ 00534 case KC_YEN: /* (Japanese keyboard) */ 00535 case KC_ABNT_C2: /* Numpad . on Portugese (Brazilian) keyboards */ 00536 break; 00537 case KC_NUMPADEQUALS: /* = on numeric keypad (NEC PC98) */ 00538 return mKeyboardBuffer[SDLK_KP_EQUALS]; 00539 case KC_PREVTRACK: /* Previous Track (KC_CIRCUMFLEX on Japanese keyboard) */ 00540 case KC_AT: /* (NEC PC98) */ 00541 case KC_COLON: /* (NEC PC98) */ 00542 return mKeyboardBuffer[SDLK_COLON]; 00543 case KC_UNDERLINE: /* (NEC PC98) */ 00544 case KC_KANJI: /* (Japanese keyboard) */ 00545 case KC_STOP: /* (NEC PC98) */ 00546 case KC_AX: /* (Japan AX) */ 00547 case KC_UNLABELED: /* (J3100) */ 00548 case KC_NEXTTRACK: /* Next Track */ 00549 case KC_NUMPADENTER: /* Enter on numeric keypad */ 00550 case KC_RCONTROL: 00551 case KC_MUTE: /* Mute */ 00552 case KC_CALCULATOR: /* Calculator */ 00553 case KC_PLAYPAUSE: /* Play / Pause */ 00554 case KC_MEDIASTOP: /* Media Stop */ 00555 case KC_VOLUMEDOWN: /* Volume - */ 00556 case KC_VOLUMEUP: /* Volume + */ 00557 case KC_WEBHOME: /* Web home */ 00558 case KC_NUMPADCOMMA: /* , on numeric keypad (NEC PC98) */ 00559 break; 00560 case KC_DIVIDE: /* / on numeric keypad */ 00561 return mKeyboardBuffer[SDLK_KP_DIVIDE]; 00562 case KC_SYSRQ: 00563 return mKeyboardBuffer[SDLK_SYSREQ] | mKeyboardBuffer[SDLK_PRINT]; 00564 case KC_RMENU: /* right Alt */ 00565 return mKeyboardBuffer[SDLK_RALT]; 00566 case KC_PAUSE: /* Pause */ 00567 break; 00568 case KC_HOME: /* Home on arrow keypad */ 00569 return mKeyboardBuffer[SDLK_HOME]; 00570 case KC_UP: /* UpArrow on arrow keypad */ 00571 return mKeyboardBuffer[SDLK_UP]; 00572 case KC_PGUP: /* PgUp on arrow keypad */ 00573 return mKeyboardBuffer[SDLK_PAGEUP]; 00574 case KC_LEFT: /* LeftArrow on arrow keypad */ 00575 return mKeyboardBuffer[SDLK_LEFT]; 00576 case KC_RIGHT: /* RightArrow on arrow keypad */ 00577 return mKeyboardBuffer[SDLK_RIGHT]; 00578 case KC_END: /* End on arrow keypad */ 00579 return mKeyboardBuffer[SDLK_END]; 00580 case KC_DOWN: /* DownArrow on arrow keypad */ 00581 return mKeyboardBuffer[SDLK_DOWN]; 00582 case KC_PGDOWN: /* PgDn on arrow keypad */ 00583 return mKeyboardBuffer[SDLK_PAGEDOWN]; 00584 case KC_INSERT: /* Insert on arrow keypad */ 00585 return mKeyboardBuffer[SDLK_INSERT]; 00586 case KC_DELETE: /* Delete on arrow keypad */ 00587 return mKeyboardBuffer[SDLK_DELETE]; 00588 case KC_LWIN: /* Left Windows key */ 00589 return mKeyboardBuffer[SDLK_LSUPER]; 00590 case KC_RWIN: /* Right Windows key */ 00591 return mKeyboardBuffer[SDLK_RSUPER]; 00592 case KC_APPS: /* AppMenu key */ 00593 case KC_POWER: /* System Power */ 00594 case KC_SLEEP: /* System Sleep */ 00595 case KC_WAKE: /* System Wake */ 00596 case KC_WEBSEARCH: /* Web Search */ 00597 case KC_WEBFAVORITES: /* Web Favorites */ 00598 case KC_WEBREFRESH: /* Web Refresh */ 00599 case KC_WEBSTOP: /* Web Stop */ 00600 case KC_WEBFORWARD: /* Web Forward */ 00601 case KC_WEBBACK: /* Web Back */ 00602 case KC_MYCOMPUTER: /* My Computer */ 00603 case KC_MAIL: /* Mail */ 00604 case KC_MEDIASELECT: /* Media Select */ 00605 break; 00606 default: 00607 break; 00608 }; 00609 00610 return 0; 00611 } 00612 00613 long SDLInput::getMouseRelX() const 00614 { 00615 return mMouseState.Xrel; 00616 } 00617 00618 long SDLInput::getMouseRelY() const 00619 { 00620 return mMouseState.Yrel; 00621 } 00622 00623 long SDLInput::getMouseRelZ() const 00624 { 00625 return mMouseState.Zrel; 00626 } 00627 00628 long SDLInput::getMouseAbsX() const 00629 { 00630 return mMouseX; 00631 } 00632 00633 long SDLInput::getMouseAbsY() const 00634 { 00635 return mMouseY; 00636 } 00637 00638 long SDLInput::getMouseAbsZ() const 00639 { 00640 return 0; 00641 } 00642 00643 bool SDLInput::getMouseButton( uchar button ) const 00644 { 00645 return mMouseState.isButtonDown( button ); 00646 } 00647 00648 void SDLInput::processBufferedKeyboard() 00649 { 00650 // XXX Arbitrarily picked 16 00651 SDL_Event events[16]; 00652 00653 int count = SDL_PeepEvents(events, 16, SDL_GETEVENT, 00654 (SDL_KEYDOWNMASK | SDL_KEYUPMASK)); 00655 if (!count) 00656 { 00657 return; 00658 } 00659 00660 for (int i = 0; i < count; i++) 00661 { 00662 bool down = false; 00663 if (events[i].type == SDL_KEYDOWN) 00664 down = true; 00665 keyChanged(_key_map[events[i].key.keysym.sym], down); 00666 } 00667 } 00668 00669 void SDLInput::processBufferedMouse() 00670 { 00671 // XXX Arbitrarily picked 16 00672 SDL_Event events[16]; 00673 00674 int count = SDL_PeepEvents(events, 16, SDL_GETEVENT, 00675 (SDL_MOUSEMOTIONMASK | SDL_MOUSEBUTTONDOWNMASK | 00676 SDL_MOUSEBUTTONUPMASK | SDL_ACTIVEEVENTMASK)); 00677 if (!count) 00678 { 00679 return; 00680 } 00681 00682 bool Xset, Yset, Zset; 00683 Xset = Yset = Zset = false; 00684 for (int i = 0; i < count; i++) 00685 { 00686 int button_mask = -1; 00687 bool button_down = false; 00688 switch (events[i].type) 00689 { 00690 case SDL_ACTIVEEVENT: 00691 _visible = events[i].active.gain ? true : false; 00692 break; 00693 case SDL_MOUSEMOTION: 00694 if (events[i].motion.xrel) 00695 { 00696 if (Xset) 00697 { 00698 mouseMoved(); 00699 } 00700 mCursor->addToX(events[i].motion.xrel * mScale); 00701 Xset = true; 00702 } 00703 if (events[i].motion.yrel) 00704 { 00705 if (Yset) 00706 { 00707 mouseMoved(); 00708 } 00709 mCursor->addToY(events[i].motion.yrel * mScale); 00710 Yset = true; 00711 } 00712 break; 00713 case SDL_MOUSEBUTTONDOWN: 00714 button_down = true; 00715 case SDL_MOUSEBUTTONUP: 00716 // grab the mouse if the user presses a mouse button 00717 if ( !mMouseGrabbed && mGrabMouse && ( mGrabMode == GRAB_MOUSE_CLICK ) ) 00718 { 00719 _grabMouse(); 00720 } 00721 switch(events[i].button.button) 00722 { 00723 case SDL_BUTTON_LEFT: 00724 button_mask = InputEvent::BUTTON0_MASK; 00725 break; 00726 case SDL_BUTTON_RIGHT: 00727 button_mask = InputEvent::BUTTON1_MASK; 00728 break; 00729 case SDL_BUTTON_MIDDLE: 00730 button_mask = InputEvent::BUTTON2_MASK; 00731 break; 00732 }; 00733 triggerMouseButton(button_mask, button_down); 00734 break; 00735 }; 00736 00737 if (Xset && Yset) 00738 { 00739 mouseMoved(); 00740 Xset = Yset = false; 00741 } 00742 } 00743 00744 if (Xset || Yset) 00745 { 00746 mouseMoved(); 00747 } 00748 00749 } 00750 00751 void SDLInput::getMouseState( MouseState& state ) const 00752 { 00753 memcpy( &state, &mMouseState, sizeof( MouseState ) ); 00754 } 00755 00756 }
Copyright © 2002-2003 by The OGRE Team
Last modified Sun Nov 28 19:48:46 2004