home *** CD-ROM | disk | FTP | other *** search
/ Game Programming in C++ - Start to Finish / GameProgrammingS.iso / developer_install / ReplicaNetFreewareV5_4.exe / data1.cab / Program_Executable_Files / Example4 / DIInterface.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2005-10-30  |  23.4 KB  |  838 lines
  1. /* START_LICENSE_HEADER
  2.  
  3. Copyright (C) 2000 Martin Piper, original design and program code
  4. Copyright (C) 2001-2005 Replica Software
  5.  
  6. This program file is copyright (C) Replica Software and can only be used under license.
  7. For more information visit: http://www.replicanet.com/
  8. Or email: info@replicanet.com
  9.  
  10. END_LICENSE_HEADER */
  11. // Direct Input Interface code
  12. #include <stdio.h>
  13. #include <windows.h> 
  14. #include <assert.h>
  15. #define DIRECTINPUT_VERSION 0x0800
  16. #include <dinput.h> 
  17. #include <math.h> 
  18. #include "diinterface.h"
  19.  
  20. // Lots of nasty globals
  21. TDIHandler* gDIHandler = 0;
  22. bool gIgnoreDInputWarnings = true;
  23.  
  24.  
  25. TDIDevice::TDIDevice(void)
  26. {
  27.     fEffect = NULL;
  28.     fDevice = NULL;
  29.     fBuffer = NULL;
  30.  
  31.     fJoystick.fDIDevice = this;
  32. }
  33.  
  34. TDIDevice::~TDIDevice(void)
  35. {
  36.     if (fBuffer) delete [] fBuffer;
  37.     
  38.     if (fDevice)
  39.     {
  40.         fDevice->Unacquire();
  41.         fDevice->Release();
  42.     }
  43. }
  44.  
  45.  
  46.  
  47.  
  48. //
  49. //  void TDIDevice::Acquire(int acquire)
  50. //
  51. //
  52. //
  53. void TDIDevice::Acquire(int acquire)
  54. {
  55.     HRESULT hr;
  56.     
  57.     if (acquire)
  58.     {
  59.         hr=fDevice->Acquire();
  60.         if (NULL != fEffect) 
  61.         {      
  62.             HRESULT hr2;
  63.             hr2 = fEffect->Start( 1, 0 );
  64.         }
  65.     }
  66.     else
  67.         hr=fDevice->Unacquire();
  68.  
  69. #ifdef _DEBUG
  70.     if (!gIgnoreDInputWarnings)
  71.     {
  72.         switch (hr)
  73.         {
  74.             case DI_OK :
  75.                 printf("TDIDevice::Acquire - result = DI_OK\n");
  76.                 break;
  77.  
  78.             case S_FALSE :
  79.                 printf("TDIDevice::Acquire - result = S_FALSE (device already acquired)\n");
  80.                 break;
  81.  
  82.             case DIERR_INVALIDPARAM :
  83.                 printf("TDIDevice::Acquire - result = DIERR_INVALIDPARAM\n");
  84.                 break;
  85.  
  86.             case DIERR_NOTINITIALIZED :
  87.                 printf("TDIDevice::Acquire - result = DIERR_NOTINITIALIZED\n");
  88.                 break;
  89.  
  90.             case DIERR_OTHERAPPHASPRIO :
  91.                 printf("TDIDevice::Acquire - result = DIERR_OTHERAPPHASPRIO\n");
  92.                 break;
  93.         };
  94.  
  95.         assert(SUCCEEDED(hr));
  96.     }
  97. #endif
  98. }
  99.  
  100.  
  101. //
  102. // void TDIDevice::Read()
  103. //
  104. //
  105. //
  106. void TDIDevice::Read()
  107. {
  108.     HRESULT dirval = fDevice->GetDeviceState(fBufSize,(LPVOID)fBuffer);
  109.     if( dirval == DI_OK )
  110.         return;
  111.     
  112.     assert(dirval == DIERR_INPUTLOST || dirval == DIERR_NOTACQUIRED);
  113.     dirval = fDevice->Acquire();        // Might fail, but will work next frame
  114.     memset(fBuffer,0,fBufSize);
  115. }
  116.  
  117.  
  118.  
  119. //
  120. //  void TDIDevice::InitialiseKeyboard(REFGUID guid,LPCDIDATAFORMAT dataFormat,int bufferSize)
  121. //
  122. //
  123. //
  124. extern HWND                    ghWnd; 
  125. void TDIKeyboard::InitialiseKeyboard(REFGUID guid,LPCDIDATAFORMAT dataFormat,int bufferSize)
  126. {
  127.     memset(fDeBounce, 0, 256 * sizeof (int));
  128.  
  129. #if DIRECTINPUT_VERSION < DIRECTINPUT8_VERSION
  130.     LPDIRECTINPUTDEVICE tempDevice;
  131. #endif
  132.  
  133.     // initialise the buffer
  134.     fBufSize=bufferSize;
  135.     fBuffer = new char[bufferSize];
  136.     memset(fBuffer,0,bufferSize);
  137.     
  138. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION
  139.     // (DirectX8) create keyboard device
  140.     #if D3D_SDK_VERSION == DX_BETA_WEEKLY2
  141.         HRESULT hr = gDIHandler->fDI->CreateDevice(    guid,                            // guid
  142.                                                     &fDevice,                        // device
  143.                                                     NULL );                            // must be set to NULL
  144.     #else
  145.         HRESULT hr = gDIHandler->fDI->CreateDeviceEx(    guid,                        // guid
  146.                                                         IID_IDirectInputDevice8,    // interface req
  147.                                                         (LPVOID*) &fDevice,            // device
  148.                                                         NULL );                        // must be set to NULL
  149.     #endif
  150. #else
  151.     // create keyboard device
  152.     HRESULT hr = gDIHandler->fDI->CreateDevice(    guid,                                // guid
  153.                                                 &tempDevice,                        // device
  154.                                                 NULL );                                // must be set to NULL
  155.     assert(SUCCEEDED(hr));
  156.  
  157.     // query for IDirectInputDevice2 interface
  158.     hr = tempDevice->QueryInterface( IID_IDirectInputDevice2, (VOID**)&fDevice );
  159.     assert(SUCCEEDED(hr));
  160. #endif
  161.     
  162.     // set the data format
  163.     hr = fDevice->SetDataFormat(dataFormat); 
  164.     assert(SUCCEEDED(hr));
  165.     
  166.     // set the cooperative level
  167.     hr = fDevice->SetCooperativeLevel(ghWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE); 
  168.     assert(SUCCEEDED(hr));
  169.     
  170.     // acquire it
  171.     Acquire(true); 
  172. }
  173.  
  174.  
  175. //
  176. //   void TDIKeyboard::ReadInputs(void) 
  177. //
  178. //   fills in the fJoystick flags with the keyboard
  179. //
  180. void TDIKeyboard::ReadInputs(void) 
  181. {
  182.     fJoystick.Clear();
  183.  
  184.     Read();          // Check we have the keyboard
  185.  
  186.     if (SysKeyDown(DIK_LEFT))       fJoystick.fButtons |= JOYSTICK_LEFT;
  187.     if (SysKeyDown(DIK_RIGHT))      fJoystick.fButtons |= JOYSTICK_RIGHT;
  188.     if (SysKeyDown(DIK_UP))         fJoystick.fButtons |= JOYSTICK_UP;
  189.     if (SysKeyDown(DIK_DOWN))       fJoystick.fButtons |= JOYSTICK_DOWN;
  190.     if (SysKeyDown(DIK_SPACE))      fJoystick.fButtons |= JOYSTICK_JUMP;
  191.     if (SysKeyDown(DIK_H))            fJoystick.fButtons |= JOYSTICK_HORN;
  192.     if (SysKeyDown(DIK_O))            fJoystick.fButtons |= JOYSTICK_USE1;
  193.     if (SysKeyDown(DIK_P))            fJoystick.fButtons |= JOYSTICK_USE2;
  194.     if (SysKeyDown(DIK_J))          fJoystick.fButtons |= JOYSTICK_USE3;
  195.     if (SysKeyDown(DIK_TAB))        fJoystick.fButtons |= JOYSTICK_PULL_CAMERA;
  196.  
  197.     if (SysKeyDown(DIK_N))          fJoystick.fButtons |= JOYSTICK_LEFT;
  198.     if (SysKeyDown(DIK_M))          fJoystick.fButtons |= JOYSTICK_RIGHT;
  199.     if (SysKeyDown(DIK_A))          fJoystick.fButtons |= JOYSTICK_ACCELERATE;
  200.     if (SysKeyDown(DIK_Z))          fJoystick.fButtons |= JOYSTICK_BRAKE;
  201.  
  202.     if (SysKeyDown(DIK_W))          fJoystick.fButtons |= JOYSTICK_W;
  203.     if (SysKeyDown(DIK_A))          fJoystick.fButtons |= JOYSTICK_A;
  204.     if (SysKeyDown(DIK_S))          fJoystick.fButtons |= JOYSTICK_S;
  205.     if (SysKeyDown(DIK_D))          fJoystick.fButtons |= JOYSTICK_D;    
  206. }
  207.  
  208.  
  209. //
  210. // void TDIJoystick::ReadInputs(void) 
  211. //
  212. //   Read the joystick
  213. //
  214. void TDIJoystick::ReadInputs(void) 
  215. {
  216.     DIJOYSTATE*              js;  
  217.  
  218.     // poll the joystick to read the current state
  219.     fDevice->Poll(); 
  220.  
  221.     // Fill in the buffer
  222.     Read();
  223.     
  224.     js = (DIJOYSTATE*)fBuffer;
  225.  
  226.     fJoystick.Clear();
  227.  
  228.     if (0)
  229.     {
  230.         int i = 0;
  231.  
  232.         /*if (js->lX > 0) { gRenderer->DebugPrintf(200, 10 + 10*i, "lX +ve (RHS)"); i++; }
  233.         if (js->lX < 0) { gRenderer->DebugPrintf(200, 10 + 10*i, "lX -ve (LHS)"); i++; }
  234.  
  235.         if (js->lY > 0) { gRenderer->DebugPrintf(200, 10 + 10*i, "lY -ve (FWD)"); i++; }
  236.         if (js->lY < 0) { gRenderer->DebugPrintf(200, 10 + 10*i, "lY +ve (REV)"); i++; }*/
  237.  
  238.         char buf[256];
  239.         for(int c = 0; c < 32; c++)
  240.             if (js->rgbButtons[c] & 0x80) 
  241.             { 
  242.                 sprintf(buf, "BTN %d\0", c); 
  243.                // gRenderer->DebugPrintf(200, 10 + 10*i, buf);
  244.                 i++; 
  245.             }
  246.     }
  247.  
  248.     // Now study the position of the stick and the buttons.
  249.  
  250.     fJoystick.fstickX = js->lX;
  251.     fJoystick.fstickY = js->lY;
  252.  
  253.     // USE1 reverse
  254.     // USE2 re-start
  255.     // JUMP jump
  256.  
  257.     int                                    deadZone = 150;
  258.  
  259.   //  if (!gPreferences.fUseWheel)
  260.     {
  261.      /*   if (js->lX < -deadZone)         fJoystick.fButtons |= JOYSTICK_LEFT;
  262.         else if (js->lX > deadZone)     fJoystick.fButtons |= JOYSTICK_RIGHT;
  263.  
  264.         if (js->lY < -deadZone)         fJoystick.fButtons |= JOYSTICK_UP;
  265.         else if (js->lY > deadZone)     fJoystick.fButtons |= JOYSTICK_DOWN;*/
  266.  
  267.         if (js->rgbButtons[7] & 0x80)   
  268.             fJoystick.fButtons |= JOYSTICK_ACCELERATE; 
  269.         
  270.         if (js->rgbButtons[6] & 0x80)   
  271.             fJoystick.fButtons |= JOYSTICK_BRAKE;
  272.  
  273.         if (js->rgbButtons[1] & 0x80)  
  274.             fJoystick.fButtons |= JOYSTICK_JUMP;
  275.  
  276.         if (js->rgbButtons[2] & 0x80)   
  277.             fJoystick.fButtons |= JOYSTICK_USE1;
  278.  
  279.         if (js->rgbButtons[8] & 0x80)   
  280.             fJoystick.fButtons |= JOYSTICK_USE2;
  281.  
  282.         if (js->rgbButtons[9] & 0x80)   
  283.             fJoystick.fButtons |= JOYSTICK_HORN;
  284.  
  285.         if (js->rgbButtons[3] & 0x80)   
  286.             fJoystick.fButtons |= JOYSTICK_USE3;
  287.  
  288.         if (js->rgbButtons[4] & 0x80)   
  289.             fJoystick.fButtons |= JOYSTICK_PULL_CAMERA;
  290.  
  291.         if (js->rgbButtons[5] & 0x80)
  292.             fJoystick.fButtons |= JOYSTICK_W;
  293.  
  294.         if (js->rgbButtons[0] & 0x80)
  295.             fJoystick.fButtons |= JOYSTICK_A;
  296.  
  297.         if (js->rgbButtons[10] & 0x80)
  298.             fJoystick.fButtons |= JOYSTICK_S;
  299.  
  300.         if (js->rgbButtons[11] & 0x80)
  301.             fJoystick.fButtons |= JOYSTICK_D;
  302.     }
  303.  
  304.     // Read the 'hat' (digital joypad directions)
  305.     if (LOWORD(js->rgdwPOV[0]) == 0xFFFF)            // -1 -> centre
  306.     {
  307.         fJoystick.frightstickX = 0;
  308.         fJoystick.frightstickY = 0;
  309.     }
  310.     else
  311.     {
  312.         fJoystick.frightstickX = long(sinf(float(js->rgdwPOV[0]) / 100.0f / 360.0f * 2.0f * 3.14159265f) * 1000.0f);
  313.         fJoystick.frightstickY = long(cosf(float(js->rgdwPOV[0]) / 100.0f / 360.0f * 2.0f * 3.14159265f) * -1000.0f);
  314.     }
  315.  
  316.    /* else // hacked wheel case...
  317.     {
  318.         if (js->lX < 0)                 fJoystick.fButtons |= JOYSTICK_LEFT;
  319.         else if (js->lX > 0)            fJoystick.fButtons |= JOYSTICK_RIGHT;
  320.  
  321.         if (js->lY < -100)                 fJoystick.fButtons |= JOYSTICK_ACCELERATE;
  322.         else if (js->lY > 100)            fJoystick.fButtons |= JOYSTICK_BRAKE;
  323.  
  324.         if (js->rgbButtons[0] & 0x80)   fJoystick.fButtons |= JOYSTICK_JUMP;
  325.         if (js->rgbButtons[3] & 0x80)   fJoystick.fButtons |= JOYSTICK_USE1;
  326.         if (js->rgbButtons[5] & 0x80)   fJoystick.fButtons |= JOYSTICK_USE2;
  327.     }*/
  328. } 
  329.  
  330.  
  331. //
  332. //  TDIHandler::TDIHandler(void)
  333. //
  334. //
  335. //
  336. TDIHandler::TDIHandler(void)
  337. {
  338.     fDI=NULL;
  339.     fNumDevices = 0;
  340.     fNextJoystick = 0;
  341.  
  342.     for (int i = 0; i < MAX_NUM_DEVICES; i++)
  343.     {
  344.         fDevice[i] = NULL;
  345.     }
  346.  
  347.     fMouse = NULL;
  348.     fGrabbed = false;
  349. }
  350.  
  351.  
  352.  
  353. //
  354. //  TDIHandler::~TDIHandler(void)
  355. //
  356. //
  357. //
  358. TDIHandler::~TDIHandler(void)
  359. {
  360.     for (int i = 0; i < fNumDevices; i++)
  361.     {
  362.         delete fDevice[i];
  363.     }
  364.  
  365.  
  366.     if (fDI)
  367.     {
  368.         fDI->Release();
  369.         fDI=NULL;
  370.     }
  371.  
  372.     if (fMouse != NULL)
  373.     {
  374.         fMouse->Unacquire();
  375.         fMouse->Release();
  376.         fMouse = NULL;
  377.     }
  378. }
  379.  
  380.  
  381.  
  382. //
  383. // void TDIHandler::Initialise(void)
  384. //
  385. //
  386. //  Create the input driver and the devices (keyboard and joystick) here
  387. //
  388. extern HINSTANCE    gAppInstance;
  389. void TDIHandler::Initialise(void)
  390. {
  391. // DirectX 8 initialisation
  392. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION
  393.     HRESULT hr = DirectInput8Create(    gAppInstance,
  394.                                         DIRECTINPUT_VERSION,
  395.                                         IID_IDirectInput8,
  396.                                         (LPVOID*) &fDI,
  397.                                         NULL );
  398. #else
  399.     // Previous versions
  400.     HRESULT hr = DirectInputCreate(gAppInstance,DIRECTINPUT_VERSION,&fDI,NULL);
  401. #endif
  402.     assert(SUCCEEDED(hr));
  403.  
  404. // Enumerate for available joystick/game controllers
  405. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION_WEEKLY2
  406.     // DirectX 8 enumeration
  407.     // joysticks are now referred to as game controllers
  408.     hr = fDI->EnumDevices(    DI8DEVCLASS_GAMECTRL,
  409.                             InitialiseJoystickEnum,
  410.                             this,
  411.                             DIEDFL_ATTACHEDONLY );
  412. #else
  413.     hr = fDI->EnumDevices(    DIDEVTYPE_JOYSTICK,
  414.                             InitialiseJoystickEnum,
  415.                             this,
  416.                             DIEDFL_ATTACHEDONLY );
  417. #endif
  418.     assert(SUCCEEDED(hr));
  419.  
  420.     for (int i = 0; i < fNumDevices; i++)
  421.     {
  422.         {
  423.             HRESULT  hr;
  424.  
  425.             hr = fDevice[i]->fDevice->EnumEffects(    JoystickEffectsEnum,
  426.                                                     (LPVOID) fDevice[i]->fDevice,
  427.                                                     DIEFT_CONSTANTFORCE );
  428.             assert(hr == DI_OK);
  429.  
  430.             // acquire device
  431.             fDevice[i]->Acquire(true);
  432.         }
  433.     }
  434.  
  435.     // create the system keyboard
  436.     fDevice[fNumDevices] = new TDIKeyboard;
  437.     fDISysKeyboard = (TDIKeyboard*)fDevice[fNumDevices];  // Cache ptr to keyboard for fast key reading in editor
  438.     fDISysKeyboard->InitialiseKeyboard(GUID_SysKeyboard,&c_dfDIKeyboard,256);
  439.     fNumDevices++;
  440.  
  441.     InitMouse();
  442. }
  443.  
  444.  
  445. //
  446. //  void TDIHandler::ReadAllInputs()
  447. //
  448. //   Called every frame,  fills in the fJoystick flags within each device
  449. //
  450. void TDIHandler::ReadAllInputs()
  451. {
  452.     for (int i = 0; i < fNumDevices; i++)
  453.         fDevice[i]->ReadInputs();
  454.  
  455. #if 0
  456.     static int counter = 0;
  457.     DWORD max_t = 0;
  458.     DWORD pre_t = timeGetTime();
  459.  
  460.     counter++;
  461.     if ( counter > 100 )
  462.     {
  463.         DWORD t = timeGetTime() - pre_t;
  464.         max_t = max(max_t, t);
  465.         gRenderer->DebugPrintf(40, 250, "INPUT TIME: %d", t);
  466.         gRenderer->DebugPrintf(40, 260, "INPUT TIME: %d MAX", max_t);
  467.     }
  468. #endif
  469. }
  470.  
  471. TJoystick* TDIHandler::GetJoystick(int theIndex)
  472. {
  473.     // Used to get joysticks for recording, probably only ever used to 
  474.     // get joystick 0
  475.     assert (theIndex < MAX_NUM_DEVICES);
  476.     assert (fDevice[theIndex] != NULL);
  477.  
  478.     return &fDevice[theIndex]->fJoystick;
  479.  
  480. }
  481.  
  482.  
  483. TJoystick* TDIHandler::GetNextJoystick()
  484. {
  485.     // Used to alloca t the joysticks on a first-come first served basis
  486.  
  487.     if (fNextJoystick >= MAX_NUM_DEVICES)
  488.         return NULL;
  489.  
  490.     if (fDevice[fNextJoystick] != NULL)
  491.     {
  492.         fNextJoystick++;
  493.         return (&fDevice[fNextJoystick - 1]->fJoystick);
  494.     }
  495.  
  496.     return NULL;
  497. }
  498.  
  499.  
  500. void TDIHandler::ResetJoystickAllocation()
  501. {
  502.     fNextJoystick = 0;
  503. }
  504.  
  505.  
  506. BOOL PASCAL JoystickEffectsEnum(LPCDIEFFECTINFO pdei, LPVOID pvRef)
  507. {
  508.     return true;
  509. }
  510.  
  511.  
  512. void TDIDevice::SetForce(float x, float y)
  513. {
  514.     if (!fEffect) return;
  515.  
  516.     // Modifying an effect is basically the same as creating
  517.     // a new one, except you need only specify the parameters
  518.     // you are modifying; the rest are left alone.
  519.     LONG rglDirection[2] = { (LONG)x, (LONG)y };
  520.  
  521.     DICONSTANTFORCE        cf;
  522.     DIEFFECT            eff;
  523.     cf.lMagnitude = (DWORD)sqrt( (double)x * (double)x +
  524.                                  (double)y * (double)y );
  525.  
  526.     eff.dwSize = sizeof(DIEFFECT);
  527.     eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
  528.     eff.cAxes = 2;
  529.     eff.rglDirection = rglDirection;
  530.     eff.lpEnvelope = 0;
  531.     eff.cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
  532.     eff.lpvTypeSpecificParams = &cf;
  533.  
  534.     // now set the new parameters and start the effect immediately.
  535.     HRESULT hr;
  536.     hr = fEffect->SetParameters(    &eff, 
  537.                                     DIEP_DIRECTION |
  538.                                     DIEP_TYPESPECIFICPARAMS |
  539.                                     DIEP_START );
  540.  
  541.     if (FAILED(hr)) assert(false);
  542. }
  543.  
  544.  
  545. //
  546. //  BOOL PASCAL InitialiseJoystickEnum(LPCDIDEVICEINSTANCE pdinst, LPVOID pvRef) 
  547. //
  548. //   Call back for enumeration of the joystick devices
  549. //
  550. BOOL PASCAL InitialiseJoystickEnum(LPCDIDEVICEINSTANCE pdinst, LPVOID pvRef) 
  551. { 
  552.    TDIHandler*        handler = (TDIHandler*)pvRef;
  553.    HRESULT            hResult;
  554.  
  555. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION
  556.    // DirectX 8 pointers
  557.    LPDIRECTINPUT8            pdi = handler->fDI;
  558. #else
  559.    // Previous version pointers
  560.    LPDIRECTINPUT            pdi = handler->fDI; 
  561.    LPDIRECTINPUTDEVICE        tempDevice;          // Till we get a v2 interface
  562. #endif
  563.  
  564.    if (handler->fDevice[handler->fNumDevices] == NULL)              
  565.    {
  566.       handler->fDevice[handler->fNumDevices] = new TDIJoystick;
  567.       assert (handler->fDevice[handler->fNumDevices] != NULL);
  568.    }
  569.  
  570. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION
  571.     #if D3D_SDK_VERSION == DX_BETA_WEEKLY2
  572.         hResult = pdi->CreateDevice(    pdinst->guidInstance,
  573.                                         &handler->fDevice[handler->fNumDevices]->fDevice,
  574.                                         NULL );
  575.     #else
  576.         hResult = pdi->CreateDeviceEx(    pdinst->guidInstance,
  577.                                         IID_IDirectInputDevice8,
  578.                                         (LPVOID*) &handler->fDevice[handler->fNumDevices]->fDevice,
  579.                                         NULL );
  580.     #endif
  581. #else
  582.     hResult = pdi->CreateDevice(    pdinst->guidInstance,
  583.                                     &tempDevice,
  584.                                     NULL );
  585. #endif
  586.  
  587.     if( FAILED( hResult ) )
  588.     { 
  589.         OutputDebugString("IDirectInput::CreateDevice FAILED\n"); 
  590.         delete handler->fDevice[handler->fNumDevices];
  591.         handler->fDevice[handler->fNumDevices] = NULL;
  592.         return DIENUM_CONTINUE;    
  593.     } 
  594.  
  595. #if DIRECTINPUT_VERSION < DIRECTINPUT8_VERSION
  596.     //  Get a version 2 interface
  597.     if (tempDevice->QueryInterface(IID_IDirectInputDevice2, (VOID**)&handler->fDevice[handler->fNumDevices]->fDevice) != DI_OK)
  598.     { 
  599.         OutputDebugString("IDirectInput::Getting device interface 2 FAILED\n"); 
  600.         delete handler->fDevice[handler->fNumDevices];
  601.         handler->fDevice[handler->fNumDevices] = NULL;
  602.         return DIENUM_CONTINUE;    
  603.     }
  604. #endif
  605.  
  606.     //  Tell direct input its a joystick
  607.     if (handler->fDevice[handler->fNumDevices]->fDevice->SetDataFormat(&c_dfDIJoystick) != DI_OK) 
  608.     { 
  609.         OutputDebugString("IDirectInputDevice::SetDataFormat FAILED\n"); 
  610.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  611.         delete handler->fDevice[handler->fNumDevices];
  612.         handler->fDevice[handler->fNumDevices] = NULL;
  613.         return DIENUM_CONTINUE; 
  614.     } 
  615.  
  616.     // Set the cooperation level
  617.     //if(handler->fDevice[handler->fNumDevices]->fDevice->SetCooperativeLevel(ghWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND) != DI_OK) 
  618.     if(handler->fDevice[handler->fNumDevices]->fDevice->SetCooperativeLevel(ghWnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND) != DI_OK) 
  619.     { 
  620.         OutputDebugString("IDirectInputDevice::SetCooperativeLevel FAILED\n"); 
  621.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  622.         delete handler->fDevice[handler->fNumDevices];
  623.         handler->fDevice[handler->fNumDevices] = NULL;
  624.         return DIENUM_CONTINUE;
  625.     } 
  626.  
  627.  
  628.     // Set the range to be returned for the x-axis, from -1000 to 1000
  629.     DIPROPRANGE diprg;     
  630.     diprg.diph.dwSize       = sizeof(diprg); 
  631.     diprg.diph.dwHeaderSize = sizeof(diprg.diph); 
  632.     diprg.diph.dwObj        = DIJOFS_X; 
  633.     diprg.diph.dwHow        = DIPH_BYOFFSET;    
  634.     diprg.lMin              = -1000; 
  635.     diprg.lMax              = +1000;  
  636.    
  637.     if FAILED(handler->fDevice[handler->fNumDevices]->fDevice->SetProperty(DIPROP_RANGE, &diprg.diph))    
  638.     { 
  639.         OutputDebugString("IDirectInputDevice::SetProperty(DIPH_RANGE) FAILED\n");       
  640.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  641.         delete handler->fDevice[handler->fNumDevices];
  642.         handler->fDevice[handler->fNumDevices] = NULL;
  643.         return DIENUM_CONTINUE;    
  644.     }
  645.  
  646.     // Set the range to be returned for the y-axis, from -1000 to 1000
  647.     diprg.diph.dwSize       = sizeof(diprg); 
  648.     diprg.diph.dwHeaderSize = sizeof(diprg.diph); 
  649.     diprg.diph.dwObj        = DIJOFS_Y; 
  650.     diprg.diph.dwHow        = DIPH_BYOFFSET;    
  651.     diprg.lMin              = -1000; 
  652.     diprg.lMax              = +1000;  
  653.  
  654.     if FAILED(handler->fDevice[handler->fNumDevices]->fDevice->SetProperty(DIPROP_RANGE, &diprg.diph))    
  655.     { 
  656.         OutputDebugString("IDirectInputDevice::SetProperty(DIPH_RANGE) FAILED\n");       
  657.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  658.         delete handler->fDevice[handler->fNumDevices];
  659.         handler->fDevice[handler->fNumDevices] = NULL;
  660.         return DIENUM_CONTINUE;    
  661.     } 
  662.  
  663.  
  664.     // Set the dead zone to extend for half the range of the x axis movement
  665.     DIPROPDWORD dipdead;
  666.  
  667.     dipdead.diph.dwSize       = sizeof(dipdead); 
  668.     dipdead.diph.dwHeaderSize = sizeof(dipdead.diph); 
  669.     dipdead.diph.dwObj        = DIJOFS_X; 
  670.     dipdead.diph.dwHow        = DIPH_BYOFFSET;   
  671.     dipdead.dwData = 0;
  672.     //(gPreferences.fUseWheel) ? dipdead.dwData = 0 : dipdead.dwData = 200; // the range
  673.  
  674.  
  675.     // set X axis dead zone to 50% (to avoid accidental turning) 
  676.     if FAILED(handler->fDevice[handler->fNumDevices]->fDevice->SetProperty(DIPROP_DEADZONE, &dipdead.diph)) 
  677.     { 
  678.         OutputDebugString("IDirectInputDevice:: SetProperty(DIPH_DEADZONE) FAILED\n"); 
  679.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  680.         delete handler->fDevice[handler->fNumDevices];
  681.         handler->fDevice[handler->fNumDevices] = NULL;
  682.         return DIENUM_CONTINUE;    
  683.     } 
  684.  
  685.     // Set the dead zone to extend for half the range of the y axis movement
  686.     dipdead.diph.dwSize       = sizeof(dipdead); 
  687.     dipdead.diph.dwHeaderSize = sizeof(dipdead.diph); 
  688.     dipdead.diph.dwObj        = DIJOFS_Y; 
  689.     dipdead.diph.dwHow        = DIPH_BYOFFSET;    
  690.     dipdead.dwData            = 200;                 // the range
  691.  
  692.  
  693.     // set X axis dead zone to 50% (to avoid accidental turning) 
  694.     if FAILED(handler->fDevice[handler->fNumDevices]->fDevice->SetProperty(DIPROP_DEADZONE, &dipdead.diph)) 
  695.     { 
  696.         OutputDebugString("IDirectInputDevice:: SetProperty(DIPH_DEADZONE) FAILED\n"); 
  697.         handler->fDevice[handler->fNumDevices]->fDevice->Release(); 
  698.         delete handler->fDevice[handler->fNumDevices];
  699.         handler->fDevice[handler->fNumDevices] = NULL;
  700.         return DIENUM_CONTINUE;    
  701.     } 
  702.  
  703.     {
  704.         HRESULT hr;
  705.  
  706.         // remove the force centering effect
  707.  
  708.         DIPROPDWORD dipdw;
  709.         dipdw.diph.dwSize = sizeof(DIPROPDWORD);
  710.         dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
  711.         dipdw.diph.dwObj = 0;
  712.         dipdw.diph.dwHow = DIPH_DEVICE;
  713.         dipdw.dwData = FALSE;
  714.  
  715.         //hr = handler->fDevice[handler->fNumDevices]->fDevice->
  716.         //    SetProperty( DIPROP_AUTOCENTER, &dipdw.diph );
  717. //        if (hr != DI_OK) assert(false);     // Removed ph 10/11/98
  718.  
  719.         // This application needs only one effect:  Applying raw forces.
  720.         DIEFFECT eff;
  721.         DWORD rgdwAxes[2] = { DIJOFS_X, DIJOFS_Y };
  722.         LONG rglDirection[2] = { 0, 0 };
  723.         DICONSTANTFORCE cf = { 0 };
  724.  
  725.         eff.dwSize = sizeof(DIEFFECT);
  726.         eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
  727.         eff.dwDuration = INFINITE;
  728.         eff.dwSamplePeriod = 0;
  729.         eff.dwGain = DI_FFNOMINALMAX;
  730.         eff.dwTriggerButton = DIEB_NOTRIGGER;
  731.         eff.dwTriggerRepeatInterval = 0;
  732.         eff.cAxes = 2;
  733.         eff.rgdwAxes = rgdwAxes;
  734.         eff.rglDirection = rglDirection;
  735.         eff.lpEnvelope = 0;
  736.         eff.cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
  737.         eff.lpvTypeSpecificParams = &cf;
  738.  
  739.         // create the prepared effect
  740.         hr = handler->fDevice[handler->fNumDevices]->fDevice->
  741.             CreateEffect(GUID_ConstantForce,
  742.                 &eff,
  743.                 &handler->fDevice[handler->fNumDevices]->fEffect,
  744.                 NULL );
  745.  
  746. //        assert(hr == DI_OK);  // Removed ph 10/11/98 
  747.  
  748.         /*
  749.         if (hr != DI_OK)
  750.         {
  751.             int error = -1;
  752.             switch(hr)
  753.             {
  754.             case DIERR_DEVICENOTREG:
  755.                 error = 1;
  756.                 break;
  757.             case DIERR_DEVICEFULL:
  758.                 error = 2;
  759.                 break;
  760.             case DIERR_INVALIDPARAM:
  761.                 error = 3;
  762.                 break;
  763.             case DIERR_NOTINITIALIZED:
  764.                 error = 4;
  765.                 break;
  766.             default:
  767.                 assert(false);
  768.             }
  769.             assert(hr == DI_OK);
  770.         }
  771.         */
  772.     }
  773.  
  774.     // Fill in the buffers for later
  775.     handler->fDevice[handler->fNumDevices]->fBufSize = sizeof(DIJOYSTATE);
  776.     handler->fDevice[handler->fNumDevices]->fBuffer = new char[sizeof(DIJOYSTATE)];
  777.     assert (handler->fDevice[handler->fNumDevices]->fBuffer != NULL);
  778.  
  779.     handler->fNumDevices++;      // Succesfully got one
  780.     return DIENUM_CONTINUE;    
  781. }
  782.  
  783.  
  784. void TDIHandler::GrabMouse()
  785. {
  786.     HRESULT hr; 
  787.     if (fMouse != NULL)
  788.     {
  789.         hr = fMouse->Acquire();
  790.     }
  791. }
  792.  
  793. void TDIHandler::ReleaseMouse()
  794. {
  795.     HRESULT hr; 
  796.     if (fMouse != NULL)
  797.     {
  798.         hr = fMouse->Unacquire();
  799.     }
  800. }
  801.  
  802.  
  803. void TDIHandler::InitMouse()
  804. {
  805.     assert (fMouse == NULL);
  806.  
  807.     HRESULT hResult;
  808.  
  809. #if DIRECTINPUT_VERSION >= DIRECTINPUT8_VERSION
  810.     // (DirectX8) Create Mouse Device
  811.     #if D3D_SDK_VERSION == DX_BETA_WEEKLY2
  812.         hResult = fDI->CreateDevice(    GUID_SysMouse,
  813.                                         &fMouse,
  814.                                         NULL );
  815.     #else
  816.         hResult = fDI->CreateDeviceEx(    GUID_SysMouse,
  817.                                         IID_IDirectInputDevice8,
  818.                                         (LPVOID*) &fMouse,
  819.                                         NULL );
  820.     #endif
  821. #else
  822.     // (Previous versions) Create Mouse Device
  823.     hResult = fDI->CreateDevice(    GUID_SysMouse,
  824.                                     &fMouse,
  825.                                     NULL);
  826. #endif
  827.     assert (SUCCEEDED(hResult));
  828.     assert (fMouse != NULL);
  829.  
  830.     // set data format
  831.     hResult = fMouse->SetDataFormat( &c_dfDIMouse );
  832.     assert (SUCCEEDED(hResult));
  833.  
  834.     // set cooperative level
  835.     hResult = fMouse->SetCooperativeLevel( ghWnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND ); 
  836.     assert (SUCCEEDED(hResult));
  837. }
  838.