arch/win32/joyhh.c

   1 /* $Id: joyhh.c,v 1.5 2004-05-22 08:00:04 btb Exp $ */
   2 //JOYC.C for D1_3Dfx and D1OpenGL
   3 //D1_3Dfx is a Win32 executable using Glide and DirectX 3
   4 //D1OpenGL is a Win32 executable using OpenGL and DirectX 3
   5 //This joystick code should run on DirectInput 2 and higher
   6 //We are not using DirectX 5 for now, since we want to stay compatible to the HH-loved Windows NT :).
   7 //So ForceFeedback is not supported
   8
   9 //Notes:
  10 // 1) Windows DirectX supports up to 7 axes, D1/DOS only 4, so we needed to increase the number to 7 at several points
  11 //    Also JOY_ALL_AXIS must be (1+2+4+8+16+32+64) in JOY.H file
  12 // 2) Windows DirectX supports up to 32 buttons. So far we however only support 4. Adding support for more should be however easily possible.
  13 // 3) _enable and _disable are not needed
  14 // 4) joy_bogus_reading is not needed, so all calls are just removed
  15 // 5) The joystick query goes over the DirectInputs function
  16 //    MMRESULT joyGetPosEx(UINT uJoyID, LPJOYINFOEX pji);
  17 //    All functions reading over BIOS, including the ASM code are removed
  18
  19
  20
  21 /*
  22 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  23 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  24 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  25 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  26 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  27 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  28 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  29 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  30 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  31 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  32 */
  33
  34 /*
  35 Modifications by Heiko Herrmann
  36 Later modified by Owen Evans to work with D1X (3/7/99)
  37 */
  38
  39
  40 #define _WIN32_OS               //HH
  41
  42 #include <windows.h>    //HH
  43 #include <mmsystem.h>   //HH
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46
  47 #include "types.h"
  48 #include "joy.h"
  49 #include "timer.h"
  50 #include "args.h"
  51
  52 #define my_hwnd g_hWnd // D1X compatibility
  53 extern HWND g_hWnd;
  54
  55 char joy_installed = 0;
  56 char joy_present = 0;
  57
  58 typedef struct Button_info {
  59         ubyte           ignore;
  60         ubyte           state;
  61         ubyte           last_state;
  62         int             timedown;
  63         ubyte           downcount;
  64         ubyte           upcount;
  65 } Button_info;
  66
  67 typedef struct Joy_info {
  68         int                     joyid;
  69         ubyte                   present_mask;
  70         ubyte       hat_present;
  71         ubyte                   slow_read;
  72         int                     max_timer;
  73         int                     read_count;
  74         ubyte                   last_value;
  75         Button_info     buttons[MAX_BUTTONS];
  76         int                     axis_min[JOY_NUM_AXES];    //changed
  77         int                     axis_center[JOY_NUM_AXES]; //changed --orulz
  78         int                     axis_max[JOY_NUM_AXES];    //changed
  79 } Joy_info;
  80
  81 Joy_info joystick;
  82
  83
  84 int joy_deadzone = 0;
  85
  86 void joy_get_cal_vals(int *axis_min, int *axis_center, int *axis_max)
  87 {
  88         int i;
  89
  90         for (i=0; i<JOY_NUM_AXES; i++)             {       //changed - orulz
  91                 axis_min[i] = joystick.axis_min[i];
  92                 axis_center[i] = joystick.axis_center[i];
  93                 axis_max[i] = joystick.axis_max[i];
  94         }
  95 }
  96
  97 void joy_set_cal_vals(int *axis_min, int *axis_center, int *axis_max)
  98 {
  99         int i;
 100
 101         for (i=0; i<JOY_NUM_AXES; i++)             {       //changed - orulz
 102                 joystick.axis_min[i] = axis_min[i];
 103                 joystick.axis_center[i] = axis_center[i];
 104                 joystick.axis_max[i] = axis_max[i];
 105         }
 106 }
 107
 108 ubyte joy_get_present_mask()    {
 109         return joystick.present_mask;
 110 }
 111
 112 void joy_set_timer_rate(int max_value ) {
 113         joystick.max_timer = max_value;
 114 }
 115
 116 int joy_get_timer_rate()        {
 117         return joystick.max_timer;
 118 }
 119
 120 void joy_flush()        {
 121         int i;
 122
 123         if (!joy_installed) return;
 124
 125         for (i=0; i<MAX_BUTTONS; i++ )  {
 126                 joystick.buttons[i].ignore = 0;
 127                 joystick.buttons[i].state = 0;
 128                 joystick.buttons[i].timedown = 0;
 129                 joystick.buttons[i].downcount = 0;
 130                 joystick.buttons[i].upcount = 0;
 131         }
 132
 133 }
 134
 135
 136 //Begin section modified 3/7/99 - Owen Evans
 137
 138 ubyte joy_read_raw_buttons()
 139 {
 140         JOYINFOEX joy;
 141         int i;
 142
 143         if (!joy_present)
 144                 return 0;
 145
 146         memset(&joy, 0, sizeof(joy));
 147         joy.dwSize = sizeof(joy);
 148         joy.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOVCTS | JOY_USEDEADZONE;
 149
 150         if (joyGetPosEx(joystick.joyid, &joy)!=JOYERR_NOERROR)
 151                 return 0;
 152
 153         for (i = 0; i < MAX_BUTTONS; i++) {
 154                 joystick.buttons[i].last_state = joystick.buttons[i].state;
 155                 joystick.buttons[i].state = (joy.dwButtons >> i) & 0x1;
 156                 if (!joystick.buttons[i].last_state && joystick.buttons[i].state) {
 157                         joystick.buttons[i].timedown = timer_get_fixed_seconds();
 158                         joystick.buttons[i].downcount++;
 159                 }
 160         }
 161
 162         /* Hat stuff */
 163
 164         if (joystick.hat_present && joy.dwPOV != JOY_POVCENTERED)
 165          {
 166            joystick.buttons[19].state = (joy.dwPOV < JOY_POVRIGHT || joy.dwPOV > JOY_POVLEFT);
 167            joystick.buttons[15].state = (joy.dwPOV < JOY_POVBACKWARD && joy.dwPOV > JOY_POVFORWARD);
 168            joystick.buttons[11].state = (joy.dwPOV < JOY_POVLEFT && joy.dwPOV > JOY_POVRIGHT);
 169            joystick.buttons[7].state = (joy.dwPOV > JOY_POVBACKWARD);
 170          }
 171
 172         return (ubyte)joy.dwButtons;
 173 }
 174
 175 //end changed section - OE
 176
 177
 178 ubyte joystick_read_raw_axis( ubyte mask, int * axis )
 179 {
 180         JOYINFOEX       joy;
 181         ubyte read_masks = 0;
 182
 183         axis[0] = 0; axis[1] = 0; //orulz: 1=x 2=y 3=r 4=z 5=u 6=v
 184         axis[2] = 0; axis[3] = 0;
 185         axis[4] = 0; axis[5] = 0; //HH: Added support for axes R and U
 186
 187         if (!joy_installed) {
 188                 return 0;
 189         }
 190
 191         memset(&joy, 0, sizeof(joy));
 192         joy.dwSize = sizeof(joy);
 193         joy.dwFlags = JOY_RETURNALL | JOY_USEDEADZONE;
 194         if (joyGetPosEx(joystick.joyid, &joy)!=JOYERR_NOERROR) {
 195                 return 0;
 196         }
 197
 198         mask &= joystick.present_mask;                  // Don't read non-present channels
 199         if ( mask==0 )  {
 200                 return 0;               // Don't read if no stick connected.
 201         }
 202
 203         if (mask & JOY_1_X_AXIS) { axis[0] = joy.dwXpos; read_masks |= JOY_1_X_AXIS; }
 204         if (mask & JOY_1_Y_AXIS) { axis[1] = joy.dwYpos; read_masks |= JOY_1_Y_AXIS; }
 205 //orulz:
 206 //        if (mask & JOY_1_Z_AXIS) { axis[2] = joy.dwZpos; read_masks |= JOY_1_Z_AXIS; }
 207 //        if (mask & JOY_1_POV)    { axis[3] = joy.dwPOV;  read_masks |= JOY_1_POV;    }
 208 //        if (mask & JOY_1_R_AXIS) { axis[4] = joy.dwRpos; read_masks |= JOY_1_R_AXIS; }
 209 //        if (mask & JOY_1_U_AXIS) { axis[5] = joy.dwUpos; read_masks |= JOY_1_U_AXIS; }
 210 //        if (mask & JOY_1_V_AXIS) { axis[6] = joy.dwVpos; read_masks |= JOY_1_V_AXIS; }
 211         if (mask & JOY_1_R_AXIS) { axis[2] = joy.dwRpos; read_masks |= JOY_1_R_AXIS; }
 212         if (mask & JOY_1_Z_AXIS) { axis[3] = joy.dwZpos; read_masks |= JOY_1_Z_AXIS; }
 213         if (mask & JOY_1_U_AXIS) { axis[4] = joy.dwZpos; read_masks |= JOY_1_U_AXIS; }
 214         if (mask & JOY_1_V_AXIS) { axis[5] = joy.dwUpos; read_masks |= JOY_1_V_AXIS; }
 215
 216         return read_masks;
 217 }
 218
 219 int hh_average(int val1, int val2)
 220 {
 221         return abs(val1-val2)/2;
 222 }
 223
 224 int joy_init(int joyid) //HH: added joyid parameter
 225 {
 226         int i;
 227         int temp_axis[JOY_NUM_AXES];       //changed - orulz
 228         JOYCAPS pjc;
 229
 230         if (FindArg("-nojoystick"))
 231                 return 0;
 232
 233         atexit(joy_close);      //HH: we are a bit lazy :). Errors are ignored, so we are even double-lazy :)
 234
 235         joy_flush();
 236         memset(&joystick, 0, sizeof(joystick));
 237
 238         for (i=0; i<MAX_BUTTONS; i++)
 239                 joystick.buttons[i].last_state = 0;
 240
 241         if ( !joy_installed )   {
 242                 joy_present = 0;
 243                 joy_installed = 1;
 244                 joystick.max_timer = 65536;
 245                 joystick.read_count = 0;
 246                 joystick.last_value = 0;
 247         }
 248
 249
 250         joystick.present_mask = JOY_ALL_AXIS;           // Assume they're all present
 251         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, temp_axis );
 252
 253         if ( joystick.present_mask & 3 )
 254                 joy_present = 1;
 255         else
 256                 joy_present = 0;
 257
 258
 259         //HH: Main Win32 joystick initialization, incl. reading cal. stuff
 260
 261         if (joyGetDevCaps(joyid, &pjc, sizeof(pjc))!=JOYERR_NOERROR) {
 262                 return 0;
 263         }
 264
 265         if (joySetThreshold(joyid, pjc.wXmax/256)!=JOYERR_NOERROR) {
 266                 return 0;
 267         }
 268
 269         joystick.max_timer      = pjc.wPeriodMax;
 270         joystick.axis_min[0]    = pjc.wXmin;
 271         joystick.axis_min[1]    = pjc.wYmin;
 272 //orulz:
 273 //        joystick.axis_min[2]    = pjc.wZmin;
 274 //        //HH: joystick.axis_min[3]  = pov-stuff
 275 //        joystick.axis_min[4]    = pjc.wRmin;
 276 //        joystick.axis_min[5]    = pjc.wUmin;
 277 //        joystick.axis_min[6]    = pjc.wVmin;
 278         joystick.axis_min[2]    = pjc.wRmin;
 279         joystick.axis_min[3]    = pjc.wZmin;
 280         joystick.axis_min[4]    = pjc.wUmin;
 281         joystick.axis_min[5]    = pjc.wVmin;
 282
 283         joystick.axis_max[0]    = pjc.wXmax;
 284         joystick.axis_max[1]    = pjc.wYmax;
 285 //orulz:
 286 //        joystick.axis_max[2]    = pjc.wZmax;
 287 //        //HH: joystick.axis_max[3]  = pov-stuff
 288 //        joystick.axis_max[4]    = pjc.wRmax;
 289 //        joystick.axis_max[5]    = pjc.wUmax;
 290 //        joystick.axis_max[6]    = pjc.wVmax;
 291         joystick.axis_max[2]    = pjc.wRmax;
 292         joystick.axis_max[3]    = pjc.wZmax;
 293         joystick.axis_max[4]    = pjc.wUmax;
 294         joystick.axis_max[5]    = pjc.wVmax;
 295
 296         joystick.axis_center[0] = hh_average(pjc.wXmax,pjc.wXmin);
 297         joystick.axis_center[1] = hh_average(pjc.wYmax,pjc.wYmin);
 298 //orulz:
 299 //        joystick.axis_center[2] = hh_average(pjc.wZmax,pjc.wZmin);
 300 //        joystick.axis_center[3] = JOY_POVCENTERED;
 301 //        joystick.axis_center[4] = hh_average(pjc.wRmax,pjc.wRmin);
 302 //        joystick.axis_center[5] = hh_average(pjc.wUmax,pjc.wUmin);
 303 //        joystick.axis_center[6] = hh_average(pjc.wVmax,pjc.wVmin);
 304         joystick.axis_center[2] = hh_average(pjc.wRmax,pjc.wRmin);
 305         joystick.axis_center[3] = hh_average(pjc.wZmax,pjc.wZmin);
 306         joystick.axis_center[4] = hh_average(pjc.wUmax,pjc.wUmin);
 307         joystick.axis_center[5] = hh_average(pjc.wVmax,pjc.wVmin);
 308
 309         joystick.present_mask = JOY_1_X_AXIS | JOY_1_Y_AXIS;
 310         if (pjc.wCaps & JOYCAPS_HASZ)   joystick.present_mask |= JOY_1_Z_AXIS;
 311         joystick.hat_present = (pjc.wCaps & JOYCAPS_HASPOV) > 0;
 312         if (pjc.wCaps & JOYCAPS_HASR)   joystick.present_mask |= JOY_1_R_AXIS;
 313         if (pjc.wCaps & JOYCAPS_HASU)   joystick.present_mask |= JOY_1_U_AXIS;
 314         if (pjc.wCaps & JOYCAPS_HASV)   joystick.present_mask |= JOY_1_V_AXIS;
 315
 316         return joy_present;
 317 }
 318
 319
 320 void joy_close()
 321 {
 322         if (!joy_installed) return;
 323         joy_installed = 0;
 324 }
 325
 326
 327 void joy_set_ul()
 328 {
 329         joystick.present_mask = JOY_ALL_AXIS;           // Assume they're all present
 330         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_min );
 331
 332         if ( joystick.present_mask & 3 )
 333                 joy_present = 1;
 334         else
 335                 joy_present = 0;
 336 }
 337
 338 void joy_set_lr()
 339 {
 340         joystick.present_mask = JOY_ALL_AXIS;           // Assume they're all present
 341         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_max );
 342
 343         if ( joystick.present_mask & 3 )
 344                 joy_present = 1;
 345         else
 346                 joy_present = 0;
 347 }
 348
 349 void joy_set_cen()
 350 {
 351         joystick.present_mask = JOY_ALL_AXIS;           // Assume they're all present
 352         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_center );
 353
 354         if ( joystick.present_mask & 3 )
 355                 joy_present = 1;
 356         else
 357                 joy_present = 0;
 358 }
 359
 360 void joy_set_cen_fake(int channel)
 361 { }
 362
 363
 364 int joy_get_scaled_reading( int raw, int axn )
 365 {
 366  int x, d;
 367
 368   // Make sure it's calibrated properly.
 369    if ( joystick.axis_center[axn] - joystick.axis_min[axn] < 128 )
 370     return 0; //HH: had to increase to 128
 371    if ( joystick.axis_max[axn] - joystick.axis_center[axn] < 128 )
 372     return 0; //HH: had to increase to 128
 373
 374         if (!(joystick.present_mask & (1 << axn)))
 375                 return 0; // fixes joy config bug where it'll always set an axis you don't even have. - 2000/01/14 Matt Mueller
 376
 377   raw -= joystick.axis_center[axn];
 378
 379    if ( raw < 0 )
 380     d = joystick.axis_center[axn]-joystick.axis_min[axn];
 381    else
 382     d = joystick.axis_max[axn]-joystick.axis_center[axn];
 383
 384
 385    if ( d )
 386     x = (raw << 7) / d;
 387    else
 388     x = 0;
 389
 390
 391    if ( x < -128 ) x = -128;
 392    if ( x > 127 ) x = 127;
 393
 394 //added on 4/13/99 by Victor Rachels to add deadzone control
 395   d =  (joy_deadzone) * 6;
 396    if ((x > (-1*d)) && (x < d))
 397     x = 0;
 398 //end this section addition -VR
 399
 400         return x;
 401 }
 402
 403 void joy_get_pos( int *x, int *y )
 404 {
 405         ubyte flags;
 406         int axis[JOY_NUM_AXES];
 407
 408         if ((!joy_installed)||(!joy_present)) { *x=*y=0; return; }
 409
 410         flags=joystick_read_raw_axis( JOY_1_X_AXIS+JOY_1_Y_AXIS, axis );
 411
 412         if ( flags & JOY_1_X_AXIS )
 413                 *x = joy_get_scaled_reading( axis[0], 0 );
 414         else
 415                 *x = 0;
 416
 417         if ( flags & JOY_1_Y_AXIS )
 418                 *y = joy_get_scaled_reading( axis[1], 1 );
 419         else
 420                 *y = 0;
 421 }
 422
 423 ubyte joy_read_stick( ubyte masks, int *axis )
 424 {
 425         ubyte flags;
 426         int raw_axis[JOY_NUM_AXES];
 427
 428         if ((!joy_installed)||(!joy_present)) {
 429                 axis[0] = 0; axis[1] = 0;
 430                 axis[2] = 0; axis[3] = 0;
 431                 axis[4] = 0; axis[5] = 0;
 432                 return 0;
 433         }
 434
 435         flags=joystick_read_raw_axis( masks, raw_axis );
 436
 437         if ( flags & JOY_1_X_AXIS )
 438                 axis[0] = joy_get_scaled_reading( raw_axis[0], 0 );
 439         else
 440                 axis[0] = 0;
 441
 442         if ( flags & JOY_1_Y_AXIS )
 443                 axis[1] = joy_get_scaled_reading( raw_axis[1], 1 );
 444         else
 445                 axis[1] = 0;
 446
 447         if ( flags & JOY_1_R_AXIS )
 448                 axis[2] = joy_get_scaled_reading( raw_axis[2], 2 );
 449         else
 450                 axis[2] = 0;
 451
 452         if ( flags & JOY_1_Z_AXIS )
 453                 axis[3] = joy_get_scaled_reading( raw_axis[3], 3 );
 454         else
 455                 axis[3] = 0;
 456
 457         if ( flags & JOY_1_U_AXIS )
 458                 axis[4] = joy_get_scaled_reading( raw_axis[4], 4);
 459         else
 460                 axis[4] = 0;
 461
 462         if ( flags & JOY_1_V_AXIS )
 463                 axis[5] = joy_get_scaled_reading( raw_axis[5], 5 );
 464         else
 465                 axis[5] = 0;
 466
 467
 468         return flags;
 469 }
 470
 471 int joy_get_btns()
 472 {
 473         if ((!joy_installed)||(!joy_present)) return 0;
 474
 475         return joy_read_raw_buttons();
 476 }
 477
 478
 479 //Begin section modified 3/7/99 - Owen Evans
 480
 481 void joy_get_btn_down_cnt( int *btn0, int *btn1 )
 482 {
 483         if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
 484
 485         joy_get_btns();
 486
 487         *btn0 = joystick.buttons[0].downcount;
 488         joystick.buttons[0].downcount = 0;
 489         *btn1 = joystick.buttons[1].downcount;
 490         joystick.buttons[1].downcount = 0;
 491 }
 492
 493 int joy_get_button_state( int btn )
 494 {
 495         if ((!joy_installed)||(!joy_present)) return 0;
 496         if ( btn >= MAX_BUTTONS ) return 0;
 497
 498         joy_get_btns();
 499
 500         return joystick.buttons[btn].state;
 501 }
 502
 503 int joy_get_button_up_cnt( int btn )
 504 {
 505         int count;
 506
 507         if ((!joy_installed)||(!joy_present)) return 0;
 508
 509         if ( btn >= MAX_BUTTONS ) return 0;
 510
 511         count = joystick.buttons[btn].upcount;
 512         joystick.buttons[btn].upcount = 0;
 513
 514         return count;
 515 }
 516
 517 int joy_get_button_down_cnt( int btn )
 518 {
 519         int count;
 520
 521         if ((!joy_installed)||(!joy_present)) return 0;
 522         if ( btn >= MAX_BUTTONS ) return 0;
 523
 524         joy_get_btns();
 525
 526         count = joystick.buttons[btn].downcount;
 527         joystick.buttons[btn].downcount = 0;
 528
 529         return count;
 530 }
 531
 532 fix joy_get_button_down_time( int btn )
 533 {
 534         fix count;
 535
 536         if ((!joy_installed)||(!joy_present)) return 0;
 537         if ( btn >= MAX_BUTTONS ) return 0;
 538
 539         joy_get_btns();
 540
 541         if (joystick.buttons[btn].state) {
 542                 count = timer_get_fixed_seconds() - joystick.buttons[btn].timedown;
 543                 joystick.buttons[btn].timedown = 0;
 544         } else count = 0;
 545
 546         return count;
 547 }
 548
 549 //end changed section - OE
 550
 551
 552 void joy_get_btn_up_cnt( int *btn0, int *btn1 )
 553 {
 554         if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
 555
 556         *btn0 = joystick.buttons[0].upcount;
 557         joystick.buttons[0].upcount = 0;
 558         *btn1 = joystick.buttons[1].upcount;
 559         joystick.buttons[1].upcount = 0;
 560 }
 561
 562 void joy_set_btn_values( int btn, int state, fix timedown, int downcount, int upcount )
 563 {
 564         joystick.buttons[btn].ignore = 1;
 565         joystick.buttons[btn].state = state;
 566         joystick.buttons[btn].timedown = fixmuldiv( timedown, 1193180, 65536 );
 567         joystick.buttons[btn].downcount = downcount;
 568         joystick.buttons[btn].upcount = upcount;
 569 }
 570
 571 void joy_poll()
 572 {
 573 }
 574