dlls/xinput1_3/xinput_main.c

   1 /*
   2  * The Wine project - Xinput Joystick Library
   3  * Copyright 2008 Andrew Fenn
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "wine/debug.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29
  30 #include "xinput.h"
  31 #include "xinput_private.h"
  32
  33 /* Not defined in the headers, used only by XInputGetStateEx */
  34 #define XINPUT_GAMEPAD_GUIDE 0x0400
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(xinput);
  37
  38 xinput_controller controllers[XUSER_MAX_COUNT];
  39
  40 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
  41 {
  42     switch(reason)
  43     {
  44         case DLL_PROCESS_ATTACH:
  45             DisableThreadLibraryCalls(inst);
  46             break;
  47         case DLL_PROCESS_DETACH:
  48             if (reserved) break;
  49             HID_destroy_gamepads(controllers);
  50             break;
  51     }
  52     return TRUE;
  53 }
  54
  55 void WINAPI DECLSPEC_HOTPATCH XInputEnable(BOOL enable)
  56 {
  57     int index;
  58
  59     TRACE("(enable %d)\n", enable);
  60
  61     /* Setting to false will stop messages from XInputSetState being sent
  62     to the controllers. Setting to true will send the last vibration
  63     value (sent to XInputSetState) to the controller and allow messages to
  64     be sent */
  65     HID_find_gamepads(controllers);
  66
  67     for (index = 0; index < XUSER_MAX_COUNT; index ++)
  68     {
  69         if (!controllers[index].connected) continue;
  70         HID_enable(&controllers[index], enable);
  71     }
  72 }
  73
  74 DWORD WINAPI DECLSPEC_HOTPATCH XInputSetState(DWORD index, XINPUT_VIBRATION* vibration)
  75 {
  76     TRACE("(index %u, vibration %p)\n", index, vibration);
  77
  78     HID_find_gamepads(controllers);
  79
  80     if (index >= XUSER_MAX_COUNT)
  81         return ERROR_BAD_ARGUMENTS;
  82     if (!controllers[index].connected)
  83         return ERROR_DEVICE_NOT_CONNECTED;
  84
  85     return HID_set_state(&controllers[index], vibration);
  86 }
  87
  88 /* Some versions of SteamOverlayRenderer hot-patch XInputGetStateEx() and call
  89  * XInputGetState() in the hook, so we need a wrapper. */
  90 static DWORD xinput_get_state(DWORD index, XINPUT_STATE *state)
  91 {
  92     HID_find_gamepads(controllers);
  93
  94     if (index >= XUSER_MAX_COUNT)
  95         return ERROR_BAD_ARGUMENTS;
  96     if (!controllers[index].connected)
  97         return ERROR_DEVICE_NOT_CONNECTED;
  98
  99     HID_update_state(&controllers[index]);
 100     memcpy(state, &controllers[index].state, sizeof(XINPUT_STATE));
 101
 102     return ERROR_SUCCESS;
 103 }
 104
 105
 106 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetState(DWORD index, XINPUT_STATE* state)
 107 {
 108     DWORD ret;
 109
 110     TRACE("(index %u, state %p)!\n", index, state);
 111
 112     ret = xinput_get_state(index, state);
 113     if (ret != ERROR_SUCCESS)
 114         return ret;
 115
 116     /* The main difference between this and the Ex version is the media guide button */
 117     state->Gamepad.wButtons &= ~XINPUT_GAMEPAD_GUIDE;
 118
 119     return ERROR_SUCCESS;
 120 }
 121
 122 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetStateEx(DWORD index, XINPUT_STATE* state)
 123 {
 124     TRACE("(index %u, state %p)!\n", index, state);
 125
 126     return xinput_get_state(index, state);
 127 }
 128
 129 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetKeystroke(DWORD index, DWORD reserved, PXINPUT_KEYSTROKE keystroke)
 130 {
 131     static int warn_once;
 132
 133     if (!warn_once++)
 134         FIXME("(index %u, reserved %u, keystroke %p) Stub!\n", index, reserved, keystroke);
 135
 136     if (index >= XUSER_MAX_COUNT)
 137         return ERROR_BAD_ARGUMENTS;
 138     if (!controllers[index].connected)
 139         return ERROR_DEVICE_NOT_CONNECTED;
 140
 141     return ERROR_NOT_SUPPORTED;
 142 }
 143
 144 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetCapabilities(DWORD index, DWORD flags, XINPUT_CAPABILITIES* capabilities)
 145 {
 146     TRACE("(index %u, flags 0x%x, capabilities %p)\n", index, flags, capabilities);
 147
 148     HID_find_gamepads(controllers);
 149
 150     if (index >= XUSER_MAX_COUNT)
 151         return ERROR_BAD_ARGUMENTS;
 152     if (!controllers[index].connected)
 153         return ERROR_DEVICE_NOT_CONNECTED;
 154     if (flags & XINPUT_FLAG_GAMEPAD && controllers[index].caps.SubType != XINPUT_DEVSUBTYPE_GAMEPAD)
 155         return ERROR_DEVICE_NOT_CONNECTED;
 156
 157     memcpy(capabilities, &controllers[index].caps, sizeof(*capabilities));
 158
 159     return ERROR_SUCCESS;
 160 }
 161
 162 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetDSoundAudioDeviceGuids(DWORD index, GUID* render_guid, GUID* capture_guid)
 163 {
 164     FIXME("(index %u, render guid %p, capture guid %p) Stub!\n", index, render_guid, capture_guid);
 165
 166     if (index >= XUSER_MAX_COUNT)
 167         return ERROR_BAD_ARGUMENTS;
 168     if (!controllers[index].connected)
 169         return ERROR_DEVICE_NOT_CONNECTED;
 170
 171     return ERROR_NOT_SUPPORTED;
 172 }
 173
 174 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetBatteryInformation(DWORD index, BYTE type, XINPUT_BATTERY_INFORMATION* battery)
 175 {
 176     static int once;
 177
 178     if (!once++)
 179         FIXME("(index %u, type %u, battery %p) Stub!\n", index, type, battery);
 180
 181     if (index >= XUSER_MAX_COUNT)
 182         return ERROR_BAD_ARGUMENTS;
 183     if (!controllers[index].connected)
 184         return ERROR_DEVICE_NOT_CONNECTED;
 185
 186     return ERROR_NOT_SUPPORTED;
 187 }