static void *dinput_init(void)
{
struct dinput_input *di = NULL;
if (!dinput_init_context())
{
RARCH_ERR("Failed to start DirectInput driver.\n");
return NULL;
}
di = (struct dinput_input*)calloc(1, sizeof(*di));
if (!di)
return NULL;
#ifdef __cplusplus
if (FAILED(IDirectInput8_CreateDevice(g_ctx, GUID_SysKeyboard, &di->keyboard, NULL)))
{
RARCH_ERR("Failed to create keyboard device.\n");
di->keyboard = NULL;
}
if (FAILED(IDirectInput8_CreateDevice(g_ctx, GUID_SysMouse, &di->mouse, NULL)))
{
RARCH_ERR("Failed to create mouse device.\n");
di->mouse = NULL;
}
#else
if (FAILED(IDirectInput8_CreateDevice(g_ctx, &GUID_SysKeyboard, &di->keyboard, NULL)))
{
RARCH_ERR("Failed to create keyboard device.\n");
di->keyboard = NULL;
}
if (FAILED(IDirectInput8_CreateDevice(g_ctx, &GUID_SysMouse, &di->mouse, NULL)))
{
RARCH_ERR("Failed to create mouse device.\n");
di->mouse = NULL;
}
#endif
if (di->keyboard)
{
IDirectInputDevice8_SetDataFormat(di->keyboard, &c_dfDIKeyboard);
IDirectInputDevice8_SetCooperativeLevel(di->keyboard,
(HWND)driver.video_window, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->keyboard);
}
if (di->mouse)
{
IDirectInputDevice8_SetDataFormat(di->mouse, &c_dfDIMouse2);
IDirectInputDevice8_SetCooperativeLevel(di->mouse, (HWND)driver.video_window,
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->mouse);
}
input_keymaps_init_keyboard_lut(rarch_key_map_dinput);
di->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
return di;
}
static HRESULT Poll(IDirectInputDevice8A * joystick, DIJOYSTATE * state)
{
HRESULT hr;
hr = IDirectInputDevice8_Poll(joystick);
/* Try to acquire the joystick */
if (FAILED(hr)) {
hr = IDirectInputDevice8_Acquire(joystick);
while (hr == DIERR_INPUTLOST)
hr = IDirectInputDevice8_Acquire(joystick);
if (hr == DIERR_INVALIDPARAM || hr == DIERR_NOTINITIALIZED)
return E_FAIL;
if (hr == DIERR_OTHERAPPHASPRIO)
return S_OK;
}
hr = IDirectInputDevice8_GetDeviceState(joystick, sizeof(DIJOYSTATE),
state);
/* Should not fail, the device has just been acquired */
if (FAILED(hr))
return hr;
return S_OK;
}
static void dinput_poll(void *data)
{
struct dinput_input *di = (struct dinput_input*)data;
memset(di->state, 0, sizeof(di->state));
if (di->keyboard)
{
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->keyboard, sizeof(di->state), di->state)))
{
IDirectInputDevice8_Acquire(di->keyboard);
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->keyboard, sizeof(di->state), di->state)))
memset(di->state, 0, sizeof(di->state));
}
}
if (di->mouse)
{
DIMOUSESTATE2 mouse_state;
memset(&mouse_state, 0, sizeof(mouse_state));
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->mouse, sizeof(mouse_state), &mouse_state)))
{
IDirectInputDevice8_Acquire(di->mouse);
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->mouse, sizeof(mouse_state), &mouse_state)))
memset(&mouse_state, 0, sizeof(mouse_state));
}
di->mouse_last_x = di->mouse_x;
di->mouse_last_y = di->mouse_y;
di->mouse_x = di->window_pos_x;
di->mouse_y = di->window_pos_y;
if (!mouse_state.rgbButtons[0])
unset_doubleclick_on_titlebar();
if (doubleclick_on_titlebar_pressed())
di->mouse_l = 0;
else
di->mouse_l = mouse_state.rgbButtons[0];
di->mouse_r = mouse_state.rgbButtons[1];
di->mouse_m = mouse_state.rgbButtons[2];
/* No simple way to get absolute coordinates
* for RETRO_DEVICE_POINTER. Just use Win32 APIs. */
POINT point = {0};
GetCursorPos(&point);
ScreenToClient((HWND)video_driver_window_get(), &point);
di->mouse_x = point.x;
di->mouse_y = point.y;
}
if (di->joypad)
di->joypad->poll();
}
static void dinput_poll(void *data)
{
struct dinput_input *di = (struct dinput_input*)data;
memset(di->state, 0, sizeof(di->state));
if (di->keyboard)
{
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->keyboard, sizeof(di->state), di->state)))
{
IDirectInputDevice8_Acquire(di->keyboard);
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->keyboard, sizeof(di->state), di->state)))
memset(di->state, 0, sizeof(di->state));
}
}
if (di->mouse)
{
DIMOUSESTATE2 mouse_state;
memset(&mouse_state, 0, sizeof(mouse_state));
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->mouse, sizeof(mouse_state), &mouse_state)))
{
IDirectInputDevice8_Acquire(di->mouse);
if (FAILED(IDirectInputDevice8_GetDeviceState(
di->mouse, sizeof(mouse_state), &mouse_state)))
memset(&mouse_state, 0, sizeof(mouse_state));
}
di->mouse_rel_x = mouse_state.lX;
di->mouse_rel_y = mouse_state.lY;
di->mouse_l = mouse_state.rgbButtons[0];
di->mouse_r = mouse_state.rgbButtons[1];
di->mouse_m = mouse_state.rgbButtons[2];
di->mouse_wu = mouse_state.rgbButtons[3];
di->mouse_wd = mouse_state.rgbButtons[4];
/* No simple way to get absolute coordinates
* for RETRO_DEVICE_POINTER. Just use Win32 APIs. */
POINT point = {0};
GetCursorPos(&point);
ScreenToClient((HWND)driver.video_window, &point);
di->mouse_x = point.x;
di->mouse_y = point.y;
}
if (di->joypad)
di->joypad->poll();
}
static void dinput_joypad_poll(void)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
struct dinput_joypad *pad = &g_pads[i];
if ((pad->joypad) && (g_xbox_pad_indexes[i] == -1))
{
memset(&pad->joy_state, 0, sizeof(pad->joy_state));
if (FAILED(IDirectInputDevice8_Poll(pad->joypad)))
{
if (FAILED(IDirectInputDevice8_Acquire(pad->joypad)))
{
memset(&pad->joy_state, 0, sizeof(DIJOYSTATE2));
continue;
}
// If this fails, something *really* bad must have happened.
if (FAILED(IDirectInputDevice8_Poll(pad->joypad)))
{
memset(&pad->joy_state, 0, sizeof(DIJOYSTATE2));
continue;
}
}
IDirectInputDevice8_GetDeviceState(pad->joypad,
sizeof(DIJOYSTATE2), &pad->joy_state);
}
}
}
static void dinput_joypad_poll(void)
{
unsigned i;
for (i = 0; i < MAX_USERS; i++)
{
struct dinput_joypad *pad = &g_pads[i];
bool polled = g_xinput_pad_indexes[i] < 0;
if (!pad || !pad->joypad || !polled)
continue;
memset(&pad->joy_state, 0, sizeof(pad->joy_state));
if (FAILED(IDirectInputDevice8_Poll(pad->joypad)))
{
if (FAILED(IDirectInputDevice8_Acquire(pad->joypad)))
{
memset(&pad->joy_state, 0, sizeof(DIJOYSTATE2));
continue;
}
/* If this fails, something *really* bad must have happened. */
if (FAILED(IDirectInputDevice8_Poll(pad->joypad)))
{
memset(&pad->joy_state, 0, sizeof(DIJOYSTATE2));
continue;
}
}
IDirectInputDevice8_GetDeviceState(pad->joypad,
sizeof(DIJOYSTATE2), &pad->joy_state);
}
}
static void poll_input(const struct Joystick *joy, DIJOYSTATE *state)
{
HRESULT hr;
hr = IDirectInputDevice8_Poll(joy->device);
/* If it failed, try to acquire the joystick */
if (FAILED(hr))
{
hr = IDirectInputDevice8_Acquire(joy->device);
while (hr == DIERR_INPUTLOST) hr = IDirectInputDevice8_Acquire(joy->device);
}
if (hr == DIERR_OTHERAPPHASPRIO) return;
IDirectInputDevice8_GetDeviceState(joy->device, sizeof(DIJOYSTATE), state);
}
static void
UpdateDINPUTJoystickState_Buffered(SDL_Joystick * joystick)
{
int i;
HRESULT result;
DWORD numevents;
DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
numevents = INPUT_QSIZE;
result =
IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
sizeof(DIDEVICEOBJECTDATA), evtbuf,
&numevents, 0);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
result =
IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
sizeof(DIDEVICEOBJECTDATA),
evtbuf, &numevents, 0);
}
/* Handle the events or punt */
if (FAILED(result)) {
joystick->hwdata->send_remove_event = SDL_TRUE;
joystick->hwdata->removed = SDL_TRUE;
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);
}
break;
}
}
}
}
static void dinput_grab_mouse(void *data, bool state)
{
struct dinput_input *di = (struct dinput_input*)data;
IDirectInputDevice8_Unacquire(di->mouse);
IDirectInputDevice8_SetCooperativeLevel(di->mouse,
(HWND)driver.video_window,
state ?
(DISCL_EXCLUSIVE | DISCL_FOREGROUND) :
(DISCL_NONEXCLUSIVE | DISCL_FOREGROUND));
IDirectInputDevice8_Acquire(di->mouse);
}
static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, DWORD expected)
{
HRESULT hr;
DIDEVICEOBJECTDATA obj_data;
DWORD data_size = 1;
int i;
hr = IDirectInputDevice8_Acquire(lpdid);
ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr);
if (event_type == INPUT_KEYBOARD)
keybd_event( event, DIK_SPACE, 0, 0);
if (event_type == INPUT_MOUSE)
mouse_event( event, 0, 0, 0, 0);
flush_events();
IDirectInputDevice8_Poll(lpdid);
hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
if (data_size != 1)
{
win_skip("We're not able to inject input into Windows dinput8 with events\n");
IDirectInputDevice_Unacquire(lpdid);
return;
}
ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected);
/* Check for buffer owerflow */
for (i = 0; i < 17; i++)
if (event_type == INPUT_KEYBOARD)
{
keybd_event( VK_SPACE, DIK_SPACE, 0, 0);
keybd_event( VK_SPACE, DIK_SPACE, KEYEVENTF_KEYUP, 0);
}
else if (event_type == INPUT_MOUSE)
{
mouse_event(MOUSEEVENTF_LEFTDOWN, 1, 1, 0, 0);
mouse_event(MOUSEEVENTF_LEFTUP, 1, 1, 0, 0);
}
flush_events();
IDirectInputDevice8_Poll(lpdid);
data_size = 1;
hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
ok(hr == DI_BUFFEROVERFLOW, "GetDeviceData() failed: %08x\n", hr);
data_size = 1;
hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
ok(hr == DI_OK && data_size == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size);
IDirectInputDevice_Unacquire(lpdid);
}
static void *dinput_init(void)
{
if (!dinput_init_context())
return NULL;
struct dinput_input *di = (struct dinput_input*)calloc(1, sizeof(*di));
if (!di)
return NULL;
#ifdef __cplusplus
if (FAILED(IDirectInput8_CreateDevice(g_ctx, GUID_SysKeyboard, &di->keyboard, NULL)))
goto error;
if (FAILED(IDirectInput8_CreateDevice(g_ctx, GUID_SysMouse, &di->mouse, NULL)))
goto error;
#else
if (FAILED(IDirectInput8_CreateDevice(g_ctx, &GUID_SysKeyboard, &di->keyboard, NULL)))
goto error;
if (FAILED(IDirectInput8_CreateDevice(g_ctx, &GUID_SysMouse, &di->mouse, NULL)))
goto error;
#endif
IDirectInputDevice8_SetDataFormat(di->keyboard, &c_dfDIKeyboard);
IDirectInputDevice8_SetCooperativeLevel(di->keyboard,
(HWND)driver.video_window, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->keyboard);
IDirectInputDevice8_SetDataFormat(di->mouse, &c_dfDIMouse2);
IDirectInputDevice8_SetCooperativeLevel(di->mouse, (HWND)driver.video_window,
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->mouse);
input_init_keyboard_lut(rarch_key_map_dinput);
di->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
return di;
error:
dinput_destroy_context();
free(di);
return NULL;
}
int
SDL_DINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
{
HRESULT ret;
DWORD flags;
DIEFFECT temp;
/* Get the effect. */
SDL_memset(&temp, 0, sizeof(DIEFFECT));
if (SDL_SYS_ToDIEFFECT(haptic, &temp, data) < 0) {
goto err_update;
}
/* Set the flags. Might be worthwhile to diff temp with loaded effect and
* only change those parameters. */
flags = DIEP_DIRECTION |
DIEP_DURATION |
DIEP_ENVELOPE |
DIEP_STARTDELAY |
DIEP_TRIGGERBUTTON |
DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS;
/* Create the actual effect. */
ret =
IDirectInputEffect_SetParameters(effect->hweffect->ref, &temp, flags);
if (ret == DIERR_NOTEXCLUSIVEACQUIRED) {
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
ret = IDirectInputDevice8_SetCooperativeLevel(haptic->hwdata->device, SDL_HelperWindow, DISCL_EXCLUSIVE | DISCL_BACKGROUND);
if (SUCCEEDED(ret)) {
ret = DIERR_NOTACQUIRED;
}
}
if (ret == DIERR_INPUTLOST || ret == DIERR_NOTACQUIRED) {
ret = IDirectInputDevice8_Acquire(haptic->hwdata->device);
if (SUCCEEDED(ret)) {
ret = IDirectInputEffect_SetParameters(effect->hweffect->ref, &temp, flags);
}
}
if (FAILED(ret)) {
DI_SetError("Unable to update effect", ret);
goto err_update;
}
/* Copy it over. */
SDL_SYS_HapticFreeDIEFFECT(&effect->hweffect->effect, data->type);
SDL_memcpy(&effect->hweffect->effect, &temp, sizeof(DIEFFECT));
return 0;
err_update:
SDL_SYS_HapticFreeDIEFFECT(&temp, data->type);
return -1;
}
BOOL CALLBACK EffectsCallback(const DIEFFECTINFO *pdei, LPVOID pvRef)
{
struct Joystick *joystick = pvRef;
HRESULT hr;
DIEFFECT diEffect;
if (joystick->effects == NULL)
{
joystick->num_effects += 1;
return DIENUM_CONTINUE;
}
dump_effect(pdei);
DWORD dwAxes[1] = { DIJOFS_X };
LONG lDirection[1] = { 200 };
DIPERIODIC diPeriodic;
diPeriodic.dwMagnitude = 5000;
diPeriodic.lOffset = 0;
diPeriodic.dwPhase = 0;
diPeriodic.dwPeriod = DI_SECONDS;
diEffect.dwSize = sizeof(DIEFFECT);
diEffect.dwFlags = DIEFF_CARTESIAN;
diEffect.dwDuration = INFINITE;
diEffect.dwSamplePeriod = 0;
diEffect.dwGain = DI_FFNOMINALMAX;
diEffect.dwTriggerButton = DIEB_NOTRIGGER;
diEffect.dwTriggerRepeatInterval = 0;
diEffect.cAxes = 1;
diEffect.rgdwAxes = dwAxes;
diEffect.rglDirection = &lDirection[0];
diEffect.lpEnvelope = NULL;
diEffect.cbTypeSpecificParams = sizeof(diPeriodic);
diEffect.lpvTypeSpecificParams = &diPeriodic;
hr = IDirectInputDevice8_Acquire(joystick->device);
if (FAILED(hr)) return DIENUM_CONTINUE;
hr = IDirectInputDevice2_CreateEffect(
joystick->device, &pdei->guid, &diEffect, &joystick->effects[joystick->cur_effect].effect, NULL);
joystick->cur_effect += 1;
return DIENUM_CONTINUE;
}
/* _al_win_joystick_dinput_acquire: [window thread]
* Acquires the joystick devices.
*/
static void joystick_dinput_acquire(void)
{
HRESULT hr;
int i;
if (!joystick_dinput)
return;
for (i=0; i < MAX_JOYSTICKS; i++) {
if (joydx_joystick[i].device) {
hr = IDirectInputDevice8_Acquire(joydx_joystick[i].device);
if (FAILED(hr))
ALLEGRO_ERROR("acquire joystick %d failed: %s\n", i, dinput_err_str(hr));
}
}
}
void
SDL_DINPUT_JoystickUpdate(SDL_Joystick * joystick)
{
HRESULT result;
result = IDirectInputDevice8_Poll(joystick->hwdata->InputDevice);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
IDirectInputDevice8_Poll(joystick->hwdata->InputDevice);
}
if (joystick->hwdata->buffered) {
UpdateDINPUTJoystickState_Buffered(joystick);
} else {
UpdateDINPUTJoystickState_Polled(joystick);
}
}
static void joydx_merge(void)
{
unsigned i;
HRESULT hr;
config_needs_merging = false;
joydx_num_joysticks = 0;
for (i = 0; i < MAX_JOYSTICKS; i++) {
ALLEGRO_JOYSTICK_DIRECTX *joy = &joydx_joystick[i];
switch (joy->config_state) {
case STATE_UNUSED:
break;
case STATE_BORN:
hr = IDirectInputDevice8_Acquire(joy->device);
if (FAILED(hr)) {
ALLEGRO_ERROR("acquire joystick %d failed: %s\n",
i, dinput_err_str(hr));
}
joy->config_state = STATE_ALIVE;
/* fall through */
case STATE_ALIVE:
JOYSTICK_WAKER(joydx_num_joysticks) = joy->waker_event;
joydx_num_joysticks++;
break;
case STATE_DYING:
joydx_inactivate_joy(joy);
break;
}
}
ALLEGRO_INFO("Merged, num joysticks=%d\n", joydx_num_joysticks);
joystick_dinput_acquire();
}
static gboolean
dx_dinput_setup_events (ControllerDXDInput *controller,
GError **error)
{
HRESULT hresult;
DIPROPDWORD dword;
gint i, k;
DXDInputSource *source;
if ((controller->event = CreateEvent (NULL, TRUE, FALSE, NULL)) == NULL)
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"CreateEvent failed: %s",
g_win32_error_message (GetLastError ()));
return FALSE;
}
controller->format = g_new (DIDATAFORMAT, 1);
controller->format->dwSize = sizeof (DIDATAFORMAT);
controller->format->dwObjSize = sizeof (DIOBJECTDATAFORMAT);
dword.diph.dwSize = sizeof (DIPROPDWORD);
dword.diph.dwHeaderSize = sizeof (DIPROPHEADER);
dword.diph.dwObj = 0;
dword.diph.dwHow = DIPH_DEVICE;
/* Get the axis mode so we can use the same in the format */
if (FAILED ((hresult = IDirectInputDevice8_GetProperty (controller->didevice8,
DIPROP_AXISMODE,
&dword.diph))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::GetParameters failed: %s",
g_win32_error_message (hresult));
goto fail0;
}
controller->format->dwFlags = dword.dwData + 1;
controller->format->dwNumObjs =
controller->num_buttons +
controller->num_axes +
controller->num_sliders +
controller->num_povs;
controller->format->rgodf = g_new (DIOBJECTDATAFORMAT, controller->format->dwNumObjs);
k = 0;
controller->format->dwDataSize = 0;
for (i = 0; i < controller->num_buttons; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_BUTTON | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = 0;
controller->format->dwDataSize += 1;
k++;
}
controller->format->dwDataSize = 4*((controller->format->dwDataSize + 3)/4);
for (i = 0; i < controller->num_axes; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_AXIS | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = DIDOI_ASPECTPOSITION;
controller->format->dwDataSize += 4;
k++;
}
for (i = 0; i < controller->num_sliders; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_AXIS | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = DIDOI_ASPECTPOSITION;
controller->format->dwDataSize += 4;
k++;
}
for (i = 0; i < controller->num_povs; i++)
{
controller->format->rgodf[k].pguid = NULL;
controller->format->rgodf[k].dwOfs = controller->format->dwDataSize;
controller->format->rgodf[k].dwType = DIDFT_POV | DIDFT_MAKEINSTANCE (i);
controller->format->rgodf[k].dwFlags = 0;
controller->format->dwDataSize += 4;
k++;
}
g_assert (k == controller->format->dwNumObjs);
controller->format->dwDataSize = 4*((controller->format->dwDataSize + 3)/4);
controller->prevdata = g_malloc (controller->format->dwDataSize);
dump_data_format (controller->format);
if (FAILED ((hresult = IDirectInputDevice8_SetDataFormat (controller->didevice8,
controller->format))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::SetDataFormat failed: %s",
g_win32_error_message (hresult));
goto fail1;
}
if (FAILED ((hresult = IDirectInputDevice8_SetEventNotification (controller->didevice8,
controller->event))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::SetEventNotification failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
if (FAILED ((hresult = IDirectInputDevice8_Acquire (controller->didevice8))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::Acquire failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
if (FAILED ((hresult = IDirectInputDevice8_GetDeviceState (controller->didevice8,
controller->format->dwDataSize,
controller->prevdata))))
{
g_set_error (error, GIMP_MODULE_ERROR, GIMP_MODULE_FAILED,
"IDirectInputDevice8::GetDeviceState failed: %s",
g_win32_error_message (hresult));
goto fail2;
}
source = (DXDInputSource *) g_source_new (&dx_dinput_event_funcs,
sizeof (DXDInputSource));
source->controller = controller;
controller->source = (GSource *) source;
controller->pollfd = g_new (GPollFD, 1);
controller->pollfd->fd = (int) controller->event;
controller->pollfd->events = G_IO_IN;
g_source_add_poll (&source->source, controller->pollfd);
g_source_attach (&source->source, NULL);
return TRUE;
fail2:
IDirectInputDevice8_SetEventNotification (controller->didevice8, NULL);
fail1:
g_free (controller->format->rgodf);
g_free (controller->format);
controller->format = NULL;
g_free (controller->prevdata);
controller->prevdata = NULL;
fail0:
CloseHandle (controller->event);
controller->event = 0;
return FALSE;
}
LRESULT CALLBACK ButtonConfigDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
static LPDIRECTINPUTDEVICE8 lpDIDevicetemp;
DIPROPDWORD dipdw;
HRESULT hr;
DWORD size;
DIDEVICEOBJECTDATA didod[8];
DWORD i;
DIDEVCAPS didc;
switch (uMsg)
{
case WM_INITDIALOG:
{
lpDIDevicetemp = (LPDIRECTINPUTDEVICE8)lParam;
if (FAILED(IDirectInputDevice8_SetCooperativeLevel(lpDIDevicetemp, hDlg,
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE | DISCL_NOWINKEY)))
return FALSE;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 8; // should be enough
// Setup Buffered input
if (FAILED((hr = IDirectInputDevice8_SetProperty(lpDIDevicetemp, DIPROP_BUFFERSIZE, &dipdw.diph))))
return FALSE;
if (!SetTimer(hDlg, 1, 100, NULL))
return FALSE;
PostMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDC_WAITINPUT), TRUE);
hook = SetWindowsHookEx(WH_KEYBOARD, KeyboardHook, GetModuleHandle(NULL), GetCurrentThreadId());
return TRUE;
}
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_CUSTOMCANCEL:
{
EndDialog(hDlg, FALSE);
return TRUE;
}
default: break;
}
break;
}
case WM_TIMER:
{
size = 8;
if (wParam == 1)
{
memset(&didod, 0, sizeof(DIDEVICEOBJECTDATA) * 8);
// Let's see if there's any data waiting
hr = IDirectInputDevice8_Poll(lpDIDevicetemp);
if (FAILED(hr))
{
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
// Make sure device is acquired
while(IDirectInputDevice8_Acquire(lpDIDevicetemp) == DIERR_INPUTLOST) {}
return TRUE;
}
}
// Poll events
if (FAILED(IDirectInputDevice8_GetDeviceData(lpDIDevicetemp,
sizeof(DIDEVICEOBJECTDATA), didod, &size, 0)))
{
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
// Make sure device is acquired
while(IDirectInputDevice8_Acquire(lpDIDevicetemp) == DIERR_INPUTLOST) {}
return TRUE;
}
}
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevicetemp, &didc)))
return TRUE;
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
for (i = 0; i < size; i++)
{
if (didod[i].dwData & 0x80)
{
// We're done. time to bail
EndDialog(hDlg, TRUE);
memcpy(&nextpress, &didod[i], sizeof(DIDEVICEOBJECTDATA));
break;
}
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
for (i = 0; i < size; i++)
{
if (didod[i].dwOfs == 0 ||
didod[i].dwOfs == 4)
{
if (didod[i].dwData <= 0x1000 ||
didod[i].dwData >= 0xF000)
{
// We're done. time to bail
EndDialog(hDlg, TRUE);
memcpy(&nextpress, &didod[i], sizeof(DIDEVICEOBJECTDATA));
break;
}
}
else if (didod[i].dwOfs == 0x20)
{
if (((int)didod[i].dwData) >= 0)
{
// We're done. time to bail
EndDialog(hDlg, TRUE);
memcpy(&nextpress, &didod[i], sizeof(DIDEVICEOBJECTDATA));
}
}
else if (didod[i].dwOfs >= 0x30)
{
if (didod[i].dwData & 0x80)
{
// We're done. time to bail
EndDialog(hDlg, TRUE);
memcpy(&nextpress, &didod[i], sizeof(DIDEVICEOBJECTDATA));
break;
}
}
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
for (i = 0; i < size; i++)
{
// Make sure it's a button press
if (didod[i].dwOfs >= DIMOFS_BUTTON0 && didod[i].dwOfs <= DIMOFS_BUTTON7)
{
if (didod[i].dwData & 0x80)
{
EndDialog(hDlg, TRUE);
memcpy(&nextpress, &didod[i], sizeof(DIDEVICEOBJECTDATA));
break;
}
}
}
}
return TRUE;
}
return FALSE;
}
case WM_DESTROY:
{
KillTimer(hDlg, 1);
UnhookWindowsHookEx(hook);
break;
}
}
return FALSE;
}
/* 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.
*/
static void
UpdateDINPUTJoystickState_Polled(SDL_Joystick * joystick)
{
DIJOYSTATE2 state;
HRESULT result;
int i;
result =
IDirectInputDevice8_GetDeviceState(joystick->hwdata->InputDevice,
sizeof(DIJOYSTATE2), &state);
if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
result =
IDirectInputDevice8_GetDeviceState(joystick->hwdata->InputDevice,
sizeof(DIJOYSTATE2), &state);
}
if (result != DI_OK) {
joystick->hwdata->send_remove_event = SDL_TRUE;
joystick->hwdata->removed = SDL_TRUE;
return;
}
/* 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(joystick, in->num, (Sint16)state.lX);
break;
case DIJOFS_Y:
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.lY);
break;
case DIJOFS_Z:
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.lZ);
break;
case DIJOFS_RX:
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.lRx);
break;
case DIJOFS_RY:
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.lRy);
break;
case DIJOFS_RZ:
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.lRz);
break;
case DIJOFS_SLIDER(0):
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.rglSlider[0]);
break;
case DIJOFS_SLIDER(1):
SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)state.rglSlider[1]);
break;
}
break;
case BUTTON:
SDL_PrivateJoystickButton(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(joystick, in->num, pos);
break;
}
}
}
}
/***********************************************************************
* ff_effects_callback [internal]
* Enumerates, creates, sets the some parameters and stores all ff effects
* supported by the joystick. Works like enum_callback, counting the effects
* first and then storing them.
*/
static BOOL CALLBACK ff_effects_callback(const DIEFFECTINFOW *pdei, void *pvRef)
{
HRESULT hr;
DIEFFECT dieffect;
DWORD axes[2] = {DIJOFS_X, DIJOFS_Y};
int direction[2] = {0, 0};
struct Joystick *joystick = pvRef;
if (joystick->effects == NULL)
{
joystick->num_effects += 1;
return DIENUM_CONTINUE;
}
hr = IDirectInputDevice8_Acquire(joystick->device);
if (FAILED(hr)) return DIENUM_CONTINUE;
ZeroMemory(&dieffect, sizeof(dieffect));
dieffect.dwSize = sizeof(dieffect);
dieffect.dwFlags = DIEFF_CARTESIAN;
dieffect.dwDuration = FF_PLAY_TIME;
dieffect.cAxes = 2;
dieffect.rgdwAxes = axes;
dieffect.rglDirection = direction;
if (IsEqualGUID(&pdei->guid, &GUID_RampForce))
{
DIRAMPFORCE rforce;
rforce.lStart = 0;
rforce.lEnd = DI_FFNOMINALMAX;
dieffect.cbTypeSpecificParams = sizeof(rforce);
dieffect.lpvTypeSpecificParams = &rforce;
dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
}
else if (IsEqualGUID(&pdei->guid, &GUID_ConstantForce))
{
DICONSTANTFORCE cforce;
cforce.lMagnitude = DI_FFNOMINALMAX;
dieffect.cbTypeSpecificParams = sizeof(cforce);
dieffect.lpvTypeSpecificParams = &cforce;
dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
}
else if (IsEqualGUID(&pdei->guid, &GUID_Sine) ||
IsEqualGUID(&pdei->guid, &GUID_Square) ||
IsEqualGUID(&pdei->guid, &GUID_Triangle) ||
IsEqualGUID(&pdei->guid, &GUID_SawtoothUp) ||
IsEqualGUID(&pdei->guid, &GUID_SawtoothDown))
{
DIPERIODIC pforce;
pforce.dwMagnitude = DI_FFNOMINALMAX;
pforce.lOffset = 0;
pforce.dwPhase = 0;
pforce.dwPeriod = FF_PERIOD_TIME;
dieffect.cbTypeSpecificParams = sizeof(pforce);
dieffect.lpvTypeSpecificParams = &pforce;
dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
}
hr = IDirectInputDevice2_CreateEffect(
joystick->device, &pdei->guid, &dieffect, &joystick->effects[joystick->cur_effect].effect, NULL);
joystick->effects[joystick->cur_effect].params = dieffect;
joystick->effects[joystick->cur_effect].info = *pdei;
joystick->cur_effect += 1;
return DIENUM_CONTINUE;
}
int
SDL_DINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickdevice)
{
HRESULT result;
LPDIRECTINPUTDEVICE8 device;
DIPROPDWORD dipdw;
joystick->hwdata->buffered = SDL_TRUE;
joystick->hwdata->Capabilities.dwSize = sizeof(DIDEVCAPS);
SDL_zero(dipdw);
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
result =
IDirectInput8_CreateDevice(dinput,
&(joystickdevice->dxdevice.guidInstance), &device, NULL);
if (FAILED(result)) {
return SetDIerror("IDirectInput::CreateDevice", result);
}
/* Now get the IDirectInputDevice8 interface, instead. */
result = IDirectInputDevice8_QueryInterface(device,
&IID_IDirectInputDevice8,
(LPVOID *)& joystick->
hwdata->InputDevice);
/* We are done with this object. Use the stored one from now on. */
IDirectInputDevice8_Release(device);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::QueryInterface", result);
}
/* Acquire shared access. Exclusive access is required for forces,
* though. */
result =
IDirectInputDevice8_SetCooperativeLevel(joystick->hwdata->
InputDevice, SDL_HelperWindow,
DISCL_EXCLUSIVE |
DISCL_BACKGROUND);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetCooperativeLevel", result);
}
/* Use the extended data structure: DIJOYSTATE2. */
result =
IDirectInputDevice8_SetDataFormat(joystick->hwdata->InputDevice,
&SDL_c_dfDIJoystick2);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetDataFormat", result);
}
/* Get device capabilities */
result =
IDirectInputDevice8_GetCapabilities(joystick->hwdata->InputDevice,
&joystick->hwdata->Capabilities);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::GetCapabilities", result);
}
/* Force capable? */
if (joystick->hwdata->Capabilities.dwFlags & DIDC_FORCEFEEDBACK) {
result = IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::Acquire", result);
}
/* reset all actuators. */
result =
IDirectInputDevice8_SendForceFeedbackCommand(joystick->hwdata->
InputDevice,
DISFFC_RESET);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SendForceFeedbackCommand", result);
}
*/
result = IDirectInputDevice8_Unacquire(joystick->hwdata->InputDevice);
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::Unacquire", result);
}
/* 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 =
IDirectInputDevice8_SetProperty(joystick->hwdata->InputDevice,
DIPROP_AUTOCENTER, &dipdw.diph);
/* Not necessarily supported, ignore if not supported.
if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetProperty", result);
}
*/
}
/* What buttons and axes does it have? */
IDirectInputDevice8_EnumObjects(joystick->hwdata->InputDevice,
EnumDevObjectsCallback, joystick,
DIDFT_BUTTON | DIDFT_AXIS | DIDFT_POV);
/* Reorder the input objects. Some devices do not report the X axis as
* the first axis, for example. */
SortDevObjects(joystick);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = INPUT_QSIZE;
/* Set the buffer size */
result =
IDirectInputDevice8_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 = SDL_FALSE;
} else if (FAILED(result)) {
return SetDIerror("IDirectInputDevice8::SetProperty", result);
}
return 0;
}
int PERDXInit(void)
{
DIPROPDWORD dipdw;
char tempstr[512];
HRESULT ret;
memset(pad, 0, sizeof(pad));
memset(paddevice, 0, sizeof(paddevice));
if (FAILED((ret = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8, NULL)) ))
{
sprintf(tempstr, "DirectInput8Create error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
IDirectInput8_EnumDevices(lpDI8, DI8DEVCLASS_ALL, EnumPeripheralsCallback,
NULL, DIEDFL_ATTACHEDONLY);
if (FAILED((ret = IDirectInput8_CreateDevice(lpDI8, &GUID_SysKeyboard, &lpDIDevice[0],
NULL)) ))
{
sprintf(tempstr, "IDirectInput8_CreateDevice error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
if (FAILED((ret = IDirectInputDevice8_SetDataFormat(lpDIDevice[0], &c_dfDIKeyboard)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetDataFormat error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
if (FAILED((ret = IDirectInputDevice8_SetCooperativeLevel(lpDIDevice[0], DXGetWindow(),
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE | DISCL_NOWINKEY)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetCooperativeLevel error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 8; // should be enough
// Setup Buffered input
if (FAILED((ret = IDirectInputDevice8_SetProperty(lpDIDevice[0], DIPROP_BUFFERSIZE, &dipdw.diph)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetProperty error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
// Make sure Keyboard is acquired already
IDirectInputDevice8_Acquire(lpDIDevice[0]);
paddevice[0].lpDIDevice = lpDIDevice[0];
paddevice[0].type = TYPE_KEYBOARD;
paddevice[0].emulatetype = 1;
PerPortReset();
LoadDefaultPort1A();
return 0;
}
void PERDXLoadDevices(char *inifilename)
{
char tempstr[MAX_PATH];
char string1[20];
char string2[20];
GUID guid;
DIDEVCAPS didc;
u32 i;
int j, i2;
int buttonid;
DIPROPDWORD dipdw;
int id;
DWORD coopflags=DISCL_FOREGROUND | DISCL_NONEXCLUSIVE;
BOOL loaddefault=TRUE;
int numpads;
HRESULT hr;
if (!PERCore)
return;
PerPortReset();
memset(pad, 0, sizeof(pad));
// Check Connection Type
if (GetPrivateProfileStringA("Input", "Port1Type", "", tempstr, MAX_PATH, inifilename) == 0)
{
// Check if it's using the old ini settings for peripherals
if (GetPrivateProfileStringA("Peripheral1", "GUID", "", tempstr, MAX_PATH, inifilename) != 0)
{
// Convert to the newer type of settings
for (i = 0; i < 2; i++)
{
sprintf(string1, "Port%dType", (int)i+1);
WritePrivateProfileStringA("Input", string1, "1", inifilename);
sprintf(string1, "Peripheral%d", (int)i+1);
sprintf(string2, "Peripheral%dA", (int)i+1);
if (GetPrivateProfileStringA(string1, "GUID", "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, "GUID", tempstr, inifilename);
if (GetPrivateProfileStringA(string1, "EmulateType", "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, "EmulateType", tempstr, inifilename);
for (i2 = 0; i2 < 13; i2++)
{
if (GetPrivateProfileStringA(string1, PerPadNames[i2], "", tempstr, MAX_PATH, inifilename))
WritePrivateProfileStringA(string2, PerPadNames[i2], tempstr, inifilename);
}
}
// Remove old ini entries
for (i = 0; i < 12; i++)
{
sprintf(string1, "Peripheral%d", (int)i+1);
WritePrivateProfileStringA(string1, NULL, NULL, inifilename);
}
loaddefault = FALSE;
}
}
else
loaddefault = FALSE;
if (loaddefault)
{
LoadDefaultPort1A();
return;
}
// Load new type settings
for (i = 0; i < 2; i++)
{
sprintf(string1, "Port%dType", (int)i+1);
if (GetPrivateProfileStringA("Input", string1, "", tempstr, MAX_PATH, inifilename) != 0)
{
porttype[i] = atoi(tempstr);
switch(porttype[i])
{
case 1:
numpads = 1;
break;
case 2:
numpads = 6;
break;
default:
numpads = 0;
break;
}
// Load new type settings
for (j = 0; j < numpads; j++)
{
int padindex=(6*i)+j;
padconf_struct *curdevice=&paddevice[padindex];
sprintf(string1, "Peripheral%d%C", (int)i+1, 'A' + j);
// Let's first fetch the guid of the device
if (GetPrivateProfileStringA(string1, "GUID", "", tempstr, MAX_PATH, inifilename) == 0)
continue;
if (GetPrivateProfileStringA(string1, "EmulateType", "0", string2, MAX_PATH, inifilename))
{
curdevice->emulatetype = atoi(string2);
if (curdevice->emulatetype == 0)
continue;
}
if (curdevice->lpDIDevice)
{
// Free the default keyboard, etc.
IDirectInputDevice8_Unacquire(curdevice->lpDIDevice);
IDirectInputDevice8_Release(curdevice->lpDIDevice);
}
StringToGUID(tempstr, &guid);
// Ok, now that we've got the GUID of the device, let's set it up
if (FAILED(IDirectInput8_CreateDevice(lpDI8, &guid, &lpDIDevice[padindex],
NULL) ))
{
curdevice->lpDIDevice = NULL;
curdevice->emulatetype = 0;
continue;
}
curdevice->lpDIDevice = lpDIDevice[padindex];
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevice[padindex], &didc) ))
continue;
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIKeyboard) ))
continue;
curdevice->type = TYPE_KEYBOARD;
coopflags |= DISCL_NOWINKEY;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIJoystick2) ))
continue;
curdevice->type = TYPE_JOYSTICK;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevice[padindex], &c_dfDIMouse2) ))
continue;
curdevice->type = TYPE_MOUSE;
coopflags = DISCL_FOREGROUND | DISCL_EXCLUSIVE;
}
hr = IDirectInputDevice8_SetCooperativeLevel(lpDIDevice[i], DXGetWindow(), coopflags);
if (FAILED(hr))
continue;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 8; // should be enough
// Setup Buffered input
if (FAILED(IDirectInputDevice8_SetProperty(lpDIDevice[padindex], DIPROP_BUFFERSIZE, &dipdw.diph)))
continue;
IDirectInputDevice8_Acquire(lpDIDevice[padindex]);
switch(curdevice->emulatetype)
{
case 1: // Standard Pad
id = PERPAD;
break;
case 2: // Analog Pad
case 3: // Stunner
case 5: // Keyboard
id = 0;
break;
case 4: // Mouse
id = PERMOUSE;
break;
default: break;
}
// Make sure we're added to the smpc list
if (i == 0)
pad[padindex] = PerAddPeripheral(&PORTDATA1, id);
else
pad[padindex] = PerAddPeripheral(&PORTDATA2, id);
// Now that we're all setup, let's fetch the controls from the ini
if (curdevice->emulatetype != 3 &&
curdevice->emulatetype != 4)
{
for (i2 = 0; i2 < 13; i2++)
{
buttonid = GetPrivateProfileIntA(string1, PerPadNames[i2], 0, inifilename);
PerSetKey(buttonid, i2, pad[padindex]);
}
}
else if (curdevice->emulatetype == 4)
{
for (i2 = 0; i2 < 4; i2++)
{
buttonid = GetPrivateProfileIntA(string1, mouse_names[i2], 0, inifilename);
PerSetKey(buttonid, PERMOUSE_LEFT+i2, pad[padindex]);
}
}
}
}
}
}
void PollKeys(void)
{
u32 i;
DWORD i2;
DWORD size=8;
DIDEVICEOBJECTDATA didod[8];
HRESULT hr;
for (i = 0; i < numpads; i++)
{
if (paddevice[i].lpDIDevice == NULL)
continue;
hr = IDirectInputDevice8_Poll(paddevice[i].lpDIDevice);
if (FAILED(hr))
{
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
// Make sure device is acquired
while(IDirectInputDevice8_Acquire(paddevice[i].lpDIDevice) == DIERR_INPUTLOST) {}
continue;
}
}
size = 8;
// Poll events
if (FAILED(IDirectInputDevice8_GetDeviceData(paddevice[i].lpDIDevice,
sizeof(DIDEVICEOBJECTDATA), didod, &size, 0)))
{
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
// Make sure device is acquired
while(IDirectInputDevice8_Acquire(paddevice[i].lpDIDevice) == DIERR_INPUTLOST) {}
continue;
}
}
if (size == 0)
continue;
switch (paddevice[i].type)
{
case TYPE_KEYBOARD:
// This probably could be optimized
for (i2 = 0; i2 < size; i2++)
{
if (didod[i2].dwData & 0x80)
PerKeyDown(didod[i2].dwOfs);
else
PerKeyUp(didod[i2].dwOfs);
}
break;
case TYPE_JOYSTICK:
{
// This probably could be optimized
for (i2 = 0; i2 < size; i2++)
{
// X Axis
if (didod[i2].dwOfs == DIJOFS_X)
{
if (didod[i2].dwData < 0x3FFF)
{
PerKeyDown(PAD_DIR_AXISLEFT);
PerKeyUp(PAD_DIR_AXISRIGHT);
}
else if (didod[i2].dwData > 0xBFFF)
{
PerKeyDown(PAD_DIR_AXISRIGHT);
PerKeyUp(PAD_DIR_AXISLEFT);
}
else
{
PerKeyUp(PAD_DIR_AXISLEFT);
PerKeyUp(PAD_DIR_AXISRIGHT);
}
}
// Y Axis
else if (didod[i2].dwOfs == DIJOFS_Y)
{
if (didod[i2].dwData < 0x3FFF)
{
PerKeyDown(PAD_DIR_AXISUP);
PerKeyUp(PAD_DIR_AXISDOWN);
}
else if (didod[i2].dwData > 0xBFFF)
{
PerKeyDown(PAD_DIR_AXISDOWN);
PerKeyUp(PAD_DIR_AXISUP);
}
else
{
PerKeyUp(PAD_DIR_AXISUP);
PerKeyUp(PAD_DIR_AXISDOWN);
}
}
else if (didod[i2].dwOfs == DIJOFS_POV(0))
{
// POV Center
if (LOWORD(didod[i2].dwData) == 0xFFFF)
{
PerKeyUp(PAD_DIR_POVUP);
PerKeyUp(PAD_DIR_POVRIGHT);
PerKeyUp(PAD_DIR_POVDOWN);
PerKeyUp(PAD_DIR_POVLEFT);
}
// POV Up
else if (didod[i2].dwData < 4500)
{
PerKeyDown(PAD_DIR_POVUP);
PerKeyUp(PAD_DIR_POVRIGHT);
PerKeyUp(PAD_DIR_POVLEFT);
}
// POV Up-right
else if (didod[i2].dwData < 9000)
{
PerKeyDown(PAD_DIR_POVUP);
PerKeyDown(PAD_DIR_POVRIGHT);
}
// POV Right
else if (didod[i2].dwData < 13500)
{
PerKeyDown(PAD_DIR_POVRIGHT);
PerKeyUp(PAD_DIR_POVDOWN);
PerKeyUp(PAD_DIR_POVUP);
}
// POV Right-down
else if (didod[i2].dwData < 18000)
{
PerKeyDown(PAD_DIR_POVRIGHT);
PerKeyDown(PAD_DIR_POVDOWN);
}
// POV Down
else if (didod[i2].dwData < 22500)
{
PerKeyDown(PAD_DIR_POVDOWN);
PerKeyUp(PAD_DIR_POVLEFT);
PerKeyUp(PAD_DIR_POVRIGHT);
}
// POV Down-left
else if (didod[i2].dwData < 27000)
{
PerKeyDown(PAD_DIR_POVDOWN);
PerKeyDown(PAD_DIR_POVLEFT);
}
// POV Left
else if (didod[i2].dwData < 31500)
{
PerKeyDown(PAD_DIR_POVLEFT);
PerKeyUp(PAD_DIR_POVUP);
PerKeyUp(PAD_DIR_POVDOWN);
}
// POV Left-up
else if (didod[i2].dwData < 36000)
{
PerKeyDown(PAD_DIR_POVLEFT);
PerKeyDown(PAD_DIR_POVUP);
}
}
else if (didod[i2].dwOfs >= DIJOFS_BUTTON(0) && didod[i2].dwOfs <= DIJOFS_BUTTON(127))
{
if (didod[i2].dwData & 0x80)
PerKeyDown(didod[i2].dwOfs);
else
PerKeyUp(didod[i2].dwOfs);
}
}
break;
}
case TYPE_MOUSE:
for (i2 = 0; i2 < size; i2++)
{
if (didod[i2].dwOfs == DIMOFS_X)
// X Axis
PerMouseMove((PerMouse_struct *)pad[i], (s32)didod[i2].dwData, 0);
else if (didod[i2].dwOfs == DIMOFS_Y)
// Y Axis
PerMouseMove((PerMouse_struct *)pad[i], 0, 0-(s32)didod[i2].dwData);
else if (didod[i2].dwOfs >= DIMOFS_BUTTON0 && didod[i2].dwOfs <= DIMOFS_BUTTON7)
{
// Mouse Buttons
if (didod[i2].dwData & 0x80)
PerKeyDown(didod[i2].dwOfs-DIMOFS_BUTTON0);
else
PerKeyUp(didod[i2].dwOfs-DIMOFS_BUTTON0);
}
}
break;
default: break;
}
}
}
unsigned int joystick_windows::process_joysticks(unsigned int p_last_id) {
HRESULT hr;
for (int i = 0; i < XUSER_MAX_COUNT; i++) {
xinput_gamepad &joy = x_joysticks[i];
if (!joy.attached) {
continue;
}
ZeroMemory(&joy.state, sizeof(XINPUT_STATE));
xinput_get_state(i, &joy.state);
if (joy.state.dwPacketNumber != joy.last_packet) {
int button_mask = XINPUT_GAMEPAD_DPAD_UP;
for (int i = 0; i <= 16; i++) {
p_last_id = input->joy_button(p_last_id, joy.id, i, joy.state.Gamepad.wButtons & button_mask);
button_mask = button_mask * 2;
}
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_0, axis_correct(joy.state.Gamepad.sThumbLX, true));
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_1, axis_correct(joy.state.Gamepad.sThumbLY, true, false, true));
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_2, axis_correct(joy.state.Gamepad.sThumbRX, true));
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_3, axis_correct(joy.state.Gamepad.sThumbRY, true, false, true));
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_4, axis_correct(joy.state.Gamepad.bLeftTrigger, true, true));
p_last_id = input->joy_axis(p_last_id, joy.id, JOY_AXIS_5, axis_correct(joy.state.Gamepad.bRightTrigger, true, true));
joy.last_packet = joy.state.dwPacketNumber;
}
uint64_t timestamp = input->get_joy_vibration_timestamp(joy.id);
if (timestamp > joy.ff_timestamp) {
Vector2 strength = input->get_joy_vibration_strength(joy.id);
float duration = input->get_joy_vibration_duration(joy.id);
if (strength.x == 0 && strength.y == 0) {
joystick_vibration_stop_xinput(i, timestamp);
} else {
joystick_vibration_start_xinput(i, strength.x, strength.y, duration, timestamp);
}
} else if (joy.vibrating && joy.ff_end_timestamp != 0) {
uint64_t current_time = OS::get_singleton()->get_ticks_usec();
if (current_time >= joy.ff_end_timestamp)
joystick_vibration_stop_xinput(i, current_time);
}
}
for (int i = 0; i < JOYSTICKS_MAX; i++) {
dinput_gamepad* joy = &d_joysticks[i];
if (!joy->attached)
continue;
DIJOYSTATE2 js;
hr = joy->di_joy->Poll();
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED) {
IDirectInputDevice8_Acquire(joy->di_joy);
joy->di_joy->Poll();
}
if (FAILED(hr = joy->di_joy->GetDeviceState(sizeof(DIJOYSTATE2), &js))) {
//printf("failed to read joy #%d\n", i);
continue;
}
p_last_id = post_hat(p_last_id, joy->id, js.rgdwPOV[0]);
for (int j = 0; j < 128; j++) {
if (js.rgbButtons[j] & 0x80) {
if (!joy->last_buttons[j]) {
p_last_id = input->joy_button(p_last_id, joy->id, j, true);
joy->last_buttons[j] = true;
}
}
else {
if (joy->last_buttons[j]) {
p_last_id = input->joy_button(p_last_id, joy->id, j, false);
joy->last_buttons[j] = false;
}
}
}
// on mingw, these constants are not constants
int count = 6;
int axes[] = { DIJOFS_X, DIJOFS_Y, DIJOFS_Z, DIJOFS_RX, DIJOFS_RY, DIJOFS_RZ };
int values[] = { js.lX, js.lY, js.lZ, js.lRx, js.lRy, js.lRz };
for (int j = 0; j < joy->joy_axis.size(); j++) {
for (int k=0; k<count; k++) {
if (joy->joy_axis[j] == axes[k]) {
p_last_id = input->joy_axis(p_last_id, joy->id, j, axis_correct(values[k]));
break;
};
};
};
}
return p_last_id;
}
JNIEXPORT jint JNICALL Java_net_java_games_input_IDirectInputDevice_nAcquire(JNIEnv *env, jclass unused, jlong address) {
LPDIRECTINPUTDEVICE8 lpDevice = (LPDIRECTINPUTDEVICE8)(INT_PTR)address;
HRESULT res = IDirectInputDevice8_Acquire(lpDevice);
return res;
}
/*
* Opens the haptic device from the file descriptor.
*
* Steps:
* - Set cooperative level.
* - Set data format.
* - Acquire exclusiveness.
* - Reset actuators.
* - Get supported features.
*/
static int
SDL_SYS_HapticOpenFromDevice8(SDL_Haptic * haptic,
LPDIRECTINPUTDEVICE8 device8, SDL_bool is_joystick)
{
HRESULT ret;
DIPROPDWORD dipdw;
/* Allocate the hwdata */
haptic->hwdata = (struct haptic_hwdata *)SDL_malloc(sizeof(*haptic->hwdata));
if (haptic->hwdata == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
/* We'll use the device8 from now on. */
haptic->hwdata->device = device8;
haptic->hwdata->is_joystick = is_joystick;
/* Grab it exclusively to use force feedback stuff. */
ret = IDirectInputDevice8_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 = IDirectInputDevice8_SetDataFormat(haptic->hwdata->device,
&c_dfDIJoystick2);
if (FAILED(ret)) {
DI_SetError("Setting data format", ret);
goto acquire_err;
}
/* Get number of axes. */
ret = IDirectInputDevice8_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 = IDirectInputDevice8_Acquire(haptic->hwdata->device);
if (FAILED(ret)) {
DI_SetError("Acquiring DirectInput device", ret);
goto acquire_err;
}
/* Reset all actuators - just in case. */
ret = IDirectInputDevice8_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_RESET);
if (FAILED(ret)) {
DI_SetError("Resetting device", ret);
goto acquire_err;
}
/* Enabling actuators. */
ret = IDirectInputDevice8_SendForceFeedbackCommand(haptic->hwdata->device,
DISFFC_SETACTUATORSON);
if (FAILED(ret)) {
DI_SetError("Enabling actuators", ret);
goto acquire_err;
}
/* Get supported effects. */
ret = IDirectInputDevice8_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 = IDirectInputDevice8_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 = IDirectInputDevice8_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:
IDirectInputDevice8_Unacquire(haptic->hwdata->device);
return -1;
}
static void *dinput_init(void)
{
struct dinput_input *di = NULL;
settings_t *settings = config_get_ptr();
if (!dinput_init_context())
{
RARCH_ERR("Failed to start DirectInput driver.\n");
return NULL;
}
di = (struct dinput_input*)calloc(1, sizeof(*di));
if (!di)
return NULL;
#ifdef __cplusplus
if (FAILED(IDirectInput8_CreateDevice(g_dinput_ctx, GUID_SysKeyboard, &di->keyboard, NULL)))
{
RARCH_ERR("Failed to create keyboard device.\n");
di->keyboard = NULL;
}
if (FAILED(IDirectInput8_CreateDevice(g_dinput_ctx, GUID_SysMouse, &di->mouse, NULL)))
{
RARCH_ERR("Failed to create mouse device.\n");
di->mouse = NULL;
}
#else
if (FAILED(IDirectInput8_CreateDevice(g_dinput_ctx, &GUID_SysKeyboard, &di->keyboard, NULL)))
{
RARCH_ERR("Failed to create keyboard device.\n");
di->keyboard = NULL;
}
if (FAILED(IDirectInput8_CreateDevice(g_dinput_ctx, &GUID_SysMouse, &di->mouse, NULL)))
{
RARCH_ERR("Failed to create mouse device.\n");
di->mouse = NULL;
}
#endif
if (di->keyboard)
{
IDirectInputDevice8_SetDataFormat(di->keyboard, &c_dfDIKeyboard);
IDirectInputDevice8_SetCooperativeLevel(di->keyboard,
(HWND)video_driver_window_get(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->keyboard);
}
if (di->mouse)
{
DIDATAFORMAT c_dfDIMouse2_custom = c_dfDIMouse2;
c_dfDIMouse2_custom.dwFlags = DIDF_ABSAXIS;
IDirectInputDevice8_SetDataFormat(di->mouse, &c_dfDIMouse2_custom);
IDirectInputDevice8_SetCooperativeLevel(di->mouse, (HWND)video_driver_window_get(),
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
IDirectInputDevice8_Acquire(di->mouse);
}
input_keymaps_init_keyboard_lut(rarch_key_map_dinput);
di->joypad = input_joypad_init_driver(settings->input.joypad_driver, di);
return di;
}
static BOOL CALLBACK enumeration_callback(const DIDEVICEINSTANCEA *lpddi, IDirectInputDevice8A *lpdid,
DWORD dwFlags, DWORD dwRemaining, LPVOID pvRef)
{
HRESULT hr;
DIPROPDWORD dp;
DIPROPRANGE dpr;
DIPROPSTRING dps;
WCHAR usernameW[MAX_PATH];
DWORD username_size = MAX_PATH;
struct enum_data *data = pvRef;
DWORD cnt;
DIDEVICEOBJECTDATA buffer[5];
IDirectInputDevice8A *lpdid2;
if (!data) return DIENUM_CONTINUE;
data->ndevices++;
/* Convert username to WCHAR */
if (data->username != NULL)
{
username_size = MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, 0);
MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, username_size);
}
else
GetUserNameW(usernameW, &username_size);
/* collect the mouse and keyboard */
if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysKeyboard))
{
IDirectInputDevice_AddRef(lpdid);
data->keyboard = lpdid;
ok (dwFlags & DIEDBS_MAPPEDPRI1, "Keyboard should be mapped as pri1 dwFlags=%08x\n", dwFlags);
}
if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysMouse))
{
IDirectInputDevice_AddRef(lpdid);
data->mouse = lpdid;
ok (dwFlags & DIEDBS_MAPPEDPRI1, "Mouse should be mapped as pri1 dwFlags=%08x\n", dwFlags);
}
/* Creating second device object to check if it has the same username */
hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance, &lpdid2, NULL);
ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr);
/* Building and setting an action map */
/* It should not use any pre-stored mappings so we use DIDBAM_HWDEFAULTS */
hr = IDirectInputDevice8_BuildActionMap(lpdid, data->lpdiaf, NULL, DIDBAM_HWDEFAULTS);
ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr);
/* Device has no data format and thus can't be acquired */
hr = IDirectInputDevice8_Acquire(lpdid);
ok (hr == DIERR_INVALIDPARAM, "Device was acquired before SetActionMap hr=%08x\n", hr);
hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, data->username, 0);
ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr);
/* Some joysticks may have no suitable actions and thus should not be tested */
if (hr == DI_NOEFFECT) return DIENUM_CONTINUE;
/* Test username after SetActionMap */
dps.diph.dwSize = sizeof(dps);
dps.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dps.diph.dwObj = 0;
dps.diph.dwHow = DIPH_DEVICE;
dps.wsz[0] = '\0';
hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_USERNAME, &dps.diph);
ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
ok (!lstrcmpW(usernameW, dps.wsz), "Username not set correctly expected=%s, got=%s\n", wine_dbgstr_w(usernameW), wine_dbgstr_w(dps.wsz));
dps.wsz[0] = '\0';
hr = IDirectInputDevice_GetProperty(lpdid2, DIPROP_USERNAME, &dps.diph);
ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
ok (!lstrcmpW(usernameW, dps.wsz), "Username not set correctly expected=%s, got=%s\n", wine_dbgstr_w(usernameW), wine_dbgstr_w(dps.wsz));
/* Test buffer size */
memset(&dp, 0, sizeof(dp));
dp.diph.dwSize = sizeof(dp);
dp.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dp.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_BUFFERSIZE, &dp.diph);
ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
ok (dp.dwData == data->lpdiaf->dwBufferSize, "SetActionMap must set the buffer, buffersize=%d\n", dp.dwData);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0);
ok(hr == DIERR_NOTACQUIRED, "GetDeviceData() failed hr=%08x\n", hr);
/* Test axis range */
memset(&dpr, 0, sizeof(dpr));
dpr.diph.dwSize = sizeof(dpr);
dpr.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dpr.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_RANGE, &dpr.diph);
/* Only test if device supports the range property */
if (SUCCEEDED(hr))
{
ok (dpr.lMin == data->lpdiaf->lAxisMin, "SetActionMap must set the min axis range expected=%d got=%d\n", data->lpdiaf->lAxisMin, dpr.lMin);
ok (dpr.lMax == data->lpdiaf->lAxisMax, "SetActionMap must set the max axis range expected=%d got=%d\n", data->lpdiaf->lAxisMax, dpr.lMax);
}
/* SetActionMap has set the data format so now it should work */
hr = IDirectInputDevice8_Acquire(lpdid);
ok (SUCCEEDED(hr), "Acquire failed hr=%08x\n", hr);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0);
ok(hr == DI_OK, "GetDeviceData() failed hr=%08x\n", hr);
/* SetActionMap should not work on an acquired device */
hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, NULL, 0);
ok (hr == DIERR_ACQUIRED, "SetActionMap succeeded with an acquired device hr=%08x\n", hr);
return DIENUM_CONTINUE;
}
void I_GetJoystickState(joystate_t *state)
{
static BOOL oldButtons[IJOY_MAXBUTTONS]; // Thats a lot of buttons.
DWORD tries, i;
DIJOYSTATE dijoy;
BOOL acquired;
HRESULT hr;
memset(state, 0, sizeof(*state));
// Initialization has not been done.
if(!didJoy || !usejoystick || !initIOk)
return;
// Some joysticks need to be polled.
IDirectInputDevice8_Poll(didJoy);
tries = 1;
acquired = FALSE;
while(!acquired && tries > 0)
{
hr = IDirectInputDevice8_GetDeviceState(didJoy, sizeof(dijoy), &dijoy);
if(SUCCEEDED(hr))
{
acquired = TRUE;
}
else if(tries > 0)
{
// Try to reacquire.
IDirectInputDevice8_Acquire(didJoy);
tries--;
}
}
if(!acquired)
return; // The operation is a failure.
state->numAxes = 8;
state->axis[0] = (int) dijoy.lX;
state->axis[1] = (int) dijoy.lY;
state->axis[2] = (int) dijoy.lZ;
state->axis[3] = (int) dijoy.lRx;
state->axis[4] = (int) dijoy.lRy;
state->axis[5] = (int) dijoy.lRz;
state->axis[6] = (int) dijoy.rglSlider[0];
state->axis[7] = (int) dijoy.rglSlider[1];
state->numButtons = 32;
for(i = 0; i < IJOY_MAXBUTTONS; ++i)
{
BOOL isDown = (dijoy.rgbButtons[i] & 0x80? TRUE : FALSE);
state->buttonDowns[i] =
state->buttonUps[i] = 0;
if(isDown && !oldButtons[i])
state->buttonDowns[i] = 1;
else if(!isDown && oldButtons[i])
state->buttonUps[i] = 1;
oldButtons[i] = isDown;
}
state->numHats = 4;
for(i = 0; i < IJOY_MAXHATS; ++i)
{
DWORD pov = dijoy.rgdwPOV[i];
if((pov & 0xffff) == 0xffff)
state->hatAngle[i] = IJOY_POV_CENTER;
else
state->hatAngle[i] = pov / 100.0f;
}
}