EnhancedRawInputWindows.h

// (c) 2025 by Lemontree Softworks - All Rights Reserved.
 
#pragma once
 
// A little bit hacky but Unreal only defines WINVER with 0x0601 (Windows 7), but for cfgmgr32 (Hotplug detection) we need at leat Windows 8
#if WINVER < 0x602 // Win8
    #undef WINVER
    #define WINVER 0x602
#endif
 
#include "Engine/Engine.h"
#include "Modules/ModuleManager.h"
#include "EnhancedRawInput.h"
#include "EnhancedRawInputSettings.h"
#include "Framework/Application/SlateApplication.h"
#include "Windows/WindowsApplication.h"
#include "hidsdi.h"
#include "cfgmgr32.h"

constexpr auto MaxHidDevices = 16;

constexpr auto MaxHidPovSwitches = 4;
 
// See https://learn.microsoft.com/en-us/windows-hardware/drivers/hid/hidclass-hardware-ids-for-top-level-collections
constexpr auto HidUsagePage = 0x01;
constexpr auto HardwareUsageJoystick = 0x04;
constexpr auto HardwareUsageGamepad = 0x05;
constexpr auto HidUsagePov = 0x39;
 
DECLARE_DELEGATE_OneParam(FHidDeviceConnectedDelegate, FString /* InterfaceName */);

struct FWindowsHidApi
{
public:
    typedef BOOLEAN(*HidD_GetSerialNumberString_Type)(HANDLE HidDeviceObject, PVOID Buffer, ULONG BufferLength);
    typedef BOOLEAN(*HidD_GetManufacturerString_Type)(HANDLE HidDeviceObject, PVOID Buffer, ULONG BufferLength);
    typedef BOOLEAN(*HidD_GetProductString_Type)(HANDLE HidDeviceObject, PVOID Buffer, ULONG BufferLength);
    typedef NTSTATUS(*HidP_GetCaps_Type)(PHIDP_PREPARSED_DATA PreparsedData, PHIDP_CAPS Capabilities);
    typedef NTSTATUS(*HidP_GetButtonCaps_Type)(HIDP_REPORT_TYPE ReportType, PHIDP_BUTTON_CAPS ButtonCaps, PUSHORT ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData);
    typedef NTSTATUS(*HidP_GetValueCaps_Type)(HIDP_REPORT_TYPE ReportType, PHIDP_VALUE_CAPS ValueCaps, PUSHORT ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData);
    typedef NTSTATUS(*HidP_GetUsages_Type)(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength);
    typedef NTSTATUS(*HidP_GetUsageValue_Type)(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, USAGE Usage, PULONG UsageValue,PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength); 
    typedef NTSTATUS(*HidP_GetData_Type)(HIDP_REPORT_TYPE ReportType, PHIDP_DATA DataList, PULONG DataLength, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength);
    
    FWindowsHidApi();
    ~FWindowsHidApi();
 
    HANDLE DllHandle = nullptr;
 
    HidD_GetSerialNumberString_Type HidD_GetSerialNumberString;
    HidD_GetManufacturerString_Type HidD_GetManufacturerString;
    HidD_GetProductString_Type HidD_GetProductString;
    HidP_GetCaps_Type HidP_GetCaps;
    HidP_GetButtonCaps_Type HidP_GetButtonCaps;
    HidP_GetValueCaps_Type HidP_GetValueCaps;
    HidP_GetUsages_Type HidP_GetUsages;
    HidP_GetUsageValue_Type HidP_GetUsageValue;
    HidP_GetData_Type HidP_GetData;
};

struct FHidAxis
{
    FHidAxis() :
        Value(0.0f),
        KeyName(NAME_None),
        bIsEnabled(false),
        OutputType(ERawInputAxisOutputType::Gamepad),
        Min(-1),
        Max(-1),
        Offset(0.0f),
        bIsInverted(false),
        bHasChanged(false)
    {}
    
    int32 Value;

    FName KeyName;

    bool bIsEnabled;

    ERawInputAxisOutputType OutputType;

    int32 Min;

    int32 Max;

    float Offset;

    bool bIsInverted;

    bool bHasChanged;

    float GetValue() const;

    bool HasValue() const;
};

struct FHidButton
{
    FHidButton() :
        bState(false),
        bHasChanged(false),
        KeyName(NAME_None),
        bIsEnabled(false)
    {}

    bool bState;

    bool bHasChanged;

    FName KeyName;

    bool bIsEnabled;
};

struct FHidPov : FHidAxis
{
    FHidPov() : DataIndex(0), PovOutputType(ERawInputPovOutputType::POV)
    {
        ButtonStates.Init(false, MaxHidPovSwitches);
        ButtonKeyNames.Init(NAME_None, MaxHidPovSwitches);
    }

    uint16 DataIndex;

    TArray<bool> ButtonStates;

    TArray<FName> ButtonKeyNames;

    ERawInputPovOutputType PovOutputType;

    int32 GetPovValueDeg() const;

    void UpdateButtonValues();

    float GetAxisValue() const;

    bool HasButtonValue(uint32 Index) const;

    bool HasAxisValue() const;
};

struct FHidDevice
{
    FHidDevice() :
        Handle(nullptr),
        DeviceInfo(0),
        ControllerId(0),
        NumberInputValueCaps(0),
        ButtonUsageMin(0),
        UserId(PLATFORMUSERID_NONE),
        DeviceId(INPUTDEVICEID_NONE),
        bIsActive(true),
        ConnectionState(EInputDeviceConnectionState::Invalid)
    {
    }

    HANDLE Handle;

    RID_DEVICE_INFO DeviceInfo;
    
    int32 ControllerId;

    int32 NumberInputValueCaps;
    
    FString InterfaceName;

    FString Manufacturer;

    FString SerialNumber;

    FString ProductName;

    uint32 ButtonUsageMin;

    FPlatformUserId UserId;

    FInputDeviceId  DeviceId;

    bool bIsActive;

    EInputDeviceConnectionState ConnectionState;

    TArray<FHidButton> Buttons;

    TMap<int32, FHidAxis> Axis;

    TArray<FHidPov> PoVs;
};

class FEnhancedRawInputWindows : public IEnhancedRawInput, IWindowsMessageHandler
{
    friend class UEnhancedRawInputSettings;
 
public:
    FEnhancedRawInputWindows(const TSharedRef<FGenericApplicationMessageHandler>& InMessageHandler);
    virtual ~FEnhancedRawInputWindows() override;
 
    // Begin IEnhancedRawInput
    virtual void SetBindings(const FString InterfaceName) override;
    virtual void SetAxisBinding(const FString InterfaceName, const int32 AxisUsage, const FName KeyName) override;
    virtual void SetButtonBinding(const FString InterfaceName, const int32 ButtonIndex, const FName KeyName) override;
    virtual void SetPovAxisBinding(const FString InterfaceName, const int32 PovIndex, FName KeyName) override;
    virtual void SetPovButtonBinding(const FString InterfaceName, const int32 PovIndex, TArray<FName> KeyNames) override;
    // End IEnhancedRawInput
 
    // Begin IInputDevice interface
    virtual void SetChannelValue(int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) override {}
    virtual void SetChannelValues(int32 ControllerId, const FForceFeedbackValues &Values) override {}
    virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override { return false; }
    virtual void SetMessageHandler(const TSharedRef<FGenericApplicationMessageHandler> &InMessageHandler) override;
    virtual void Tick(float DeltaTime) override;
    virtual void SendControllerEvents() override;
    virtual bool SupportsForceFeedback(int32 ControllerId) override { return false; }
    // End IInputDevice interface
 
    // Begin IWindowsMessageHandler interface
    virtual bool ProcessMessage(HWND Hwnd, uint32 Msg, WPARAM WParam, LPARAM LParam, int32& OutResult) override;
    // End IWindowsMessageHandler interface
    
    void EnumerateDevices();

    TArray<FHidDevice> GetConnectedDevices();

    FHidDevice *FindDeviceByUserAndDeviceId(const FPlatformUserId UserId, const FInputDeviceId DeviceId);

    FHidDevice* FindDeviceByInterfaceName(const FString& InterfaceName);

    TMap<int32, FHidAxis> GetAxisInfo(const FString& InterfaceName);

    TArray<FHidPov> GetPovInfo(const FString& InterfaceName);

    void SetDeviceActivity(const FString& InterfaceName, bool bIsActive);

    DWORD NotificationCallback(CM_NOTIFY_ACTION Action);

    FHidDeviceConnectedDelegate HidDeviceConnectedHandler;

    FHidDeviceConnectedDelegate HidDeviceDisconnectedHandler;
 
private:
    FWindowsHidApi HidApi;
    typedef CONFIGRET(*CM_Register_Notification_Type)(PCM_NOTIFY_FILTER pFilter, PVOID pContext, PCM_NOTIFY_CALLBACK pCallback, PHCMNOTIFICATION pNotifyContext);
 
    CM_Register_Notification_Type CmRegisterNotification;
    HANDLE Cfgmgr32DllHandle = nullptr;
    HCMNOTIFICATION NotifyContext;
 
    bool bRefreshDevices = false;
    FDateTime DeviceRefreshStart;
 
    bool bDeviceRegistered = false;
 
    FHidDevice HidDevices[MaxHidDevices];
    TArray<FString> ActualConnectedDevices;
    
    bool QueryDevices();
    void QueryDeviceCaps(FHidDevice &Device) const;
 
    FHidDevice *FindDeviceByHandle(HANDLE Handle);
    
    void ShowDebug(AHUD* HUD, UCanvas* Canvas, const FDebugDisplayInfo& DisplayInfo, float& YL, float& YPos);
 
    static bool TryRegisterInputDevice();
};
 
typedef FEnhancedRawInputWindows FPlatformEnhancedRawInput;