q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-11-26 20:25:54 +01:00
Code Issues Packages Projects Releases Wiki Activity
1f1291d2bc
Serious-Engine/Sources/Engine/Base/SDL/SDLInput.cpp
ptitSeb 19bd3f733b Use SDL constants for mouse buttons
2016-04-07 10:45:45 +02:00

1037 lines
31 KiB
C++
Raw Blame History

/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
/* rcg10072001 Moved stuff into this file. */
#include "SDL.h"
#include <Engine/Base/Timer.h>
#include <Engine/Base/Input.h>
#include <Engine/Base/Translation.h>
#include <Engine/Base/KeyNames.h>
#include <Engine/Math/Functions.h>
#include <Engine/Graphics/ViewPort.h>
#include <Engine/Base/Console.h>
#include <Engine/Base/Synchronization.h>
#include <Engine/Base/SDL/SDLEvents.h>
#include <Engine/Base/Shell.h>
#include <Engine/Base/ErrorReporting.h>
extern INDEX inp_iKeyboardReadingMethod;
extern FLOAT inp_fMouseSensitivity;
extern INDEX inp_bAllowMouseAcceleration;
extern INDEX inp_bMousePrecision;
extern FLOAT inp_fMousePrecisionFactor;
extern FLOAT inp_fMousePrecisionThreshold;
extern FLOAT inp_fMousePrecisionTimeout;
extern FLOAT inp_bInvertMouse;
extern INDEX inp_bFilterMouse;
extern INDEX inp_bAllowPrescan;
extern INDEX inp_i2ndMousePort;
extern FLOAT inp_f2ndMouseSensitivity;
extern INDEX inp_b2ndMousePrecision;
extern FLOAT inp_f2ndMousePrecisionThreshold;
extern FLOAT inp_f2ndMousePrecisionTimeout;
extern FLOAT inp_f2ndMousePrecisionFactor;
extern INDEX inp_bFilter2ndMouse;
extern INDEX inp_bInvert2ndMouse;
static BOOL inp_bSDLPermitCtrlG = TRUE;
static BOOL inp_bSDLGrabInput = TRUE;
static Sint16 mouse_relative_x = 0;
static Sint16 mouse_relative_y = 0;
static Sint16 mouse_previous_x = 0;
static Sint16 mouse_previous_y = 0;
INDEX inp_iMButton4Dn = 0x20040;
INDEX inp_iMButton4Up = 0x20000;
INDEX inp_iMButton5Dn = 0x10020;
INDEX inp_iMButton5Up = 0x10000;
INDEX inp_bMsgDebugger = FALSE;
INDEX inp_bForceJoystickPolling = 0;
INDEX inp_bAutoDisableJoysticks = 0;
extern INDEX inp_ctJoysticksAllowed;
/*
NOTE: Two different types of key codes are used here:
1) kid - engine internal type - defined in KeyNames.h
2) virtkey - virtual key codes used by SDL.
*/
// name that is not translated (international)
#define INTNAME(str) str, ""
// name that is translated
#define TRANAME(str) str, "ETRS" str
// basic key conversion table
static struct KeyConversion {
INDEX kc_iKID;
INDEX kc_iVirtKey;
const char *kc_strName;
const char *kc_strNameTrans;
} _akcKeys[] = {
// reserved for 'no-key-pressed'
{ KID_NONE, -1, TRANAME("None")},
// numbers row
{ KID_1 , SDLK_1, INTNAME("1")},
{ KID_2 , SDLK_2, INTNAME("2")},
{ KID_3 , SDLK_3, INTNAME("3")},
{ KID_4 , SDLK_4, INTNAME("4")},
{ KID_5 , SDLK_5, INTNAME("5")},
{ KID_6 , SDLK_6, INTNAME("6")},
{ KID_7 , SDLK_7, INTNAME("7")},
{ KID_8 , SDLK_8, INTNAME("8")},
{ KID_9 , SDLK_9, INTNAME("9")},
{ KID_0 , SDLK_0, INTNAME("0")},
{ KID_MINUS , SDLK_MINUS, INTNAME("-")},
{ KID_EQUALS , SDLK_EQUALS, INTNAME("=")},
// 1st alpha row
{ KID_Q , SDLK_q, INTNAME("Q")},
{ KID_W , SDLK_w, INTNAME("W")},
{ KID_E , SDLK_e, INTNAME("E")},
{ KID_R , SDLK_r, INTNAME("R")},
{ KID_T , SDLK_t, INTNAME("T")},
{ KID_Y , SDLK_y, INTNAME("Y")},
{ KID_U , SDLK_u, INTNAME("U")},
{ KID_I , SDLK_i, INTNAME("I")},
{ KID_O , SDLK_o, INTNAME("O")},
{ KID_P , SDLK_p, INTNAME("P")},
{ KID_LBRACKET , SDLK_RIGHTPAREN, INTNAME("[")},
{ KID_RBRACKET , SDLK_RIGHTPAREN, INTNAME("]")},
{ KID_BACKSLASH , SDLK_BACKSLASH, INTNAME("\\")},
// 2nd alpha row
{ KID_A , SDLK_a, INTNAME("A")},
{ KID_S , SDLK_s, INTNAME("S")},
{ KID_D , SDLK_d, INTNAME("D")},
{ KID_F , SDLK_f, INTNAME("F")},
{ KID_G , SDLK_g, INTNAME("G")},
{ KID_H , SDLK_h, INTNAME("H")},
{ KID_J , SDLK_j, INTNAME("J")},
{ KID_K , SDLK_k, INTNAME("K")},
{ KID_L , SDLK_l, INTNAME("L")},
{ KID_SEMICOLON , SDLK_SEMICOLON, INTNAME(";")},
{ KID_APOSTROPHE , SDLK_QUOTE, INTNAME("'")},
// 3rd alpha row
{ KID_Z , SDLK_z, INTNAME("Z")},
{ KID_X , SDLK_x, INTNAME("X")},
{ KID_C , SDLK_c, INTNAME("C")},
{ KID_V , SDLK_v, INTNAME("V")},
{ KID_B , SDLK_b, INTNAME("B")},
{ KID_N , SDLK_n, INTNAME("N")},
{ KID_M , SDLK_m, INTNAME("M")},
{ KID_COMMA , SDLK_COMMA, INTNAME(",")},
{ KID_PERIOD , SDLK_PERIOD, INTNAME(".")},
{ KID_SLASH , SDLK_SLASH, INTNAME("/")},
// row with F-keys
{ KID_F1 , SDLK_F1, INTNAME("F1")},
{ KID_F2 , SDLK_F2, INTNAME("F2")},
{ KID_F3 , SDLK_F3, INTNAME("F3")},
{ KID_F4 , SDLK_F4, INTNAME("F4")},
{ KID_F5 , SDLK_F5, INTNAME("F5")},
{ KID_F6 , SDLK_F6, INTNAME("F6")},
{ KID_F7 , SDLK_F7, INTNAME("F7")},
{ KID_F8 , SDLK_F8, INTNAME("F8")},
{ KID_F9 , SDLK_F9, INTNAME("F9")},
{ KID_F10 , SDLK_F10, INTNAME("F10")},
{ KID_F11 , SDLK_F11, INTNAME("F11")},
{ KID_F12 , SDLK_F12, INTNAME("F12")},
// extra keys
{ KID_ESCAPE , SDLK_ESCAPE, TRANAME("Escape")},
{ KID_TILDE , -1, TRANAME("Tilde")},
{ KID_BACKSPACE , SDLK_BACKSPACE, TRANAME("Backspace")},
{ KID_TAB , SDLK_TAB, TRANAME("Tab")},
{ KID_CAPSLOCK , SDLK_CAPSLOCK, TRANAME("Caps Lock")},
{ KID_ENTER , SDLK_RETURN, TRANAME("Enter")},
{ KID_SPACE , SDLK_SPACE, TRANAME("Space")},
// modifier keys
{ KID_LSHIFT , SDLK_LSHIFT , TRANAME("Left Shift")},
{ KID_RSHIFT , SDLK_RSHIFT , TRANAME("Right Shift")},
{ KID_LCONTROL , SDLK_LCTRL, TRANAME("Left Control")},
{ KID_RCONTROL , SDLK_RCTRL, TRANAME("Right Control")},
{ KID_LALT , SDLK_LALT , TRANAME("Left Alt")},
{ KID_RALT , SDLK_RALT , TRANAME("Right Alt")},
// navigation keys
{ KID_ARROWUP , SDLK_UP, TRANAME("Arrow Up")},
{ KID_ARROWDOWN , SDLK_DOWN, TRANAME("Arrow Down")},
{ KID_ARROWLEFT , SDLK_LEFT, TRANAME("Arrow Left")},
{ KID_ARROWRIGHT , SDLK_RIGHT, TRANAME("Arrow Right")},
{ KID_INSERT , SDLK_INSERT, TRANAME("Insert")},
{ KID_DELETE , SDLK_DELETE, TRANAME("Delete")},
{ KID_HOME , SDLK_HOME, TRANAME("Home")},
{ KID_END , SDLK_END, TRANAME("End")},
{ KID_PAGEUP , SDLK_PAGEUP, TRANAME("Page Up")},
{ KID_PAGEDOWN , SDLK_PAGEDOWN, TRANAME("Page Down")},
{ KID_PRINTSCR , SDLK_PRINT, TRANAME("Print Screen")},
{ KID_SCROLLLOCK , SDLK_SCROLLOCK, TRANAME("Scroll Lock")},
{ KID_PAUSE , SDLK_PAUSE, TRANAME("Pause")},
// numpad numbers
{ KID_NUM0 , SDLK_KP0, INTNAME("Num 0")},
{ KID_NUM1 , SDLK_KP1, INTNAME("Num 1")},
{ KID_NUM2 , SDLK_KP2, INTNAME("Num 2")},
{ KID_NUM3 , SDLK_KP3, INTNAME("Num 3")},
{ KID_NUM4 , SDLK_KP4, INTNAME("Num 4")},
{ KID_NUM5 , SDLK_KP5, INTNAME("Num 5")},
{ KID_NUM6 , SDLK_KP6, INTNAME("Num 6")},
{ KID_NUM7 , SDLK_KP7, INTNAME("Num 7")},
{ KID_NUM8 , SDLK_KP8, INTNAME("Num 8")},
{ KID_NUM9 , SDLK_KP9, INTNAME("Num 9")},
{ KID_NUMDECIMAL , SDLK_KP_PERIOD, INTNAME("Num .")},
// numpad gray keys
{ KID_NUMLOCK , SDLK_NUMLOCK, INTNAME("Num Lock")},
{ KID_NUMSLASH , SDLK_KP_DIVIDE, INTNAME("Num /")},
{ KID_NUMMULTIPLY , SDLK_KP_MULTIPLY, INTNAME("Num *")},
{ KID_NUMMINUS , SDLK_KP_MINUS, INTNAME("Num -")},
{ KID_NUMPLUS , SDLK_KP_PLUS, INTNAME("Num +")},
{ KID_NUMENTER , SDLK_KP_ENTER, TRANAME("Num Enter")},
// mouse buttons
{ KID_MOUSE1 , -1, TRANAME("Mouse Button 1")},
{ KID_MOUSE2 , -1, TRANAME("Mouse Button 2")},
{ KID_MOUSE3 , -1, TRANAME("Mouse Button 3")},
{ KID_MOUSE4 , -1, TRANAME("Mouse Button 4")},
{ KID_MOUSE5 , -1, TRANAME("Mouse Button 5")},
{ KID_MOUSEWHEELUP , -1, TRANAME("Mouse Wheel Up")},
{ KID_MOUSEWHEELDOWN , -1, TRANAME("Mouse Wheel Down")},
// 2nd mouse buttons
{ KID_2MOUSE1 , -1, TRANAME("2nd Mouse Button 1")},
{ KID_2MOUSE2 , -1, TRANAME("2nd Mouse Button 2")},
{ KID_2MOUSE3 , -1, TRANAME("2nd Mouse Button 3")},
};
// autogenerated fast conversion tables
static INDEX _aiVirtToKid[SDLK_LAST];
// make fast conversion tables from the general table
static void MakeConversionTables(void)
{
// clear conversion tables
// memset(_aiScanToKid, -1, sizeof(_aiScanToKid));
memset(_aiVirtToKid, -1, sizeof(_aiVirtToKid));
// for each Key
for (INDEX iKey=0; iKey<ARRAYCOUNT(_akcKeys); iKey++) {
struct KeyConversion &kc = _akcKeys[iKey];
// get codes
INDEX iKID = kc.kc_iKID;
//INDEX iScan = kc.kc_iScanCode;
INDEX iVirt = kc.kc_iVirtKey;
if (iVirt>=0) {
_aiVirtToKid[iVirt] = iKID;
}
}
}
// variables for message interception
//static HHOOK _hGetMsgHook = NULL;
//static HHOOK _hSendMsgHook = NULL;
static int _iMouseZ = 0;
static BOOL _bWheelUp = FALSE;
static BOOL _bWheelDn = FALSE;
CTCriticalSection csInput;
// which keys are pressed, as recorded by message interception (by KIDs)
static UBYTE _abKeysPressed[256];
// set a key according to a keydown/keyup message
static void SetKeyFromEvent(const SDL_Event *event, BOOL bDown)
{
assert((event->type == SDL_KEYUP) || (event->type == SDL_KEYDOWN));
if ( (event->key.keysym.mod & KMOD_CTRL) &&
(event->key.keysym.sym == SDLK_g) &&
(event->type == SDL_KEYDOWN) &&
(inp_bSDLPermitCtrlG) )
{
if (inp_bSDLGrabInput)
{
//assert(SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON);
// turn off input grab.
SDL_ShowCursor(1);
SDL_WM_GrabInput(SDL_GRAB_OFF);
inp_bSDLGrabInput = FALSE;
mouse_previous_x = mouse_previous_y = 0;
} // if
else
{
//assert(SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF);
// turn on input grab.
SDL_ShowCursor(0);
SDL_WM_GrabInput(SDL_GRAB_ON);
inp_bSDLGrabInput = TRUE;
int x, y;
SDL_GetMouseState(&x, &y);
mouse_previous_x = x;
mouse_previous_y = y;
} // else
mouse_relative_x = mouse_relative_y = 0;
return;
} // if
INDEX iKID = -1;
SDLKey iVirt = event->key.keysym.sym;
// convert virtualkey to kid
iKID = _aiVirtToKid[iVirt];
if (iKID>=0 && iKID<ARRAYCOUNT(_abKeysPressed)) {
// CPrintF("%s: %d\n", _pInput->inp_strButtonNames[iKID], bDown);
_abKeysPressed[iKID] = bDown;
}
}
static void sdl_event_handler(const SDL_Event *event)
{
switch (event->type)
{
case SDL_MOUSEMOTION:
#if 1
mouse_relative_x += event->motion.xrel;
mouse_relative_y += event->motion.yrel;
#else
if (inp_bSDLGrabInput)
{
mouse_relative_x += event->motion.xrel;
mouse_relative_y += event->motion.yrel;
} // if
else
{
mouse_relative_x += (event->motion.x - mouse_previous_x);
mouse_relative_y += (event->motion.y - mouse_previous_y);
mouse_previous_x = event->motion.x;
mouse_previous_y = event->motion.y;
} // else
#endif
break;
case SDL_MOUSEBUTTONDOWN:
switch (event->button.button)
{
case SDL_BUTTON_LEFT:
_abKeysPressed[KID_MOUSE1] = TRUE;
break;
case SDL_BUTTON_RIGHT:
_abKeysPressed[KID_MOUSE2] = TRUE;
break;
case SDL_BUTTON_MIDDLE:
_abKeysPressed[KID_MOUSE3] = TRUE;
break;
// !!! FIXME: mousewheel number should be set by a cvar.
case 4:
_abKeysPressed[KID_MOUSEWHEELUP] = TRUE;
break;
case 5:
_abKeysPressed[KID_MOUSEWHEELDOWN] = TRUE;
break;
} // switch
break;
case SDL_MOUSEBUTTONUP:
switch (event->button.button)
{
case SDL_BUTTON_LEFT:
_abKeysPressed[KID_MOUSE1] = FALSE;
break;
case SDL_BUTTON_RIGHT:
_abKeysPressed[KID_MOUSE2] = FALSE;
break;
case SDL_BUTTON_MIDDLE:
_abKeysPressed[KID_MOUSE3] = FALSE;
break;
// !!! FIXME: mousewheel number should be set by a cvar.
// ignore mousewheel button-up events, since they are sent
// at the same time as the button-down, and cancel each other
// out in this system.
} // switch
break;
case SDL_KEYDOWN:
SetKeyFromEvent(event, TRUE);
break;
case SDL_KEYUP:
SetKeyFromEvent(event, FALSE);
break;
} // switch
} // sdl_event_handler
// This keeps the input subsystem in sync with everything else, by
// making sure all SDL events tunnel through one function.
// DO NOT DIRECTLY MESS WITH THE SDL EVENT QUEUE THROUGH ANY OTHER FUNCTION.
// Parameters/retval are same as SDL_PollEvent().
int SE_SDL_InputEventPoll(SDL_Event *sdlevent)
{
ASSERT(sdlevent != NULL);
int retval = SDL_PollEvent(sdlevent);
if (retval)
sdl_event_handler(sdlevent);
return(retval);
} // SE_SDL_InputEventPoll
#if 0 // !!! FIXME: Can we support this?
// --------- 2ND MOUSE HANDLING
#define MOUSECOMBUFFERSIZE 256L
static HANDLE _h2ndMouse = NONE;
static BOOL _bIgnoreMouse2 = TRUE;
static INDEX _i2ndMouseX, _i2ndMouseY, _i2ndMouseButtons;
static INDEX _iByteNum = 0;
static UBYTE _aubComBytes[4] = {0,0,0,0};
static INDEX _iLastPort = -1;
static void Poll2ndMouse(void)
{
// reset (mouse reading is relative)
_i2ndMouseX = 0;
_i2ndMouseY = 0;
if( _h2ndMouse==NONE) return;
// check
COMSTAT csComStat;
DWORD dwErrorFlags;
ClearCommError( _h2ndMouse, &dwErrorFlags, &csComStat);
DWORD dwLength = Min( MOUSECOMBUFFERSIZE, (INDEX)csComStat.cbInQue);
if( dwLength<=0) return;
// readout
UBYTE aubMouseBuffer[MOUSECOMBUFFERSIZE];
INDEX iRetries = 999;
while( iRetries>0 && !ReadFile( _h2ndMouse, aubMouseBuffer, dwLength, &dwLength, NULL)) iRetries--;
if( iRetries<=0) return; // what, didn't make it?
// parse the mouse packets
for( INDEX i=0; i<dwLength; i++)
{
// prepare
if( aubMouseBuffer[i] & 64) _iByteNum = 0;
if( _iByteNum<4) _aubComBytes[_iByteNum] = aubMouseBuffer[i];
_iByteNum++;
// buttons ?
if( _iByteNum==1) {
_i2ndMouseButtons &= ~3;
_i2ndMouseButtons |= (_aubComBytes[0] & (32+16)) >>4;
}
// axes ?
else if( _iByteNum==3) {
char iDX = ((_aubComBytes[0] & 3) <<6) + _aubComBytes[1];
char iDY = ((_aubComBytes[0] & 12) <<4) + _aubComBytes[2];
_i2ndMouseX += iDX;
_i2ndMouseY += iDY;
}
// 3rd button?
else if( _iByteNum==4) {
_i2ndMouseButtons &= ~4;
if( aubMouseBuffer[i]&32) _i2ndMouseButtons |= 4;
}
}
// ignore pooling?
if( _bIgnoreMouse2) {
if( _i2ndMouseX!=0 || _i2ndMouseY!=0) _bIgnoreMouse2 = FALSE;
_i2ndMouseX = 0;
_i2ndMouseY = 0;
_i2ndMouseButtons = 0;
return;
}
}
static void Startup2ndMouse(INDEX iPort)
{
// skip if disabled
ASSERT( iPort>=0 && iPort<=4);
if( iPort==0) return;
// determine port string
CTString str2ndMousePort( 0, "COM%d", iPort);
// create COM handle if needed
if( _h2ndMouse==NONE) {
_h2ndMouse = CreateFile( str2ndMousePort, GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if( _h2ndMouse==INVALID_HANDLE_VALUE) {
// failed! :(
INDEX iError = GetLastError();
if( iError==5) CPrintF( "Cannot open %s (access denied).\n"
"The port is probably already used by another device (mouse, modem...)\n",
str2ndMousePort);
else CPrintF( "Cannot open %s (error %d).\n", str2ndMousePort, iError);
_h2ndMouse = NONE;
return;
}
}
// setup and purge buffers
SetupComm( _h2ndMouse, MOUSECOMBUFFERSIZE, MOUSECOMBUFFERSIZE);
PurgeComm( _h2ndMouse, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
// setup port to 1200 7N1
DCB dcb;
dcb.DCBlength = sizeof(DCB);
GetCommState( _h2ndMouse, &dcb);
dcb.BaudRate = CBR_1200;
dcb.ByteSize = 7;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.fBinary = TRUE;
dcb.fParity = TRUE;
SetCommState( _h2ndMouse, &dcb);
// reset
_iByteNum = 0;
_aubComBytes[0] = _aubComBytes[1] = _aubComBytes[2] = _aubComBytes[3] = 0;
_bIgnoreMouse2 = TRUE; // ignore mouse polling until 1 after non-0 readout
_iLastPort = iPort;
//CPrintF( "STARTUP M2!\n");
}
static void Shutdown2ndMouse(void)
{
// skip if already disabled
if( _h2ndMouse==NONE) return;
// disable!
SetCommMask( _h2ndMouse, 0);
EscapeCommFunction( _h2ndMouse, CLRDTR);
EscapeCommFunction( _h2ndMouse, CLRRTS);
PurgeComm( _h2ndMouse, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
// close port if changed
if( _iLastPort != inp_i2ndMousePort) {
CloseHandle( _h2ndMouse);
_h2ndMouse = NONE;
} // over and out
_bIgnoreMouse2 = TRUE;
}
#endif
static SDL_Joystick **sticks = NULL;
static int ctJoysticks = 0;
BOOL CInput::PlatformInit(void)
{
#if 0
_h2ndMouse = NONE;
#endif
assert(sticks == NULL);
assert(ctJoysticks == 0);
_pShell->DeclareSymbol("persistent user INDEX inp_bSDLPermitCtrlG;", (void*)&inp_bSDLPermitCtrlG);
_pShell->DeclareSymbol("persistent user INDEX inp_bSDLGrabInput;", (void*)&inp_bSDLGrabInput);
MakeConversionTables();
return(TRUE);
}
// destructor
CInput::~CInput()
{
if (sticks != NULL) {
int max = ctJoysticks;
for (int i = 0; i < max; i++) {
if (sticks[i] != NULL) {
SDL_JoystickClose(sticks[i]);
}
}
delete[] sticks;
sticks = NULL;
}
ctJoysticks = 0;
#if 0
if (_h2ndMouse != NONE)
CloseHandle(_h2ndMouse);
_h2ndMouse = NONE;
#endif
}
BOOL CInput::PlatformSetKeyNames(void)
{
// for each Key
for (INDEX iKey=0; iKey<ARRAYCOUNT(_akcKeys); iKey++) {
struct KeyConversion &kc = _akcKeys[iKey];
// set the name
if (kc.kc_strName!=NULL) {
inp_strButtonNames[kc.kc_iKID] = kc.kc_strName;
if (strlen(kc.kc_strNameTrans)==0) {
inp_strButtonNamesTra[kc.kc_iKID] = kc.kc_strName;
} else {
inp_strButtonNamesTra[kc.kc_iKID] = TranslateConst(kc.kc_strNameTrans, 4);
}
}
}
return(TRUE);
}
LONG CInput::PlatformGetJoystickCount(void)
{
if (SDL_Init(SDL_INIT_JOYSTICK) == -1)
{
CPrintF("SDL_Init(SDL_INIT_JOYSTICK) failed!\n reason: %s\n",
SDL_GetError());
return(0);
} // if
LONG retval = (LONG) SDL_NumJoysticks();
if (retval > 0) {
sticks = new SDL_Joystick *[retval];
ctJoysticks = (int) retval;
memset(sticks, '\0', sizeof (SDL_Joystick *) * retval);
}
return(retval);
}
// check if a joystick exists
BOOL CInput::CheckJoystick(INDEX iJoy)
{
CPrintF(TRANSV(" joy %d:"), iJoy + 1);
assert(ctJoysticks > iJoy);
CPrintF(" '%s'\n", SDL_JoystickName(iJoy));
SDL_Joystick *stick = SDL_JoystickOpen(iJoy);
if (stick == NULL) {
CPrintF(" ...can't open joystick.\n reason: %s\n", SDL_GetError());
return FALSE;
}
assert(sticks != NULL);
assert(sticks[iJoy] == NULL);
sticks[iJoy] = stick;
int ctAxes = SDL_JoystickNumAxes(stick);
CPrintF(TRANSV(" %d axes\n"), ctAxes);
CPrintF(TRANSV(" %d buttons\n"), SDL_JoystickNumButtons(stick));
if (SDL_JoystickNumHats(stick) > 0) {
CPrintF(TRANSV(" POV hat present\n"));
}
// for each axis
for(INDEX iAxis=0; iAxis<MAX_AXES_PER_JOYSTICK; iAxis++) {
ControlAxisInfo &cai= inp_caiAllAxisInfo[ FIRST_JOYAXIS+iJoy*MAX_AXES_PER_JOYSTICK+iAxis];
// remember min/max info
cai.cai_slMin = -32768; cai.cai_slMax = 32767;
cai.cai_bExisting = (iAxis < ctAxes);
}
return TRUE;
}
void CInput::EnableInput(HWND hwnd)
{
// skip if already enabled
if( inp_bInputEnabled) return;
SDL_Surface *screen = SDL_GetVideoSurface();
assert(screen != NULL);
SDL_JoystickEventState(SDL_ENABLE);
SDL_EnableKeyRepeat(0, 0);
// determine screen center position
inp_slScreenCenterX = screen->w / 2;
inp_slScreenCenterY = screen->h / 2;
// remember mouse pos
int mousex, mousey;
SDL_GetMouseState(&mousex, &mousey);
inp_ptOldMousePos.x = mousex;
inp_ptOldMousePos.y = mousey;
if (inp_bSDLGrabInput)
{
SDL_ShowCursor(0);
SDL_WM_GrabInput(SDL_GRAB_ON);
} // if
else
{
SDL_ShowCursor(1);
SDL_WM_GrabInput(SDL_GRAB_OFF);
} // else
// save system mouse settings
memset(&inp_mscMouseSettings, '\0', sizeof (MouseSpeedControl));
#if 0
// if required, try to enable 2nd mouse
Shutdown2ndMouse();
inp_i2ndMousePort = Clamp( inp_i2ndMousePort, 0L, 4L);
Startup2ndMouse(inp_i2ndMousePort);
#endif
// clear button's buffer
memset( _abKeysPressed, 0, sizeof( _abKeysPressed));
// remember current status
inp_bInputEnabled = TRUE;
inp_bPollJoysticks = FALSE;
}
/*
* Disable direct input
*/
void CInput::DisableInput( void)
{
// skip if allready disabled
if( !inp_bInputEnabled) return;
assert(SDL_GetVideoSurface() != NULL);
SDL_JoystickEventState(SDL_DISABLE);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// show mouse on screen
SDL_ShowCursor(1);
if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON)
SDL_WM_GrabInput(SDL_GRAB_OFF);
SDL_WarpMouse(inp_ptOldMousePos.x, inp_ptOldMousePos.y);
// eventually disable 2nd mouse
#if 0
Shutdown2ndMouse();
#endif
// remember current status
inp_bInputEnabled = FALSE;
inp_bPollJoysticks = FALSE;
}
// blank any queued mousemove events...SDLInput.cpp needs this when
// returning from the menus/console to game or the viewport will jump...
void CInput::ClearRelativeMouseMotion(void)
{
mouse_relative_x = mouse_relative_y = 0;
}
/*
* Scan states of all available input sources
*/
void CInput::GetInput(BOOL bPreScan)
{
// CTSingleLock sl(&csInput, TRUE);
if (!inp_bInputEnabled) {
return;
}
if (bPreScan && !inp_bAllowPrescan) {
return;
}
SDL_Event event;
while (SE_SDL_InputEventPoll(&event)) { /* do nothing... */ }
// if not pre-scanning
if (!bPreScan) {
// clear button's buffer
memset( inp_ubButtonsBuffer, 0, sizeof( inp_ubButtonsBuffer));
// for each Key
for (INDEX iKey=0; iKey<ARRAYCOUNT(_akcKeys); iKey++) {
struct KeyConversion &kc = _akcKeys[iKey];
// get codes
INDEX iKID = kc.kc_iKID;
//INDEX iScan = kc.kc_iScanCode;
//INDEX iVirt = kc.kc_iVirtKey;
// if snooped that key is pressed
if (_abKeysPressed[iKID]) {
// mark it as pressed
inp_ubButtonsBuffer[iKID] = 0xFF;
}
}
}
// reset this every frame (since we explicitly ignore the button-up events).
_abKeysPressed[KID_MOUSEWHEELUP] = FALSE;
_abKeysPressed[KID_MOUSEWHEELDOWN] = FALSE;
// read mouse position
if ((mouse_relative_x != 0) || (mouse_relative_y != 0)) {
FLOAT fDX = FLOAT( mouse_relative_x );
FLOAT fDY = FLOAT( mouse_relative_y );
mouse_relative_x = mouse_relative_y = 0;
FLOAT fSensitivity = inp_fMouseSensitivity;
if( inp_bAllowMouseAcceleration) fSensitivity *= 0.25f;
FLOAT fD = Sqrt(fDX*fDX+fDY*fDY);
if (inp_bMousePrecision) {
static FLOAT _tmTime = 0.0f;
if( fD<inp_fMousePrecisionThreshold) _tmTime += 0.05f;
else _tmTime = 0.0f;
if( _tmTime>inp_fMousePrecisionTimeout) fSensitivity /= inp_fMousePrecisionFactor;
}
static FLOAT fDXOld;
static FLOAT fDYOld;
static TIME tmOldDelta;
static CTimerValue tvBefore;
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
TIME tmNowDelta = (tvNow-tvBefore).GetSeconds();
if (tmNowDelta<0.001f) {
tmNowDelta = 0.001f;
}
tvBefore = tvNow;
FLOAT fDXSmooth = (fDXOld*tmOldDelta+fDX*tmNowDelta)/(tmOldDelta+tmNowDelta);
FLOAT fDYSmooth = (fDYOld*tmOldDelta+fDY*tmNowDelta)/(tmOldDelta+tmNowDelta);
fDXOld = fDX;
fDYOld = fDY;
tmOldDelta = tmNowDelta;
if (inp_bFilterMouse) {
fDX = fDXSmooth;
fDY = fDYSmooth;
}
// get final mouse values
FLOAT fMouseRelX = +fDX*fSensitivity;
FLOAT fMouseRelY = -fDY*fSensitivity;
if (inp_bInvertMouse) {
fMouseRelY = -fMouseRelY;
}
FLOAT fMouseRelZ = _iMouseZ;
// just interpret values as normal
inp_caiAllAxisInfo[1].cai_fReading = fMouseRelX;
inp_caiAllAxisInfo[2].cai_fReading = fMouseRelY;
inp_caiAllAxisInfo[3].cai_fReading = fMouseRelZ;
} else {
inp_caiAllAxisInfo[1].cai_fReading = 0.0;
inp_caiAllAxisInfo[2].cai_fReading = 0.0;
inp_caiAllAxisInfo[3].cai_fReading = 0.0;
}
/*
// if not pre-scanning
if (!bPreScan) {
// detect wheel up/down movement
_bWheelDn = FALSE;
if (_iMouseZ>0) {
if (_bWheelUp) {
inp_ubButtonsBuffer[KID_MOUSEWHEELUP] = 0x00;
} else {
inp_ubButtonsBuffer[KID_MOUSEWHEELUP] = 0xFF;
_iMouseZ = ClampDn(_iMouseZ-120, 0);
}
}
_bWheelUp = inp_ubButtonsBuffer[KID_MOUSEWHEELUP];
if (_iMouseZ<0) {
if (_bWheelDn) {
inp_ubButtonsBuffer[KID_MOUSEWHEELDOWN] = 0x00;
} else {
inp_ubButtonsBuffer[KID_MOUSEWHEELDOWN] = 0xFF;
_iMouseZ = ClampUp(_iMouseZ+120, 0);
}
}
_bWheelDn = inp_ubButtonsBuffer[KID_MOUSEWHEELDOWN];
}
*/
inp_bLastPrescan = bPreScan;
// !!! FIXME
#if 0
// readout 2nd mouse if enabled
if( _h2ndMouse!=NONE)
{
Poll2ndMouse();
//CPrintF( "m2X: %4d, m2Y: %4d, m2B: 0x%02X\n", _i2ndMouseX, _i2ndMouseY, _i2ndMouseButtons);
// handle 2nd mouse buttons
if( _i2ndMouseButtons & 2) inp_ubButtonsBuffer[KID_2MOUSE1] = 0xFF;
if( _i2ndMouseButtons & 1) inp_ubButtonsBuffer[KID_2MOUSE2] = 0xFF;
if( _i2ndMouseButtons & 4) inp_ubButtonsBuffer[KID_2MOUSE3] = 0xFF;
// handle 2nd mouse movement
FLOAT fDX = _i2ndMouseX;
FLOAT fDY = _i2ndMouseY;
FLOAT fSensitivity = inp_f2ndMouseSensitivity;
FLOAT fD = Sqrt(fDX*fDX+fDY*fDY);
if( inp_b2ndMousePrecision) {
static FLOAT _tm2Time = 0.0f;
if( fD<inp_f2ndMousePrecisionThreshold) _tm2Time += 0.05f;
else _tm2Time = 0.0f;
if( _tm2Time>inp_f2ndMousePrecisionTimeout) fSensitivity /= inp_f2ndMousePrecisionFactor;
}
static FLOAT f2DXOld;
static FLOAT f2DYOld;
static TIME tm2OldDelta;
static CTimerValue tv2Before;
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
TIME tmNowDelta = (tvNow-tv2Before).GetSeconds();
if( tmNowDelta<0.001f) tmNowDelta = 0.001f;
tv2Before = tvNow;
FLOAT fDXSmooth = (f2DXOld*tm2OldDelta+fDX*tmNowDelta) / (tm2OldDelta+tmNowDelta);
FLOAT fDYSmooth = (f2DYOld*tm2OldDelta+fDY*tmNowDelta) / (tm2OldDelta+tmNowDelta);
f2DXOld = fDX;
f2DYOld = fDY;
tm2OldDelta = tmNowDelta;
if( inp_bFilter2ndMouse) {
fDX = fDXSmooth;
fDY = fDYSmooth;
}
// get final mouse values
FLOAT fMouseRelX = +fDX*fSensitivity;
FLOAT fMouseRelY = -fDY*fSensitivity;
if( inp_bInvert2ndMouse) fMouseRelY = -fMouseRelY;
// just interpret values as normal
inp_caiAllAxisInfo[4].cai_fReading = fMouseRelX;
inp_caiAllAxisInfo[5].cai_fReading = fMouseRelY;
}
#endif
// if joystick polling is enabled
if (inp_bPollJoysticks || inp_bForceJoystickPolling) {
// scan all available joysticks
for( INDEX iJoy=0; iJoy<MAX_JOYSTICKS; iJoy++) {
if (inp_abJoystickOn[iJoy] && iJoy<inp_ctJoysticksAllowed) {
// scan joy state
BOOL bSucceeded = ScanJoystick(iJoy, bPreScan);
// if joystick reading failed
if (!bSucceeded && inp_bAutoDisableJoysticks) {
// kill it, so it doesn't slow down CPU
CPrintF(TRANSV("Joystick %d failed, disabling it!\n"), iJoy+1);
inp_abJoystickOn[iJoy] = FALSE;
}
}
}
}
}
/*
* Scans axis and buttons for given joystick
*/
BOOL CInput::ScanJoystick(INDEX iJoy, BOOL bPreScan)
{
assert(ctJoysticks > iJoy);
assert(sticks != NULL);
assert(sticks[iJoy] != NULL);
SDL_Joystick *stick = sticks[iJoy];
// for each available axis
for( INDEX iAxis=0; iAxis<MAX_AXES_PER_JOYSTICK; iAxis++) {
ControlAxisInfo &cai = inp_caiAllAxisInfo[ FIRST_JOYAXIS+iJoy*MAX_AXES_PER_JOYSTICK+iAxis];
// if the axis is not present
if (!cai.cai_bExisting) {
// read as zero
cai.cai_fReading = 0.0f;
// skip to next axis
continue;
}
// read its state
SLONG slAxisReading = SDL_JoystickGetAxis(stick, iAxis);
// convert from min..max to -1..+1
FLOAT fAxisReading = FLOAT(slAxisReading-cai.cai_slMin)/(cai.cai_slMax-cai.cai_slMin)*2.0f-1.0f;
// set current axis value
cai.cai_fReading = fAxisReading;
}
// if not pre-scanning
if (!bPreScan) {
INDEX iButtonTotal = FIRST_JOYBUTTON+iJoy*MAX_BUTTONS_PER_JOYSTICK;
// for each available button
for( INDEX iButton=0; iButton<32; iButton++) {
// test if the button is pressed
if (SDL_JoystickGetButton(stick, iButton)) {
inp_ubButtonsBuffer[ iButtonTotal++] = 128;
} else {
inp_ubButtonsBuffer[ iButtonTotal++] = 0;
}
}
/*
!!! FIXME: Support hats as extra buttons...
// POV hat initially not pressed
// CPrintF("%d\n", ji.dwPOV);
INDEX iStartPOV = iButtonTotal;
inp_ubButtonsBuffer[ iStartPOV+0] = 0;
inp_ubButtonsBuffer[ iStartPOV+1] = 0;
inp_ubButtonsBuffer[ iStartPOV+2] = 0;
inp_ubButtonsBuffer[ iStartPOV+3] = 0;
// check the four pov directions
if (ji.dwPOV==JOY_POVFORWARD) {
inp_ubButtonsBuffer[ iStartPOV+0] = 128;
} else if (ji.dwPOV==JOY_POVRIGHT) {
inp_ubButtonsBuffer[ iStartPOV+1] = 128;
} else if (ji.dwPOV==JOY_POVBACKWARD) {
inp_ubButtonsBuffer[ iStartPOV+2] = 128;
} else if (ji.dwPOV==JOY_POVLEFT) {
inp_ubButtonsBuffer[ iStartPOV+3] = 128;
// and four mid-positions
} else if (ji.dwPOV==JOY_POVFORWARD+4500) {
inp_ubButtonsBuffer[ iStartPOV+0] = 128;
inp_ubButtonsBuffer[ iStartPOV+1] = 128;
} else if (ji.dwPOV==JOY_POVRIGHT+4500) {
inp_ubButtonsBuffer[ iStartPOV+1] = 128;
inp_ubButtonsBuffer[ iStartPOV+2] = 128;
} else if (ji.dwPOV==JOY_POVBACKWARD+4500) {
inp_ubButtonsBuffer[ iStartPOV+2] = 128;
inp_ubButtonsBuffer[ iStartPOV+3] = 128;
} else if (ji.dwPOV==JOY_POVLEFT+4500) {
inp_ubButtonsBuffer[ iStartPOV+3] = 128;
inp_ubButtonsBuffer[ iStartPOV+0] = 128;
}
*/
}
// successful
return TRUE;
}
// end of SDLInput.cpp ...
Reference in New Issue View Git Blame Copy Permalink