sdlInput.cpp

Public Functions

buildScanCodeArray()

ConsoleFunction(getJoystickAxes , const char * , 2 , 2 , "getJoystickAxes( instance )" )

ConsoleFunction(isJoystickDetected , bool , 1 , 1 , "isJoystickDetected()" )

fillAsciiTable()

mapScanCode(U32 sdl, U32 torque)

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2012 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#include "platform/platformInput.h"
 25#include "console/console.h"
 26#include "core/util/journal/process.h"
 27#include "windowManager/platformWindowMgr.h"
 28
 29#include "sdlInput.h"
 30#include "platform/platformInput.h"
 31#include "SDL.h"
 32
 33#ifdef LOG_INPUT
 34#include <time.h>
 35#include <stdarg.h>
 36#endif
 37
 38// Static class variables:
 39InputManager*  Input::smManager;
 40bool           Input::smActive;
 41U8             Input::smModifierKeys;
 42bool           Input::smLastKeyboardActivated;
 43bool           Input::smLastMouseActivated;
 44bool           Input::smLastJoystickActivated;
 45InputEvent     Input::smInputEvent;
 46
 47#ifdef LOG_INPUT
 48static HANDLE gInputLog;
 49#endif
 50
 51static void fillAsciiTable() {}
 52
 53//------------------------------------------------------------------------------
 54//
 55// This function gets the standard ASCII code corresponding to our key code
 56// and the existing modifier key state.
 57//
 58//------------------------------------------------------------------------------
 59struct AsciiData
 60{
 61   struct KeyData
 62   {
 63      U16   ascii;
 64      bool  isDeadChar;
 65   };
 66
 67   KeyData upper;
 68   KeyData lower;
 69   KeyData goofy;
 70};
 71
 72
 73#define NUM_KEYS ( KEY_OEM_102 + 1 )
 74#define KEY_FIRST KEY_ESCAPE
 75
 76//------------------------------------------------------------------------------
 77void Input::init()
 78{
 79   Con::printf( "Input Init:" );
 80
 81   destroy();
 82
 83   smActive = false;
 84   smLastKeyboardActivated = true;
 85   smLastMouseActivated = true;
 86   smLastJoystickActivated = true;
 87
 88   SDL_InitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER | SDL_INIT_EVENTS );
 89
 90   // Init the current modifier keys
 91   setModifierKeys(0);
 92   fillAsciiTable();
 93   Con::printf( "" );
 94
 95   // Set ourselves to participate in per-frame processing.
 96   Process::notify(Input::process, PROCESS_INPUT_ORDER);
 97
 98}
 99
100//------------------------------------------------------------------------------
101ConsoleFunction( isJoystickDetected, bool, 1, 1, "isJoystickDetected()" )
102{
103   return( SDL_NumJoysticks() > 0 );
104}
105
106//------------------------------------------------------------------------------
107ConsoleFunction( getJoystickAxes, const char*, 2, 2, "getJoystickAxes( instance )" )
108{
109   // TODO SDL
110   return( "" );
111}
112
113//------------------------------------------------------------------------------
114U16 Input::getKeyCode( U16 asciiCode )
115{
116    if( asciiCode > 255 )
117        return 0;
118
119    char c[2];
120    c[0]= asciiCode;
121    c[1] = NULL;
122    return KeyMapSDL::getTorqueScanCodeFromSDL( SDL_GetScancodeFromName( c ) );
123}
124
125//------------------------------------------------------------------------------
126U16 Input::getAscii( U16 keyCode, KEY_STATE keyState )
127{
128   if ( keyCode >= NUM_KEYS )
129      return 0;
130
131   U32 SDLKey = KeyMapSDL::getSDLScanCodeFromTorque( keyCode );
132   SDLKey = SDL_GetKeyFromScancode( (SDL_Scancode)SDLKey );
133
134   const char *text = SDL_GetKeyName( SDLKey );
135   if(text[1] != 0)
136      return 0;
137   U8 ret = text[0];
138
139   if( !dIsalpha(ret) )
140      return ret;
141
142   switch ( keyState )
143   {
144      case STATE_LOWER:
145         return dTolower( ret );
146      case STATE_UPPER:
147         return dToupper( ret );
148      case STATE_GOOFY:
149         return 0; // TODO SDL
150      default:
151         return(0);
152
153   }
154}
155
156//------------------------------------------------------------------------------
157void Input::destroy()
158{
159   Process::remove(Input::process);
160
161   SDL_QuitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER );
162
163}
164
165//------------------------------------------------------------------------------
166bool Input::enable()
167{
168   if ( smManager && !smManager->isEnabled() )
169      return( smManager->enable() );
170
171   return( false );
172}
173
174//------------------------------------------------------------------------------
175void Input::disable()
176{
177   if ( smManager && smManager->isEnabled() )
178      smManager->disable();
179}
180
181//------------------------------------------------------------------------------
182
183void Input::activate()
184{
185#ifdef UNICODE
186   //winState.imeHandle = ImmGetContext( getWin32WindowHandle() );
187   //ImmReleaseContext( getWin32WindowHandle(), winState.imeHandle );
188#endif
189
190   if ( !Con::getBoolVariable( "$enableDirectInput" ) )
191      return;
192
193   if ( smManager && smManager->isEnabled() && !smActive )
194   {
195      Con::printf( "Activating Input..." );
196      smActive = true;
197   }
198}
199
200//------------------------------------------------------------------------------
201void Input::deactivate()
202{
203   if ( smManager && smManager->isEnabled() && smActive )
204   {
205      smActive = false;
206      Con::printf( "Input deactivated." );
207   }
208}
209
210//------------------------------------------------------------------------------
211bool Input::isEnabled()
212{
213   if ( smManager )
214      return smManager->isEnabled();
215   return false;
216}
217
218//------------------------------------------------------------------------------
219bool Input::isActive()
220{
221   return smActive;
222}
223
224//------------------------------------------------------------------------------
225void Input::process()
226{
227   if ( smManager && smManager->isEnabled() && smActive )
228      smManager->process();
229}
230
231//------------------------------------------------------------------------------
232InputManager* Input::getManager()
233{
234   return( smManager );
235}
236
237//-----------------------------------------------------------------------------
238// Clipboard functions
239const char* Platform::getClipboard()
240{
241   //note - this function never returns NULL
242   return SDL_HasClipboardText() ? SDL_GetClipboardText() : "";
243}
244
245//-----------------------------------------------------------------------------
246bool Platform::setClipboard(const char *text)
247{
248   if (!text)
249      return false;
250
251   SDL_SetClipboardText(text);
252
253   return true;
254}
255
256
257namespace
258{
259   const int TableSize = 256;
260   U32 SDL_T3D[256];
261   U32 T3D_SDL[256];
262   static bool _buildScanCode = true;
263}
264
265void mapScanCode(U32 sdl, U32 torque)
266{
267   SDL_T3D[sdl] = torque;
268   T3D_SDL[torque] = sdl;
269}
270
271
272
273void buildScanCodeArray()
274{
275   _buildScanCode = false;
276
277   for(int i = 0; i < TableSize; ++i)
278   {
279      SDL_T3D[i] = 0;
280      T3D_SDL[i] = 0;
281   }
282
283   // SDL, Torque
284   mapScanCode(SDL_SCANCODE_A, KEY_A);
285   mapScanCode(SDL_SCANCODE_B, KEY_B);
286   mapScanCode(SDL_SCANCODE_C, KEY_C);
287   mapScanCode(SDL_SCANCODE_D, KEY_D);
288   mapScanCode(SDL_SCANCODE_E, KEY_E);
289   mapScanCode(SDL_SCANCODE_F, KEY_F);
290   mapScanCode(SDL_SCANCODE_G, KEY_G);
291   mapScanCode(SDL_SCANCODE_H, KEY_H);
292   mapScanCode(SDL_SCANCODE_I, KEY_I);
293   mapScanCode(SDL_SCANCODE_J, KEY_J);
294   mapScanCode(SDL_SCANCODE_K, KEY_K);
295   mapScanCode(SDL_SCANCODE_L, KEY_L);
296   mapScanCode(SDL_SCANCODE_M, KEY_M);
297   mapScanCode(SDL_SCANCODE_N, KEY_N);
298   mapScanCode(SDL_SCANCODE_O, KEY_O);
299   mapScanCode(SDL_SCANCODE_P, KEY_P);
300   mapScanCode(SDL_SCANCODE_Q, KEY_Q);
301   mapScanCode(SDL_SCANCODE_R, KEY_R);
302   mapScanCode(SDL_SCANCODE_S, KEY_S);
303   mapScanCode(SDL_SCANCODE_T, KEY_T);
304   mapScanCode(SDL_SCANCODE_U, KEY_U);
305   mapScanCode(SDL_SCANCODE_V, KEY_V);
306   mapScanCode(SDL_SCANCODE_W, KEY_W);
307   mapScanCode(SDL_SCANCODE_X, KEY_X);
308   mapScanCode(SDL_SCANCODE_Y, KEY_Y);
309   mapScanCode(SDL_SCANCODE_Z, KEY_Z);
310
311   mapScanCode(SDL_SCANCODE_1, KEY_1);
312   mapScanCode(SDL_SCANCODE_2, KEY_2);
313   mapScanCode(SDL_SCANCODE_3, KEY_3);
314   mapScanCode(SDL_SCANCODE_4, KEY_4);
315   mapScanCode(SDL_SCANCODE_5, KEY_5);
316   mapScanCode(SDL_SCANCODE_6, KEY_6);
317   mapScanCode(SDL_SCANCODE_7, KEY_7);
318   mapScanCode(SDL_SCANCODE_8, KEY_8);
319   mapScanCode(SDL_SCANCODE_9, KEY_9);
320   mapScanCode(SDL_SCANCODE_0, KEY_0);
321
322   mapScanCode(SDL_SCANCODE_BACKSPACE, KEY_BACKSPACE);
323   mapScanCode(SDL_SCANCODE_TAB, KEY_TAB);
324   mapScanCode(SDL_SCANCODE_RETURN, KEY_RETURN);
325   mapScanCode(SDL_SCANCODE_LCTRL, KEY_CONTROL);
326   mapScanCode(SDL_SCANCODE_RCTRL, KEY_CONTROL);
327   mapScanCode(SDL_SCANCODE_LALT, KEY_ALT);
328   mapScanCode(SDL_SCANCODE_RALT, KEY_ALT);
329   mapScanCode(SDL_SCANCODE_LSHIFT, KEY_SHIFT);
330   mapScanCode(SDL_SCANCODE_RSHIFT, KEY_SHIFT);
331   mapScanCode(SDL_SCANCODE_PAUSE, KEY_PAUSE);
332   mapScanCode(SDL_SCANCODE_CAPSLOCK, KEY_CAPSLOCK);
333   mapScanCode(SDL_SCANCODE_ESCAPE, KEY_ESCAPE);
334   mapScanCode(SDL_SCANCODE_SPACE, KEY_SPACE);
335   mapScanCode(SDL_SCANCODE_PAGEDOWN, KEY_PAGE_DOWN);
336   mapScanCode(SDL_SCANCODE_PAGEUP, KEY_PAGE_UP);
337   mapScanCode(SDL_SCANCODE_END, KEY_END);
338   mapScanCode(SDL_SCANCODE_HOME, KEY_HOME);
339   mapScanCode(SDL_SCANCODE_LEFT, KEY_LEFT);
340   mapScanCode(SDL_SCANCODE_UP, KEY_UP);
341   mapScanCode(SDL_SCANCODE_RIGHT, KEY_RIGHT);
342   mapScanCode(SDL_SCANCODE_DOWN, KEY_DOWN);
343   mapScanCode(SDL_SCANCODE_PRINTSCREEN, KEY_PRINT);
344   mapScanCode(SDL_SCANCODE_INSERT, KEY_INSERT);
345   mapScanCode(SDL_SCANCODE_DELETE, KEY_DELETE);
346   mapScanCode(SDL_SCANCODE_HELP, KEY_HELP);
347
348   mapScanCode(SDL_SCANCODE_GRAVE, KEY_TILDE);
349   mapScanCode(SDL_SCANCODE_MINUS, KEY_MINUS);
350   mapScanCode(SDL_SCANCODE_EQUALS, KEY_EQUALS);
351   mapScanCode(SDL_SCANCODE_LEFTBRACKET, KEY_LBRACKET);
352   mapScanCode(SDL_SCANCODE_RIGHTBRACKET, KEY_RBRACKET);
353   mapScanCode(SDL_SCANCODE_BACKSLASH, KEY_BACKSLASH);
354   mapScanCode(SDL_SCANCODE_SEMICOLON, KEY_SEMICOLON);
355   mapScanCode(SDL_SCANCODE_APOSTROPHE, KEY_APOSTROPHE);
356   mapScanCode(SDL_SCANCODE_COMMA, KEY_COMMA);
357   mapScanCode(SDL_SCANCODE_PERIOD, KEY_PERIOD);
358   mapScanCode(SDL_SCANCODE_SLASH, KEY_SLASH);
359   mapScanCode(SDL_SCANCODE_KP_0, KEY_NUMPAD0);
360   mapScanCode(SDL_SCANCODE_KP_1, KEY_NUMPAD1);
361   mapScanCode(SDL_SCANCODE_KP_2, KEY_NUMPAD2);
362   mapScanCode(SDL_SCANCODE_KP_3, KEY_NUMPAD3);
363   mapScanCode(SDL_SCANCODE_KP_4, KEY_NUMPAD4);
364   mapScanCode(SDL_SCANCODE_KP_5, KEY_NUMPAD5);
365   mapScanCode(SDL_SCANCODE_KP_6, KEY_NUMPAD6);
366   mapScanCode(SDL_SCANCODE_KP_7, KEY_NUMPAD7);
367   mapScanCode(SDL_SCANCODE_KP_8, KEY_NUMPAD8);
368   mapScanCode(SDL_SCANCODE_KP_9, KEY_NUMPAD9);
369   mapScanCode(SDL_SCANCODE_KP_MULTIPLY, KEY_MULTIPLY);
370   mapScanCode(SDL_SCANCODE_KP_PLUS, KEY_ADD);
371   mapScanCode(SDL_SCANCODE_KP_EQUALS, KEY_SEPARATOR);
372   mapScanCode(SDL_SCANCODE_KP_MINUS, KEY_SUBTRACT);
373   mapScanCode(SDL_SCANCODE_KP_PERIOD, KEY_DECIMAL);
374   mapScanCode(SDL_SCANCODE_KP_DIVIDE, KEY_DIVIDE);
375   mapScanCode(SDL_SCANCODE_KP_ENTER, KEY_NUMPADENTER);
376
377   mapScanCode(SDL_SCANCODE_F1, KEY_F1);
378   mapScanCode(SDL_SCANCODE_F2, KEY_F2);
379   mapScanCode(SDL_SCANCODE_F3, KEY_F3);
380   mapScanCode(SDL_SCANCODE_F4, KEY_F4);
381   mapScanCode(SDL_SCANCODE_F5, KEY_F5);
382   mapScanCode(SDL_SCANCODE_F6, KEY_F6);
383   mapScanCode(SDL_SCANCODE_F7, KEY_F7);
384   mapScanCode(SDL_SCANCODE_F8, KEY_F8);
385   mapScanCode(SDL_SCANCODE_F9, KEY_F9);
386   mapScanCode(SDL_SCANCODE_F10, KEY_F10);
387   mapScanCode(SDL_SCANCODE_F11, KEY_F11);
388   mapScanCode(SDL_SCANCODE_F12, KEY_F12);
389   mapScanCode(SDL_SCANCODE_F13, KEY_F13);
390   mapScanCode(SDL_SCANCODE_F14, KEY_F14);
391   mapScanCode(SDL_SCANCODE_F15, KEY_F15);
392   mapScanCode(SDL_SCANCODE_F16, KEY_F16);
393   mapScanCode(SDL_SCANCODE_F17, KEY_F17);
394   mapScanCode(SDL_SCANCODE_F18, KEY_F18);
395   mapScanCode(SDL_SCANCODE_F19, KEY_F19);
396   mapScanCode(SDL_SCANCODE_F20, KEY_F20);
397   mapScanCode(SDL_SCANCODE_F21, KEY_F21);
398   mapScanCode(SDL_SCANCODE_F22, KEY_F22);
399   mapScanCode(SDL_SCANCODE_F23, KEY_F23);
400   mapScanCode(SDL_SCANCODE_F24, KEY_F24);
401
402   //mapScanCode(SDL_SCANCODE_LOCKINGNUMLOCK, KEY_NUMLOCK);
403   //mapScanCode(SDL_SCANCODE_LOCKINGSCROLLLOCK, KEY_SCROLLLOCK);
404   mapScanCode(SDL_SCANCODE_LCTRL, KEY_LCONTROL);
405   mapScanCode(SDL_SCANCODE_RCTRL, KEY_RCONTROL);
406   mapScanCode(SDL_SCANCODE_LALT, KEY_LALT);
407   mapScanCode(SDL_SCANCODE_RALT, KEY_RALT);
408   mapScanCode(SDL_SCANCODE_LSHIFT, KEY_LSHIFT);
409   mapScanCode(SDL_SCANCODE_RSHIFT, KEY_RSHIFT);
410   //mapScanCode(____, KEY_WIN_LWINDOW);
411   //mapScanCode(____, KEY_WIN_RWINDOW);
412   //mapScanCode(____, KEY_WIN_APPS);
413   //mapScanCode(____, KEY_OEM_102);
414
415   //mapScanCode(____, KEY_MAC_OPT);
416   //mapScanCode(____, KEY_MAC_LOPT);
417   //mapScanCode(____, KEY_MAC_ROPT);
418
419   //for(int i = 0; i < 48; ++i)
420   //   mapScanCode(____, KEY_BUTTON0 + i );
421
422   //mapScanCode(____, KEY_ANYKEY);   
423}
424
425U32 KeyMapSDL::getTorqueScanCodeFromSDL(U32 sdl)
426{
427   if(_buildScanCode)
428      buildScanCodeArray();
429
430   return SDL_T3D[sdl];
431}
432
433U32 KeyMapSDL::getSDLScanCodeFromTorque(U32 torque)
434{
435   if(_buildScanCode)
436      buildScanCodeArray();
437
438   return T3D_SDL[torque];
439}
440