Win32 input device refinements and XInput support

CMakeLists.txt

@@ -65,7 +65,7 @@ if(WIN32)
 
   list(APPEND _BOO_SYS_DEFINES -DUNICODE -D_UNICODE)
 
-  list(APPEND _BOO_SYS_LIBS Winusb opengl32 Setupapi Imm32 Winmm Shlwapi)
+  list(APPEND _BOO_SYS_LIBS Winusb opengl32 Setupapi Imm32 Winmm Shlwapi Hid Xinput)
 elseif(APPLE)
   list(APPEND PLAT_SRCS
        lib/mac/ApplicationCocoa.mm
@@ -214,6 +214,7 @@ add_library(boo
             lib/inputdev/RevolutionPad.cpp include/boo/inputdev/RevolutionPad.hpp
             lib/inputdev/DolphinSmashAdapter.cpp include/boo/inputdev/DolphinSmashAdapter.hpp
             lib/inputdev/DualshockPad.cpp include/boo/inputdev/DualshockPad.hpp
+            include/boo/inputdev/XInputPad.hpp
             lib/inputdev/GenericPad.cpp include/boo/inputdev/GenericPad.hpp
             lib/inputdev/DeviceSignature.cpp include/boo/inputdev/DeviceSignature.hpp
             lib/inputdev/DeviceFinder.cpp include/boo/inputdev/DeviceFinder.hpp

InputDeviceClasses.cpp

@@ -1,6 +1,7 @@
 #include "boo/inputdev/DeviceSignature.hpp"
 #include "boo/inputdev/DolphinSmashAdapter.hpp"
 #include "boo/inputdev/DualshockPad.hpp"
+#include "boo/inputdev/XInputPad.hpp"
 
 namespace boo
 {
@@ -9,6 +10,7 @@ const DeviceSignature BOO_DEVICE_SIGS[] =
 {
     DEVICE_SIG(DolphinSmashAdapter, 0x57e, 0x337, DeviceType::USB),
     DEVICE_SIG(DualshockPad, 0x54c, 0x268, DeviceType::HID),
+    DEVICE_SIG(XInputPad, 0, 0, DeviceType::XInput),
     DEVICE_SIG_SENTINEL()
 };
 

include/boo/inputdev/DeviceFinder.hpp

@@ -37,7 +37,7 @@ private:
 
     /* Platform-specific USB event registration
      * (for auto-scanning, NULL if not registered) */
-    IHIDListener* m_listener;
+    std::unique_ptr<IHIDListener> m_listener;
 
     /* Set of presently-connected device tokens */
     TDeviceTokens m_tokens;
@@ -95,7 +95,6 @@ public:
 
     /* Application must specify its interested device-types */
     DeviceFinder(std::unordered_set<std::type_index> types)
-    : m_listener(NULL)
     {
         if (skDevFinder)
         {
@@ -118,7 +117,6 @@ public:
     {
         if (m_listener)
             m_listener->stopScanning();
-        delete m_listener;
         skDevFinder = NULL;
     }
 

include/boo/inputdev/DeviceSignature.hpp

@@ -4,6 +4,7 @@
 #include <vector>
 #include <functional>
 #include <typeindex>
+#include <memory>
 
 namespace boo
 {
@@ -13,7 +14,8 @@ enum class DeviceType
     None       = 0,
     USB        = 1,
     Bluetooth  = 2,
-    HID = 3
+    HID        = 3,
+    XInput     = 4
 };
 
 class DeviceToken;

include/boo/inputdev/DeviceToken.hpp

@@ -11,6 +11,7 @@ namespace boo
 class DeviceToken
 {
     friend struct DeviceSignature;
+    friend class HIDListenerWinUSB;
     DeviceType m_devType;
     unsigned m_vendorId;
     unsigned m_productId;

include/boo/inputdev/DualshockPad.hpp

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <type_traits>
 #include "DeviceBase.hpp"
-#include "../System.hpp"
+#include "boo/System.hpp"
 
 namespace boo
 {
@@ -117,9 +117,8 @@ struct DualshockPadState
 class DualshockPad;
 struct IDualshockPadCallback
 {
-    DualshockPad* ctrl = nullptr;
     virtual void controllerDisconnected() {}
-    virtual void controllerUpdate(const DualshockPadState&) {}
+    virtual void controllerUpdate(DualshockPad&, const DualshockPadState&) {}
 };
 
 class DualshockPad final : public DeviceBase
@@ -141,8 +140,7 @@ public:
     DualshockPad(DeviceToken* token);
     ~DualshockPad();
 
-    void setCallback(IDualshockPadCallback* cb)
+    void setCallback(IDualshockPadCallback* cb) { m_callback = cb; }
-    { m_callback = cb; if (m_callback) m_callback->ctrl = this; }
 
     void startRumble(EDualshockMotor motor, uint8_t duration = 254, uint8_t intensity=255)
     {
@@ -159,9 +157,9 @@ public:
         }
     }
 
-    void stopRumble(int motor)
+    void stopRumble(EDualshockMotor motor)
     {
-        m_rumbleRequest &= ~EDualshockMotor(motor);
+        m_rumbleRequest &= ~motor;
     }
 
     EDualshockLED getLED()

include/boo/inputdev/IHIDListener.hpp

@@ -33,7 +33,7 @@ public:
 };
 
 /* Platform-specific constructor */
-IHIDListener* IHIDListenerNew(DeviceFinder& finder);
+std::unique_ptr<IHIDListener> IHIDListenerNew(DeviceFinder& finder);
 
 }
 

include/boo/inputdev/XInputPad.hpp

@@ -0,0 +1,68 @@
+#ifndef XINPUTPAD_HPP
+#define XINPUTPAD_HPP
+
+#include "DeviceBase.hpp"
+#include "boo/System.hpp"
+
+namespace boo
+{
+
+struct XInputPadState
+{
+    uint16_t wButtons;
+    uint8_t bLeftTrigger;
+    uint8_t bRightTrigger;
+    int16_t sThumbLX;
+    int16_t sThumbLY;
+    int16_t sThumbRX;
+    int16_t sThumbRY;
+};
+
+enum class EXInputMotor : uint8_t
+{
+    None  = 0,
+    Right = 1<<0,
+    Left  = 1<<1,
+};
+ENABLE_BITWISE_ENUM(EXInputMotor)
+
+class XInputPad;
+struct IXInputPadCallback
+{
+    virtual void controllerDisconnected() {}
+    virtual void controllerUpdate(XInputPad& pad, const XInputPadState&) {}
+};
+
+class XInputPad final : public DeviceBase
+{
+    friend class HIDListenerWinUSB;
+    IXInputPadCallback* m_callback;
+    uint16_t m_rumbleRequest[2] = {};
+    uint16_t m_rumbleState[2] = {};
+public:
+    XInputPad(DeviceToken* token) : DeviceBase(token) {}
+    void setCallback(IXInputPadCallback* cb) { m_callback = cb; }
+    void deviceDisconnected()
+    {
+        if (m_callback)
+            m_callback->controllerDisconnected();
+    }
+    void startRumble(EXInputMotor motors, uint16_t intensity)
+    {
+        if ((motors & EXInputMotor::Left) != EXInputMotor::None)
+            m_rumbleRequest[0] = intensity;
+        if ((motors & EXInputMotor::Right) != EXInputMotor::None)
+            m_rumbleRequest[1] = intensity;
+    }
+    void stopRumble(EXInputMotor motors)
+    {
+        if ((motors & EXInputMotor::Left) != EXInputMotor::None)
+            m_rumbleRequest[0] = 0;
+        if ((motors & EXInputMotor::Right) != EXInputMotor::None)
+            m_rumbleRequest[1] = 0;
+    }
+};
+
+}
+
+#endif // XINPUTPAD_HPP

lib/inputdev/DeviceFinder.cpp

@@ -2,6 +2,8 @@
 
 #if _WIN32
 #include <Dbt.h>
+#include <hidclass.h>
+#include <usbiodef.h>
 #endif
 
 namespace boo
@@ -21,26 +23,44 @@ LRESULT DeviceFinder::winDevChangedHandler(WPARAM wParam, LPARAM lParam)
     {
         if (dbh->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
         {
+            DeviceType type = DeviceType::None;
+            if (dbhi->dbcc_classguid == GUID_DEVINTERFACE_USB_DEVICE)
+                type = DeviceType::USB;
+            else if (dbhi->dbcc_classguid == GUID_DEVINTERFACE_HID)
+                type = DeviceType::HID;
+
+            if (type != DeviceType::None)
+            {
 #ifdef UNICODE
-            char devPath[1024];
+                char devPath[1024];
-            wcstombs(devPath, dbhi->dbcc_name, 1024);
+                wcstombs(devPath, dbhi->dbcc_name, 1024);
-            finder->m_listener->_extDevConnect(devPath);
+                finder->m_listener->_extDevConnect(devPath);
 #else
-            finder->m_listener->_extDevConnect(dbhi->dbcc_name);
+                finder->m_listener->_extDevConnect(dbhi->dbcc_name);
 #endif
+            }
         }
     }
     else if (wParam == DBT_DEVICEREMOVECOMPLETE)
     {
         if (dbh->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
         {
+            DeviceType type = DeviceType::None;
+            if (dbhi->dbcc_classguid == GUID_DEVINTERFACE_USB_DEVICE)
+                type = DeviceType::USB;
+            else if (dbhi->dbcc_classguid == GUID_DEVINTERFACE_HID)
+                type = DeviceType::HID;
+
+            if (type != DeviceType::None)
+            {
 #ifdef UNICODE
-            char devPath[1024];
+                char devPath[1024];
-            wcstombs(devPath, dbhi->dbcc_name, 1024);
+                wcstombs(devPath, dbhi->dbcc_name, 1024);
-            finder->m_listener->_extDevDisconnect(devPath);
+                finder->m_listener->_extDevDisconnect(devPath);
 #else
-            finder->m_listener->_extDevDisconnect(dbhi->dbcc_name);
+                finder->m_listener->_extDevDisconnect(dbhi->dbcc_name);
 #endif
+            }
         }
     }
 

lib/inputdev/DualshockPad.cpp

@@ -81,7 +81,7 @@ void DualshockPad::receivedHIDReport(const uint8_t* data, size_t length, HIDRepo
 
     state.m_gyrometerZ = bswap16(state.m_gyrometerZ);
     if (m_callback)
-        m_callback->controllerUpdate(state);
+        m_callback->controllerUpdate(*this, state);
 
     if (m_rumbleRequest != m_rumbleState)
     {

lib/inputdev/HIDDeviceWinUSB.cpp

@@ -7,6 +7,7 @@
 #include <condition_variable>
 #include <string.h>
 #include <stdio.h>
+#include <algorithm>
 
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
@@ -15,6 +16,10 @@
 #include <winusb.h>
 #include <usb100.h>
 #include <Winusbio.h>
+#include <hidsdi.h>
+
+#undef min
+#undef max
 
 namespace boo
 {
@@ -25,7 +30,8 @@ class HIDDeviceWinUSB final : public IHIDDevice
     DeviceBase& m_devImp;
 
     HANDLE m_devHandle = 0;
-    WINUSB_INTERFACE_HANDLE m_usbHandle = NULL;
+    HANDLE m_hidHandle = 0;
+    WINUSB_INTERFACE_HANDLE m_usbHandle = nullptr;
     unsigned m_usbIntfInPipe = 0;
     unsigned m_usbIntfOutPipe = 0;
     bool m_runningTransferLoop = false;
@@ -140,7 +146,6 @@ class HIDDeviceWinUSB final : public IHIDDevice
         WinUsb_Free(device->m_usbHandle);
         CloseHandle(device->m_devHandle);
         device->m_devHandle = 0;
-
     }
 
     static void _threadProcBTLL(HIDDeviceWinUSB* device)
@@ -157,24 +162,76 @@ class HIDDeviceWinUSB final : public IHIDDevice
         while (device->m_runningTransferLoop)
             device->m_devImp.transferCycle();
         device->m_devImp.finalCycle();
-
     }
 
+    size_t m_minFeatureSz = 0;
+    size_t m_minInputSz = 0;
+    size_t m_minOutputSz = 0;
+
     static void _threadProcHID(HIDDeviceWinUSB* device)
     {
+        char errStr[256];
         std::unique_lock<std::mutex> lk(device->m_initMutex);
 
+        /* POSIX.. who needs it?? -MS */
+        device->m_hidHandle = CreateFileA(device->m_devPath.c_str(),
+                                          GENERIC_WRITE | GENERIC_READ,
+                                          FILE_SHARE_WRITE | FILE_SHARE_READ,
+                                          NULL,
+                                          OPEN_EXISTING,
+                                          FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
+                                          NULL);
+        if (INVALID_HANDLE_VALUE == device->m_hidHandle)
+        {
+            _snprintf(errStr, 256, "Unable to open %s@%s: %d\n",
+                      device->m_token.getProductName().c_str(),
+                      device->m_devPath.c_str(), GetLastError());
+            device->m_devImp.deviceError(errStr);
+            lk.unlock();
+            device->m_initCond.notify_one();
+            return;
+        }
+
+        PHIDP_PREPARSED_DATA preparsedData;
+        if (!HidD_GetPreparsedData(device->m_hidHandle, &preparsedData))
+        {
+            _snprintf(errStr, 256, "Unable get preparsed data of %s@%s: %d\n",
+                      device->m_token.getProductName().c_str(),
+                      device->m_devPath.c_str(), GetLastError());
+            device->m_devImp.deviceError(errStr);
+            lk.unlock();
+            device->m_initCond.notify_one();
+            return;
+        }
+
+        HIDP_CAPS caps;
+        HidP_GetCaps(preparsedData, &caps);
+        device->m_minFeatureSz = caps.FeatureReportByteLength;
+        device->m_minInputSz = caps.InputReportByteLength;
+        device->m_minOutputSz = caps.OutputReportByteLength;
+        HidD_FreePreparsedData(preparsedData);
+
         /* Return control to main thread */
         device->m_runningTransferLoop = true;
         lk.unlock();
         device->m_initCond.notify_one();
 
+        /* Allocate read buffer */
+        size_t inBufferSz = std::max(device->m_minInputSz, device->m_devImp.getInputBufferSize());
+        std::unique_ptr<uint8_t[]> readBuf(new uint8_t[inBufferSz]);
+
         /* Start transfer loop */
         device->m_devImp.initialCycle();
         while (device->m_runningTransferLoop)
+        {
+            device->ReadCycle(readBuf.get(), inBufferSz);
             device->m_devImp.transferCycle();
+        }
         device->m_devImp.finalCycle();
 
+        /* Cleanup */
+        CloseHandle(device->m_hidHandle);
+        device->m_hidHandle = nullptr;
     }
 
     void _deviceDisconnected()
@@ -182,9 +239,84 @@ class HIDDeviceWinUSB final : public IHIDDevice
         m_runningTransferLoop = false;
     }
 
-    bool _sendHIDReport(const uint8_t* data, size_t length, uint16_t message)
+    std::vector<uint8_t> m_sendBuf;
+    std::vector<uint8_t> m_recvBuf;
+
+    bool _sendHIDReport(const uint8_t* data, size_t length, HIDReportType tp, uint32_t message)
     {
-        return false;
+        size_t maxOut = std::max(m_minFeatureSz, std::max(m_minOutputSz, length));
+        if (m_sendBuf.size() < maxOut)
+            m_sendBuf.resize(maxOut);
+        if (maxOut > length)
+            memset(m_sendBuf.data() + length, 0, maxOut - length);
+        memmove(m_sendBuf.data(), data, length);
+
+        if (tp == HIDReportType::Output)
+        {
+            DWORD useLength = DWORD(std::max(length, m_minOutputSz));
+            DWORD BytesWritten;
+            OVERLAPPED Overlapped;
+            ZeroMemory(&Overlapped, sizeof(Overlapped));
+            BOOL Result = WriteFile(m_hidHandle, m_sendBuf.data(), useLength, &BytesWritten, &Overlapped);
+            if (!Result)
+            {
+                DWORD Error = GetLastError();
+
+                if (Error == ERROR_INVALID_USER_BUFFER)
+                {
+                    //std::cout << "Falling back to SetOutputReport" << std::endl;
+                    if (!HidD_SetOutputReport(m_hidHandle, (PVOID)m_sendBuf.data(), useLength))
+                        return false;
+                }
+
+                if (Error != ERROR_IO_PENDING)
+                {
+                    fprintf(stderr, "Write Failed %08X\n", Error);
+                    return false;
+                }
+            }
+
+            if (!GetOverlappedResult(m_hidHandle, &Overlapped, &BytesWritten, TRUE))
+            {
+                DWORD Error = GetLastError();
+                fprintf(stderr, "Write Failed %08X\n", Error);
+                return false;
+            }
+        }
+        else if (tp == HIDReportType::Feature)
+        {
+            DWORD useLength = DWORD(std::max(length, m_minFeatureSz));
+            if (!HidD_SetFeature(m_hidHandle, (PVOID)m_sendBuf.data(), useLength))
+            {
+                int error = GetLastError();
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    size_t _receiveHIDReport(uint8_t* data, size_t length, HIDReportType tp, uint32_t message)
+    {
+        size_t maxIn = std::max(m_minFeatureSz, std::max(m_minInputSz, length));
+        if (m_recvBuf.size() < maxIn)
+            m_recvBuf.resize(maxIn);
+        memset(m_recvBuf.data(), 0, length);
+        m_recvBuf[0] = message;
+
+        if (tp == HIDReportType::Input)
+        {
+            if (!HidD_GetInputReport(m_hidHandle, m_recvBuf.data(), ULONG(std::max(m_minInputSz, length))))
+                return 0;
+        }
+        else if (tp == HIDReportType::Feature)
+        {
+            if (!HidD_GetFeature(m_hidHandle, m_recvBuf.data(), ULONG(std::max(m_minFeatureSz, length))))
+                return 0;
+        }
+
+        memmove(data, m_recvBuf.data(), length);
+        return length;
     }
 
 public:
@@ -194,14 +326,13 @@ public:
       m_devImp(devImp),
       m_devPath(token.getDevicePath())
     {
-        devImp.m_hidDev = this;
         std::unique_lock<std::mutex> lk(m_initMutex);
-        DeviceToken::DeviceType dType = token.getDeviceType();
+        DeviceType dType = token.getDeviceType();
-        if (dType == DeviceToken::DeviceType::USB)
+        if (dType == DeviceType::USB)
             m_thread = std::thread(_threadProcUSBLL, this);
-        else if (dType == DeviceToken::DeviceType::Bluetooth)
+        else if (dType == DeviceType::Bluetooth)
             m_thread = std::thread(_threadProcBTLL, this);
-        else if (dType == DeviceToken::DeviceType::GenericHID)
+        else if (dType == DeviceType::HID)
             m_thread = std::thread(_threadProcHID, this);
         else
             throw std::runtime_error("invalid token supplied to device constructor");
@@ -214,12 +345,55 @@ public:
         m_thread.join();
     }
 
+    OVERLAPPED m_overlapped = {};
 
+    void ReadCycle(uint8_t* inBuffer, size_t inBufferSz)
+    {
+        while (true)
+        {
+            ZeroMemory(inBuffer, inBufferSz);
+            DWORD BytesRead = 0;
+            BOOL Result = ReadFile(m_hidHandle, inBuffer, DWORD(inBufferSz), &BytesRead, &m_overlapped);
+            if (!Result)
+            {
+                DWORD Error = GetLastError();
+                if (Error != ERROR_IO_PENDING)
+                {
+                    fprintf(stderr, "Read Failed: %08X\n", Error);
+                    return;
+                }
+                else
+                {
+                    if (!GetOverlappedResult(m_hidHandle, &m_overlapped, &BytesRead, TRUE))
+                    {
+                        Error = GetLastError();
+                        if (Error == ERROR_IO_INCOMPLETE)
+                            return;
+                        fprintf(stderr, "Read Failed: %08X\n", Error);
+                        return;
+                    }
+
+                    if (m_overlapped.Internal == STATUS_PENDING)
+                    {
+                        //std::cout << "Read Interrupted" << std::endl;
+                        if(!CancelIo(m_hidHandle))
+                        {
+                            Error = GetLastError();
+                            fprintf(stderr, "Cancel IO Failed: %08X\n", Error);
+                        }
+                        return;
+                    }
+                }
+            }
+
+            m_devImp.receivedHIDReport(inBuffer, BytesRead, HIDReportType::Input, inBuffer[0]);
+        }
+    }
 };
 
-IHIDDevice* IHIDDeviceNew(DeviceToken& token, DeviceBase& devImp)
+std::unique_ptr<IHIDDevice> IHIDDeviceNew(DeviceToken& token, DeviceBase& devImp)
 {
-    return new HIDDeviceWinUSB(token, devImp);
+    return std::make_unique<HIDDeviceWinUSB>(token, devImp);
 }
 
 }

lib/inputdev/HIDListenerIOKit.cpp

@@ -329,9 +329,9 @@ public:
     
 };
 
-IHIDListener* IHIDListenerNew(DeviceFinder& finder)
+std::unique_ptr<IHIDListener> IHIDListenerNew(DeviceFinder& finder)
 {
-    return new HIDListenerIOKit(finder);
+    return std::make_unique<HIDListenerIOKit>(finder);
 }
 
 }

lib/inputdev/HIDListenerWinUSB.cpp

@@ -1,6 +1,7 @@
 #define _CRT_SECURE_NO_WARNINGS 1 /* STFU MSVC */
 #include "boo/inputdev/IHIDListener.hpp"
 #include "boo/inputdev/DeviceFinder.hpp"
+#include "boo/inputdev/XInputPad.hpp"
 #include <string.h>
 #include <thread>
 
@@ -14,6 +15,8 @@
 #include <Cfgmgr32.h>
 #include <Usbiodef.h>
 #include <Devpkey.h>
+#include <hidclass.h>
+#include <Xinput.h>
 
 namespace boo
 {
@@ -28,9 +31,8 @@ class HIDListenerWinUSB final : public IHIDListener
      * Reference: https://github.com/pbatard/libwdi/blob/master/libwdi/libwdi.c
      */
 
-    void _pollDevices(const char* pathFilter)
+    void _enumerate(DeviceType type, CONST GUID* TypeGUID, const char* pathFilter)
     {
-
         /* Don't ask */
         static const LPCSTR arPrefix[3] = {"VID_", "PID_", "MI_"};
         unsigned i, j;
@@ -51,17 +53,16 @@ class HIDListenerWinUSB final : public IHIDListener
         LPSTR pszToken, pszNextToken;
         CHAR szVid[MAX_DEVICE_ID_LEN], szPid[MAX_DEVICE_ID_LEN], szMi[MAX_DEVICE_ID_LEN];
 
-        /* List all connected USB devices */
+        /* List all connected HID devices */
         hDevInfo = SetupDiGetClassDevs(NULL, 0, 0, DIGCF_PRESENT | DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE);
         if (hDevInfo == INVALID_HANDLE_VALUE)
             return;
 
         for (i=0 ; ; ++i)
         {
-
             if (!SetupDiEnumDeviceInterfaces(hDevInfo,
                                              NULL,
-                                             &GUID_DEVINTERFACE_USB_DEVICE,
+                                             TypeGUID,
                                              i,
                                              &DeviceInterfaceData))
                 break;
@@ -75,7 +76,7 @@ class HIDListenerWinUSB final : public IHIDListener
                                                   &DeviceInfoData))
                 continue;
 
-            r = CM_Get_Device_IDA(DeviceInfoData.DevInst, szDeviceInstanceID , MAX_PATH, 0);
+            r = CM_Get_Device_IDA(DeviceInfoData.DevInst, szDeviceInstanceID, MAX_PATH, 0);
             if (r != CR_SUCCESS)
                 continue;
 
@@ -115,8 +116,8 @@ class HIDListenerWinUSB final : public IHIDListener
             unsigned vid = strtol(szVid+4, NULL, 16);
             unsigned pid = strtol(szPid+4, NULL, 16);
 
-            WCHAR productW[1024] = {0};
+            CHAR productW[1024] = {0};
-            CHAR product[1024] = {0};
+            //CHAR product[1024] = {0};
             DWORD productSz = 0;
             if (!SetupDiGetDevicePropertyW(hDevInfo, &DeviceInfoData, &DEVPKEY_Device_BusReportedDeviceDesc,
                                            &devpropType, (BYTE*)productW, 1024, &productSz, 0)) {
@@ -124,14 +125,15 @@ class HIDListenerWinUSB final : public IHIDListener
                 SetupDiGetDeviceRegistryPropertyA(hDevInfo, &DeviceInfoData, SPDRP_DEVICEDESC,
                                                   &reg_type, (BYTE*)productW, 1024, &productSz);
             }
-            wcstombs(product, productW, productSz / 2);
+            /* DAFUQ??? Why isn't this really WCHAR??? */
+            //WideCharToMultiByte(CP_UTF8, 0, productW, -1, product, 1024, nullptr, nullptr);
 
             WCHAR manufW[1024] = L"Someone"; /* Windows Vista and earlier will use this as the vendor */
             CHAR manuf[1024] = {0};
             DWORD manufSz = 0;
             SetupDiGetDevicePropertyW(hDevInfo, &DeviceInfoData, &DEVPKEY_Device_Manufacturer,
                                       &devpropType, (BYTE*)manufW, 1024, &manufSz, 0);
-            wcstombs(manuf, manufW, manufSz / 2);
+            WideCharToMultiByte(CP_UTF8, 0, manufW, -1, manuf, 1024, nullptr, nullptr);
 
             /* Store as a shouting string (to keep hash-lookups consistent) */
             CharUpperA(DeviceInterfaceDetailData.wtf.DevicePath);
@@ -140,16 +142,86 @@ class HIDListenerWinUSB final : public IHIDListener
             if (pathFilter && strcmp(pathFilter, DeviceInterfaceDetailData.wtf.DevicePath))
                 continue;
 
-            /* Whew!! that's a single device enumerated!! */
+            if (!m_scanningEnabled || m_finder._hasToken(DeviceInterfaceDetailData.wtf.DevicePath))
-            if (!m_finder._hasToken(DeviceInterfaceDetailData.wtf.DevicePath))
+                continue;
-                m_finder._insertToken(DeviceToken(DeviceToken::DeviceType::USB,
-                                                  vid, pid, manuf, product,
-                                                  DeviceInterfaceDetailData.wtf.DevicePath));
 
+            /* Whew!! that's a single device enumerated!! */
+            m_finder._insertToken(std::make_unique<DeviceToken>(
+                                  type, vid, pid, manuf, productW,
+                                  DeviceInterfaceDetailData.wtf.DevicePath));
         }
 
         SetupDiDestroyDeviceInfoList(hDevInfo);
+    }
 
+    void _pollDevices(const char* pathFilter)
+    {
+        _enumerate(DeviceType::HID, &GUID_DEVINTERFACE_HID, pathFilter);
+        _enumerate(DeviceType::USB, &GUID_DEVINTERFACE_USB_DEVICE, pathFilter);
+    }
+
+    static XInputPadState ConvertXInputState(const XINPUT_GAMEPAD& pad)
+    {
+        return {pad.wButtons, pad.bLeftTrigger, pad.bRightTrigger,
+                pad.sThumbLX, pad.sThumbLY, pad.sThumbLY, pad.sThumbRY};
+    }
+
+    std::thread m_xinputThread;
+    bool m_xinputRunning = true;
+    DWORD m_xinputPackets[4] = {DWORD(-1), DWORD(-1), DWORD(-1), DWORD(-1)};
+    std::vector<DeviceToken> m_xinputTokens;
+    void _xinputProc()
+    {
+        m_xinputTokens.reserve(4);
+        for (int i=0 ; i<4 ; ++i)
+            m_xinputTokens.emplace_back(DeviceType::XInput, 0, i, "", "", "");
+
+        while (m_xinputRunning)
+        {
+            for (int i=0 ; i<4 ; ++i)
+            {
+                DeviceToken& tok = m_xinputTokens[i];
+                XINPUT_STATE state;
+                if (XInputGetState(i, &state) == ERROR_SUCCESS)
+                {
+                    if (state.dwPacketNumber != m_xinputPackets[i])
+                    {
+                        if (m_xinputPackets[i] == -1)
+                            m_finder.deviceConnected(tok);
+                        m_xinputPackets[i] = state.dwPacketNumber;
+                        if (tok.m_connectedDev)
+                        {
+                            XInputPad& pad = static_cast<XInputPad&>(*tok.m_connectedDev);
+                            if (pad.m_callback)
+                                pad.m_callback->controllerUpdate(pad, ConvertXInputState(state.Gamepad));
+                        }
+                    }
+                    if (tok.m_connectedDev)
+                    {
+                        XInputPad& pad = static_cast<XInputPad&>(*tok.m_connectedDev);
+                        if (pad.m_rumbleRequest[0] != pad.m_rumbleState[0] ||
+                            pad.m_rumbleRequest[1] != pad.m_rumbleState[1])
+                        {
+                            pad.m_rumbleState[0] = pad.m_rumbleRequest[0];
+                            pad.m_rumbleState[1] = pad.m_rumbleRequest[1];
+                            XINPUT_VIBRATION vibe = {pad.m_rumbleRequest[0], pad.m_rumbleRequest[1]};
+                            XInputSetState(i, &vibe);
+                        }
+                    }
+                }
+                else if (m_xinputPackets[i] != -1)
+                {
+                    m_xinputPackets[i] = -1;
+                    if (tok.m_connectedDev)
+                    {
+                        XInputPad& pad = static_cast<XInputPad&>(*tok.m_connectedDev);
+                        pad.deviceDisconnected();
+                    }
+                    m_finder.deviceDisconnected(tok, tok.m_connectedDev.get());
+                }
+            }
+            Sleep(10);
+        }
     }
 
 public:
@@ -157,11 +229,25 @@ public:
     : m_finder(finder)
     {
         /* Initial HID Device Add */
-        _pollDevices(NULL);
+        _pollDevices(nullptr);
+
+        /* XInput arbitration thread */
+        for (const DeviceSignature* sig : m_finder.getTypes())
+        {
+            if (sig->m_type == DeviceType::XInput)
+            {
+                m_xinputThread = std::thread(std::bind(&HIDListenerWinUSB::_xinputProc, this));
+                break;
+            }
+        }
     }
 
     ~HIDListenerWinUSB()
-    {}
+    {
+        m_xinputRunning = false;
+        if (m_xinputThread.joinable())
+            m_xinputThread.join();
+    }
 
     /* Automatic device scanning */
     bool startScanning()
@@ -178,7 +264,7 @@ public:
     /* Manual device scanning */
     bool scanNow()
     {
-        _pollDevices(NULL);
+        _pollDevices(nullptr);
         return true;
     }
 
@@ -200,12 +286,11 @@ public:
         m_finder._removeToken(upperPath);
         return true;
     }
-
 };
 
-IHIDListener* IHIDListenerNew(DeviceFinder& finder)
+std::unique_ptr<IHIDListener> IHIDListenerNew(DeviceFinder& finder)
 {
-    return new HIDListenerWinUSB(finder);
+    return std::make_unique<HIDListenerWinUSB>(finder);
 }
 
 }

lib/win/ApplicationWin32.cpp

@@ -528,7 +528,7 @@ static const DEV_BROADCAST_DEVICEINTERFACE HOTPLUG_CONF =
     sizeof(DEV_BROADCAST_DEVICEINTERFACE),
     DBT_DEVTYP_DEVICEINTERFACE,
     0,
-    GUID_DEVINTERFACE_USB_DEVICE
+    0
 };
 static bool HOTPLUG_REGISTERED = false;
 static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
@@ -536,7 +536,8 @@ static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM l
     if (!HOTPLUG_REGISTERED && uMsg == WM_CREATE)
     {
         /* Register hotplug notification with windows */
-        RegisterDeviceNotification(hwnd, (LPVOID)&HOTPLUG_CONF, DEVICE_NOTIFY_WINDOW_HANDLE);
+        RegisterDeviceNotification(hwnd, (LPVOID)&HOTPLUG_CONF,
+                                   DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
         HOTPLUG_REGISTERED = true;
     }
     return static_cast<boo::ApplicationWin32*>(boo::APP)->winHwndHandler(hwnd, uMsg, wParam, lParam);

test/main.cpp

@@ -38,7 +38,7 @@ class DualshockPadCallback : public IDualshockPadCallback
     {
         printf("CONTROLLER DISCONNECTED\n");
     }
-    void controllerUpdate(const DualshockPadState& state)
+    void controllerUpdate(DualshockPad& pad, const DualshockPadState& state)
     {
         static time_t timeTotal;
         static time_t lastTime = 0;
@@ -59,8 +59,8 @@ class DualshockPadCallback : public IDualshockPadCallback
         {
             if (timeDif >= 1) // wait 30 seconds before issuing another rumble event
             {
-                ctrl->startRumble(EDualshockMotor::Left);
+                pad.startRumble(EDualshockMotor::Left);
-                ctrl->startRumble(EDualshockMotor::Right, 100);
+                pad.startRumble(EDualshockMotor::Right, 100);
                 lastTime = timeTotal;
             }
         }