home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / client / in_win.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-21  |  27.7 KB  |  1,233 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20. // in_win.c -- windows 95 mouse and joystick code
  21. // 02/21/97 JCB Added extended DirectInput code to support external controllers.
  22.  
  23. #include <dinput.h>
  24. #include "quakedef.h"
  25. #include "winquake.h"
  26. //#include "dosisms.h"
  27.  
  28. #define DINPUT_BUFFERSIZE           16
  29. #define iDirectInputCreate(a,b,c,d)    pDirectInputCreate(a,b,c,d)
  30.  
  31. HRESULT (WINAPI *pDirectInputCreate)(HINSTANCE hinst, DWORD dwVersion,
  32.     LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter);
  33.  
  34. // mouse variables
  35. cvar_t    m_filter = {"m_filter","0"};
  36.  
  37. int            mouse_buttons;
  38. int            mouse_oldbuttonstate;
  39. POINT        current_pos;
  40. int            mouse_x, mouse_y, old_mouse_x, old_mouse_y, mx_accum, my_accum;
  41.  
  42. static qboolean    restore_spi;
  43. static int        originalmouseparms[3], newmouseparms[3] = {0, 0, 1};
  44. qboolean        mouseinitialized;
  45. static qboolean    mouseparmsvalid, mouseactivatetoggle;
  46. static qboolean    mouseshowtoggle = 1;
  47. static qboolean    dinput_acquired;
  48. static unsigned int        mstate_di;
  49. unsigned int uiWheelMessage;
  50.  
  51. qboolean    mouseactive;
  52.  
  53. // joystick defines and variables
  54. // where should defines be moved?
  55. #define JOY_ABSOLUTE_AXIS    0x00000000        // control like a joystick
  56. #define JOY_RELATIVE_AXIS    0x00000010        // control like a mouse, spinner, trackball
  57. #define    JOY_MAX_AXES        6                // X, Y, Z, R, U, V
  58. #define JOY_AXIS_X            0
  59. #define JOY_AXIS_Y            1
  60. #define JOY_AXIS_Z            2
  61. #define JOY_AXIS_R            3
  62. #define JOY_AXIS_U            4
  63. #define JOY_AXIS_V            5
  64.  
  65. enum _ControlList
  66. {
  67.     AxisNada = 0, AxisForward, AxisLook, AxisSide, AxisTurn
  68. };
  69.  
  70. DWORD    dwAxisFlags[JOY_MAX_AXES] =
  71. {
  72.     JOY_RETURNX, JOY_RETURNY, JOY_RETURNZ, JOY_RETURNR, JOY_RETURNU, JOY_RETURNV
  73. };
  74.  
  75. DWORD    dwAxisMap[JOY_MAX_AXES];
  76. DWORD    dwControlMap[JOY_MAX_AXES];
  77. PDWORD    pdwRawValue[JOY_MAX_AXES];
  78.  
  79. // none of these cvars are saved over a session
  80. // this means that advanced controller configuration needs to be executed
  81. // each time.  this avoids any problems with getting back to a default usage
  82. // or when changing from one controller to another.  this way at least something
  83. // works.
  84. cvar_t    in_joystick = {"joystick","0", true};
  85. cvar_t    joy_name = {"joyname", "joystick"};
  86. cvar_t    joy_advanced = {"joyadvanced", "0"};
  87. cvar_t    joy_advaxisx = {"joyadvaxisx", "0"};
  88. cvar_t    joy_advaxisy = {"joyadvaxisy", "0"};
  89. cvar_t    joy_advaxisz = {"joyadvaxisz", "0"};
  90. cvar_t    joy_advaxisr = {"joyadvaxisr", "0"};
  91. cvar_t    joy_advaxisu = {"joyadvaxisu", "0"};
  92. cvar_t    joy_advaxisv = {"joyadvaxisv", "0"};
  93. cvar_t    joy_forwardthreshold = {"joyforwardthreshold", "0.15"};
  94. cvar_t    joy_sidethreshold = {"joysidethreshold", "0.15"};
  95. cvar_t    joy_pitchthreshold = {"joypitchthreshold", "0.15"};
  96. cvar_t    joy_yawthreshold = {"joyyawthreshold", "0.15"};
  97. cvar_t    joy_forwardsensitivity = {"joyforwardsensitivity", "-1.0"};
  98. cvar_t    joy_sidesensitivity = {"joysidesensitivity", "-1.0"};
  99. cvar_t    joy_pitchsensitivity = {"joypitchsensitivity", "1.0"};
  100. cvar_t    joy_yawsensitivity = {"joyyawsensitivity", "-1.0"};
  101. cvar_t    joy_wwhack1 = {"joywwhack1", "0.0"};
  102. cvar_t    joy_wwhack2 = {"joywwhack2", "0.0"};
  103.  
  104. qboolean    joy_avail, joy_advancedinit, joy_haspov;
  105. DWORD        joy_oldbuttonstate, joy_oldpovstate;
  106.  
  107. int            joy_id;
  108. DWORD        joy_flags;
  109. DWORD        joy_numbuttons;
  110.  
  111. static LPDIRECTINPUT        g_pdi;
  112. static LPDIRECTINPUTDEVICE    g_pMouse;
  113.  
  114. static JOYINFOEX    ji;
  115.  
  116. static HINSTANCE hInstDI;
  117.  
  118. static qboolean    dinput;
  119.  
  120. typedef struct MYDATA {
  121.     LONG  lX;                   // X axis goes here
  122.     LONG  lY;                   // Y axis goes here
  123.     LONG  lZ;                   // Z axis goes here
  124.     BYTE  bButtonA;             // One button goes here
  125.     BYTE  bButtonB;             // Another button goes here
  126.     BYTE  bButtonC;             // Another button goes here
  127.     BYTE  bButtonD;             // Another button goes here
  128. } MYDATA;
  129.  
  130. static DIOBJECTDATAFORMAT rgodf[] = {
  131.   { &GUID_XAxis,    FIELD_OFFSET(MYDATA, lX),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
  132.   { &GUID_YAxis,    FIELD_OFFSET(MYDATA, lY),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
  133.   { &GUID_ZAxis,    FIELD_OFFSET(MYDATA, lZ),       0x80000000 | DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
  134.   { 0,              FIELD_OFFSET(MYDATA, bButtonA), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
  135.   { 0,              FIELD_OFFSET(MYDATA, bButtonB), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
  136.   { 0,              FIELD_OFFSET(MYDATA, bButtonC), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
  137.   { 0,              FIELD_OFFSET(MYDATA, bButtonD), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
  138. };
  139.  
  140. #define NUM_OBJECTS (sizeof(rgodf) / sizeof(rgodf[0]))
  141.  
  142. static DIDATAFORMAT    df = {
  143.     sizeof(DIDATAFORMAT),       // this structure
  144.     sizeof(DIOBJECTDATAFORMAT), // size of object data format
  145.     DIDF_RELAXIS,               // absolute axis coordinates
  146.     sizeof(MYDATA),             // device data size
  147.     NUM_OBJECTS,                // number of objects
  148.     rgodf,                      // and here they are
  149. };
  150.  
  151. // forward-referenced functions
  152. void IN_StartupJoystick (void);
  153. void Joy_AdvancedUpdate_f (void);
  154. void IN_JoyMove (usercmd_t *cmd);
  155.  
  156.  
  157. /*
  158. ===========
  159. Force_CenterView_f
  160. ===========
  161. */
  162. void Force_CenterView_f (void)
  163. {
  164.     cl.viewangles[PITCH] = 0;
  165. }
  166.  
  167.  
  168. /*
  169. ===========
  170. IN_UpdateClipCursor
  171. ===========
  172. */
  173. void IN_UpdateClipCursor (void)
  174. {
  175.  
  176.     if (mouseinitialized && mouseactive && !dinput)
  177.     {
  178.         ClipCursor (&window_rect);
  179.     }
  180. }
  181.  
  182.  
  183. /*
  184. ===========
  185. IN_ShowMouse
  186. ===========
  187. */
  188. void IN_ShowMouse (void)
  189. {
  190.  
  191.     if (!mouseshowtoggle)
  192.     {
  193.         ShowCursor (TRUE);
  194.         mouseshowtoggle = 1;
  195.     }
  196. }
  197.  
  198.  
  199. /*
  200. ===========
  201. IN_HideMouse
  202. ===========
  203. */
  204. void IN_HideMouse (void)
  205. {
  206.  
  207.     if (mouseshowtoggle)
  208.     {
  209.         ShowCursor (FALSE);
  210.         mouseshowtoggle = 0;
  211.     }
  212. }
  213.  
  214.  
  215. /*
  216. ===========
  217. IN_ActivateMouse
  218. ===========
  219. */
  220. void IN_ActivateMouse (void)
  221. {
  222.  
  223.     mouseactivatetoggle = true;
  224.  
  225.     if (mouseinitialized)
  226.     {
  227.         if (dinput)
  228.         {
  229.             if (g_pMouse)
  230.             {
  231.                 if (!dinput_acquired)
  232.                 {
  233.                     IDirectInputDevice_Acquire(g_pMouse);
  234.                     dinput_acquired = true;
  235.                 }
  236.             }
  237.             else
  238.             {
  239.                 return;
  240.             }
  241.         }
  242.         else
  243.         {
  244.             if (mouseparmsvalid)
  245.                 restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
  246.  
  247.             SetCursorPos (window_center_x, window_center_y);
  248.             SetCapture (mainwindow);
  249.             ClipCursor (&window_rect);
  250.         }
  251.  
  252.         mouseactive = true;
  253.     }
  254. }
  255.  
  256.  
  257. /*
  258. ===========
  259. IN_SetQuakeMouseState
  260. ===========
  261. */
  262. void IN_SetQuakeMouseState (void)
  263. {
  264.     if (mouseactivatetoggle)
  265.         IN_ActivateMouse ();
  266. }
  267.  
  268.  
  269. /*
  270. ===========
  271. IN_DeactivateMouse
  272. ===========
  273. */
  274. void IN_DeactivateMouse (void)
  275. {
  276.  
  277.     mouseactivatetoggle = false;
  278.  
  279.     if (mouseinitialized)
  280.     {
  281.         if (dinput)
  282.         {
  283.             if (g_pMouse)
  284.             {
  285.                 if (dinput_acquired)
  286.                 {
  287.                     IDirectInputDevice_Unacquire(g_pMouse);
  288.                     dinput_acquired = false;
  289.                 }
  290.             }
  291.         }
  292.         else
  293.         {
  294.         if (restore_spi)
  295.             SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0);
  296.  
  297.         ClipCursor (NULL);
  298.         ReleaseCapture ();
  299.     }
  300.  
  301.         mouseactive = false;
  302.     }
  303. }
  304.  
  305.  
  306. /*
  307. ===========
  308. IN_RestoreOriginalMouseState
  309. ===========
  310. */
  311. void IN_RestoreOriginalMouseState (void)
  312. {
  313.     if (mouseactivatetoggle)
  314.     {
  315.         IN_DeactivateMouse ();
  316.         mouseactivatetoggle = true;
  317.     }
  318.  
  319. // try to redraw the cursor so it gets reinitialized, because sometimes it
  320. // has garbage after the mode switch
  321.     ShowCursor (TRUE);
  322.     ShowCursor (FALSE);
  323. }
  324.  
  325.  
  326. /*
  327. ===========
  328. IN_InitDInput
  329. ===========
  330. */
  331. qboolean IN_InitDInput (void)
  332. {
  333.     HRESULT        hr;
  334.     DIPROPDWORD    dipdw = {
  335.         {
  336.             sizeof(DIPROPDWORD),        // diph.dwSize
  337.             sizeof(DIPROPHEADER),       // diph.dwHeaderSize
  338.             0,                          // diph.dwObj
  339.             DIPH_DEVICE,                // diph.dwHow
  340.         },
  341.         DINPUT_BUFFERSIZE,              // dwData
  342.     };
  343.  
  344.     if (!hInstDI)
  345.     {
  346.         hInstDI = LoadLibrary("dinput.dll");
  347.         
  348.         if (hInstDI == NULL)
  349.         {
  350.             Con_SafePrintf ("Couldn't load dinput.dll\n");
  351.             return false;
  352.         }
  353.     }
  354.  
  355.     if (!pDirectInputCreate)
  356.     {
  357.         pDirectInputCreate = (void *)GetProcAddress(hInstDI,"DirectInputCreateA");
  358.  
  359.         if (!pDirectInputCreate)
  360.         {
  361.             Con_SafePrintf ("Couldn't get DI proc addr\n");
  362.             return false;
  363.         }
  364.     }
  365.  
  366. // register with DirectInput and get an IDirectInput to play with.
  367.     hr = iDirectInputCreate(global_hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
  368.  
  369.     if (FAILED(hr))
  370.     {
  371.         return false;
  372.     }
  373.  
  374. // obtain an interface to the system mouse device.
  375.     hr = IDirectInput_CreateDevice(g_pdi, &GUID_SysMouse, &g_pMouse, NULL);
  376.  
  377.     if (FAILED(hr))
  378.     {
  379.         Con_SafePrintf ("Couldn't open DI mouse device\n");
  380.         return false;
  381.     }
  382.  
  383. // set the data format to "mouse format".
  384.     hr = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
  385.  
  386.     if (FAILED(hr))
  387.     {
  388.         Con_SafePrintf ("Couldn't set DI mouse format\n");
  389.         return false;
  390.     }
  391.  
  392. // set the cooperativity level.
  393.     hr = IDirectInputDevice_SetCooperativeLevel(g_pMouse, mainwindow,
  394.             DISCL_EXCLUSIVE | DISCL_FOREGROUND);
  395.  
  396.     if (FAILED(hr))
  397.     {
  398.         Con_SafePrintf ("Couldn't set DI coop level\n");
  399.         return false;
  400.     }
  401.  
  402.  
  403. // set the buffer size to DINPUT_BUFFERSIZE elements.
  404. // the buffer size is a DWORD property associated with the device
  405.     hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
  406.  
  407.     if (FAILED(hr))
  408.     {
  409.         Con_SafePrintf ("Couldn't set DI buffersize\n");
  410.         return false;
  411.     }
  412.  
  413.     return true;
  414. }
  415.  
  416.  
  417. /*
  418. ===========
  419. IN_StartupMouse
  420. ===========
  421. */
  422. void IN_StartupMouse (void)
  423. {
  424.     HDC            hdc;
  425.  
  426.     if ( COM_CheckParm ("-nomouse") ) 
  427.         return; 
  428.  
  429.     mouseinitialized = true;
  430.  
  431.     if (COM_CheckParm ("-dinput"))
  432.     {
  433.         dinput = IN_InitDInput ();
  434.  
  435.         if (dinput)
  436.         {
  437.             Con_SafePrintf ("DirectInput initialized\n");
  438.         }
  439.         else
  440.         {
  441.             Con_SafePrintf ("DirectInput not initialized\n");
  442.         }
  443.     }
  444.  
  445.     if (!dinput)
  446.     {
  447.         mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
  448.  
  449.         if (mouseparmsvalid)
  450.         {
  451.             if ( COM_CheckParm ("-noforcemspd") ) 
  452.                 newmouseparms[2] = originalmouseparms[2];
  453.  
  454.             if ( COM_CheckParm ("-noforcemaccel") ) 
  455.             {
  456.                 newmouseparms[0] = originalmouseparms[0];
  457.                 newmouseparms[1] = originalmouseparms[1];
  458.             }
  459.  
  460.             if ( COM_CheckParm ("-noforcemparms") ) 
  461.             {
  462.                 newmouseparms[0] = originalmouseparms[0];
  463.                 newmouseparms[1] = originalmouseparms[1];
  464.                 newmouseparms[2] = originalmouseparms[2];
  465.             }
  466.         }
  467.     }
  468.  
  469.     mouse_buttons = 3;
  470.  
  471. // if a fullscreen video mode was set before the mouse was initialized,
  472. // set the mouse state appropriately
  473.     if (mouseactivatetoggle)
  474.         IN_ActivateMouse ();
  475. }
  476.  
  477.  
  478. /*
  479. ===========
  480. IN_Init
  481. ===========
  482. */
  483. void IN_Init (void)
  484. {
  485.     // mouse variables
  486.     Cvar_RegisterVariable (&m_filter);
  487.  
  488.     // joystick variables
  489.     Cvar_RegisterVariable (&in_joystick);
  490.     Cvar_RegisterVariable (&joy_name);
  491.     Cvar_RegisterVariable (&joy_advanced);
  492.     Cvar_RegisterVariable (&joy_advaxisx);
  493.     Cvar_RegisterVariable (&joy_advaxisy);
  494.     Cvar_RegisterVariable (&joy_advaxisz);
  495.     Cvar_RegisterVariable (&joy_advaxisr);
  496.     Cvar_RegisterVariable (&joy_advaxisu);
  497.     Cvar_RegisterVariable (&joy_advaxisv);
  498.     Cvar_RegisterVariable (&joy_forwardthreshold);
  499.     Cvar_RegisterVariable (&joy_sidethreshold);
  500.     Cvar_RegisterVariable (&joy_pitchthreshold);
  501.     Cvar_RegisterVariable (&joy_yawthreshold);
  502.     Cvar_RegisterVariable (&joy_forwardsensitivity);
  503.     Cvar_RegisterVariable (&joy_sidesensitivity);
  504.     Cvar_RegisterVariable (&joy_pitchsensitivity);
  505.     Cvar_RegisterVariable (&joy_yawsensitivity);
  506.     Cvar_RegisterVariable (&joy_wwhack1);
  507.     Cvar_RegisterVariable (&joy_wwhack2);
  508.  
  509.     Cmd_AddCommand ("force_centerview", Force_CenterView_f);
  510.     Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
  511.  
  512.     uiWheelMessage = RegisterWindowMessage ( "MSWHEEL_ROLLMSG" );
  513.  
  514.     IN_StartupMouse ();
  515.     IN_StartupJoystick ();
  516. }
  517.  
  518. /*
  519. ===========
  520. IN_Shutdown
  521. ===========
  522. */
  523. void IN_Shutdown (void)
  524. {
  525.  
  526.     IN_DeactivateMouse ();
  527.     IN_ShowMouse ();
  528.  
  529.     if (g_pMouse)
  530.     {
  531.         IDirectInputDevice_Release(g_pMouse);
  532.         g_pMouse = NULL;
  533.     }
  534.  
  535.     if (g_pdi)
  536.     {
  537.         IDirectInput_Release(g_pdi);
  538.         g_pdi = NULL;
  539.     }
  540. }
  541.  
  542.  
  543. /*
  544. ===========
  545. IN_MouseEvent
  546. ===========
  547. */
  548. void IN_MouseEvent (int mstate)
  549. {
  550.     int        i;
  551.  
  552.     if (mouseactive && !dinput)
  553.     {
  554.     // perform button actions
  555.         for (i=0 ; i<mouse_buttons ; i++)
  556.         {
  557.             if ( (mstate & (1<<i)) &&
  558.                 !(mouse_oldbuttonstate & (1<<i)) )
  559.             {
  560.                 Key_Event (K_MOUSE1 + i, true);
  561.             }
  562.  
  563.             if ( !(mstate & (1<<i)) &&
  564.                 (mouse_oldbuttonstate & (1<<i)) )
  565.             {
  566.                     Key_Event (K_MOUSE1 + i, false);
  567.             }
  568.         }    
  569.             
  570.         mouse_oldbuttonstate = mstate;
  571.     }
  572. }
  573.  
  574.  
  575. /*
  576. ===========
  577. IN_MouseMove
  578. ===========
  579. */
  580. void IN_MouseMove (usercmd_t *cmd)
  581. {
  582.     int        mx, my;
  583.     HDC    hdc;
  584.     int                    i;
  585.     DIDEVICEOBJECTDATA    od;
  586.     DWORD                dwElements;
  587.     HRESULT                hr;
  588.  
  589.     if (!mouseactive)
  590.         return;
  591.  
  592.     if (dinput)
  593.     {
  594.         mx = 0;
  595.         my = 0;
  596.  
  597.         for (;;)
  598.         {
  599.             dwElements = 1;
  600.  
  601.             hr = IDirectInputDevice_GetDeviceData(g_pMouse,
  602.                     sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
  603.  
  604.             if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
  605.             {
  606.                 dinput_acquired = true;
  607.                 IDirectInputDevice_Acquire(g_pMouse);
  608.                 break;
  609.             }
  610.  
  611.             /* Unable to read data or no data available */
  612.             if (FAILED(hr) || dwElements == 0)
  613.             {
  614.                 break;
  615.             }
  616.  
  617.             /* Look at the element to see what happened */
  618.  
  619.             switch (od.dwOfs)
  620.             {
  621.                 case DIMOFS_X:
  622.                     mx += od.dwData;
  623.                     break;
  624.  
  625.                 case DIMOFS_Y:
  626.                     my += od.dwData;
  627.                     break;
  628.  
  629.                 case DIMOFS_BUTTON0:
  630.                     if (od.dwData & 0x80)
  631.                         mstate_di |= 1;
  632.                     else
  633.                         mstate_di &= ~1;
  634.                     break;
  635.  
  636.                 case DIMOFS_BUTTON1:
  637.                     if (od.dwData & 0x80)
  638.                         mstate_di |= (1<<1);
  639.                     else
  640.                         mstate_di &= ~(1<<1);
  641.                     break;
  642.                     
  643.                 case DIMOFS_BUTTON2:
  644.                     if (od.dwData & 0x80)
  645.                         mstate_di |= (1<<2);
  646.                     else
  647.                         mstate_di &= ~(1<<2);
  648.                     break;
  649.             }
  650.         }
  651.  
  652.     // perform button actions
  653.         for (i=0 ; i<mouse_buttons ; i++)
  654.         {
  655.             if ( (mstate_di & (1<<i)) &&
  656.                 !(mouse_oldbuttonstate & (1<<i)) )
  657.             {
  658.                 Key_Event (K_MOUSE1 + i, true);
  659.             }
  660.  
  661.             if ( !(mstate_di & (1<<i)) &&
  662.                 (mouse_oldbuttonstate & (1<<i)) )
  663.             {
  664.                 Key_Event (K_MOUSE1 + i, false);
  665.             }
  666.         }    
  667.             
  668.         mouse_oldbuttonstate = mstate_di;
  669.     }
  670.     else
  671.     {
  672.         GetCursorPos (¤t_pos);
  673.     mx = current_pos.x - window_center_x + mx_accum;
  674.     my = current_pos.y - window_center_y + my_accum;
  675.     mx_accum = 0;
  676.     my_accum = 0;
  677.     }
  678.  
  679.     if (m_filter.value)
  680.     {
  681.         mouse_x = (mx + old_mouse_x) * 0.5;
  682.         mouse_y = (my + old_mouse_y) * 0.5;
  683.     }
  684.     else
  685.     {
  686.         mouse_x = mx;
  687.         mouse_y = my;
  688.     }
  689.  
  690.     old_mouse_x = mx;
  691.     old_mouse_y = my;
  692.  
  693.     mouse_x *= sensitivity.value;
  694.     mouse_y *= sensitivity.value;
  695.  
  696. // add mouse X/Y movement to cmd
  697.     if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
  698.         cmd->sidemove += m_side.value * mouse_x;
  699.     else
  700.         cl.viewangles[YAW] -= m_yaw.value * mouse_x;
  701.  
  702.     if (in_mlook.state & 1)
  703.         V_StopPitchDrift ();
  704.         
  705.     if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
  706.     {
  707.         cl.viewangles[PITCH] += m_pitch.value * mouse_y;
  708.         if (cl.viewangles[PITCH] > 80)
  709.             cl.viewangles[PITCH] = 80;
  710.         if (cl.viewangles[PITCH] < -70)
  711.             cl.viewangles[PITCH] = -70;
  712.     }
  713.     else
  714.     {
  715.         if ((in_strafe.state & 1) && noclip_anglehack)
  716.             cmd->upmove -= m_forward.value * mouse_y;
  717.         else
  718.             cmd->forwardmove -= m_forward.value * mouse_y;
  719.     }
  720.  
  721. // if the mouse has moved, force it to the center, so there's room to move
  722.     if (mx || my)
  723.     {
  724.         SetCursorPos (window_center_x, window_center_y);
  725.     }
  726. }
  727.  
  728.  
  729. /*
  730. ===========
  731. IN_Move
  732. ===========
  733. */
  734. void IN_Move (usercmd_t *cmd)
  735. {
  736.  
  737.     if (ActiveApp && !Minimized)
  738.     {
  739.         IN_MouseMove (cmd);
  740.         IN_JoyMove (cmd);
  741.     }
  742. }
  743.  
  744.  
  745. /*
  746. ===========
  747. IN_Accumulate
  748. ===========
  749. */
  750. void IN_Accumulate (void)
  751. {
  752.     int        mx, my;
  753.     HDC    hdc;
  754.  
  755.     if (mouseactive)
  756.     {
  757.         GetCursorPos (¤t_pos);
  758.  
  759.         mx_accum += current_pos.x - window_center_x;
  760.         my_accum += current_pos.y - window_center_y;
  761.  
  762.     // force the mouse to the center, so there's room to move
  763.         SetCursorPos (window_center_x, window_center_y);
  764.     }
  765. }
  766.  
  767.  
  768. /*
  769. ===================
  770. IN_ClearStates
  771. ===================
  772. */
  773. void IN_ClearStates (void)
  774. {
  775.  
  776.     if (mouseactive)
  777.     {
  778.         mx_accum = 0;
  779.         my_accum = 0;
  780.         mouse_oldbuttonstate = 0;
  781.     }
  782. }
  783.  
  784.  
  785. /* 
  786. =============== 
  787. IN_StartupJoystick 
  788. =============== 
  789. */  
  790. void IN_StartupJoystick (void) 
  791. { 
  792.     int            i, numdevs;
  793.     JOYCAPS        jc;
  794.     MMRESULT    mmr;
  795.  
  796.      // assume no joystick
  797.     joy_avail = false; 
  798.  
  799.     // abort startup if user requests no joystick
  800.     if ( COM_CheckParm ("-nojoy") ) 
  801.         return; 
  802.  
  803.     // verify joystick driver is present
  804.     if ((numdevs = joyGetNumDevs ()) == 0)
  805.     {
  806.         Con_Printf ("\njoystick not found -- driver not present\n\n");
  807.         return;
  808.     }
  809.  
  810.     // cycle through the joystick ids for the first valid one
  811.     for (joy_id=0 ; joy_id<numdevs ; joy_id++)
  812.     {
  813.         memset (&ji, 0, sizeof(ji));
  814.         ji.dwSize = sizeof(ji);
  815.         ji.dwFlags = JOY_RETURNCENTERED;
  816.  
  817.         if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR)
  818.             break;
  819.     } 
  820.  
  821.     // abort startup if we didn't find a valid joystick
  822.     if (mmr != JOYERR_NOERROR)
  823.     {
  824.         Con_Printf ("\njoystick not found -- no valid joysticks (%x)\n\n", mmr);
  825.         return;
  826.     }
  827.  
  828.     // get the capabilities of the selected joystick
  829.     // abort startup if command fails
  830.     memset (&jc, 0, sizeof(jc));
  831.     if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof(jc))) != JOYERR_NOERROR)
  832.     {
  833.         Con_Printf ("\njoystick not found -- invalid joystick capabilities (%x)\n\n", mmr); 
  834.         return;
  835.     }
  836.  
  837.     // save the joystick's number of buttons and POV status
  838.     joy_numbuttons = jc.wNumButtons;
  839.     joy_haspov = jc.wCaps & JOYCAPS_HASPOV;
  840.  
  841.     // old button and POV states default to no buttons pressed
  842.     joy_oldbuttonstate = joy_oldpovstate = 0;
  843.  
  844.     // mark the joystick as available and advanced initialization not completed
  845.     // this is needed as cvars are not available during initialization
  846.  
  847.     joy_avail = true; 
  848.     joy_advancedinit = false;
  849.  
  850.     Con_Printf ("\njoystick detected\n\n"); 
  851. }
  852.  
  853.  
  854. /*
  855. ===========
  856. RawValuePointer
  857. ===========
  858. */
  859. PDWORD RawValuePointer (int axis)
  860. {
  861.     switch (axis)
  862.     {
  863.     case JOY_AXIS_X:
  864.         return &ji.dwXpos;
  865.     case JOY_AXIS_Y:
  866.         return &ji.dwYpos;
  867.     case JOY_AXIS_Z:
  868.         return &ji.dwZpos;
  869.     case JOY_AXIS_R:
  870.         return &ji.dwRpos;
  871.     case JOY_AXIS_U:
  872.         return &ji.dwUpos;
  873.     case JOY_AXIS_V:
  874.         return &ji.dwVpos;
  875.     }
  876. }
  877.  
  878.  
  879. /*
  880. ===========
  881. Joy_AdvancedUpdate_f
  882. ===========
  883. */
  884. void Joy_AdvancedUpdate_f (void)
  885. {
  886.  
  887.     // called once by IN_ReadJoystick and by user whenever an update is needed
  888.     // cvars are now available
  889.     int    i;
  890.     DWORD dwTemp;
  891.  
  892.     // initialize all the maps
  893.     for (i = 0; i < JOY_MAX_AXES; i++)
  894.     {
  895.         dwAxisMap[i] = AxisNada;
  896.         dwControlMap[i] = JOY_ABSOLUTE_AXIS;
  897.         pdwRawValue[i] = RawValuePointer(i);
  898.     }
  899.  
  900.     if( joy_advanced.value == 0.0)
  901.     {
  902.         // default joystick initialization
  903.         // 2 axes only with joystick control
  904.         dwAxisMap[JOY_AXIS_X] = AxisTurn;
  905.         // dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
  906.         dwAxisMap[JOY_AXIS_Y] = AxisForward;
  907.         // dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
  908.     }
  909.     else
  910.     {
  911.         if (Q_strcmp (joy_name.string, "joystick") != 0)
  912.         {
  913.             // notify user of advanced controller
  914.             Con_Printf ("\n%s configured\n\n", joy_name.string);
  915.         }
  916.  
  917.         // advanced initialization here
  918.         // data supplied by user via joy_axisn cvars
  919.         dwTemp = (DWORD) joy_advaxisx.value;
  920.         dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
  921.         dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
  922.         dwTemp = (DWORD) joy_advaxisy.value;
  923.         dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
  924.         dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
  925.         dwTemp = (DWORD) joy_advaxisz.value;
  926.         dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
  927.         dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
  928.         dwTemp = (DWORD) joy_advaxisr.value;
  929.         dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
  930.         dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
  931.         dwTemp = (DWORD) joy_advaxisu.value;
  932.         dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
  933.         dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
  934.         dwTemp = (DWORD) joy_advaxisv.value;
  935.         dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
  936.         dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
  937.     }
  938.  
  939.     // compute the axes to collect from DirectInput
  940.     joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV;
  941.     for (i = 0; i < JOY_MAX_AXES; i++)
  942.     {
  943.         if (dwAxisMap[i] != AxisNada)
  944.         {
  945.             joy_flags |= dwAxisFlags[i];
  946.         }
  947.     }
  948. }
  949.  
  950.  
  951. /*
  952. ===========
  953. IN_Commands
  954. ===========
  955. */
  956. void IN_Commands (void)
  957. {
  958.     int        i, key_index;
  959.     DWORD    buttonstate, povstate;
  960.  
  961.     if (!joy_avail)
  962.     {
  963.         return;
  964.     }
  965.  
  966.     
  967.     // loop through the joystick buttons
  968.     // key a joystick event or auxillary event for higher number buttons for each state change
  969.     buttonstate = ji.dwButtons;
  970.     for (i=0 ; i < joy_numbuttons ; i++)
  971.     {
  972.         if ( (buttonstate & (1<<i)) && !(joy_oldbuttonstate & (1<<i)) )
  973.         {
  974.             key_index = (i < 4) ? K_JOY1 : K_AUX1;
  975.             Key_Event (key_index + i, true);
  976.         }
  977.  
  978.         if ( !(buttonstate & (1<<i)) && (joy_oldbuttonstate & (1<<i)) )
  979.         {
  980.             key_index = (i < 4) ? K_JOY1 : K_AUX1;
  981.             Key_Event (key_index + i, false);
  982.         }
  983.     }
  984.     joy_oldbuttonstate = buttonstate;
  985.  
  986.     if (joy_haspov)
  987.     {
  988.         // convert POV information into 4 bits of state information
  989.         // this avoids any potential problems related to moving from one
  990.         // direction to another without going through the center position
  991.         povstate = 0;
  992.         if(ji.dwPOV != JOY_POVCENTERED)
  993.         {
  994.             if (ji.dwPOV == JOY_POVFORWARD)
  995.                 povstate |= 0x01;
  996.             if (ji.dwPOV == JOY_POVRIGHT)
  997.                 povstate |= 0x02;
  998.             if (ji.dwPOV == JOY_POVBACKWARD)
  999.                 povstate |= 0x04;
  1000.             if (ji.dwPOV == JOY_POVLEFT)
  1001.                 povstate |= 0x08;
  1002.         }
  1003.         // determine which bits have changed and key an auxillary event for each change
  1004.         for (i=0 ; i < 4 ; i++)
  1005.         {
  1006.             if ( (povstate & (1<<i)) && !(joy_oldpovstate & (1<<i)) )
  1007.             {
  1008.                 Key_Event (K_AUX29 + i, true);
  1009.             }
  1010.  
  1011.             if ( !(povstate & (1<<i)) && (joy_oldpovstate & (1<<i)) )
  1012.             {
  1013.                 Key_Event (K_AUX29 + i, false);
  1014.             }
  1015.         }
  1016.         joy_oldpovstate = povstate;
  1017.     }
  1018. }
  1019.  
  1020.  
  1021. /* 
  1022. =============== 
  1023. IN_ReadJoystick
  1024. =============== 
  1025. */  
  1026. qboolean IN_ReadJoystick (void)
  1027. {
  1028.  
  1029.     memset (&ji, 0, sizeof(ji));
  1030.     ji.dwSize = sizeof(ji);
  1031.     ji.dwFlags = joy_flags;
  1032.  
  1033.     if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR)
  1034.     {
  1035.         // this is a hack -- there is a bug in the Logitech WingMan Warrior DirectInput Driver
  1036.         // rather than having 32768 be the zero point, they have the zero point at 32668
  1037.         // go figure -- anyway, now we get the full resolution out of the device
  1038.         if (joy_wwhack1.value != 0.0)
  1039.         {
  1040.             ji.dwUpos += 100;
  1041.         }
  1042.         return true;
  1043.     }
  1044.     else
  1045.     {
  1046.         // read error occurred
  1047.         // turning off the joystick seems too harsh for 1 read error,\
  1048.         // but what should be done?
  1049.         // Con_Printf ("IN_ReadJoystick: no response\n");
  1050.         // joy_avail = false;
  1051.         return false;
  1052.     }
  1053. }
  1054.  
  1055.  
  1056. /*
  1057. ===========
  1058. IN_JoyMove
  1059. ===========
  1060. */
  1061. void IN_JoyMove (usercmd_t *cmd)
  1062. {
  1063.     float    speed, aspeed;
  1064.     float    fAxisValue, fTemp;
  1065.     int        i;
  1066.  
  1067.     // complete initialization if first time in
  1068.     // this is needed as cvars are not available at initialization time
  1069.     if( joy_advancedinit != true )
  1070.     {
  1071.         Joy_AdvancedUpdate_f();
  1072.         joy_advancedinit = true;
  1073.     }
  1074.  
  1075.     // verify joystick is available and that the user wants to use it
  1076.     if (!joy_avail || !in_joystick.value)
  1077.     {
  1078.         return; 
  1079.     }
  1080.  
  1081.     // collect the joystick data, if possible
  1082.     if (IN_ReadJoystick () != true)
  1083.     {
  1084.         return;
  1085.     }
  1086.  
  1087.     if (in_speed.state & 1)
  1088.         speed = cl_movespeedkey.value;
  1089.     else
  1090.         speed = 1;
  1091.     aspeed = speed * host_frametime;
  1092.  
  1093.     // loop through the axes
  1094.     for (i = 0; i < JOY_MAX_AXES; i++)
  1095.     {
  1096.         // get the floating point zero-centered, potentially-inverted data for the current axis
  1097.         fAxisValue = (float) *pdwRawValue[i];
  1098.         // move centerpoint to zero
  1099.         fAxisValue -= 32768.0;
  1100.  
  1101.         if (joy_wwhack2.value != 0.0)
  1102.         {
  1103.             if (dwAxisMap[i] == AxisTurn)
  1104.             {
  1105.                 // this is a special formula for the Logitech WingMan Warrior
  1106.                 // y=ax^b; where a = 300 and b = 1.3
  1107.                 // also x values are in increments of 800 (so this is factored out)
  1108.                 // then bounds check result to level out excessively high spin rates
  1109.                 fTemp = 300.0 * pow(abs(fAxisValue) / 800.0, 1.3);
  1110.                 if (fTemp > 14000.0)
  1111.                     fTemp = 14000.0;
  1112.                 // restore direction information
  1113.                 fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp;
  1114.             }
  1115.         }
  1116.  
  1117.         // convert range from -32768..32767 to -1..1 
  1118.         fAxisValue /= 32768.0;
  1119.  
  1120.         switch (dwAxisMap[i])
  1121.         {
  1122.         case AxisForward:
  1123.             if ((joy_advanced.value == 0.0) && (in_mlook.state & 1))
  1124.             {
  1125.                 // user wants forward control to become look control
  1126.                 if (fabs(fAxisValue) > joy_pitchthreshold.value)
  1127.                 {        
  1128.                     // if mouse invert is on, invert the joystick pitch value
  1129.                     // only absolute control support here (joy_advanced is false)
  1130.                     if (m_pitch.value < 0.0)
  1131.                     {
  1132.                         cl.viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
  1133.                     }
  1134.                     else
  1135.                     {
  1136.                         cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
  1137.                     }
  1138.                     V_StopPitchDrift();
  1139.                 }
  1140.                 else
  1141.                 {
  1142.                     // no pitch movement
  1143.                     // disable pitch return-to-center unless requested by user
  1144.                     // *** this code can be removed when the lookspring bug is fixed
  1145.                     // *** the bug always has the lookspring feature on
  1146.                     if(lookspring.value == 0.0)
  1147.                         V_StopPitchDrift();
  1148.                 }
  1149.             }
  1150.             else
  1151.             {
  1152.                 // user wants forward control to be forward control
  1153.                 if (fabs(fAxisValue) > joy_forwardthreshold.value)
  1154.                 {
  1155.                     cmd->forwardmove += (fAxisValue * joy_forwardsensitivity.value) * speed * cl_forwardspeed.value;
  1156.                 }
  1157.             }
  1158.             break;
  1159.  
  1160.         case AxisSide:
  1161.             if (fabs(fAxisValue) > joy_sidethreshold.value)
  1162.             {
  1163.                 cmd->sidemove += (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
  1164.             }
  1165.             break;
  1166.  
  1167.         case AxisTurn:
  1168.             if ((in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1)))
  1169.             {
  1170.                 // user wants turn control to become side control
  1171.                 if (fabs(fAxisValue) > joy_sidethreshold.value)
  1172.                 {
  1173.                     cmd->sidemove -= (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
  1174.                 }
  1175.             }
  1176.             else
  1177.             {
  1178.                 // user wants turn control to be turn control
  1179.                 if (fabs(fAxisValue) > joy_yawthreshold.value)
  1180.                 {
  1181.                     if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
  1182.                     {
  1183.                         cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * aspeed * cl_yawspeed.value;
  1184.                     }
  1185.                     else
  1186.                     {
  1187.                         cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * speed * 180.0;
  1188.                     }
  1189.  
  1190.                 }
  1191.             }
  1192.             break;
  1193.  
  1194.         case AxisLook:
  1195.             if (in_mlook.state & 1)
  1196.             {
  1197.                 if (fabs(fAxisValue) > joy_pitchthreshold.value)
  1198.                 {
  1199.                     // pitch movement detected and pitch movement desired by user
  1200.                     if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
  1201.                     {
  1202.                         cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
  1203.                     }
  1204.                     else
  1205.                     {
  1206.                         cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * speed * 180.0;
  1207.                     }
  1208.                     V_StopPitchDrift();
  1209.                 }
  1210.                 else
  1211.                 {
  1212.                     // no pitch movement
  1213.                     // disable pitch return-to-center unless requested by user
  1214.                     // *** this code can be removed when the lookspring bug is fixed
  1215.                     // *** the bug always has the lookspring feature on
  1216.                     if(lookspring.value == 0.0)
  1217.                         V_StopPitchDrift();
  1218.                 }
  1219.             }
  1220.             break;
  1221.  
  1222.         default:
  1223.             break;
  1224.         }
  1225.     }
  1226.  
  1227.     // bounds check pitch
  1228.     if (cl.viewangles[PITCH] > 80.0)
  1229.         cl.viewangles[PITCH] = 80.0;
  1230.     if (cl.viewangles[PITCH] < -70.0)
  1231.         cl.viewangles[PITCH] = -70.0;
  1232. }
  1233.