void DX5_DInputReset(_THIS, int fullscreen)
{
DWORD level;
int i;
HRESULT result;
HWND topwnd;
for ( i=0; i<MAX_INPUTS; ++i ) {
if ( SDL_DIdev[i] != NULL ) {
if ( fullscreen ) {
level = inputs[i].raw_level;
} else {
level = inputs[i].win_level;
}
IDirectInputDevice2_Unacquire(SDL_DIdev[i]);
topwnd = GetTopLevelParent(SDL_Window);
result = IDirectInputDevice2_SetCooperativeLevel(
SDL_DIdev[i], topwnd, level);
IDirectInputDevice2_Acquire(SDL_DIdev[i]);
if ( result != DI_OK ) {
SetDIerror(
"DirectInputDevice::SetCooperativeLevel", result);
}
}
}
mouse_lost = 1;
DX5_CheckInput(this, 0, FALSE);
}
static void DIJoystick_poll_joysticks(void)
{
HRESULT hr;
DWORD i;
This.m_bCoinSlot = 0;
for (i = 0; i < This.num_joysticks; i++)
{
/* start by clearing the structure, then fill it in if possible */
ClearJoyState(&This.joysticks[i].dijs);
if (This.joysticks[i].did == NULL)
continue;
if (This.joysticks[i].use_joystick == FALSE)
continue;
hr = IDirectInputDevice2_Poll(This.joysticks[i].did);
hr = IDirectInputDevice2_GetDeviceState(This.joysticks[i].did,sizeof(DIJOYSTATE),
&This.joysticks[i].dijs);
if (FAILED(hr))
{
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
hr = IDirectInputDevice2_Acquire(This.joysticks[i].did);
}
continue;
}
}
}
void Joystick_Activate(UINT wParam)
{
#if 1
(void)wParam;
#else
if (wParam != WA_INACTIVE)
{
if (joy[0]) IDirectInputDevice2_Acquire(joy[0]);
if (joy[1]) IDirectInputDevice2_Acquire(joy[1]);
}
else
{
if (joy[0]) IDirectInputDevice2_Unacquire(joy[0]);
if (joy[1]) IDirectInputDevice2_Unacquire(joy[1]);
}
#endif
}
int get_joystick_status(struct wwvi_js_event *wjse)
{
HRESULT hr;
DIJOYSTATE2 js;
int i;
if (!joystick || !wjse)
return -1;
/* poll the device to read the current state */
hr = IDirectInputDevice2_Poll(joystick);
if (FAILED(hr)) {
/* input stream has been interrupted, re-acquire and try again */
hr = IDirectInputDevice2_Acquire(joystick);
while(hr == DIERR_INPUTLOST)
hr = IDirectInputDevice2_Acquire(joystick);
/* other errors may occur when the app is minimized
or in the process of switching, so just try again later */
if (FAILED(hr))
return -1;
/* try to poll again */
hr = IDirectInputDevice2_Poll(joystick);
if (FAILED(hr))
return -1;
}
/* get the device state */
hr = IDirectInputDevice2_GetDeviceState(joystick, sizeof(DIJOYSTATE2), &js);
if(FAILED(hr))
return -1;
/* write out state */
wjse->stick_x = js.lX;
wjse->stick_y = js.lY;
for (i = 0; i < 11; ++i) {
wjse->button[i] = (js.rgbButtons[i] & 0x80) ? 1 : 0;
}
return 0;
}
void
SDL_SYS_JoystickUpdate_Buffered(SDL_Joystick * joystick)
{
int i;
HRESULT result;
DWORD numevents;
DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
numevents = INPUT_QSIZE;
result =
IDirectInputDevice2_GetDeviceData(joystick->hwdata->InputDevice,
sizeof(DIDEVICEOBJECTDATA), evtbuf,
&numevents, 0);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice2_Acquire(joystick->hwdata->InputDevice);
result =
IDirectInputDevice2_GetDeviceData(joystick->hwdata->InputDevice,
sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
}
/* Handle the events or punt */
if (FAILED(result))
return;
for (i = 0; i < (int) numevents; ++i) {
int j;
for (j = 0; j < joystick->hwdata->NumInputs; ++j) {
const input_t *in = &joystick->hwdata->Inputs[j];
if (evtbuf[i].dwOfs != in->ofs)
continue;
switch (in->type) {
case AXIS:
SDL_PrivateJoystickAxis(joystick, in->num,
(Sint16) evtbuf[i].dwData);
break;
case BUTTON:
SDL_PrivateJoystickButton(joystick, in->num,
(Uint8) (evtbuf[i].
dwData ? SDL_PRESSED :
SDL_RELEASED));
break;
case HAT:
{
Uint8 pos = TranslatePOV(evtbuf[i].dwData);
SDL_PrivateJoystickHat(joystick, in->num, pos);
}
}
}
}
}
/* joystick_dinput_acquire: [window thread]
* Acquires the joystick devices.
*/
int joystick_dinput_acquire(void)
{
HRESULT hr;
int i;
if (joystick_dinput) {
for (i=0; i<dinput_joy_num; i++) {
hr = IDirectInputDevice2_Acquire(dinput_joystick[i].device);
if (FAILED(hr))
_TRACE(PREFIX_E "acquire joystick %d failed: %s\n", i, dinput_err_str(hr));
}
}
return 0;
}
void
SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
{
HRESULT result;
result = IDirectInputDevice2_Poll(joystick->hwdata->InputDevice);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice2_Acquire(joystick->hwdata->InputDevice);
IDirectInputDevice2_Poll(joystick->hwdata->InputDevice);
}
if (joystick->hwdata->buffered)
SDL_SYS_JoystickUpdate_Buffered(joystick);
else
SDL_SYS_JoystickUpdate_Polled(joystick);
}
HRESULT GetDeviceState(LPDIRECTINPUTDEVICE2 dev, int size, void *ptr)
{
HRESULT hr = IDirectInputDevice2_GetDeviceState(dev, size, ptr);
if ( hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED ) {
hr = IDirectInputDevice2_Acquire(dev);
if ( hr != DI_OK )
{
LOG->Trace( hr_ssprintf(hr, "?") );
return hr;
}
hr = IDirectInputDevice2_GetDeviceState(dev, size, ptr);
}
return hr;
}
void InputHandler_DInput::PollAndAcquireDevices()
{
for( unsigned i = 0; i < Devices.size(); ++i )
{
HRESULT hr = IDirectInputDevice2_Poll( Devices[i].Device );
if ( hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED )
{
/* This will fail with "access denied" on the keyboard if we don't
* have focus. */
hr = IDirectInputDevice2_Acquire( Devices[i].Device );
if ( hr != DI_OK )
continue;
IDirectInputDevice2_Poll( Devices[i].Device );
}
}
}
bool joystick_poll( int joysticknum )
{
HRESULT hRes;
int i, j, povdir;
/* joystick doesn't exist */
if( !lpdiJoystick[joysticknum] )
return false;
poll:
/* poll the device */
hRes = IDirectInputDevice2_Poll(lpdiJoystick[joysticknum]);
/* not needed or succeeded */
if ( hRes == DI_NOEFFECT && hRes == DI_OK )
goto state;
/* lets look for some errors */
switch ( hRes )
{
// Access to the input device has been lost. It must be reacquired.
case DIERR_INPUTLOST:
// The operation cannot be performed unless the device is acquired.
case DIERR_NOTACQUIRED:
// acquire the device
hRes = IDirectInputDevice2_Acquire(lpdiJoystick[joysticknum]);
// must be a deeper issue
if ( hRes != DI_OK )
return false;
// try again
goto poll;
break;
// The object has not been initialized.
case DIERR_NOTINITIALIZED:
// must be a deeper issue
return false;
break;
}
state:
// get data from the joystick
hRes = IDirectInputDevice_GetDeviceState( lpdiJoystick[joysticknum],
sizeof(DIJOYSTATE2),
&js[ new_input ][joysticknum]);
// if we got an error
if ( hRes == DI_OK )
goto povs;
// lets check out some errors
switch (hRes)
{
// Access to the input device has been lost. It must be reacquired.
case DIERR_INPUTLOST:
// The operation cannot be performed unless the device is acquired.
case DIERR_NOTACQUIRED:
// acquire the device
hRes = IDirectInputDevice2_Acquire(lpdiJoystick[joysticknum]);
// must be a deeper issue
if ( hRes != DI_OK )
return false;
// try again
goto state;
break;
case DIERR_INVALIDPARAM:
case DIERR_NOTINITIALIZED:
// must be a deeper issue
return false;
break;
// Data is not yet available.
case E_PENDING:
// no data just say ok and get out of here
return true;
break;
}
povs:
/* who knows what the rest of this does */
// for each hat switch
for (i = 0; i < JoystickInfo[joysticknum].NumPOVs; i++)
{
povdir = GetPOVMask( js[ new_input ][ joysticknum ].rgdwPOV[ i ] );
for (j = 0; j < MAX_POV_DIRECTIONS; j++)
js_pov[ new_input ][ joysticknum ][ i ][ j ] =
( povdir & ( 1 << j ) ) ? 0x80 : 0;
}
/* everything fine */
return true;
}
static int DX5_CheckInput(_THIS, int timeout, BOOL processInput)
{
MSG msg;
int i;
HRESULT result;
DWORD event;
posted = 0;
while ( ! posted &&
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
DispatchMessage(&msg);
} else {
return(-1);
}
}
if ( posted ) {
return(1);
}
if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
for ( i=0; i<MAX_INPUTS; ++i ) {
if ( SDL_DIdev[i] != NULL ) {
result = IDirectInputDevice2_Poll(SDL_DIdev[i]);
if ( (result == DIERR_INPUTLOST) ||
(result == DIERR_NOTACQUIRED) ) {
if ( SDL_strcmp(inputs[i].name, "mouse") == 0 ) {
mouse_lost = 1;
}
IDirectInputDevice2_Acquire(SDL_DIdev[i]);
IDirectInputDevice2_Poll(SDL_DIdev[i]);
}
}
}
}
event = MsgWaitForMultipleObjects(SDL_DIndev, SDL_DIevt, FALSE,
timeout, QS_ALLEVENTS);
if ((event >= WAIT_OBJECT_0) && (event < (WAIT_OBJECT_0+SDL_DIndev))) {
DWORD numevents;
static DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
event -= WAIT_OBJECT_0;
numevents = INPUT_QSIZE;
result = IDirectInputDevice2_GetDeviceData(
SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
if ( (result == DIERR_INPUTLOST) ||
(result == DIERR_NOTACQUIRED) ) {
if ( SDL_strcmp(inputs[event].name, "mouse") == 0 ) {
mouse_lost = 1;
}
IDirectInputDevice2_Acquire(SDL_DIdev[event]);
result = IDirectInputDevice2_GetDeviceData(
SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
}
if ( result == DI_OK && processInput ) {
(*SDL_DIfun[event])((int)numevents, evtbuf);
return(1);
}
}
if ( event != WAIT_TIMEOUT ) {
if ( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
DispatchMessage(&msg);
} else {
return(-1);
}
return(1);
}
}
return(0);
}
/* The main Win32 event handler */
LONG
DX5_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
#ifdef WM_ACTIVATEAPP
case WM_ACTIVATEAPP: {
int i, active;
active = (wParam && (GetForegroundWindow() == hwnd));
if ( active ) {
for ( i=0; SDL_DIdev[i]; ++i ) {
IDirectInputDevice2_Acquire(
SDL_DIdev[i]);
}
} else {
for ( i=0; SDL_DIdev[i]; ++i ) {
IDirectInputDevice2_Unacquire(
SDL_DIdev[i]);
}
mouse_lost = 1;
}
}
break;
#endif /* WM_ACTIVATEAPP */
#ifdef WM_DISPLAYCHANGE
case WM_DISPLAYCHANGE: {
WORD BitsPerPixel;
WORD SizeX, SizeY;
/* Ack! The display changed size and/or depth! */
SizeX = LOWORD(lParam);
SizeY = HIWORD(lParam);
BitsPerPixel = wParam;
/* We cause this message when we go fullscreen */
}
break;
#endif /* WM_DISPLAYCHANGE */
/* The keyboard is handled via DirectInput */
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_KEYDOWN: {
/* Ignore windows keyboard messages */;
}
return(0);
#if defined(SC_SCREENSAVE) || defined(SC_MONITORPOWER)
/* Don't allow screen savers or monitor power downs.
This is because they quietly clear DirectX surfaces.
It would be better to allow the application to
decide whether or not to blow these off, but the
semantics of SDL_PrivateSysWMEvent() don't allow
the application that choice.
*/
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
/* Fall through to default processing */
#endif /* SC_SCREENSAVE || SC_MONITORPOWER */
default: {
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
/* DJM: If the user isn't watching for private
messages in her SDL event loop, then pass it
along to any win32 specific window proc.
*/
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
static int DX5_DInputInit(_THIS)
{
int i;
LPDIRECTINPUTDEVICE device;
HRESULT result;
DIPROPDWORD dipdw;
HWND topwnd;
result = DInputCreate(SDL_Instance, DIRECTINPUT_VERSION,
&dinput, NULL);
if ( result != DI_OK ) {
SetDIerror("DirectInputCreate", result);
return(-1);
}
SDL_DIndev = 0;
for ( i=0; inputs[i].name; ++i ) {
result = IDirectInput_CreateDevice(dinput, inputs[i].guid,
&device, NULL);
if ( result != DI_OK ) {
SetDIerror("DirectInput::CreateDevice", result);
return(-1);
}
result = IDirectInputDevice_QueryInterface(device,
&IID_IDirectInputDevice2, (LPVOID *)&SDL_DIdev[i]);
IDirectInputDevice_Release(device);
if ( result != DI_OK ) {
SetDIerror("DirectInputDevice::QueryInterface", result);
return(-1);
}
topwnd = GetTopLevelParent(SDL_Window);
result = IDirectInputDevice2_SetCooperativeLevel(SDL_DIdev[i],
topwnd, inputs[i].win_level);
if ( result != DI_OK ) {
SetDIerror("DirectInputDevice::SetCooperativeLevel",
result);
return(-1);
}
result = IDirectInputDevice2_SetDataFormat(SDL_DIdev[i],
inputs[i].format);
if ( result != DI_OK ) {
SetDIerror("DirectInputDevice::SetDataFormat", result);
return(-1);
}
SDL_memset(&dipdw, 0, sizeof(dipdw));
dipdw.diph.dwSize = sizeof(dipdw);
dipdw.diph.dwHeaderSize = sizeof(dipdw.diph);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = INPUT_QSIZE;
result = IDirectInputDevice2_SetProperty(SDL_DIdev[i],
DIPROP_BUFFERSIZE, &dipdw.diph);
if ( result != DI_OK ) {
SetDIerror("DirectInputDevice::SetProperty", result);
return(-1);
}
SDL_DIevt[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
if ( SDL_DIevt[i] == NULL ) {
SDL_SetError("Couldn't create DirectInput event");
return(-1);
}
result = IDirectInputDevice2_SetEventNotification(SDL_DIdev[i],
SDL_DIevt[i]);
if ( result != DI_OK ) {
SetDIerror("DirectInputDevice::SetEventNotification",
result);
return(-1);
}
SDL_DIfun[i] = inputs[i].fun;
IDirectInputDevice2_Acquire(SDL_DIdev[i]);
++SDL_DIndev;
}
mouse_pressed = 0;
mouse_buttons_swapped = GetSystemMetrics(SM_SWAPBUTTON);
return(0);
}
LRESULT DX5_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
#ifdef WM_ACTIVATEAPP
case WM_ACTIVATEAPP: {
int i, active;
active = (wParam && (GetForegroundWindow() == hwnd));
if ( active ) {
for ( i=0; i<MAX_INPUTS; ++i ) {
if (SDL_DIdev[i] != NULL)
IDirectInputDevice2_Acquire(
SDL_DIdev[i]);
}
} else {
for ( i=0; i<MAX_INPUTS; ++i ) {
if (SDL_DIdev[i] != NULL)
IDirectInputDevice2_Unacquire(
SDL_DIdev[i]);
}
mouse_lost = 1;
}
}
break;
#endif
#ifdef WM_DISPLAYCHANGE
case WM_DISPLAYCHANGE: {
WPARAM BitsPerPixel;
WORD SizeX, SizeY;
SizeX = LOWORD(lParam);
SizeY = HIWORD(lParam);
BitsPerPixel = wParam;
}
break;
#endif
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_KEYDOWN: {
;
}
return(0);
#if defined(SC_SCREENSAVE) || defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
#endif
default: {
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
/*
* Opens the haptic device from the file descriptor.
*
* Steps:
* - Set cooperative level.
* - Set data format.
* - Acquire exclusiveness.
* - Reset actuators.
* - Get supported featuers.
*/
static int
SDL_SYS_HapticOpenFromDevice2(SDL_Haptic * haptic,
LPDIRECTINPUTDEVICE2 device2)
{
HRESULT ret;
DIPROPDWORD dipdw;
/* We'll use the device2 from now on. */
haptic->hwdata->device = device2;
/* Grab it exclusively to use force feedback stuff. */
ret = IDirectInputDevice2_SetCooperativeLevel(haptic->hwdata->device,
SDL_HelperWindow,
DISCL_EXCLUSIVE |
DISCL_BACKGROUND);
if (FAILED(ret)) {
DI_SetError("Setting cooperative level to exclusive", ret);
goto acquire_err;
}
/* Set data format. */
ret = IDirectInputDevice2_SetDataFormat(haptic->hwdata->device,
&c_dfDIJoystick2);
if (FAILED(ret)) {
DI_SetError("Setting data format", ret);
goto acquire_err;
}
/* Get number of axes. */
ret = IDirectInputDevice2_EnumObjects(haptic->hwdata->device,
DI_DeviceObjectCallback,
haptic, DIDFT_AXIS);
if (FAILED(ret)) {
DI_SetError("Getting device axes", ret);
goto acquire_err;
}
/* Acquire the device. */
ret = IDirectInputDevice2_Acquire(haptic->hwdata->device);
if (FAILED(ret)) {
DI_SetError("Acquiring DirectInput device", ret);
goto acquire_err;
}
/* Reset all actuators - just in case. */
ret = IDirectInputDevice2_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_RESET);
if (FAILED(ret)) {
DI_SetError("Resetting device", ret);
goto acquire_err;
}
/* Enabling actuators. */
ret = IDirectInputDevice2_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_SETACTUATORSON);
if (FAILED(ret)) {
DI_SetError("Enabling actuators", ret);
goto acquire_err;
}
/* Get supported effects. */
ret = IDirectInputDevice2_EnumEffects(haptic->hwdata->device,
DI_EffectCallback, haptic,
DIEFT_ALL);
if (FAILED(ret)) {
DI_SetError("Enumerating supported effects", ret);
goto acquire_err;
}
if (haptic->supported == 0) { /* Error since device supports nothing. */
SDL_SetError("Haptic: Internal error on finding supported effects.");
goto acquire_err;
}
/* Check autogain and autocenter. */
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 10000;
ret = IDirectInputDevice2_SetProperty(haptic->hwdata->device,
DIPROP_FFGAIN, &dipdw.diph);
if (!FAILED(ret)) { /* Gain is supported. */
haptic->supported |= SDL_HAPTIC_GAIN;
}
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DIPROPAUTOCENTER_OFF;
ret = IDirectInputDevice2_SetProperty(haptic->hwdata->device,
DIPROP_AUTOCENTER, &dipdw.diph);
if (!FAILED(ret)) { /* Autocenter is supported. */
haptic->supported |= SDL_HAPTIC_AUTOCENTER;
}
/* Status is always supported. */
haptic->supported |= SDL_HAPTIC_STATUS | SDL_HAPTIC_PAUSE;
/* Check maximum effects. */
haptic->neffects = 128; /* This is not actually supported as thus under windows,
there is no way to tell the number of EFFECTS that a
device can hold, so we'll just use a "random" number
instead and put warnings in SDL_haptic.h */
haptic->nplaying = 128; /* Even more impossible to get this then neffects. */
/* Prepare effects memory. */
haptic->effects = (struct haptic_effect *)
SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
if (haptic->effects == NULL) {
SDL_OutOfMemory();
goto acquire_err;
}
/* Clear the memory */
SDL_memset(haptic->effects, 0,
sizeof(struct haptic_effect) * haptic->neffects);
return 0;
/* Error handling */
acquire_err:
IDirectInputDevice2_Unacquire(haptic->hwdata->device);
return -1;
}
/* This function checks the windows message queue and DirectInput and returns
1 if there was input, 0 if there was no input, or -1 if the application has
posted a quit message.
*/
static int DX5_CheckInput(_THIS, int timeout, BOOL processInput)
{
MSG msg;
int i;
HRESULT result;
DWORD event;
/* Check the normal windows queue (highest preference) */
posted = 0;
while ( ! posted &&
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
DispatchMessage(&msg);
} else {
return(-1);
}
}
if ( posted ) {
return(1);
}
/* Pump the DirectInput flow */
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
for ( i=0; i<SDL_DIndev; ++i ) {
result = IDirectInputDevice2_Poll(SDL_DIdev[i]);
if ( (result == DIERR_INPUTLOST) ||
(result == DIERR_NOTACQUIRED) ) {
if ( strcmp(inputs[i].name, "mouse") == 0 ) {
mouse_lost = 1;
}
IDirectInputDevice2_Acquire(SDL_DIdev[i]);
IDirectInputDevice2_Poll(SDL_DIdev[i]);
}
}
}
/* Wait for messages and input events */
event = MsgWaitForMultipleObjects(SDL_DIndev, SDL_DIevt, FALSE,
timeout, QS_ALLEVENTS);
if ((event >= WAIT_OBJECT_0) && (event < (WAIT_OBJECT_0+SDL_DIndev))) {
DWORD numevents;
DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
event -= WAIT_OBJECT_0;
numevents = INPUT_QSIZE;
result = IDirectInputDevice2_GetDeviceData(
SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
if ( (result == DIERR_INPUTLOST) ||
(result == DIERR_NOTACQUIRED) ) {
if ( strcmp(inputs[event].name, "mouse") == 0 ) {
mouse_lost = 1;
}
IDirectInputDevice2_Acquire(SDL_DIdev[event]);
result = IDirectInputDevice2_GetDeviceData(
SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
}
/* Handle the events */
if ( result == DI_OK && processInput ) {
/* Note: This can post multiple events to event queue
*/
(*SDL_DIfun[event])((int)numevents, evtbuf);
return(1);
}
}
if ( event != WAIT_TIMEOUT ) {
/* Maybe there was a windows message? */
if ( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
DispatchMessage(&msg);
} else {
return(-1);
}
return(1);
}
}
return(0);
}
void InputHandler_DInput::InputThreadMain()
{
if(!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST))
LOG->Warn(werr_ssprintf(GetLastError(), "Failed to set DirectInput thread priority"));
/* Enable priority boosting. */
SetThreadPriorityBoost( GetCurrentThread(), FALSE );
vector<DIDevice*> BufferedDevices, UnbufferedDevices;
HANDLE Handle = CreateEvent(NULL, FALSE, FALSE, NULL);
for( unsigned i = 0; i < Devices.size(); ++i )
{
if( !Devices[i].buffered )
{
UnbufferedDevices.push_back( &Devices[i] );
continue;
}
BufferedDevices.push_back( &Devices[i] );
IDirectInputDevice2_Unacquire(Devices[i].Device);
HRESULT hr = IDirectInputDevice2_SetEventNotification(Devices[i].Device, Handle);
if( FAILED(hr) )
LOG->Warn("IDirectInputDevice2_SetEventNotification failed on %i", i);
IDirectInputDevice2_Acquire(Devices[i].Device);
}
while(!shutdown)
{
m_DebugTimer.StartUpdate();
CHECKPOINT;
if( BufferedDevices.size() )
{
/* Update buffered devices. */
PollAndAcquireDevices();
int ret = WaitForSingleObjectEx( Handle, 50, true );
if( ret == -1 )
{
LOG->Trace( werr_ssprintf(GetLastError(), "WaitForSingleObjectEx failed") );
continue;
}
if( ret == WAIT_OBJECT_0 )
{
RageTimer now;
for( unsigned i = 0; i < BufferedDevices.size(); ++i )
UpdateBuffered( *BufferedDevices[i], now );
}
}
CHECKPOINT;
/* If we have no buffered devices, we didn't delay at WaitForMultipleObjectsEx. */
if( BufferedDevices.size() == 0 )
usleep( 50000 );
CHECKPOINT;
m_DebugTimer.EndUpdate();
}
CHECKPOINT;
for( unsigned i = 0; i < Devices.size(); ++i )
{
if( !Devices[i].buffered )
continue;
IDirectInputDevice2_Unacquire(Devices[i].Device);
IDirectInputDevice2_SetEventNotification( Devices[i].Device, NULL );
}
CloseHandle(Handle);
}
/* Function to open a joystick for use.
The joystick to open is specified by the index field of the joystick.
This should fill the nbuttons and naxes fields of the joystick structure.
It returns 0, or -1 if there is an error.
*/
int
SDL_SYS_JoystickOpen(SDL_Joystick * joystick)
{
HRESULT result;
LPDIRECTINPUTDEVICE device;
DIPROPDWORD dipdw;
SDL_memset(&dipdw, 0, sizeof(DIPROPDWORD));
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
/* allocate memory for system specific hardware data */
joystick->hwdata =
(struct joystick_hwdata *) SDL_malloc(sizeof(struct joystick_hwdata));
if (joystick->hwdata == NULL) {
SDL_OutOfMemory();
return (-1);
}
SDL_memset(joystick->hwdata, 0, sizeof(struct joystick_hwdata));
joystick->hwdata->buffered = 1;
joystick->hwdata->Capabilities.dwSize = sizeof(DIDEVCAPS);
result =
IDirectInput_CreateDevice(dinput,
&SYS_Joystick[joystick->index].
guidInstance, &device, NULL);
if (FAILED(result)) {
SetDIerror("IDirectInput::CreateDevice", result);
return (-1);
}
/* Now get the IDirectInputDevice2 interface, instead. */
result = IDirectInputDevice_QueryInterface(device,
&IID_IDirectInputDevice2,
(LPVOID *) & joystick->
hwdata->InputDevice);
/* We are done with this object. Use the stored one from now on. */
IDirectInputDevice_Release(device);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice::QueryInterface", result);
return (-1);
}
/* Aquire shared access. Exclusive access is required for forces,
* though. */
result =
IDirectInputDevice2_SetCooperativeLevel(joystick->hwdata->
InputDevice, SDL_HelperWindow,
DISCL_EXCLUSIVE |
DISCL_BACKGROUND);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::SetCooperativeLevel", result);
return (-1);
}
/* Use the extended data structure: DIJOYSTATE2. */
result =
IDirectInputDevice2_SetDataFormat(joystick->hwdata->InputDevice,
&c_dfDIJoystick2);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::SetDataFormat", result);
return (-1);
}
/* Get device capabilities */
result =
IDirectInputDevice2_GetCapabilities(joystick->hwdata->InputDevice,
&joystick->hwdata->Capabilities);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::GetCapabilities", result);
return (-1);
}
/* Force capable? */
if (joystick->hwdata->Capabilities.dwFlags & DIDC_FORCEFEEDBACK) {
result = IDirectInputDevice2_Acquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::Acquire", result);
return (-1);
}
/* reset all accuators. */
result =
IDirectInputDevice2_SendForceFeedbackCommand(joystick->hwdata->
InputDevice,
DISFFC_RESET);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::SendForceFeedbackCommand",
result);
return (-1);
}
*/
result = IDirectInputDevice2_Unacquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::Unacquire", result);
return (-1);
}
/* Turn on auto-centering for a ForceFeedback device (until told
* otherwise). */
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DIPROPAUTOCENTER_ON;
result =
IDirectInputDevice2_SetProperty(joystick->hwdata->InputDevice,
DIPROP_AUTOCENTER, &dipdw.diph);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::SetProperty", result);
return (-1);
}
*/
}
/* What buttons and axes does it have? */
IDirectInputDevice2_EnumObjects(joystick->hwdata->InputDevice,
EnumDevObjectsCallback, joystick,
DIDFT_BUTTON | DIDFT_AXIS | DIDFT_POV);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = INPUT_QSIZE;
/* Set the buffer size */
result =
IDirectInputDevice2_SetProperty(joystick->hwdata->InputDevice,
DIPROP_BUFFERSIZE, &dipdw.diph);
if (result == DI_POLLEDDEVICE) {
/* This device doesn't support buffering, so we're forced
* to use less reliable polling. */
joystick->hwdata->buffered = 0;
} else if (FAILED(result)) {
SetDIerror("IDirectInputDevice2::SetProperty", result);
return (-1);
}
return (0);
}
/* Function to update the state of a joystick - called as a device poll.
* This function shouldn't update the joystick structure directly,
* but instead should call SDL_PrivateJoystick*() to deliver events
* and update joystick device state.
*/
void
SDL_SYS_JoystickUpdate_Polled(SDL_Joystick * joystick)
{
DIJOYSTATE2 state;
HRESULT result;
int i;
result =
IDirectInputDevice2_GetDeviceState(joystick->hwdata->InputDevice,
sizeof(DIJOYSTATE2), &state);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice2_Acquire(joystick->hwdata->InputDevice);
result =
IDirectInputDevice2_GetDeviceState(joystick->hwdata->InputDevice,
sizeof(DIJOYSTATE2), &state);
}
/* Set each known axis, button and POV. */
for (i = 0; i < joystick->hwdata->NumInputs; ++i) {
const input_t *in = &joystick->hwdata->Inputs[i];
switch (in->type) {
case AXIS:
switch (in->ofs) {
case DIJOFS_X:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lX);
break;
case DIJOFS_Y:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lY);
break;
case DIJOFS_Z:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lZ);
break;
case DIJOFS_RX:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lRx);
break;
case DIJOFS_RY:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lRy);
break;
case DIJOFS_RZ:
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.lRz);
break;
case DIJOFS_SLIDER(0):
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.rglSlider[0]);
break;
case DIJOFS_SLIDER(1):
SDL_PrivateJoystickAxis_Int(joystick, in->num,
(Sint16) state.rglSlider[1]);
break;
}
break;
case BUTTON:
SDL_PrivateJoystickButton_Int(joystick, in->num,
(Uint8) (state.
rgbButtons[in->ofs -
DIJOFS_BUTTON0]
? SDL_PRESSED :
SDL_RELEASED));
break;
case HAT:
{
Uint8 pos = TranslatePOV(state.rgdwPOV[in->ofs -
DIJOFS_POV(0)]);
SDL_PrivateJoystickHat_Int(joystick, in->num, pos);
break;
}
}
}
}
static void InitJoystick(joystick_type *joystick)
{
LPDIRECTINPUTDEVICE didTemp;
HRESULT hr;
LPDIRECTINPUT di = GetDirectInput();
joystick->use_joystick = FALSE;
joystick->did = NULL;
joystick->num_axes = 0;
joystick->is_light_gun = (strcmp(joystick->name, "ACT LABS GS (ACT LABS GS)") == 0);
/* get a did1 interface first... */
hr = IDirectInput_CreateDevice(di, &joystick->guidDevice, &didTemp, NULL);
if (FAILED(hr))
{
ErrorMsg("DirectInput CreateDevice() joystick failed: %s\n", DirectXDecodeError(hr));
return;
}
/* get a did2 interface to work with polling (most) joysticks */
hr = IDirectInputDevice_QueryInterface(didTemp,
&IID_IDirectInputDevice2,
(void**)&joystick->did);
/* dispose of the temp interface */
IDirectInputDevice_Release(didTemp);
/* check result of getting the did2 */
if (FAILED(hr))
{
/* no error message because this happens in dx3 */
/* ErrorMsg("DirectInput QueryInterface joystick failed\n"); */
joystick->did = NULL;
return;
}
hr = IDirectInputDevice2_SetCooperativeLevel(joystick->did, GetMainWindow(),
DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
if (FAILED(hr))
{
ErrorMsg("DirectInput SetCooperativeLevel() joystick failed: %s\n", DirectXDecodeError(hr));
return;
}
hr = IDirectInputDevice2_SetDataFormat(joystick->did, &c_dfDIJoystick);
if (FAILED(hr))
{
ErrorMsg("DirectInput SetDataFormat() joystick failed: %s\n", DirectXDecodeError(hr));
return;
}
if (joystick->is_light_gun)
{
/* setup light gun to report raw screen pixel data */
DIPROPDWORD diprop;
memset(&diprop, 0, sizeof(diprop));
diprop.diph.dwSize = sizeof(DIPROPDWORD);
diprop.diph.dwHeaderSize = sizeof(DIPROPHEADER);
diprop.diph.dwObj = 0;
diprop.diph.dwHow = DIPH_DEVICE;
diprop.dwData = DIPROPCALIBRATIONMODE_RAW;
IDirectInputDevice2_SetProperty(joystick->did, DIPROP_CALIBRATIONMODE, &diprop.diph);
}
else
{
/* enumerate our axes */
hr = IDirectInputDevice_EnumObjects(joystick->did,
DIJoystick_EnumAxisObjectsProc,
joystick,
DIDFT_AXIS);
if (FAILED(hr))
{
ErrorMsg("DirectInput EnumObjects() Axes failed: %s\n", DirectXDecodeError(hr));
return;
}
/* enumerate our POV hats */
joystick->num_pov = 0;
hr = IDirectInputDevice_EnumObjects(joystick->did,
DIJoystick_EnumPOVObjectsProc,
joystick,
DIDFT_POV);
if (FAILED(hr))
{
ErrorMsg("DirectInput EnumObjects() POVs failed: %s\n", DirectXDecodeError(hr));
return;
}
}
/* enumerate our buttons */
joystick->num_buttons = 0;
hr = IDirectInputDevice_EnumObjects(joystick->did,
DIJoystick_EnumButtonObjectsProc,
joystick,
DIDFT_BUTTON);
if (FAILED(hr))
{
ErrorMsg("DirectInput EnumObjects() Buttons failed: %s\n", DirectXDecodeError(hr));
return;
}
hr = IDirectInputDevice2_Acquire(joystick->did);
if (FAILED(hr))
{
ErrorMsg("DirectInputDevice Acquire joystick failed!\n");
return;
}
/* start by clearing the structures */
ClearJoyState(&joystick->dijs);
joystick->use_joystick = TRUE;
}
bool joysticks_init(void)
{
HRESULT err;
DIPROPDWORD dipdw =
{
{
sizeof(DIPROPDWORD), // diph.dwSize
sizeof(DIPROPHEADER), // diph.dwHeaderSize
0, // diph.dwObj
DIPH_DEVICE, // diph.dwHow
},
DINPUT_BUFFERSIZE, // dwData
};
LPDIRECTINPUTDEVICE tempJoystick = NULL;
LPVOID joysticknumptr;
int i, j, k;
bool failjoystick;
err = DirectInputCreate(GetModuleHandle(NULL), DIRECTINPUT_VERSION, &lpdi, NULL);
if (FAILED(err))//DirectInput8Create(hInstApp, DIRECTINPUT_VERSION, &IID_IDirectInput8, (void**)&lpdi, NULL)))
{
return false;
}
// try to create Joystick devices
for ( i = 0; i < MAX_JOYSTICKS; i++ )
lpdiJoystick[i] = NULL;
Num_Joysticks = 0;
lpdi->lpVtbl->EnumDevices(lpdi,
DIDEVTYPE_JOYSTICK,
//DI8DEVCLASS_GAMECTRL,
InitJoystickInput, lpdi, DIEDFL_ATTACHEDONLY);
failjoystick = false;
for (i = 0; i < Num_Joysticks; i++)
{
JoystickInfo[i].assigned = false;
JoystickInfo[i].connected = true;
JoystickInfo[i].NumAxis = 0;
JoystickInfo[i].NumButtons = 0;
JoystickInfo[i].NumPOVs = 0;
joysticknumptr = (LPVOID)&i;
for (j = AXIS_Start; j <= AXIS_End; j++)
{
JoystickInfo[i].Axis[j].exists = false;
}
lpdiJoystick[i]->lpVtbl->EnumObjects(lpdiJoystick[i], DIEnumDeviceObjectsProc,
joysticknumptr, DIDFT_ALL);
for (j = AXIS_Start; j <= AXIS_End; j++)
{
JoystickInfo[i].Axis[j].action = SHIPACTION_Nothing;
JoystickInfo[i].Axis[j].inverted = false;
JoystickInfo[i].Axis[j].deadzone = 20;
JoystickInfo[i].Axis[j].fine = true;
}
for (j = 0; j < JoystickInfo[i].NumButtons; j++)
JoystickInfo[i].Button[j].action = SHIPACTION_Nothing;
for (j = 0; j < JoystickInfo[i].NumPOVs; j++)
{
for (k = 0; k < MAX_POV_DIRECTIONS; k++)
JoystickInfo[i].POV[j].action[k] = SHIPACTION_Nothing;
}
// Tell DirectInput that we want to receive data in joystick format
if (IDirectInputDevice2_SetDataFormat(lpdiJoystick[i], &c_dfDIJoystick2) == DI_OK)
{
// set cooperative level
if(IDirectInputDevice2_SetCooperativeLevel(lpdiJoystick[i], GetActiveWindow(),
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND) == DI_OK)
{
// try to acquire the Joystick
err = IDirectInputDevice2_Acquire(lpdiJoystick[i]);
if (err != DI_OK)
{
failjoystick = true;
}
}else
{
failjoystick = true;
}
}
else
{
failjoystick = true;
}
if (failjoystick)
{
failjoystick = false;
IDirectInputDevice2_Release(lpdiJoystick[i]);
lpdiJoystick[i] = NULL;
}
}
DebugPrintf( "joysticks_init: %d joysticks connected\n", Num_Joysticks );
// if we get here, all DirectInput objects were created ok
return true;
}
