in_win.c

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