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