GameInputDeviceInfo

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GameInputUsage
{
    public ushort page;
    public ushort id;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GameInputVersion
{
    public ushort major;
    public ushort minor;
    public ushort build;
    public ushort revision;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct APP_LOCAL_DEVICE_ID
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] value;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GameInputDeviceInfo
{
    public uint infoSize;
    public ushort vendorId;
    public ushort productId;
    public ushort revisionNumber;
    public byte interfaceNumber;
    public byte collectionNumber;
    public GameInputUsage usage;
    public GameInputVersion hardwareVersion;
    public GameInputVersion firmwareVersion;
    public APP_LOCAL_DEVICE_ID deviceId;
    public APP_LOCAL_DEVICE_ID deviceRootId;
    public int deviceFamily;
    public int capabilities;
    public int supportedInput;
    public int supportedRumbleMotors;
    public uint inputReportCount;
    public uint outputReportCount;
    public uint featureReportCount;
    public uint controllerAxisCount;
    public uint controllerButtonCount;
    public uint controllerSwitchCount;
    public uint touchPointCount;
    public uint touchSensorCount;
    public uint forceFeedbackMotorCount;
    public uint hapticFeedbackMotorCount;
    public uint deviceStringCount;
    public uint deviceDescriptorSize;
    public IntPtr inputReportInfo;
    public IntPtr outputReportInfo;
    public IntPtr featureReportInfo;
    public IntPtr controllerAxisInfo;
    public IntPtr controllerButtonInfo;
    public IntPtr controllerSwitchInfo;
    public IntPtr keyboardInfo;
    public IntPtr mouseInfo;
    public IntPtr touchSensorInfo;
    public IntPtr motionInfo;
    public IntPtr arcadeStickInfo;
    public IntPtr flightStickInfo;
    public IntPtr gamepadInfo;
    public IntPtr racingWheelInfo;
    public IntPtr uiNavigationInfo;
    public IntPtr forceFeedbackMotorInfo;
    public IntPtr hapticFeedbackMotorInfo;
    public IntPtr displayName;
    public IntPtr deviceStrings;
    public IntPtr deviceDescriptorData;
    public int supportedSystemButtons;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GameInputUsage
    Public page As UShort
    Public id As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GameInputVersion
    Public major As UShort
    Public minor As UShort
    Public build As UShort
    Public revision As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure APP_LOCAL_DEVICE_ID
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public value() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GameInputDeviceInfo
    Public infoSize As UInteger
    Public vendorId As UShort
    Public productId As UShort
    Public revisionNumber As UShort
    Public interfaceNumber As Byte
    Public collectionNumber As Byte
    Public usage As GameInputUsage
    Public hardwareVersion As GameInputVersion
    Public firmwareVersion As GameInputVersion
    Public deviceId As APP_LOCAL_DEVICE_ID
    Public deviceRootId As APP_LOCAL_DEVICE_ID
    Public deviceFamily As Integer
    Public capabilities As Integer
    Public supportedInput As Integer
    Public supportedRumbleMotors As Integer
    Public inputReportCount As UInteger
    Public outputReportCount As UInteger
    Public featureReportCount As UInteger
    Public controllerAxisCount As UInteger
    Public controllerButtonCount As UInteger
    Public controllerSwitchCount As UInteger
    Public touchPointCount As UInteger
    Public touchSensorCount As UInteger
    Public forceFeedbackMotorCount As UInteger
    Public hapticFeedbackMotorCount As UInteger
    Public deviceStringCount As UInteger
    Public deviceDescriptorSize As UInteger
    Public inputReportInfo As IntPtr
    Public outputReportInfo As IntPtr
    Public featureReportInfo As IntPtr
    Public controllerAxisInfo As IntPtr
    Public controllerButtonInfo As IntPtr
    Public controllerSwitchInfo As IntPtr
    Public keyboardInfo As IntPtr
    Public mouseInfo As IntPtr
    Public touchSensorInfo As IntPtr
    Public motionInfo As IntPtr
    Public arcadeStickInfo As IntPtr
    Public flightStickInfo As IntPtr
    Public gamepadInfo As IntPtr
    Public racingWheelInfo As IntPtr
    Public uiNavigationInfo As IntPtr
    Public forceFeedbackMotorInfo As IntPtr
    Public hapticFeedbackMotorInfo As IntPtr
    Public displayName As IntPtr
    Public deviceStrings As IntPtr
    Public deviceDescriptorData As IntPtr
    Public supportedSystemButtons As Integer
End Structure

import ctypes
from ctypes import wintypes

class GameInputUsage(ctypes.Structure):
    _fields_ = [
        ("page", ctypes.c_ushort),
        ("id", ctypes.c_ushort),
    ]

class GameInputVersion(ctypes.Structure):
    _fields_ = [
        ("major", ctypes.c_ushort),
        ("minor", ctypes.c_ushort),
        ("build", ctypes.c_ushort),
        ("revision", ctypes.c_ushort),
    ]

class APP_LOCAL_DEVICE_ID(ctypes.Structure):
    _fields_ = [
        ("value", ctypes.c_ubyte * 32),
    ]

class GameInputDeviceInfo(ctypes.Structure):
    _fields_ = [
        ("infoSize", wintypes.DWORD),
        ("vendorId", ctypes.c_ushort),
        ("productId", ctypes.c_ushort),
        ("revisionNumber", ctypes.c_ushort),
        ("interfaceNumber", ctypes.c_ubyte),
        ("collectionNumber", ctypes.c_ubyte),
        ("usage", GameInputUsage),
        ("hardwareVersion", GameInputVersion),
        ("firmwareVersion", GameInputVersion),
        ("deviceId", APP_LOCAL_DEVICE_ID),
        ("deviceRootId", APP_LOCAL_DEVICE_ID),
        ("deviceFamily", ctypes.c_int),
        ("capabilities", ctypes.c_int),
        ("supportedInput", ctypes.c_int),
        ("supportedRumbleMotors", ctypes.c_int),
        ("inputReportCount", wintypes.DWORD),
        ("outputReportCount", wintypes.DWORD),
        ("featureReportCount", wintypes.DWORD),
        ("controllerAxisCount", wintypes.DWORD),
        ("controllerButtonCount", wintypes.DWORD),
        ("controllerSwitchCount", wintypes.DWORD),
        ("touchPointCount", wintypes.DWORD),
        ("touchSensorCount", wintypes.DWORD),
        ("forceFeedbackMotorCount", wintypes.DWORD),
        ("hapticFeedbackMotorCount", wintypes.DWORD),
        ("deviceStringCount", wintypes.DWORD),
        ("deviceDescriptorSize", wintypes.DWORD),
        ("inputReportInfo", ctypes.c_void_p),
        ("outputReportInfo", ctypes.c_void_p),
        ("featureReportInfo", ctypes.c_void_p),
        ("controllerAxisInfo", ctypes.c_void_p),
        ("controllerButtonInfo", ctypes.c_void_p),
        ("controllerSwitchInfo", ctypes.c_void_p),
        ("keyboardInfo", ctypes.c_void_p),
        ("mouseInfo", ctypes.c_void_p),
        ("touchSensorInfo", ctypes.c_void_p),
        ("motionInfo", ctypes.c_void_p),
        ("arcadeStickInfo", ctypes.c_void_p),
        ("flightStickInfo", ctypes.c_void_p),
        ("gamepadInfo", ctypes.c_void_p),
        ("racingWheelInfo", ctypes.c_void_p),
        ("uiNavigationInfo", ctypes.c_void_p),
        ("forceFeedbackMotorInfo", ctypes.c_void_p),
        ("hapticFeedbackMotorInfo", ctypes.c_void_p),
        ("displayName", ctypes.c_void_p),
        ("deviceStrings", ctypes.c_void_p),
        ("deviceDescriptorData", ctypes.c_void_p),
        ("supportedSystemButtons", ctypes.c_int),
    ]

#[repr(C)]
pub struct GameInputUsage {
    pub page: u16,
    pub id: u16,
}

#[repr(C)]
pub struct GameInputVersion {
    pub major: u16,
    pub minor: u16,
    pub build: u16,
    pub revision: u16,
}

#[repr(C)]
pub struct APP_LOCAL_DEVICE_ID {
    pub value: [u8; 32],
}

#[repr(C)]
pub struct GameInputDeviceInfo {
    pub infoSize: u32,
    pub vendorId: u16,
    pub productId: u16,
    pub revisionNumber: u16,
    pub interfaceNumber: u8,
    pub collectionNumber: u8,
    pub usage: GameInputUsage,
    pub hardwareVersion: GameInputVersion,
    pub firmwareVersion: GameInputVersion,
    pub deviceId: APP_LOCAL_DEVICE_ID,
    pub deviceRootId: APP_LOCAL_DEVICE_ID,
    pub deviceFamily: i32,
    pub capabilities: i32,
    pub supportedInput: i32,
    pub supportedRumbleMotors: i32,
    pub inputReportCount: u32,
    pub outputReportCount: u32,
    pub featureReportCount: u32,
    pub controllerAxisCount: u32,
    pub controllerButtonCount: u32,
    pub controllerSwitchCount: u32,
    pub touchPointCount: u32,
    pub touchSensorCount: u32,
    pub forceFeedbackMotorCount: u32,
    pub hapticFeedbackMotorCount: u32,
    pub deviceStringCount: u32,
    pub deviceDescriptorSize: u32,
    pub inputReportInfo: *mut core::ffi::c_void,
    pub outputReportInfo: *mut core::ffi::c_void,
    pub featureReportInfo: *mut core::ffi::c_void,
    pub controllerAxisInfo: *mut core::ffi::c_void,
    pub controllerButtonInfo: *mut core::ffi::c_void,
    pub controllerSwitchInfo: *mut core::ffi::c_void,
    pub keyboardInfo: *mut core::ffi::c_void,
    pub mouseInfo: *mut core::ffi::c_void,
    pub touchSensorInfo: *mut core::ffi::c_void,
    pub motionInfo: *mut core::ffi::c_void,
    pub arcadeStickInfo: *mut core::ffi::c_void,
    pub flightStickInfo: *mut core::ffi::c_void,
    pub gamepadInfo: *mut core::ffi::c_void,
    pub racingWheelInfo: *mut core::ffi::c_void,
    pub uiNavigationInfo: *mut core::ffi::c_void,
    pub forceFeedbackMotorInfo: *mut core::ffi::c_void,
    pub hapticFeedbackMotorInfo: *mut core::ffi::c_void,
    pub displayName: *mut core::ffi::c_void,
    pub deviceStrings: *mut core::ffi::c_void,
    pub deviceDescriptorData: *mut core::ffi::c_void,
    pub supportedSystemButtons: i32,
}

import "golang.org/x/sys/windows"

type GameInputUsage struct {
	page uint16
	id uint16
}

type GameInputVersion struct {
	major uint16
	minor uint16
	build uint16
	revision uint16
}

type APP_LOCAL_DEVICE_ID struct {
	value [32]byte
}

type GameInputDeviceInfo struct {
	infoSize uint32
	vendorId uint16
	productId uint16
	revisionNumber uint16
	interfaceNumber byte
	collectionNumber byte
	usage GameInputUsage
	hardwareVersion GameInputVersion
	firmwareVersion GameInputVersion
	deviceId APP_LOCAL_DEVICE_ID
	deviceRootId APP_LOCAL_DEVICE_ID
	deviceFamily int32
	capabilities int32
	supportedInput int32
	supportedRumbleMotors int32
	inputReportCount uint32
	outputReportCount uint32
	featureReportCount uint32
	controllerAxisCount uint32
	controllerButtonCount uint32
	controllerSwitchCount uint32
	touchPointCount uint32
	touchSensorCount uint32
	forceFeedbackMotorCount uint32
	hapticFeedbackMotorCount uint32
	deviceStringCount uint32
	deviceDescriptorSize uint32
	inputReportInfo uintptr
	outputReportInfo uintptr
	featureReportInfo uintptr
	controllerAxisInfo uintptr
	controllerButtonInfo uintptr
	controllerSwitchInfo uintptr
	keyboardInfo uintptr
	mouseInfo uintptr
	touchSensorInfo uintptr
	motionInfo uintptr
	arcadeStickInfo uintptr
	flightStickInfo uintptr
	gamepadInfo uintptr
	racingWheelInfo uintptr
	uiNavigationInfo uintptr
	forceFeedbackMotorInfo uintptr
	hapticFeedbackMotorInfo uintptr
	displayName uintptr
	deviceStrings uintptr
	deviceDescriptorData uintptr
	supportedSystemButtons int32
}

type
  GameInputUsage = record
    page: Word;
    id: Word;
  end;

  GameInputVersion = record
    major: Word;
    minor: Word;
    build: Word;
    revision: Word;
  end;

  APP_LOCAL_DEVICE_ID = record
    value: array[0..31] of Byte;
  end;

  GameInputDeviceInfo = record
    infoSize: DWORD;
    vendorId: Word;
    productId: Word;
    revisionNumber: Word;
    interfaceNumber: Byte;
    collectionNumber: Byte;
    usage: GameInputUsage;
    hardwareVersion: GameInputVersion;
    firmwareVersion: GameInputVersion;
    deviceId: APP_LOCAL_DEVICE_ID;
    deviceRootId: APP_LOCAL_DEVICE_ID;
    deviceFamily: Integer;
    capabilities: Integer;
    supportedInput: Integer;
    supportedRumbleMotors: Integer;
    inputReportCount: DWORD;
    outputReportCount: DWORD;
    featureReportCount: DWORD;
    controllerAxisCount: DWORD;
    controllerButtonCount: DWORD;
    controllerSwitchCount: DWORD;
    touchPointCount: DWORD;
    touchSensorCount: DWORD;
    forceFeedbackMotorCount: DWORD;
    hapticFeedbackMotorCount: DWORD;
    deviceStringCount: DWORD;
    deviceDescriptorSize: DWORD;
    inputReportInfo: Pointer;
    outputReportInfo: Pointer;
    featureReportInfo: Pointer;
    controllerAxisInfo: Pointer;
    controllerButtonInfo: Pointer;
    controllerSwitchInfo: Pointer;
    keyboardInfo: Pointer;
    mouseInfo: Pointer;
    touchSensorInfo: Pointer;
    motionInfo: Pointer;
    arcadeStickInfo: Pointer;
    flightStickInfo: Pointer;
    gamepadInfo: Pointer;
    racingWheelInfo: Pointer;
    uiNavigationInfo: Pointer;
    forceFeedbackMotorInfo: Pointer;
    hapticFeedbackMotorInfo: Pointer;
    displayName: Pointer;
    deviceStrings: Pointer;
    deviceDescriptorData: Pointer;
    supportedSystemButtons: Integer;
  end;

const GameInputUsage = extern struct {
    page: u16,
    id: u16,
};

const GameInputVersion = extern struct {
    major: u16,
    minor: u16,
    build: u16,
    revision: u16,
};

const APP_LOCAL_DEVICE_ID = extern struct {
    value: [32]u8,
};

const GameInputDeviceInfo = extern struct {
    infoSize: u32,
    vendorId: u16,
    productId: u16,
    revisionNumber: u16,
    interfaceNumber: u8,
    collectionNumber: u8,
    usage: GameInputUsage,
    hardwareVersion: GameInputVersion,
    firmwareVersion: GameInputVersion,
    deviceId: APP_LOCAL_DEVICE_ID,
    deviceRootId: APP_LOCAL_DEVICE_ID,
    deviceFamily: i32,
    capabilities: i32,
    supportedInput: i32,
    supportedRumbleMotors: i32,
    inputReportCount: u32,
    outputReportCount: u32,
    featureReportCount: u32,
    controllerAxisCount: u32,
    controllerButtonCount: u32,
    controllerSwitchCount: u32,
    touchPointCount: u32,
    touchSensorCount: u32,
    forceFeedbackMotorCount: u32,
    hapticFeedbackMotorCount: u32,
    deviceStringCount: u32,
    deviceDescriptorSize: u32,
    inputReportInfo: ?*anyopaque,
    outputReportInfo: ?*anyopaque,
    featureReportInfo: ?*anyopaque,
    controllerAxisInfo: ?*anyopaque,
    controllerButtonInfo: ?*anyopaque,
    controllerSwitchInfo: ?*anyopaque,
    keyboardInfo: ?*anyopaque,
    mouseInfo: ?*anyopaque,
    touchSensorInfo: ?*anyopaque,
    motionInfo: ?*anyopaque,
    arcadeStickInfo: ?*anyopaque,
    flightStickInfo: ?*anyopaque,
    gamepadInfo: ?*anyopaque,
    racingWheelInfo: ?*anyopaque,
    uiNavigationInfo: ?*anyopaque,
    forceFeedbackMotorInfo: ?*anyopaque,
    hapticFeedbackMotorInfo: ?*anyopaque,
    displayName: ?*anyopaque,
    deviceStrings: ?*anyopaque,
    deviceDescriptorData: ?*anyopaque,
    supportedSystemButtons: i32,
};

type
  GameInputUsage {.bycopy.} = object
    page: uint16
    id: uint16

  GameInputVersion {.bycopy.} = object
    major: uint16
    minor: uint16
    build: uint16
    revision: uint16

  APP_LOCAL_DEVICE_ID {.bycopy.} = object
    value: array[32, uint8]

  GameInputDeviceInfo {.bycopy.} = object
    infoSize: uint32
    vendorId: uint16
    productId: uint16
    revisionNumber: uint16
    interfaceNumber: uint8
    collectionNumber: uint8
    usage: GameInputUsage
    hardwareVersion: GameInputVersion
    firmwareVersion: GameInputVersion
    deviceId: APP_LOCAL_DEVICE_ID
    deviceRootId: APP_LOCAL_DEVICE_ID
    deviceFamily: int32
    capabilities: int32
    supportedInput: int32
    supportedRumbleMotors: int32
    inputReportCount: uint32
    outputReportCount: uint32
    featureReportCount: uint32
    controllerAxisCount: uint32
    controllerButtonCount: uint32
    controllerSwitchCount: uint32
    touchPointCount: uint32
    touchSensorCount: uint32
    forceFeedbackMotorCount: uint32
    hapticFeedbackMotorCount: uint32
    deviceStringCount: uint32
    deviceDescriptorSize: uint32
    inputReportInfo: pointer
    outputReportInfo: pointer
    featureReportInfo: pointer
    controllerAxisInfo: pointer
    controllerButtonInfo: pointer
    controllerSwitchInfo: pointer
    keyboardInfo: pointer
    mouseInfo: pointer
    touchSensorInfo: pointer
    motionInfo: pointer
    arcadeStickInfo: pointer
    flightStickInfo: pointer
    gamepadInfo: pointer
    racingWheelInfo: pointer
    uiNavigationInfo: pointer
    forceFeedbackMotorInfo: pointer
    hapticFeedbackMotorInfo: pointer
    displayName: pointer
    deviceStrings: pointer
    deviceDescriptorData: pointer
    supportedSystemButtons: int32

struct GameInputUsage
{
    ushort page;
    ushort id;
}

struct GameInputVersion
{
    ushort major;
    ushort minor;
    ushort build;
    ushort revision;
}

struct APP_LOCAL_DEVICE_ID
{
    ubyte[32] value;
}

struct GameInputDeviceInfo
{
    uint infoSize;
    ushort vendorId;
    ushort productId;
    ushort revisionNumber;
    ubyte interfaceNumber;
    ubyte collectionNumber;
    GameInputUsage usage;
    GameInputVersion hardwareVersion;
    GameInputVersion firmwareVersion;
    APP_LOCAL_DEVICE_ID deviceId;
    APP_LOCAL_DEVICE_ID deviceRootId;
    int deviceFamily;
    int capabilities;
    int supportedInput;
    int supportedRumbleMotors;
    uint inputReportCount;
    uint outputReportCount;
    uint featureReportCount;
    uint controllerAxisCount;
    uint controllerButtonCount;
    uint controllerSwitchCount;
    uint touchPointCount;
    uint touchSensorCount;
    uint forceFeedbackMotorCount;
    uint hapticFeedbackMotorCount;
    uint deviceStringCount;
    uint deviceDescriptorSize;
    void* inputReportInfo;
    void* outputReportInfo;
    void* featureReportInfo;
    void* controllerAxisInfo;
    void* controllerButtonInfo;
    void* controllerSwitchInfo;
    void* keyboardInfo;
    void* mouseInfo;
    void* touchSensorInfo;
    void* motionInfo;
    void* arcadeStickInfo;
    void* flightStickInfo;
    void* gamepadInfo;
    void* racingWheelInfo;
    void* uiNavigationInfo;
    void* forceFeedbackMotorInfo;
    void* hapticFeedbackMotorInfo;
    void* displayName;
    void* deviceStrings;
    void* deviceDescriptorData;
    int supportedSystemButtons;
}