/* in_win.c windows 95 mouse and joystick code Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA $Id$ */ // 02/21/97 JCB Added extended DirectInput code to support external controllers. #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifdef __MINGW32__ # define INITGUID #endif #include "winquake.h" #include #include "client.h" #include "keys.h" #include "console.h" #include "qargs.h" #include "cmd.h" #include "input.h" #include "cl_input.h" #include "view.h" //#include "dosisms.h" #include "host.h" #define DINPUT_BUFFERSIZE 16 #define iDirectInputCreate(a,b,c,d) pDirectInputCreate(a,b,c,d) HRESULT (WINAPI * pDirectInputCreate) (HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter); // mouse public variables float mouse_x, mouse_y; qboolean mouseactive; unsigned int uiWheelMessage; // mouse local variables static int mouse_buttons; static int mouse_oldbuttonstate; static POINT current_pos; static float old_mouse_x, old_mouse_y, mx_accum, my_accum; static qboolean mouseinitialized; static cvar_t *m_filter; static qboolean restore_spi; static int originalmouseparms[3], newmouseparms[3] = { 0, 0, 1 }; static qboolean mouseparmsvalid, mouseactivatetoggle; static qboolean mouseshowtoggle = 1; static qboolean dinput_acquired; static unsigned int mstate_di; // joystick defines and variables // where should defines be moved? #define JOY_ABSOLUTE_AXIS 0x00000000 // control like a joystick #define JOY_RELATIVE_AXIS 0x00000010 // control like a mouse, spinner, // trackball #define JOY_MAX_AXES 6 // X, Y, Z, R, U, V #define JOY_AXIS_X 0 #define JOY_AXIS_Y 1 #define JOY_AXIS_Z 2 #define JOY_AXIS_R 3 #define JOY_AXIS_U 4 #define JOY_AXIS_V 5 enum _ControlList { AxisNada = 0, AxisForward, AxisLook, AxisSide, AxisTurn }; static DWORD dwAxisFlags[JOY_MAX_AXES] = { JOY_RETURNX, JOY_RETURNY, JOY_RETURNZ, JOY_RETURNR, JOY_RETURNU, JOY_RETURNV }; static DWORD dwAxisMap[JOY_MAX_AXES]; static DWORD dwControlMap[JOY_MAX_AXES]; static PDWORD pdwRawValue[JOY_MAX_AXES]; // none of these cvars are saved over a session // this means that advanced controller configuration needs to be executed // each time. this avoids any problems with getting back to a default usage // or when changing from one controller to another. this way at least something // works. static cvar_t *in_joystick; static cvar_t *joy_name; static cvar_t *joy_advanced; static cvar_t *joy_advaxisx; static cvar_t *joy_advaxisy; static cvar_t *joy_advaxisz; static cvar_t *joy_advaxisr; static cvar_t *joy_advaxisu; static cvar_t *joy_advaxisv; static cvar_t *joy_forwardthreshold; static cvar_t *joy_sidethreshold; static cvar_t *joy_pitchthreshold; static cvar_t *joy_yawthreshold; static cvar_t *joy_forwardsensitivity; static cvar_t *joy_sidesensitivity; static cvar_t *joy_pitchsensitivity; static cvar_t *joy_yawsensitivity; static cvar_t *joy_wwhack1; static cvar_t *joy_wwhack2; static qboolean joy_avail, joy_advancedinit, joy_haspov; static DWORD joy_oldbuttonstate, joy_oldpovstate; static int joy_id; static DWORD joy_flags; static DWORD joy_numbuttons; // misc locals static LPDIRECTINPUT g_pdi; static LPDIRECTINPUTDEVICE g_pMouse; static JOYINFOEX ji; static HINSTANCE hInstDI; static qboolean dinput; typedef struct MYDATA { LONG lX; // X axis goes here LONG lY; // Y axis goes here LONG lZ; // Z axis goes here BYTE bButtonA; // One button goes here BYTE bButtonB; // Another button goes here BYTE bButtonC; // Another button goes here BYTE bButtonD; // Another button goes here } MYDATA; static DIOBJECTDATAFORMAT rgodf[] = { {&GUID_XAxis, FIELD_OFFSET (MYDATA, lX), DIDFT_AXIS | DIDFT_ANYINSTANCE, 0,}, {&GUID_YAxis, FIELD_OFFSET (MYDATA, lY), DIDFT_AXIS | DIDFT_ANYINSTANCE, 0,}, {&GUID_ZAxis, FIELD_OFFSET (MYDATA, lZ), 0x80000000 | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0,}, {0, FIELD_OFFSET (MYDATA, bButtonA), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,}, {0, FIELD_OFFSET (MYDATA, bButtonB), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,}, {0, FIELD_OFFSET (MYDATA, bButtonC), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,}, {0, FIELD_OFFSET (MYDATA, bButtonD), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,}, }; #define NUM_OBJECTS (sizeof(rgodf) / sizeof(rgodf[0])) static DIDATAFORMAT df = { sizeof (DIDATAFORMAT), // this structure sizeof (DIOBJECTDATAFORMAT), // size of object data format DIDF_RELAXIS, // absolute axis coordinates sizeof (MYDATA), // device data size NUM_OBJECTS, // number of objects rgodf, // and here they are }; // forward-referenced functions, locals static void IN_StartupJoystick (void); static void Joy_AdvancedUpdate_f (void); static void IN_JoyMove (usercmd_t *cmd); /* =========== Force_CenterView_f =========== */ static void Force_CenterView_f (void) { cl.viewangles[PITCH] = 0; } /* =========== IN_UpdateClipCursor =========== */ void IN_UpdateClipCursor (void) { if (mouseinitialized && mouseactive && !dinput) { ClipCursor (&window_rect); } } /* =========== IN_ShowMouse =========== */ void IN_ShowMouse (void) { if (!mouseshowtoggle) { ShowCursor (TRUE); mouseshowtoggle = 1; } } /* =========== IN_HideMouse =========== */ void IN_HideMouse (void) { if (mouseshowtoggle) { ShowCursor (FALSE); mouseshowtoggle = 0; } } /* =========== IN_ActivateMouse =========== */ void IN_ActivateMouse (void) { mouseactivatetoggle = true; if (mouseinitialized) { if (dinput) { if (g_pMouse) { if (!dinput_acquired) { IDirectInputDevice_Acquire (g_pMouse); dinput_acquired = true; } } else { return; } } else { if (mouseparmsvalid) restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0); SetCursorPos (window_center_x, window_center_y); SetCapture (mainwindow); ClipCursor (&window_rect); } mouseactive = true; } } /* =========== IN_SetQuakeMouseState =========== */ void IN_SetQuakeMouseState (void) { if (mouseactivatetoggle) IN_ActivateMouse (); } /* =========== IN_DeactivateMouse =========== */ void IN_DeactivateMouse (void) { mouseactivatetoggle = false; if (mouseinitialized) { if (dinput) { if (g_pMouse) { if (dinput_acquired) { IDirectInputDevice_Unacquire (g_pMouse); dinput_acquired = false; } } } else { if (restore_spi) SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0); ClipCursor (NULL); ReleaseCapture (); } mouseactive = false; } } /* =========== IN_RestoreOriginalMouseState =========== */ void IN_RestoreOriginalMouseState (void) { if (mouseactivatetoggle) { IN_DeactivateMouse (); mouseactivatetoggle = true; } // try to redraw the cursor so it gets reinitialized, because sometimes it // has garbage after the mode switch ShowCursor (TRUE); ShowCursor (FALSE); } /* =========== IN_InitDInput =========== */ static qboolean IN_InitDInput (void) { HRESULT hr; DIPROPDWORD dipdw = { { sizeof (DIPROPDWORD), // diph.dwSize sizeof (DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow } , DINPUT_BUFFERSIZE, // dwData }; if (!hInstDI) { hInstDI = LoadLibrary ("dinput.dll"); if (hInstDI == NULL) { Con_Printf ("Couldn't load dinput.dll\n"); return false; } } if (!pDirectInputCreate) { pDirectInputCreate = (void *) GetProcAddress (hInstDI, "DirectInputCreateA"); if (!pDirectInputCreate) { Con_Printf ("Couldn't get DI proc addr\n"); return false; } } // register with DirectInput and get an IDirectInput to play with. hr = iDirectInputCreate (global_hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL); if (FAILED (hr)) { return false; } // obtain an interface to the system mouse device. hr = IDirectInput_CreateDevice (g_pdi, &GUID_SysMouse, &g_pMouse, NULL); if (FAILED (hr)) { Con_Printf ("Couldn't open DI mouse device\n"); return false; } // set the data format to "mouse format". hr = IDirectInputDevice_SetDataFormat (g_pMouse, &df); if (FAILED (hr)) { Con_Printf ("Couldn't set DI mouse format\n"); return false; } // set the cooperativity level. hr = IDirectInputDevice_SetCooperativeLevel (g_pMouse, mainwindow, DISCL_EXCLUSIVE | DISCL_FOREGROUND); if (FAILED (hr)) { Con_Printf ("Couldn't set DI coop level\n"); return false; } // set the buffer size to DINPUT_BUFFERSIZE elements. // the buffer size is a DWORD property associated with the device hr = IDirectInputDevice_SetProperty (g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph); if (FAILED (hr)) { Con_Printf ("Couldn't set DI buffersize\n"); return false; } return true; } /* =========== IN_StartupMouse =========== */ static void IN_StartupMouse (void) { // HDC hdc; if (COM_CheckParm ("-nomouse")) return; mouseinitialized = true; if (COM_CheckParm ("-dinput")) { dinput = IN_InitDInput (); if (dinput) { Con_Printf ("DirectInput initialized\n"); } else { Con_Printf ("DirectInput not initialized\n"); } } if (!dinput) { mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0); if (mouseparmsvalid) { if (COM_CheckParm ("-noforcemspd")) newmouseparms[2] = originalmouseparms[2]; if (COM_CheckParm ("-noforcemaccel")) { newmouseparms[0] = originalmouseparms[0]; newmouseparms[1] = originalmouseparms[1]; } if (COM_CheckParm ("-noforcemparms")) { newmouseparms[0] = originalmouseparms[0]; newmouseparms[1] = originalmouseparms[1]; newmouseparms[2] = originalmouseparms[2]; } } } mouse_buttons = 3; // if a fullscreen video mode was set before the mouse was initialized, // set the mouse state appropriately if (mouseactivatetoggle) IN_ActivateMouse (); } /* =========== IN_Init =========== */ void IN_Init (void) { Cmd_AddCommand ("force_centerview", Force_CenterView_f); Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f); uiWheelMessage = RegisterWindowMessage ("MSWHEEL_ROLLMSG"); IN_StartupMouse (); IN_StartupJoystick (); } void IN_Init_Cvars (void) { // mouse variables m_filter = Cvar_Get ("m_filter", "0", CVAR_NONE, "None"); // joystick variables in_joystick = Cvar_Get ("joystick", "0", CVAR_ARCHIVE, "None"); joy_name = Cvar_Get ("joyname", "joystick", CVAR_NONE, "None"); joy_advanced = Cvar_Get ("joyadvanced", "0", CVAR_NONE, "None"); joy_advaxisx = Cvar_Get ("joyadvaxisx", "0", CVAR_NONE, "None"); joy_advaxisy = Cvar_Get ("joyadvaxisy", "0", CVAR_NONE, "None"); joy_advaxisz = Cvar_Get ("joyadvaxisz", "0", CVAR_NONE, "None"); joy_advaxisr = Cvar_Get ("joyadvaxisr", "0", CVAR_NONE, "None"); joy_advaxisu = Cvar_Get ("joyadvaxisu", "0", CVAR_NONE, "None"); joy_advaxisv = Cvar_Get ("joyadvaxisv", "0", CVAR_NONE, "None"); joy_forwardthreshold = Cvar_Get ("joyforwardthreshold", "0.15", CVAR_NONE, "None"); joy_sidethreshold = Cvar_Get ("joysidethreshold", "0.15", CVAR_NONE, "None"); joy_pitchthreshold = Cvar_Get ("joypitchthreshold", "0.15", CVAR_NONE, "None"); joy_yawthreshold = Cvar_Get ("joyyawthreshold", "0.15", CVAR_NONE, "None"); joy_forwardsensitivity = Cvar_Get ("joyforwardsensitivity", "-1.0", CVAR_NONE, "None"); joy_sidesensitivity = Cvar_Get ("joysidesensitivity", "-1.0", CVAR_NONE, "None"); joy_pitchsensitivity = Cvar_Get ("joypitchsensitivity", "1.0", CVAR_NONE, "None"); joy_yawsensitivity = Cvar_Get ("joyyawsensitivity", "-1.0", CVAR_NONE, "None"); joy_wwhack1 = Cvar_Get ("joywwhack1", "0.0", CVAR_NONE, "None"); joy_wwhack2 = Cvar_Get ("joywwhack2", "0.0", CVAR_NONE, "None"); } /* =========== IN_Shutdown =========== */ void IN_Shutdown (void) { IN_DeactivateMouse (); IN_ShowMouse (); if (g_pMouse) { IDirectInputDevice_Release (g_pMouse); g_pMouse = NULL; } if (g_pdi) { IDirectInput_Release (g_pdi); g_pdi = NULL; } } /* =========== IN_MouseEvent =========== */ void IN_MouseEvent (int mstate) { int i; if (mouseactive && !dinput) { // perform button actions for (i = 0; i < mouse_buttons; i++) { if ((mstate & (1 << i)) && !(mouse_oldbuttonstate & (1 << i))) { Key_Event (K_MOUSE1 + i, -1, true); } if (!(mstate & (1 << i)) && (mouse_oldbuttonstate & (1 << i))) { Key_Event (K_MOUSE1 + i, -1, false); } } mouse_oldbuttonstate = mstate; } } /* =========== IN_MouseMove =========== */ void IN_MouseMove (usercmd_t *cmd) { int mx, my; // HDC hdc; int i; DIDEVICEOBJECTDATA od; DWORD dwElements; HRESULT hr; if (!mouseactive) return; if (dinput) { mx = 0; my = 0; for (;;) { dwElements = 1; hr = IDirectInputDevice_GetDeviceData (g_pMouse, sizeof (DIDEVICEOBJECTDATA), &od, &dwElements, 0); if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED)) { dinput_acquired = true; IDirectInputDevice_Acquire (g_pMouse); break; } /* Unable to read data or no data available */ if (FAILED (hr) || dwElements == 0) { break; } /* Look at the element to see what happened */ switch (od.dwOfs) { case DIMOFS_X: mx += od.dwData; break; case DIMOFS_Y: my += od.dwData; break; case DIMOFS_BUTTON0: if (od.dwData & 0x80) mstate_di |= 1; else mstate_di &= ~1; break; case DIMOFS_BUTTON1: if (od.dwData & 0x80) mstate_di |= (1 << 1); else mstate_di &= ~(1 << 1); break; case DIMOFS_BUTTON2: if (od.dwData & 0x80) mstate_di |= (1 << 2); else mstate_di &= ~(1 << 2); break; } } // perform button actions for (i = 0; i < mouse_buttons; i++) { if ((mstate_di & (1 << i)) && !(mouse_oldbuttonstate & (1 << i))) { Key_Event (K_MOUSE1 + i, -1, true); } if (!(mstate_di & (1 << i)) && (mouse_oldbuttonstate & (1 << i))) { Key_Event (K_MOUSE1 + i, -1, false); } } mouse_oldbuttonstate = mstate_di; } else { GetCursorPos (¤t_pos); mx = current_pos.x - window_center_x + mx_accum; my = current_pos.y - window_center_y + my_accum; mx_accum = 0; my_accum = 0; } if (m_filter->value) { mouse_x = (mx + old_mouse_x) * 0.5; mouse_y = (my + old_mouse_y) * 0.5; } else { mouse_x = mx; mouse_y = my; } old_mouse_x = mx; old_mouse_y = my; mouse_x *= sensitivity->value; mouse_y *= sensitivity->value; // add mouse X/Y movement to cmd if ((in_strafe.state & 1) || (lookstrafe->int_val && freelook)) cmd->sidemove += m_side->value * mouse_x; else cl.viewangles[YAW] -= m_yaw->value * mouse_x; if (freelook) V_StopPitchDrift (); if (freelook && !(in_strafe.state & 1)) { cl.viewangles[PITCH] += m_pitch->value * mouse_y; cl.viewangles[PITCH] = bound (-70, cl.viewangles[PITCH], 80); } else { if ((in_strafe.state & 1) && noclip_anglehack) cmd->upmove -= m_forward->value * mouse_y; else cmd->forwardmove -= m_forward->value * mouse_y; } // if the mouse has moved, force it to the center, so there's room to move if (mx || my) { SetCursorPos (window_center_x, window_center_y); } } /* =========== IN_Move =========== */ void IN_Move (usercmd_t *cmd) { if (ActiveApp && !Minimized) { IN_MouseMove (cmd); IN_JoyMove (cmd); } } /* =========== IN_Accumulate =========== */ void IN_Accumulate (void) { // int mx, my; // HDC hdc; if (mouseactive) { GetCursorPos (¤t_pos); mx_accum += current_pos.x - window_center_x; my_accum += current_pos.y - window_center_y; // force the mouse to the center, so there's room to move SetCursorPos (window_center_x, window_center_y); } } /* =================== IN_ClearStates =================== */ void IN_ClearStates (void) { if (mouseactive) { mx_accum = 0; my_accum = 0; mouse_oldbuttonstate = 0; } } /* =============== IN_StartupJoystick =============== */ static void IN_StartupJoystick (void) { int /* i, */ numdevs; JOYCAPS jc; MMRESULT mmr = !JOYERR_NOERROR; // assume no joystick joy_avail = false; // abort startup if user requests no joystick if (COM_CheckParm ("-nojoy")) return; // verify joystick driver is present if ((numdevs = joyGetNumDevs ()) == 0) { Con_Printf ("\njoystick not found -- driver not present\n\n"); return; } // cycle through the joystick ids for the first valid one for (joy_id = 0; joy_id < numdevs; joy_id++) { memset (&ji, 0, sizeof (ji)); ji.dwSize = sizeof (ji); ji.dwFlags = JOY_RETURNCENTERED; if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR) break; } // abort startup if we didn't find a valid joystick if (mmr != JOYERR_NOERROR) { Con_Printf ("\njoystick not found -- no valid joysticks (%x)\n\n", mmr); return; } // get the capabilities of the selected joystick // abort startup if command fails memset (&jc, 0, sizeof (jc)); if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof (jc))) != JOYERR_NOERROR) { Con_Printf ("\njoystick not found -- invalid joystick capabilities (%x)\n\n", mmr); return; } // save the joystick's number of buttons and POV status joy_numbuttons = jc.wNumButtons; joy_haspov = jc.wCaps & JOYCAPS_HASPOV; // old button and POV states default to no buttons pressed joy_oldbuttonstate = joy_oldpovstate = 0; // mark the joystick as available and advanced initialization not // completed // this is needed as cvars are not available during initialization joy_avail = true; joy_advancedinit = false; Con_Printf ("\njoystick detected\n\n"); } /* =========== RawValuePointer =========== */ static PDWORD RawValuePointer (int axis) { switch (axis) { case JOY_AXIS_X: return &ji.dwXpos; case JOY_AXIS_Y: return &ji.dwYpos; case JOY_AXIS_Z: return &ji.dwZpos; case JOY_AXIS_R: return &ji.dwRpos; case JOY_AXIS_U: return &ji.dwUpos; case JOY_AXIS_V: return &ji.dwVpos; } return NULL; } /* =========== Joy_AdvancedUpdate_f =========== */ static void Joy_AdvancedUpdate_f (void) { // called once by IN_ReadJoystick and by user whenever an update is // needed // cvars are now available int i; DWORD dwTemp; // initialize all the maps for (i = 0; i < JOY_MAX_AXES; i++) { dwAxisMap[i] = AxisNada; dwControlMap[i] = JOY_ABSOLUTE_AXIS; pdwRawValue[i] = RawValuePointer (i); } if (joy_advanced->int_val) { // default joystick initialization // 2 axes only with joystick control dwAxisMap[JOY_AXIS_X] = AxisTurn; // dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS; dwAxisMap[JOY_AXIS_Y] = AxisForward; // dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS; } else { if (strcmp (joy_name->string, "joystick") != 0) { // notify user of advanced controller Con_Printf ("\n%s configured\n\n", joy_name->string); } // advanced initialization here // data supplied by user via joy_axisn cvars dwTemp = joy_advaxisx->int_val; dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS; dwTemp = joy_advaxisy->int_val; dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS; dwTemp = joy_advaxisz->int_val; dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS; dwTemp = joy_advaxisr->int_val; dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS; dwTemp = joy_advaxisu->int_val; dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS; dwTemp = joy_advaxisv->int_val; dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f; dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS; } // compute the axes to collect from DirectInput joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV; for (i = 0; i < JOY_MAX_AXES; i++) { if (dwAxisMap[i] != AxisNada) { joy_flags |= dwAxisFlags[i]; } } } /* =========== IN_Commands =========== */ void IN_Commands (void) { int i, key_index; DWORD buttonstate, povstate; if (!joy_avail) { return; } // loop through the joystick buttons // key a joystick event or auxillary event for higher number buttons for // each state change buttonstate = ji.dwButtons; for (i = 0; i < joy_numbuttons; i++) { if ((buttonstate & (1 << i)) && !(joy_oldbuttonstate & (1 << i))) { key_index = (i < 4) ? K_JOY1 : K_AUX1; Key_Event (key_index + i, -1, true); } if (!(buttonstate & (1 << i)) && (joy_oldbuttonstate & (1 << i))) { key_index = (i < 4) ? K_JOY1 : K_AUX1; Key_Event (key_index + i, -1, false); } } joy_oldbuttonstate = buttonstate; if (joy_haspov) { // convert POV information into 4 bits of state information // this avoids any potential problems related to moving from one // direction to another without going through the center position povstate = 0; if (ji.dwPOV != JOY_POVCENTERED) { if (ji.dwPOV == JOY_POVFORWARD) povstate |= 0x01; if (ji.dwPOV == JOY_POVRIGHT) povstate |= 0x02; if (ji.dwPOV == JOY_POVBACKWARD) povstate |= 0x04; if (ji.dwPOV == JOY_POVLEFT) povstate |= 0x08; } // determine which bits have changed and key an auxillary event for // each change for (i = 0; i < 4; i++) { if ((povstate & (1 << i)) && !(joy_oldpovstate & (1 << i))) { Key_Event (K_AUX29 + i, -1, true); } if (!(povstate & (1 << i)) && (joy_oldpovstate & (1 << i))) { Key_Event (K_AUX29 + i, -1, false); } } joy_oldpovstate = povstate; } } /* =============== IN_ReadJoystick =============== */ static qboolean IN_ReadJoystick (void) { memset (&ji, 0, sizeof (ji)); ji.dwSize = sizeof (ji); ji.dwFlags = joy_flags; if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR) { // this is a hack -- there is a bug in the Logitech WingMan Warrior // DirectInput Driver // rather than having 32768 be the zero point, they have the zero // point at 32668 // go figure -- anyway, now we get the full resolution out of the // device if (joy_wwhack1->int_val) { ji.dwUpos += 100; } return true; } else { // read error occurred // turning off the joystick seems too harsh for 1 read error, // but what should be done? // Con_Printf ("IN_ReadJoystick: no response\n"); // joy_avail = false; return false; } } /* =========== IN_JoyMove =========== */ static void IN_JoyMove (usercmd_t *cmd) { float speed, aspeed; float fAxisValue, fTemp; int i; // complete initialization if first time in // this is needed as cvars are not available at initialization time if (joy_advancedinit != true) { Joy_AdvancedUpdate_f (); joy_advancedinit = true; } // verify joystick is available and that the user wants to use it if (!joy_avail || !in_joystick->int_val) { return; } // collect the joystick data, if possible if (IN_ReadJoystick () != true) { return; } if (in_speed.state & 1) speed = cl_movespeedkey->value; else speed = 1; aspeed = speed * host_frametime; // loop through the axes for (i = 0; i < JOY_MAX_AXES; i++) { // get the floating point zero-centered, potentially-inverted data // for the current axis fAxisValue = (float) *pdwRawValue[i]; // move centerpoint to zero fAxisValue -= 32768.0; if (joy_wwhack2->int_val) { if (dwAxisMap[i] == AxisTurn) { // this is a special formula for the Logitech WingMan Warrior // y=ax^b; where a = 300 and b = 1.3 // also x values are in increments of 800 (so this is // factored out) // then bounds check result to level out excessively high // spin rates fTemp = 300.0 * pow (abs (fAxisValue) / 800.0, 1.3); if (fTemp > 14000.0) fTemp = 14000.0; // restore direction information fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp; } } // convert range from -32768..32767 to -1..1 fAxisValue /= 32768.0; switch (dwAxisMap[i]) { case AxisForward: if (!joy_advanced->int_val && freelook) { // user wants forward control to become look control if (fabs (fAxisValue) > joy_pitchthreshold->value) { // if mouse invert is on, invert the joystick pitch // value // only absolute control support here (joy_advanced // is false) if (m_pitch->value < 0.0) { cl.viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value; } else { cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value; } V_StopPitchDrift (); } else { // no pitch movement // disable pitch return-to-center unless requested by // user // *** this code can be removed when the lookspring // bug is fixed // *** the bug always has the lookspring feature on if (!lookspring->int_val) V_StopPitchDrift (); } } else { // user wants forward control to be forward control if (fabs (fAxisValue) > joy_forwardthreshold->value) { cmd->forwardmove += (fAxisValue * joy_forwardsensitivity->value) * speed * cl_forwardspeed->value; } } break; case AxisSide: if (fabs (fAxisValue) > joy_sidethreshold->value) { cmd->sidemove += (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value; } break; case AxisTurn: if ((in_strafe.state & 1) || (lookstrafe->int_val && freelook)) { // user wants turn control to become side control if (fabs (fAxisValue) > joy_sidethreshold->value) { cmd->sidemove -= (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value; } } else { // user wants turn control to be turn control if (fabs (fAxisValue) > joy_yawthreshold->value) { if (dwControlMap[i] == JOY_ABSOLUTE_AXIS) { cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * aspeed * cl_yawspeed->value; } else { cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * speed * 180.0; } } } break; case AxisLook: if (freelook) { if (fabs (fAxisValue) > joy_pitchthreshold->value) { // pitch movement detected and pitch movement desired // by user if (dwControlMap[i] == JOY_ABSOLUTE_AXIS) { cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value; } else { cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * speed * 180.0; } V_StopPitchDrift (); } else { // no pitch movement // disable pitch return-to-center unless requested by // user // *** this code can be removed when the lookspring // bug is fixed // *** the bug always has the lookspring feature on if (!lookspring->int_val) V_StopPitchDrift (); } } break; default: break; } } // bounds check pitch if (cl.viewangles[PITCH] > 80.0) cl.viewangles[PITCH] = 80.0; if (cl.viewangles[PITCH] < -70.0) cl.viewangles[PITCH] = -70.0; }