/* ______ ___ ___ * /\ _ \ /\_ \ /\_ \ * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___ * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\ * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \ * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/ * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/ * /\____/ * \_/__/ * * Windows DirectInput joystick driver. * * By Eric Botcazou. * * Omar Cornut fixed it to handle a weird peculiarity of * the DirectInput joystick API. * * Modified extensively for the new joystick API by Peter Wang. * * See readme.txt for copyright information. */ /* * Driver operation: * * 1. When the driver is initialised all the joysticks on the system * are enumerated. For each joystick, an ALLEGRO_JOYSTICK_DIRECTX structure * is created. A win32 Event is also created for each joystick and DirectInput * is told to set that event whenever the joystick state changes. For some * devices this is not possible -- they must be polled. In that case, a * Waitable Timer object is used instead of a win32 Event. Once all the * joysticks are set up, a dedicated background thread is started. * * 2. When al_get_joystick() is called the address of one of the * ALLEGRO_JOYSTICK_DIRECTX structures is returned to the user. * * 3. The background thread waits upon the win32 Events/Waitable Timer * objects. When one of them is triggered, the thread wakes up and * reads in buffered joystick events. An internal ALLEGRO_JOYSTICK_STATE * structure (part of ALLEGRO_JOYSTICK_DIRECTX) is updated accordingly. * Also, any Allegro events are generated if necessary. * * 4. When the user calls al_get_joystick_state() the contents of the * internal ALLEGRO_JOYSTICK_STATE structure are copied to a user * ALLEGRO_JOYSTICK_STATE structure. * * 5. Every second or so, all the joysticks on the system are enumerated again. * We compare the GUIDs of the enumerated joysticks with the existing * ALLEGRO_JOYSTICK structures to tell if any new joysticks have been connected, * or old ones disconnected. */ #define ALLEGRO_NO_COMPATIBILITY #define DIRECTINPUT_VERSION 0x0800 /* For waitable timers */ #define _WIN32_WINNT 0x0501 #include "allegro5/allegro.h" #include "allegro5/internal/aintern.h" #include "allegro5/platform/aintwin.h" #include "allegro5/internal/aintern_events.h" #include "allegro5/internal/aintern_joystick.h" #include "allegro5/internal/aintern_bitmap.h" #ifndef ALLEGRO_WINDOWS #error something is wrong with the makefile #endif #ifdef ALLEGRO_MINGW32 #undef MAKEFOURCC #endif #include #include #include #include /* We need XInput detection if we actually compile the XInput driver in. */ #ifdef ALLEGRO_CFG_XINPUT /* Windows XP is required. If you still use older Windows, XInput won't work anyway. */ #undef WIN32_LEAN_AND_MEAN #include #include #define ALLEGRO_DINPUT_FILTER_XINPUT #endif ALLEGRO_DEBUG_CHANNEL("dinput") #include "allegro5/joystick.h" #include "allegro5/internal/aintern_joystick.h" #include "allegro5/internal/aintern_wjoydxnu.h" #include "allegro5/internal/aintern_wunicode.h" /* forward declarations */ static bool joydx_init_joystick(void); static void joydx_exit_joystick(void); static bool joydx_reconfigure_joysticks(void); static int joydx_get_num_joysticks(void); static ALLEGRO_JOYSTICK *joydx_get_joystick(int num); static void joydx_release_joystick(ALLEGRO_JOYSTICK *joy); static void joydx_get_joystick_state(ALLEGRO_JOYSTICK *joy, ALLEGRO_JOYSTICK_STATE *ret_state); static const char *joydx_get_name(ALLEGRO_JOYSTICK *joy); static bool joydx_get_active(ALLEGRO_JOYSTICK *joy); static void joydx_inactivate_joy(ALLEGRO_JOYSTICK_DIRECTX *joy); static unsigned __stdcall joydx_thread_proc(LPVOID unused); static void update_joystick(ALLEGRO_JOYSTICK_DIRECTX *joy); static void handle_axis_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT output, DWORD value); static void handle_pov_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT *outputs, DWORD _value); static void handle_button_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT output, DWORD value); /* the driver vtable */ ALLEGRO_JOYSTICK_DRIVER _al_joydrv_directx = { AL_JOY_TYPE_DIRECTX, "", "", "DirectInput joystick", joydx_init_joystick, joydx_exit_joystick, joydx_reconfigure_joysticks, joydx_get_num_joysticks, joydx_get_joystick, joydx_release_joystick, joydx_get_joystick_state, joydx_get_name, joydx_get_active }; /* GUID values are borrowed from Wine */ #define DEFINE_PRIVATE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ static const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } DEFINE_PRIVATE_GUID(__al_GUID_XAxis, 0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_YAxis, 0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_ZAxis, 0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_RxAxis,0xA36D02F4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_RyAxis,0xA36D02F5,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_RzAxis,0xA36D02E3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_Slider,0xA36D02E4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_Button,0xA36D02F0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_GUID_POV, 0xA36D02F2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00); DEFINE_PRIVATE_GUID(__al_IID_IDirectInput8W, 0xBF798031,0x483A,0x4DA2,0xAA,0x99,0x5D,0x64,0xED,0x36,0x97,0x00); DEFINE_PRIVATE_GUID(__al_IID_IDirectInput8A, 0xBF798030,0x483A,0x4DA2,0xAA,0x99,0x5D,0x64,0xED,0x36,0x97,0x00); DEFINE_PRIVATE_GUID(__al_IID_IDirectInputDevice8A,0x54D41080,0xDC15,0x4833,0xA4,0x1B,0x74,0x8F,0x73,0xA3,0x81,0x79); DEFINE_PRIVATE_GUID(__al_IID_IDirectInputDevice8W,0x54D41081,0xDC15,0x4833,0xA4,0x1B,0x74,0x8F,0x73,0xA3,0x81,0x79); #ifdef UNICODE #define __al_IID_IDirectInput8 __al_IID_IDirectInput8W #define __al_IID_IDirectInputDevice8 __al_IID_IDirectInputDevice8W #else #define __al_IID_IDirectInput __al_IID_IDirectInput8A #define __al_IID_IDirectInputDevice __al_IID_IDirectInputDevice8A #endif /* definition of DirectInput Joystick was borrowed from Wine implementation */ #define DIDFT_AXIS 0x00000003 #define DIDFT_ANYINSTANCE 0x00FFFF00 #define DIDFT_OPTIONAL 0x80000000 static const DIOBJECTDATAFORMAT __al_dfDIJoystick[] = { { &__al_GUID_XAxis, DIJOFS_X, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_YAxis, DIJOFS_Y, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_ZAxis, DIJOFS_Z, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_RxAxis, DIJOFS_RX, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_RyAxis, DIJOFS_RY, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_RzAxis, DIJOFS_RZ, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_POV, DIJOFS_POV(0), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_POV, DIJOFS_POV(1), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_POV, DIJOFS_POV(2), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0}, { &__al_GUID_POV, DIJOFS_POV(3), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(0), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(1), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(2), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(3), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(4), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(5), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(6), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(7), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(8), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(9), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(10), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(11), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(12), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(13), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(14), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(15), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(16), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(17), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(18), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(19), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(20), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(21), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(22), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(23), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(24), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(25), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(26), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(27), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(28), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(29), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(30), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, { NULL, DIJOFS_BUTTON(31), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0}, }; static const DIDATAFORMAT __al_c_dfDIJoystick = { sizeof(DIDATAFORMAT), sizeof(DIOBJECTDATAFORMAT), DIDF_ABSAXIS, sizeof(DIJOYSTATE), sizeof(__al_dfDIJoystick) / sizeof(*__al_dfDIJoystick), (LPDIOBJECTDATAFORMAT)__al_dfDIJoystick }; /* end of Wine code */ /* DirectInput creation prototype */ typedef HRESULT (WINAPI *DIRECTINPUT8CREATEPROC)(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID * ppvOut, LPUNKNOWN punkOuter); /* DirectInput module name */ static const char* _al_dinput_module_name = "dinput8.dll"; /* DirecInput module handle */ static HMODULE _al_dinput_module = NULL; /* DirectInput creation procedure */ static DIRECTINPUT8CREATEPROC _al_dinput_create = (DIRECTINPUT8CREATEPROC)NULL; /* a handle to the DirectInput interface */ static LPDIRECTINPUT joystick_dinput = NULL; /* last display which acquired the devices */ static ALLEGRO_DISPLAY_WIN *win_disp; /* number of joysticks visible to user */ static int joydx_num_joysticks; /* the joystick structures */ static ALLEGRO_JOYSTICK_DIRECTX joydx_joystick[MAX_JOYSTICKS]; /* for the background thread */ static HANDLE joydx_thread = NULL; static CRITICAL_SECTION joydx_thread_cs; /* whether the DirectInput devices need to be enumerated again */ static bool need_device_enumeration = false; /* whether the user should call al_reconfigure_joysticks */ static bool config_needs_merging = false; /* An array of objects that are to wake the background thread when * something interesting happens. The first handle is for thread * termination. The rest point to joydx_joystick[i].waker_event values, * for each active joystick. joydx_joystick[i].waker_event is NOT * necessarily at JOYSTICK_WAKER(i). */ static HANDLE joydx_thread_wakers[1+MAX_JOYSTICKS]; #define STOP_EVENT (joydx_thread_wakers[0]) #define JOYSTICK_WAKER(n) (joydx_thread_wakers[1+(n)]) /* names for things in case DirectInput doesn't provide them */ static char default_name_x[] = "X"; static char default_name_y[] = "Y"; static char default_name_z[] = "Z"; static char default_name_rx[] = "RX"; static char default_name_ry[] = "RY"; static char default_name_rz[] = "RZ"; static char default_name_stick[] = "stick"; static char default_name_slider[] = "slider"; static char default_name_hat[] = "hat"; static const char *default_name_button[MAX_BUTTONS] = { "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "B10", "B11", "B12", "B13", "B14", "B15", "B16", "B17", "B18", "B19", "B20", "B21", "B22", "B23", "B24", "B25", "B26", "B27", "B28", "B29", "B30", "B31", "B32" }; #define JOY_POVFORWARD_WRAP 36000 /* Returns a pointer to a static buffer, for debugging. */ static char *guid_to_string(const GUID * guid) { static char buf[200]; sprintf(buf, "%lx-%x-%x-%x%x%x%x%x%x%x%x", guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] ); return buf; } /* Returns a pointer to a static buffer, for debugging. */ static char *joydx_guid_string(ALLEGRO_JOYSTICK_DIRECTX *joy) { return guid_to_string((const GUID *)&joy->guid); } /* dinput_err_str: * Returns a DirectInput error string. */ #ifdef DEBUGMODE static char* dinput_err_str(long err) { static char err_str[64]; switch (err) { case DIERR_ACQUIRED: _al_sane_strncpy(err_str, "the device is acquired", sizeof(err_str)); break; case DIERR_NOTACQUIRED: _al_sane_strncpy(err_str, "the device is not acquired", sizeof(err_str)); break; case DIERR_INPUTLOST: _al_sane_strncpy(err_str, "access to the device was not granted", sizeof(err_str)); break; case DIERR_INVALIDPARAM: _al_sane_strncpy(err_str, "the device does not have a selected data format", sizeof(err_str)); break; case DIERR_OTHERAPPHASPRIO: _al_sane_strncpy(err_str, "can't acquire the device in background", sizeof(err_str)); break; default: _al_sane_strncpy(err_str, "unknown error", sizeof(err_str)); } return err_str; } #else #define dinput_err_str(hr) "\0" #endif /* _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)); } } } /* _al_win_joystick_dinput_trigger_enumeration: [window thread] * Let joydx_thread_proc() know to reenumerate joysticks. */ void _al_win_joystick_dinput_trigger_enumeration(void) { if (!joystick_dinput) return; EnterCriticalSection(&joydx_thread_cs); need_device_enumeration = true; LeaveCriticalSection(&joydx_thread_cs); } /* _al_win_joystick_dinput_unacquire: [window thread] * Unacquires the joystick devices. */ void _al_win_joystick_dinput_unacquire(void *unused) { int i; (void)unused; if (joystick_dinput && win_disp) { for (i=0; i < MAX_JOYSTICKS; i++) { if (joydx_joystick[i].device) { ALLEGRO_DEBUG("Unacquiring joystick device at slot %d\n", i); IDirectInputDevice8_Unacquire(joydx_joystick[i].device); } } } } /* _al_win_joystick_dinput_grab: [window thread] * Grabs the joystick devices. */ void _al_win_joystick_dinput_grab(void *param) { int i; if (!joystick_dinput) return; /* Release the input from the previous window just in case, otherwise set cooperative level will fail. */ if (win_disp) { _al_win_wnd_call_proc(win_disp->window, _al_win_joystick_dinput_unacquire, NULL); } win_disp = (ALLEGRO_DISPLAY_WIN *)param; /* set cooperative level */ for (i = 0; i < MAX_JOYSTICKS; i++) { HRESULT hr; if (!joydx_joystick[i].device) continue; hr = IDirectInputDevice8_SetCooperativeLevel(joydx_joystick[i].device, win_disp->window, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE); if (FAILED(hr)) { ALLEGRO_ERROR("IDirectInputDevice8_SetCooperativeLevel failed.\n"); return; } } joystick_dinput_acquire(); } static ALLEGRO_JOYSTICK_DIRECTX *joydx_by_guid(const GUID guid, const GUID product_guid) { unsigned i; for (i = 0; i < MAX_JOYSTICKS; i++) { if ( GUID_EQUAL(joydx_joystick[i].guid, guid) && GUID_EQUAL(joydx_joystick[i].product_guid, product_guid) /* && joydx_joystick[i].config_state == STATE_ALIVE */ ) return &joydx_joystick[i]; } return NULL; } static ALLEGRO_JOYSTICK_DIRECTX *joydx_allocate_structure(int *num) { int i; for (i = 0; i < MAX_JOYSTICKS; i++) { if (joydx_joystick[i].config_state == STATE_UNUSED) { *num = i; return &joydx_joystick[i]; } } *num = -1; return NULL; } /* object_enum_callback: [primary thread] * Helper function to find out what objects we have on the device. */ static BOOL CALLBACK object_enum_callback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef) { #define GUIDTYPE_EQ(x) GUID_EQUAL(lpddoi->guidType, x) CAPS_AND_NAMES *can = (CAPS_AND_NAMES *)pvRef; if (GUIDTYPE_EQ(__al_GUID_XAxis)) { can->have_x = true; _tcsncpy(can->name_x, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_YAxis)) { can->have_y = true; _tcsncpy(can->name_y, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_ZAxis)) { can->have_z = true; _tcsncpy(can->name_z, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_RxAxis)) { can->have_rx = true; _tcsncpy(can->name_rx, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_RyAxis)) { can->have_ry = true; _tcsncpy(can->name_ry, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_RzAxis)) { can->have_rz = true; _tcsncpy(can->name_rz, lpddoi->tszName, NAME_LEN); } else if (GUIDTYPE_EQ(__al_GUID_Slider)) { if (can->num_sliders < MAX_SLIDERS) { _tcsncpy(can->name_slider[can->num_sliders], lpddoi->tszName, NAME_LEN); can->num_sliders++; } } else if (GUIDTYPE_EQ(__al_GUID_POV)) { if (can->num_povs < MAX_POVS) { _tcsncpy(can->name_pov[can->num_povs], lpddoi->tszName, NAME_LEN); can->num_povs++; } } else if (GUIDTYPE_EQ(__al_GUID_Button)) { if (can->num_buttons < MAX_BUTTONS) { _tcsncpy(can->name_button[can->num_buttons], lpddoi->tszName, NAME_LEN); can->num_buttons++; } } return DIENUM_CONTINUE; #undef GUIDTYPE_EQ } /* fill_standard_gamepad: [primary thread] */ static bool fill_standard_gamepad(ALLEGRO_JOYSTICK_DIRECTX *joy, const CAPS_AND_NAMES *can) { DIPROPDWORD property_vidpid = { /* the header */ { sizeof(DIPROPDWORD), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, /* the data */ 0, // dwData }; DIPROPSTRING property_productname = { /* the header */ { sizeof(DIPROPSTRING), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, /* the data */ 0, // wsz }; if (FAILED(IDirectInputDevice8_GetProperty(joy->device, DIPROP_VIDPID, &property_vidpid.diph))) return false; int vendor = LOWORD(property_vidpid.dwData); int product = HIWORD(property_vidpid.dwData); if (FAILED(IDirectInputDevice8_GetProperty(joy->device, DIPROP_PRODUCTNAME, &property_productname.diph))) return false; const char *product_string = _twin_tchar_to_utf8(property_productname.wsz); ALLEGRO_JOYSTICK_GUID guid; if (vendor && product) guid = _al_new_joystick_guid(0x03, vendor, product, 0, NULL, product_string, 0, 0); else guid = _al_new_joystick_guid(0x05, vendor, product, 0, NULL, product_string, 0, 0); joy->parent.info.guid = guid; const _AL_JOYSTICK_MAPPING *mapping = _al_get_gamepad_mapping("Windows", guid); if (!mapping) return false; int axis = 0; int num_axes_mapped = 0; int num_hats_mapped = 0; int num_buttons_mapped = 0; _AL_JOYSTICK_OUTPUT *output; int i = 0; if (can->have_x) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->x_mapping = *output; num_axes_mapped++; } } if (can->have_y) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->y_mapping = *output; num_axes_mapped++; } } if (can->have_z) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->z_mapping = *output; num_axes_mapped++; } } if (can->have_rx) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->rx_mapping = *output; num_axes_mapped++; } } if (can->have_ry) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->ry_mapping = *output; num_axes_mapped++; } } if (can->have_rz) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->rz_mapping = *output; num_axes_mapped++; } } for (i = 0; i < can->num_sliders; i++) { output = _al_get_joystick_output(&mapping->axis_map, axis++); if (output) { joy->slider_mapping[i] = *output; num_axes_mapped++; } } for (i = 0; i < 2 * can->num_povs; i++) { output = _al_get_joystick_output(&mapping->hat_map, i); if (output) { joy->pov_mapping[i] = *output; num_hats_mapped++; } } for (i = 0; i < can->num_buttons; i++) { output = _al_get_joystick_output(&mapping->button_map, i); if (output) { joy->button_mapping[i] = *output; num_buttons_mapped++; } } if (num_axes_mapped != (int)_al_vector_size(&mapping->axis_map)) { return false; } if (num_hats_mapped != (int)_al_vector_size(&mapping->hat_map)) { return false; } if (num_buttons_mapped != (int)_al_vector_size(&mapping->button_map)) { return false; } _al_fill_gamepad_info(&joy->parent.info); memcpy(joy->name, mapping->name, sizeof(mapping->name)); return true; } /* fill_joystick_info_using_caps_and_names: [primary thread] * Helper to fill in the contents of the joystick structure using the * information painstakingly stored into the caps_and_names substructure. */ static void fill_joystick_info_using_caps_and_names(ALLEGRO_JOYSTICK_DIRECTX *joy, const CAPS_AND_NAMES *can) { _AL_JOYSTICK_INFO *info = &joy->parent.info; int i; #define N_STICK (info->num_sticks) #define N_AXIS (info->stick[N_STICK].num_axes) #define ADD_STRING(A, dfl) ((A) ? _twin_tchar_to_utf8(A) : _al_strdup(dfl)) /* the X, Y, Z axes make up the first stick */ if (can->have_x || can->have_y || can->have_z) { if (can->have_x) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_x, default_name_x); joy->x_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } if (can->have_y) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_y, default_name_y); joy->y_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } if (can->have_z) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_z, default_name_z); joy->z_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } info->stick[N_STICK].name = ADD_STRING(NULL, default_name_stick); N_STICK++; } /* the Rx, Ry, Rz axes make up the next stick */ if (can->have_rx || can->have_ry || can->have_rz) { if (can->have_rx) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_rx, default_name_rx); joy->rx_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } if (can->have_ry) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_ry, default_name_ry); joy->ry_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } if (can->have_rz) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].axis[N_AXIS].name = ADD_STRING(can->name_rz, default_name_rz); joy->rz_mapping = _al_new_joystick_stick_output(N_STICK, N_AXIS); N_AXIS++; } info->stick[N_STICK].name = _al_strdup(default_name_stick); N_STICK++; } /* sliders are assigned to one stick each */ for (i = 0; i < can->num_sliders; i++) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL | ALLEGRO_JOYFLAG_ANALOGUE; info->stick[N_STICK].num_axes = 1; info->stick[N_STICK].axis[0].name = _al_strdup("axis"); info->stick[N_STICK].name = ADD_STRING(can->name_slider[i], default_name_slider); joy->slider_mapping[i] = _al_new_joystick_stick_output(N_STICK, 0); N_STICK++; } /* POV devices are assigned to one stick each */ for (i = 0; i < 2 * can->num_povs; i += 2) { info->stick[N_STICK].flags = ALLEGRO_JOYFLAG_DIGITAL; info->stick[N_STICK].num_axes = 2; info->stick[N_STICK].axis[0].name = _al_strdup("left/right"); info->stick[N_STICK].axis[1].name = _al_strdup("up/down"); info->stick[N_STICK].name = ADD_STRING(can->name_pov[i], default_name_hat); joy->pov_mapping[i] = _al_new_joystick_stick_output(N_STICK, 0); joy->pov_mapping[i + 1] = _al_new_joystick_stick_output(N_STICK, 1); N_STICK++; } /* buttons */ for (i = 0; i < can->num_buttons; i++) { info->button[i].name = ADD_STRING(can->name_button[i], default_name_button[i]); joy->button_mapping[i] = _al_new_joystick_button_output(i); } info->num_buttons = can->num_buttons; /* correct buggy MP-8866 Dual USB Joypad info received from DirectInput */ if (strstr(joy->name, "MP-8866")) { /* axes were mapped weird; remap as expected */ /* really R-stick X axis */ joy->z_mapping = _al_new_joystick_stick_output(1, 0); /* really R-stick Y axis */ joy->rz_mapping = _al_new_joystick_stick_output(1, 1); info->stick[0].num_axes = 2; info->stick[1].num_axes = 2; /* reuse the axis names from the first stick */ al_free(info->stick[1].axis[0].name); al_free(info->stick[1].axis[1].name); al_free(info->stick[2].axis[0].name); al_free(info->stick[2].axis[1].name); info->stick[1].axis[0].name = _al_strdup(info->stick[0].axis[0].name); info->stick[1].axis[1].name = _al_strdup(info->stick[0].axis[1].name); info->stick[2].axis[0].name = _al_strdup(info->stick[0].axis[0].name); info->stick[2].axis[1].name = _al_strdup(info->stick[0].axis[1].name); /* first four button names contained junk; replace with valid strings */ info->button[0].name = _al_strdup("Triangle"); info->button[1].name = _al_strdup("Circle"); info->button[2].name = _al_strdup("X"); info->button[3].name = _al_strdup("Square"); /* while we're at it, give these controls more sensible names, too */ info->stick[0].name = _al_strdup("[L-stick] or D-pad"); info->stick[1].name = _al_strdup("[R-stick]"); info->stick[2].name = _al_strdup("[D-pad]"); } #undef N_AXIS #undef N_STICK #undef ADD_STRING } #ifdef ALLEGRO_DINPUT_FILTER_XINPUT /* A better Xinput detection method inspired by from SDL. * The method proposed by Microsoft on their web site is problematic because it * requires non standard compiler extensions and hard to get headers. * This method only needs Windows XP and user32.dll. */ static bool dinput_is_device_xinput(const GUID *guid) { PRAWINPUTDEVICELIST device_list = NULL; UINT amount = 0; UINT i; bool result = false; bool found = false; /* Go through RAWINPUT (WinXP and later) to find HID devices. */ if ((GetRawInputDeviceList(NULL, &amount, sizeof (RAWINPUTDEVICELIST)) != 0)) { ALLEGRO_ERROR("Could not get amount of raw input devices.\n"); return false; /* drat... */ } if (amount < 1) { ALLEGRO_ERROR("Could not get any of raw input devices.\n"); return false; /* drat again... */ } device_list = (PRAWINPUTDEVICELIST) al_malloc(sizeof(RAWINPUTDEVICELIST) * amount); if (!device_list) { ALLEGRO_ERROR("Could allocate memory for raw input devices.\n"); return false; /* No luck. */ } if (GetRawInputDeviceList(device_list, &amount, sizeof(RAWINPUTDEVICELIST)) == ((UINT)-1)) { ALLEGRO_ERROR("Could not retrieve %d raw input devices.\n", amount); al_free((void *)device_list); return false; } for (i = 0; i < amount; i++) { PRAWINPUTDEVICELIST device = device_list + i; RID_DEVICE_INFO rdi; char device_name[128]; UINT rdi_size = sizeof (rdi); UINT name_size = 127; rdi.cbSize = sizeof (rdi); /* Get device info. */ if (GetRawInputDeviceInfoA(device->hDevice, RIDI_DEVICEINFO, &rdi, &rdi_size) == ((UINT)-1)) { ALLEGRO_ERROR("Could not get raw device info for list index %d.\n", i); continue; } /* See if vendor and product id match. */ if (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) != ((LONG)guid->Data1)) continue; found = true; /* Get device name */ memset(device_name, 0, 128); if(GetRawInputDeviceInfoA(device->hDevice, RIDI_DEVICENAME, device_name, &name_size) == ((UINT)-1)) { ALLEGRO_ERROR("Could not get raw device name for list index %d.\n", i); continue; } /* See if there is IG_ in the name, if it is , it's an XInput device. */ ALLEGRO_DEBUG("Checking for XInput : %s\n", device_name); if (strstr(device_name, "IG_") != NULL) { ALLEGRO_DEBUG("Device %s is an XInput device.\n", device_name); result = true; break; } } if (!found) { ALLEGRO_ERROR("Could not find device %s in the raw device list.\n", guid_to_string(guid)); result = true; /* Ignore "mystery" devices. Testing shows that on MinGW these are never valid DirectInput devices. Real ones should show up in the raw device list. */ } al_free((void *)device_list); return result; } #endif /* joystick_enum_callback: [primary thread] * Helper function to find out how many joysticks we have and set them up. * At the end joydx_num_joysticks and joydx_joystick[] will be initialised. */ static BOOL CALLBACK joystick_enum_callback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef) { DIPROPRANGE property_range = { /* the header */ { sizeof(DIPROPRANGE), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, /* the data */ -32767, // lMin +32767 // lMax }; DIPROPDWORD property_deadzone = { /* the header */ { sizeof(DIPROPDWORD), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, /* the data */ 0, // dwData }; DIPROPDWORD property_buffersize = { /* the header */ { sizeof(DIPROPDWORD), // diph.dwSize sizeof(DIPROPHEADER), // diph.dwHeaderSize 0, // diph.dwObj DIPH_DEVICE, // diph.dwHow }, /* the data */ DEVICE_BUFFER_SIZE // number of data items }; LPDIRECTINPUTDEVICE _dinput_device1; LPDIRECTINPUTDEVICE2 dinput_device = NULL; HRESULT hr; LPVOID temp; CAPS_AND_NAMES caps_and_names; ALLEGRO_JOYSTICK_DIRECTX *joy = NULL; int num; (void)pvRef; /* check if the joystick already existed before * Aslo have to check the product GUID because devices like the Logitech * F710 have a backside switch that will change the product GUID, * but not the instance guid. */ joy = joydx_by_guid(lpddi->guidInstance, lpddi->guidProduct); if (joy) { ALLEGRO_DEBUG("Device %s still exists\n", joydx_guid_string(joy)); joy->marked = true; return DIENUM_CONTINUE; } /* If we are compiling the XInput driver, ignore XInput devices, those can go though the XInput driver, unless if the DirectInput driver was set explicitly in the configuration. */ #ifdef ALLEGRO_DINPUT_FILTER_XINPUT if (dinput_is_device_xinput(&lpddi->guidProduct)) { ALLEGRO_DEBUG("Filtered out XInput device %s\n", guid_to_string(&lpddi->guidInstance)); goto Error; } #endif /* create the DirectInput joystick device */ hr = IDirectInput8_CreateDevice(joystick_dinput, lpddi->guidInstance, &_dinput_device1, NULL); if (FAILED(hr)) goto Error; /* query the DirectInputDevice2 interface needed for the poll() method */ hr = IDirectInputDevice8_QueryInterface(_dinput_device1, __al_IID_IDirectInputDevice8, &temp); IDirectInputDevice8_Release(_dinput_device1); if (FAILED(hr)) goto Error; dinput_device = (LPDIRECTINPUTDEVICE2)temp; /* enumerate objects available on the device */ memset(&caps_and_names, 0, sizeof(caps_and_names)); hr = IDirectInputDevice8_EnumObjects(dinput_device, object_enum_callback, &caps_and_names, DIDFT_PSHBUTTON | DIDFT_AXIS | DIDFT_POV); if (FAILED(hr)) goto Error; /* set data format */ hr = IDirectInputDevice8_SetDataFormat(dinput_device, &__al_c_dfDIJoystick); if (FAILED(hr)) goto Error; /* set the range of axes */ hr = IDirectInputDevice8_SetProperty(dinput_device, DIPROP_RANGE, &property_range.diph); if (FAILED(hr)) goto Error; /* set the dead zone of axes */ hr = IDirectInputDevice8_SetProperty(dinput_device, DIPROP_DEADZONE, &property_deadzone.diph); if (FAILED(hr)) goto Error; /* set the buffer size */ hr = IDirectInputDevice8_SetProperty(dinput_device, DIPROP_BUFFERSIZE, &property_buffersize.diph); if (FAILED(hr)) goto Error; /* set up the joystick structure */ joy = joydx_allocate_structure(&num); if (!joy) { ALLEGRO_ERROR("Joystick array full\n"); goto Error; } joy->config_state = STATE_BORN; joy->marked = true; joy->device = dinput_device; memcpy(&joy->guid, &lpddi->guidInstance, sizeof(GUID)); memcpy(&joy->product_guid, &lpddi->guidProduct, sizeof(GUID)); _twin_copy_tchar_to_utf8(joy->name, lpddi->tszInstanceName, sizeof(joy->name)); /* fill in the joystick structure */ if (!fill_standard_gamepad(joy, &caps_and_names)) fill_joystick_info_using_caps_and_names(joy, &caps_and_names); /* create a thread event for this joystick, unless it was already created */ joy->waker_event = CreateEvent(NULL, false, false, NULL); /* tell the joystick background thread to wake up when this joystick * device's state changes */ hr = IDirectInputDevice8_SetEventNotification(joy->device, joy->waker_event); if (FAILED(hr)) { ALLEGRO_ERROR("SetEventNotification failed for joystick %d: %s\n", num, dinput_err_str(hr)); goto Error; } if (hr == DI_POLLEDDEVICE) { /* This joystick device must be polled -- replace the Event with * a Waitable Timer object. * * Theoretically all polled devices could share a single * waitable timer object. But, really, how many such devices * are there going to be on a system? */ CloseHandle(joy->waker_event); joy->waker_event = CreateWaitableTimer(NULL, false, NULL); if (joy->waker_event == NULL) { ALLEGRO_ERROR("CreateWaitableTimer failed for polled device.\n"); goto Error; } { LARGE_INTEGER due_time = { 0 }; due_time.QuadPart = -1; /* Start ASAP... */ SetWaitableTimer(joy->waker_event, &due_time, 15, /* ... then periodic, every 15ms*/ NULL, NULL, false); } } ALLEGRO_INFO("Joystick %d initialized, GUID: %s\n", num, joydx_guid_string(joy)); config_needs_merging = true; return DIENUM_CONTINUE; Error: if (dinput_device) IDirectInputDevice8_Release(dinput_device); if (joy) { joy->device = NULL; joydx_inactivate_joy(joy); } return DIENUM_CONTINUE; } static void joydx_inactivate_joy(ALLEGRO_JOYSTICK_DIRECTX *joy) { if (joy->config_state == STATE_UNUSED) return; joy->config_state = STATE_UNUSED; joy->marked = false; if (joy->device) { IDirectInputDevice8_SetEventNotification(joy->device, NULL); IDirectInputDevice8_Release(joy->device); joy->device = NULL; } memset(&joy->guid, 0, sizeof(GUID)); if (joy->waker_event) { CloseHandle(joy->waker_event); joy->waker_event = NULL; } _al_destroy_joystick_info(&joy->parent.info); memset(&joy->parent.info, 0, sizeof(joy->parent.info)); /* XXX the joystick name really belongs in joy->parent.info too */ joy->name[0] = '\0'; memset(&joy->joystate, 0, sizeof(joy->joystate)); /* Don't forget to wipe the guids as well! */ memset(&joy->guid, 0, sizeof(joy->guid)); memset(&joy->product_guid, 0, sizeof(joy->product_guid)); } static void joydx_generate_configure_event(void) { ALLEGRO_EVENT event; event.joystick.type = ALLEGRO_EVENT_JOYSTICK_CONFIGURATION; event.joystick.timestamp = al_get_time(); _al_generate_joystick_event(&event); } static bool joydx_scan(bool configure) { HRESULT hr; unsigned i; /* Clear mark bits. */ for (i = 0; i < MAX_JOYSTICKS; i++) joydx_joystick[i].marked = false; /* enumerate the joysticks attached to the system */ hr = IDirectInput8_EnumDevices(joystick_dinput, DI8DEVCLASS_GAMECTRL, joystick_enum_callback, NULL, DIEDFL_ATTACHEDONLY); if (FAILED(hr)) { /* XXX will this ruin everything? */ IDirectInput8_Release(joystick_dinput); joystick_dinput = NULL; return false; } /* Schedule unmarked structures to be inactivated. */ for (i = 0; i < MAX_JOYSTICKS; i++) { ALLEGRO_JOYSTICK_DIRECTX *joy = &joydx_joystick[i]; if (joy->config_state == STATE_ALIVE && !joy->marked) { ALLEGRO_DEBUG("Joystick %s to be inactivated\n", joydx_guid_string(joy)); joy->config_state = STATE_DYING; config_needs_merging = true; } } if (config_needs_merging && configure) joydx_generate_configure_event(); return config_needs_merging; } 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(); } /* joydx_init_joystick: [primary thread] * * Initialises the DirectInput joystick devices. * * To avoid enumerating the the joysticks over and over, this does * the enumeration once and does almost all the setting up required * of the devices. joydx_get_joystick() is left with very little work * to do. */ static bool joydx_init_joystick(void) { HRESULT hr; ALLEGRO_SYSTEM *system; size_t i; MAKE_UNION(&joystick_dinput, LPDIRECTINPUT *); ALLEGRO_ASSERT(!joystick_dinput); ALLEGRO_ASSERT(!joydx_num_joysticks); ALLEGRO_ASSERT(!joydx_thread); ALLEGRO_ASSERT(!STOP_EVENT); /* load DirectInput module */ _al_dinput_module = _al_win_safe_load_library(_al_dinput_module_name); if (_al_dinput_module == NULL) { ALLEGRO_ERROR("Failed to open '%s' library\n", _al_dinput_module_name); joystick_dinput = NULL; return false; } /* import DirectInput create proc */ _al_dinput_create = (DIRECTINPUT8CREATEPROC)GetProcAddress(_al_dinput_module, "DirectInput8Create"); if (_al_dinput_create == NULL) { ALLEGRO_ERROR("DirectInput8Create not in %s\n", _al_dinput_module_name); FreeLibrary(_al_dinput_module); joystick_dinput = NULL; return false; } /* get the DirectInput interface */ hr = _al_dinput_create(GetModuleHandle(NULL), DIRECTINPUT_VERSION, __al_IID_IDirectInput8, u.v, NULL); if (FAILED(hr)) { ALLEGRO_ERROR("Failed to create DirectInput interface\n"); FreeLibrary(_al_dinput_module); joystick_dinput = NULL; return false; } /* initialise the lock for the background thread */ InitializeCriticalSection(&joydx_thread_cs); // This initializes present joystick state joydx_scan(false); // This copies present state to user state joydx_merge(); /* create the dedicated thread stopping event */ STOP_EVENT = CreateEvent(NULL, false, false, NULL); /* If one of our windows is the foreground window make it grab the input. */ system = al_get_system_driver(); for (i = 0; i < _al_vector_size(&system->displays); i++) { ALLEGRO_DISPLAY_WIN **pwin_disp = (ALLEGRO_DISPLAY_WIN **)_al_vector_ref(&system->displays, i); ALLEGRO_DISPLAY_WIN *win_disp = *pwin_disp; if (win_disp->window == GetForegroundWindow()) { _al_win_wnd_call_proc(win_disp->window, _al_win_joystick_dinput_grab, win_disp); } } /* start the background thread */ joydx_thread = (HANDLE) _beginthreadex(NULL, 0, joydx_thread_proc, NULL, 0, NULL); return true; } /* joydx_exit_joystick: [primary thread] * Shuts down the DirectInput joystick devices. */ static void joydx_exit_joystick(void) { int i; ALLEGRO_SYSTEM *system; size_t j; ALLEGRO_DEBUG("Entering joydx_exit_joystick\n"); ALLEGRO_ASSERT(joydx_thread); /* stop the thread */ SetEvent(STOP_EVENT); WaitForSingleObject(joydx_thread, INFINITE); CloseHandle(joydx_thread); joydx_thread = NULL; /* free thread resources */ CloseHandle(STOP_EVENT); STOP_EVENT = NULL; DeleteCriticalSection(&joydx_thread_cs); /* The toplevel display is assumed to have the input acquired. Release it. */ system = al_get_system_driver(); for (j = 0; j < _al_vector_size(&system->displays); j++) { ALLEGRO_DISPLAY_WIN **pwin_disp = (ALLEGRO_DISPLAY_WIN **)_al_vector_ref(&system->displays, j); ALLEGRO_DISPLAY_WIN *win_disp = *pwin_disp; if (win_disp->window == GetForegroundWindow()) { ALLEGRO_DEBUG("Requesting window unacquire joystick devices\n"); _al_win_wnd_call_proc(win_disp->window, _al_win_joystick_dinput_unacquire, win_disp); } } /* destroy the devices */ for (i = 0; i < MAX_JOYSTICKS; i++) { joydx_inactivate_joy(&joydx_joystick[i]); } joydx_num_joysticks = 0; for (i = 0; i < MAX_JOYSTICKS; i++) { JOYSTICK_WAKER(i) = NULL; } /* destroy the DirectInput interface */ IDirectInput8_Release(joystick_dinput); joystick_dinput = NULL; /* release module handle */ FreeLibrary(_al_dinput_module); _al_dinput_module = NULL; ALLEGRO_DEBUG("Leaving joydx_exit_joystick\n"); } /* joydx_reconfigure_joysticks: [primary thread] */ static bool joydx_reconfigure_joysticks(void) { bool ret = false; EnterCriticalSection(&joydx_thread_cs); if (config_needs_merging) { joydx_merge(); ret = true; } LeaveCriticalSection(&joydx_thread_cs); return ret; } /* joydx_get_num_joysticks: [primary thread] * Return the number of joysticks available on the system. */ static int joydx_get_num_joysticks(void) { return joydx_num_joysticks; } /* joydx_get_joystick: [primary thread] * * Returns the address of a ALLEGRO_JOYSTICK structure for the device * number NUM. */ static ALLEGRO_JOYSTICK *joydx_get_joystick(int num) { ALLEGRO_JOYSTICK *ret = NULL; unsigned i; ALLEGRO_ASSERT(num >= 0); EnterCriticalSection(&joydx_thread_cs); for (i = 0; i < MAX_JOYSTICKS; i++) { ALLEGRO_JOYSTICK_DIRECTX *joy = &joydx_joystick[i]; if (ACTIVE_STATE(joy->config_state)) { if (num == 0) { ret = (ALLEGRO_JOYSTICK *)joy; break; } num--; } } /* Must set the driver of the joystick for the wrapper driver */ ret->driver = &_al_joydrv_directx; LeaveCriticalSection(&joydx_thread_cs); #if 0 /* is this needed? */ if (ret) { ALLEGRO_DISPLAY *display = al_get_current_display(); if (display) _al_win_joystick_dinput_grab(display); } #endif return ret; } /* joydx_release_joystick: [primary thread] * Releases a previously gotten joystick. */ static void joydx_release_joystick(ALLEGRO_JOYSTICK *joy) { (void)joy; } /* joydx_get_joystick_state: [primary thread] * Copy the internal joystick state to a user-provided structure. */ static void joydx_get_joystick_state(ALLEGRO_JOYSTICK *joy_, ALLEGRO_JOYSTICK_STATE *ret_state) { ALLEGRO_JOYSTICK_DIRECTX *joy = (ALLEGRO_JOYSTICK_DIRECTX *)joy_; ALLEGRO_EVENT_SOURCE *es = al_get_joystick_event_source(); _al_event_source_lock(es); { *ret_state = joy->joystate; } _al_event_source_unlock(es); } static const char *joydx_get_name(ALLEGRO_JOYSTICK *joy_) { ALLEGRO_JOYSTICK_DIRECTX *joy = (ALLEGRO_JOYSTICK_DIRECTX *)joy_; return joy->name; } static bool joydx_get_active(ALLEGRO_JOYSTICK *joy) { ALLEGRO_JOYSTICK_DIRECTX *joydx = (ALLEGRO_JOYSTICK_DIRECTX *)joy; return ACTIVE_STATE(joydx->config_state); } /* joydx_thread_proc: [joystick thread] * Thread loop function for the joystick thread. */ static unsigned __stdcall joydx_thread_proc(LPVOID unused) { double last_update = al_get_time(); /* XXX is this needed? */ _al_win_thread_init(); while (true) { DWORD result; result = WaitForMultipleObjects(joydx_num_joysticks + 1, /* +1 for STOP_EVENT */ joydx_thread_wakers, false, /* wait for any */ 1000); /* 1 second wait */ if (result == WAIT_OBJECT_0) break; /* STOP_EVENT */ EnterCriticalSection(&joydx_thread_cs); { /* handle hot plugging */ if (al_get_time() > last_update+1 || result == WAIT_TIMEOUT) { if (need_device_enumeration) { joydx_scan(true); need_device_enumeration = false; } last_update = al_get_time(); } if (result != WAIT_TIMEOUT) { int waker_num = result - WAIT_OBJECT_0 - 1; /* -1 for STOP_EVENT */ HANDLE waker = JOYSTICK_WAKER(waker_num); unsigned i; for (i = 0; i < MAX_JOYSTICKS; i++) { if (waker == joydx_joystick[i].waker_event) { update_joystick(&joydx_joystick[i]); break; } } if (i == MAX_JOYSTICKS) { ALLEGRO_WARN("unable to match event to joystick\n"); } } } LeaveCriticalSection(&joydx_thread_cs); } _al_win_thread_exit(); (void)unused; return 0; } /* update_joystick: [joystick thread] * Reads in data for a single DirectInput joystick device, updates * the internal ALLEGRO_JOYSTICK_STATE structure, and generates any Allegro * events required. */ static void update_joystick(ALLEGRO_JOYSTICK_DIRECTX *joy) { DIDEVICEOBJECTDATA buffer[DEVICE_BUFFER_SIZE]; DWORD num_items = DEVICE_BUFFER_SIZE; HRESULT hr; ALLEGRO_EVENT_SOURCE *es = al_get_joystick_event_source(); /* some devices require polling */ IDirectInputDevice8_Poll(joy->device); /* get device data into buffer */ hr = IDirectInputDevice8_GetDeviceData(joy->device, sizeof(DIDEVICEOBJECTDATA), buffer, &num_items, 0); if (hr != DI_OK && hr != DI_BUFFEROVERFLOW) { if ((hr == DIERR_NOTACQUIRED) || (hr == DIERR_INPUTLOST)) { ALLEGRO_WARN("joystick device not acquired or lost\n"); } else { ALLEGRO_ERROR("unexpected error while polling the joystick\n"); } return; } /* don't bother locking the event source if there's no work to do */ /* this happens a lot for polled devices */ if (num_items == 0) return; _al_event_source_lock(es); { unsigned int i; for (i = 0; i < num_items; i++) { const DIDEVICEOBJECTDATA *item = &buffer[i]; const int dwOfs = item->dwOfs; const DWORD dwData = item->dwData; if (dwOfs == DIJOFS_X) handle_axis_event(joy, joy->x_mapping, dwData); else if (dwOfs == DIJOFS_Y) handle_axis_event(joy, joy->y_mapping, dwData); else if (dwOfs == DIJOFS_Z) handle_axis_event(joy, joy->z_mapping, dwData); else if (dwOfs == DIJOFS_RX) handle_axis_event(joy, joy->rx_mapping, dwData); else if (dwOfs == DIJOFS_RY) handle_axis_event(joy, joy->ry_mapping, dwData); else if (dwOfs == DIJOFS_RZ) handle_axis_event(joy, joy->rz_mapping, dwData); else if ((unsigned int)dwOfs == DIJOFS_SLIDER(0)) handle_axis_event(joy, joy->slider_mapping[0], dwData); else if ((unsigned int)dwOfs == DIJOFS_SLIDER(1)) handle_axis_event(joy, joy->slider_mapping[1], dwData); else if ((unsigned int)dwOfs == DIJOFS_POV(0)) handle_pov_event(joy, &joy->pov_mapping[0], dwData); else if ((unsigned int)dwOfs == DIJOFS_POV(1)) handle_pov_event(joy, &joy->pov_mapping[2], dwData); else if ((unsigned int)dwOfs == DIJOFS_POV(2)) handle_pov_event(joy, &joy->pov_mapping[4], dwData); else if ((unsigned int)dwOfs == DIJOFS_POV(3)) handle_pov_event(joy, &joy->pov_mapping[6], dwData); else { /* buttons */ int num = (dwOfs - DIJOFS_BUTTON0) / (DIJOFS_BUTTON1 - DIJOFS_BUTTON0); if (num < MAX_BUTTONS) handle_button_event(joy, joy->button_mapping[num], (dwData & 0x80)); } } } _al_event_source_unlock(es); } /* handle_axis_event: [joystick thread] * Helper function to handle a state change in a non-POV axis. * The joystick must be locked BEFORE entering this function. */ static void handle_axis_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT output, DWORD value) { float pos = (int)value / 32767.0; if (output.button_enabled || output.pos_enabled || output.neg_enabled) _al_joystick_generate_axis_event((ALLEGRO_JOYSTICK*)joy, &joy->joystate, output, pos); } /* handle_pov_event: [joystick thread] * Helper function to handle a state change in a POV device. * The joystick must be locked BEFORE entering this function. */ static void handle_pov_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT *outputs, DWORD _value) { int value = _value; float px, py; /* left */ if ((value > JOY_POVBACKWARD) && (value < JOY_POVFORWARD_WRAP)) px = -1.0; /* right */ else if ((value > JOY_POVFORWARD) && (value < JOY_POVBACKWARD)) px = +1.0; else px = 0.0; /* forward */ if (((value > JOY_POVLEFT) && (value <= JOY_POVFORWARD_WRAP)) || ((value >= JOY_POVFORWARD) && (value < JOY_POVRIGHT))) py = -1.0; /* backward */ else if ((value > JOY_POVRIGHT) && (value < JOY_POVLEFT)) py = +1.0; else py = 0.0; _AL_JOYSTICK_OUTPUT output; output = outputs[0]; if (output.button_enabled || output.pos_enabled || output.neg_enabled) _al_joystick_generate_axis_event((ALLEGRO_JOYSTICK*)joy, &joy->joystate, output, px); output = outputs[1]; if (output.button_enabled || output.pos_enabled || output.neg_enabled) _al_joystick_generate_axis_event((ALLEGRO_JOYSTICK*)joy, &joy->joystate, output, py); } /* handle_button_event: [joystick thread] * Helper function to handle a state change in a button. * The joystick must be locked BEFORE entering this function. */ static void handle_button_event(ALLEGRO_JOYSTICK_DIRECTX *joy, _AL_JOYSTICK_OUTPUT output, DWORD value) { if (output.button_enabled || output.pos_enabled || output.neg_enabled) _al_joystick_generate_button_event((ALLEGRO_JOYSTICK *)joy, &joy->joystate, output, value); } /* * Local Variables: * c-basic-offset: 3 * indent-tabs-mode: nil * End: */ /* vim: set sts=3 sw=3 et: */