Test

Source/SkyPortal/Private/SkyPortalSubsystem.cpp

@@ -1,16 +1,20 @@
 #include "SkyPortalSubsystem.h"
 #include "Engine/Engine.h"
+#include "hidapi.h"
 
 void USkyPortalSubsystem::Initialize(FSubsystemCollectionBase& Collection)
 {
 	Super::Initialize(Collection);
 	// Custom initialization logic
 	UE_LOG(LogTemp, Warning, TEXT("SkyPortalSubsystem Initialized"));
+
+
 }
 
 void USkyPortalSubsystem::Deinitialize()
 {
 	// Custom cleanup logic
+	hid_exit();
 	UE_LOG(LogTemp, Warning, TEXT("SkyPortalSubsystem Deinitialized"));
 	Super::Deinitialize();
 }

Source/SkyPortal/SkyPortal.Build.cs

@@ -1,5 +1,6 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
+using System.IO;
 using UnrealBuildTool;
 
 public class SkyPortal : ModuleRules
@@ -7,11 +8,42 @@ public class SkyPortal : ModuleRules
     public SkyPortal(ReadOnlyTargetRules Target) : base(Target)
     {
         PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+        bEnableUndefinedIdentifierWarnings = false;
+        CppStandard = CppStandardVersion.Cpp17;
+
+        IsRedistributableOverride = true; ;
+        bLegalToDistributeObjectCode = true;
+        bPrecompile = true;
+        PrecompileForTargets = PrecompileTargetsType.Any;
+
+        if (Target.Platform == UnrealTargetPlatform.Linux)
+        {
+            PublicIncludePaths.AddRange(new[] {
+                "/usr/include",
+                "/usr/include/x86_64-linux-gnu"
+            });
+            PublicSystemLibraries.Add("udev"); // Link with libudev on Linux
+            PublicSystemLibraryPaths.AddRange(new[] {
+                "/usr/lib",
+                "/usr/lib/x86_64-linux-gnu",
+                "/usr/lib/aarch64-linux-gnu",
+                "/usr/local/lib",
+                "/usr/local/lib/x86_64-linux-gnu",
+                "/usr/local/lib/aarch64-linux-gnu"
+            });
+        }
+        else if (Target.Platform == UnrealTargetPlatform.Win64)
+        {
+            PublicAdditionalLibraries.Add("hid.lib");  // Use Windows HID library
+        }
+
+        string HIDAPIPath = Path.Combine(ModuleDirectory, "../../ThirdParty/hidapi/include");
+
 
         PublicIncludePaths.AddRange(
             new string[] {
-				// ... add public include paths required here ...
+                HIDAPIPath,
-			}
+    }
             );
 
 

ThirdParty/hidapi/include/Linux/hid.cpp

@@ -0,0 +1,896 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        https://github.com/libusb/hidapi .
+********************************************************/
+
+#include "CoreMinimal.h"
+
+#if PLATFORM_LINUX
+/**
+ * Hack: We need to wrap these includes within an
+ *       anonymous namespace to work around an
+ *       unreal engine bug.
+ * 
+ * Bug: Unreal is getting confused between its reference to
+ * "Engine/Source/ThirdParty/Linux/LibCxx/include/c++/v1/"
+ *  and
+ * "Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux/Linux_x64/v19_clang..."
+ * for includes such as 'locale.h'
+ */
+namespace
+{
+#ifdef LINUX_VERSION_CODE
+#undef LINUX_VERSION_CODE
+#endif
+#ifdef KERNEL_VERSION
+#undef KERNEL_VERSION
+#endif
+
+
+/**
+ * Hack: We need to wrap these includes within an
+ *       anonymous namespace to work around an
+ *       unreal engine bug.
+ * 
+ * Bug: Unreal is getting confused between its reference to
+ * "Engine/Source/ThirdParty/Linux/LibCxx/include/c++/v1/"
+ *  and
+ * "Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux/Linux_x64/v19_clang..."
+ * for includes such as 'locale.h'
+ */
+namespace {
+#ifdef LINUX_VERSION_CODE
+#undef LINUX_VERSION_CODE
+#endif
+#ifdef KERNEL_VERSION
+#undef KERNEL_VERSION
+#endif
+
+/* C */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <errno.h>
+
+/* Unix */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <poll.h>
+
+/* Linux */
+#include <linux/hidraw.h>
+#include <linux/version.h>
+#include <linux/input.h>
+#include <libudev.h>
+}
+
+} // namespace
+
+#include "hidapi.h"
+
+
+/* USB HID device property names */
+const char *device_string_names[] = {
+	"manufacturer",
+	"product",
+	"serial",
+};
+
+/* Symbolic names for the properties above */
+enum device_string_id {
+	DEVICE_STRING_MANUFACTURER,
+	DEVICE_STRING_PRODUCT,
+	DEVICE_STRING_SERIAL,
+
+	DEVICE_STRING_COUNT,
+};
+
+struct hid_device_ {
+	int device_handle;
+	int blocking;
+	int uses_numbered_reports;
+	wchar_t *last_error_str;
+};
+
+/* Global error message that is not specific to a device, e.g. for
+   hid_open(). It is thread-local like errno. */
+__thread wchar_t *last_global_error_str = NULL;
+
+static hid_device *new_hid_device(void)
+{
+	hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
+	dev->device_handle = -1;
+	dev->blocking = 1;
+	dev->uses_numbered_reports = 0;
+	dev->last_error_str = NULL;
+
+	return dev;
+}
+
+
+/* The caller must free the returned string with free(). */
+static wchar_t *utf8_to_wchar_t(const char *utf8)
+{
+	wchar_t *ret = NULL;
+
+	if (utf8) {
+		size_t wlen = mbstowcs(NULL, utf8, 0);
+		if ((size_t) -1 == wlen) {
+			return wcsdup(L"");
+		}
+		ret = (wchar_t*) calloc(wlen+1, sizeof(wchar_t));
+		mbstowcs(ret, utf8, wlen+1);
+		ret[wlen] = 0x0000;
+	}
+
+	return ret;
+}
+
+
+/* Set the last global error to be reported by hid_error(NULL).
+ * The given error message will be copied (and decoded according to the
+ * currently locale, so do not pass in string constants).
+ * The last stored global error message is freed.
+ * Use register_global_error(NULL) to indicate "no error". */
+static void register_global_error(const char *msg)
+{
+	if (last_global_error_str)
+		free(last_global_error_str);
+
+	last_global_error_str = utf8_to_wchar_t(msg);
+}
+
+
+/* Set the last error for a device to be reported by hid_error(device).
+ * The given error message will be copied (and decoded according to the
+ * currently locale, so do not pass in string constants).
+ * The last stored global error message is freed.
+ * Use register_device_error(device, NULL) to indicate "no error". */
+static void register_device_error(hid_device *dev, const char *msg)
+{
+	if (dev->last_error_str)
+		free(dev->last_error_str);
+
+	dev->last_error_str = utf8_to_wchar_t(msg);
+}
+
+/* See register_device_error, but you can pass a format string into this function. */
+static void register_device_error_format(hid_device *dev, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+
+	char msg[100];
+	vsnprintf(msg, sizeof(msg), format, args);
+
+	va_end(args);
+
+	register_device_error(dev, msg);
+}
+
+/* Get an attribute value from a udev_device and return it as a whar_t
+   string. The returned string must be freed with free() when done.*/
+static wchar_t *copy_udev_string(struct udev_device *dev, const char *udev_name)
+{
+	return utf8_to_wchar_t(udev_device_get_sysattr_value(dev, udev_name));
+}
+
+/* uses_numbered_reports() returns 1 if report_descriptor describes a device
+   which contains numbered reports. */
+static int uses_numbered_reports(__u8 *report_descriptor, __u32 size) {
+	unsigned int i = 0;
+	int size_code;
+	int data_len, key_size;
+
+	while (i < size) {
+		int key = report_descriptor[i];
+
+		/* Check for the Report ID key */
+		if (key == 0x85/*Report ID*/) {
+			/* This device has a Report ID, which means it uses
+			   numbered reports. */
+			return 1;
+		}
+
+		//printf("key: %02hhx\n", key);
+
+		if ((key & 0xf0) == 0xf0) {
+			/* This is a Long Item. The next byte contains the
+			   length of the data section (value) for this key.
+			   See the HID specification, version 1.11, section
+			   6.2.2.3, titled "Long Items." */
+			if (i+1 < size)
+				data_len = report_descriptor[i+1];
+			else
+				data_len = 0; /* malformed report */
+			key_size = 3;
+		}
+		else {
+			/* This is a Short Item. The bottom two bits of the
+			   key contain the size code for the data section
+			   (value) for this key.  Refer to the HID
+			   specification, version 1.11, section 6.2.2.2,
+			   titled "Short Items." */
+			size_code = key & 0x3;
+			switch (size_code) {
+			case 0:
+			case 1:
+			case 2:
+				data_len = size_code;
+				break;
+			case 3:
+				data_len = 4;
+				break;
+			default:
+				/* Can't ever happen since size_code is & 0x3 */
+				data_len = 0;
+				break;
+			};
+			key_size = 1;
+		}
+
+		/* Skip over this key and it's associated data */
+		i += data_len + key_size;
+	}
+
+	/* Didn't find a Report ID key. Device doesn't use numbered reports. */
+	return 0;
+}
+
+/*
+ * The caller is responsible for free()ing the (newly-allocated) character
+ * strings pointed to by serial_number_utf8 and product_name_utf8 after use.
+ */
+static int
+parse_uevent_info(const char *uevent, int *bus_type,
+	unsigned short *vendor_id, unsigned short *product_id,
+	char **serial_number_utf8, char **product_name_utf8)
+{
+	char *tmp = strdup(uevent);
+	char *saveptr = NULL;
+	char *line;
+	char *key;
+	char *value;
+
+	int found_id = 0;
+	int found_serial = 0;
+	int found_name = 0;
+
+	line = strtok_r(tmp, "\n", &saveptr);
+	while (line != NULL) {
+		/* line: "KEY=value" */
+		key = line;
+		value = strchr(line, '=');
+		if (!value) {
+			goto next_line;
+		}
+		*value = '\0';
+		value++;
+
+		if (strcmp(key, "HID_ID") == 0) {
+			/**
+			 *        type vendor   product
+			 * HID_ID=0003:000005AC:00008242
+			 **/
+			int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
+			if (ret == 3) {
+				found_id = 1;
+			}
+		} else if (strcmp(key, "HID_NAME") == 0) {
+			/* The caller has to free the product name */
+			*product_name_utf8 = strdup(value);
+			found_name = 1;
+		} else if (strcmp(key, "HID_UNIQ") == 0) {
+			/* The caller has to free the serial number */
+			*serial_number_utf8 = strdup(value);
+			found_serial = 1;
+		}
+
+next_line:
+		line = strtok_r(NULL, "\n", &saveptr);
+	}
+
+	free(tmp);
+	return (found_id && found_name && found_serial);
+}
+
+
+static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen)
+{
+	struct udev *udev;
+	struct udev_device *udev_dev, *parent, *hid_dev;
+	struct stat s;
+	int ret = -1;
+        char *serial_number_utf8 = NULL;
+        char *product_name_utf8 = NULL;
+
+	/* Create the udev object */
+	udev = udev_new();
+	if (!udev) {
+		register_global_error("Couldn't create udev context");
+		return -1;
+	}
+
+	/* Get the dev_t (major/minor numbers) from the file handle. */
+	ret = fstat(dev->device_handle, &s);
+	if (-1 == ret)
+		return ret;
+	/* Open a udev device from the dev_t. 'c' means character device. */
+	udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
+	if (udev_dev) {
+		hid_dev = udev_device_get_parent_with_subsystem_devtype(
+			udev_dev,
+			"hid",
+			NULL);
+		if (hid_dev) {
+			unsigned short dev_vid;
+			unsigned short dev_pid;
+			int bus_type;
+			size_t retm;
+
+			ret = parse_uevent_info(
+			           udev_device_get_sysattr_value(hid_dev, "uevent"),
+			           &bus_type,
+			           &dev_vid,
+			           &dev_pid,
+			           &serial_number_utf8,
+			           &product_name_utf8);
+
+			if (bus_type == BUS_BLUETOOTH) {
+				switch (key) {
+					case DEVICE_STRING_MANUFACTURER:
+						wcsncpy(string, L"", maxlen);
+						ret = 0;
+						break;
+					case DEVICE_STRING_PRODUCT:
+						retm = mbstowcs(string, product_name_utf8, maxlen);
+						ret = (retm == (size_t)-1)? -1: 0;
+						break;
+					case DEVICE_STRING_SERIAL:
+						retm = mbstowcs(string, serial_number_utf8, maxlen);
+						ret = (retm == (size_t)-1)? -1: 0;
+						break;
+					case DEVICE_STRING_COUNT:
+					default:
+						ret = -1;
+						break;
+				}
+			}
+			else {
+				/* This is a USB device. Find its parent USB Device node. */
+				parent = udev_device_get_parent_with_subsystem_devtype(
+					   udev_dev,
+					   "usb",
+					   "usb_device");
+				if (parent) {
+					const char *str;
+					const char *key_str = NULL;
+
+					if (key >= 0 && key < DEVICE_STRING_COUNT) {
+						key_str = device_string_names[key];
+					} else {
+						ret = -1;
+						goto end;
+					}
+
+					str = udev_device_get_sysattr_value(parent, key_str);
+					if (str) {
+						/* Convert the string from UTF-8 to wchar_t */
+						retm = mbstowcs(string, str, maxlen);
+						ret = (retm == (size_t)-1)? -1: 0;
+						goto end;
+					}
+				}
+			}
+		}
+	}
+
+end:
+        free(serial_number_utf8);
+        free(product_name_utf8);
+
+	udev_device_unref(udev_dev);
+	/* parent and hid_dev don't need to be (and can't be) unref'd.
+	   I'm not sure why, but they'll throw double-free() errors. */
+	udev_unref(udev);
+
+	return ret;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+	const char *locale;
+
+	/* Set the locale if it's not set. */
+	locale = setlocale(LC_CTYPE, NULL);
+	if (!locale)
+		setlocale(LC_CTYPE, "");
+
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	/* Free global error message */
+	register_global_error(NULL);
+
+	return 0;
+}
+
+
+struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	struct udev *udev;
+	struct udev_enumerate *enumerate;
+	struct udev_list_entry *devices, *dev_list_entry;
+
+	struct hid_device_info *root = NULL; /* return object */
+	struct hid_device_info *cur_dev = NULL;
+	struct hid_device_info *prev_dev = NULL; /* previous device */
+
+	hid_init();
+
+	/* Create the udev object */
+	udev = udev_new();
+	if (!udev) {
+		register_global_error("Couldn't create udev context");
+		return NULL;
+	}
+
+	/* Create a list of the devices in the 'hidraw' subsystem. */
+	enumerate = udev_enumerate_new(udev);
+	udev_enumerate_add_match_subsystem(enumerate, "hidraw");
+	udev_enumerate_scan_devices(enumerate);
+	devices = udev_enumerate_get_list_entry(enumerate);
+	/* For each item, see if it matches the vid/pid, and if so
+	   create a udev_device record for it */
+	udev_list_entry_foreach(dev_list_entry, devices) {
+		const char *sysfs_path;
+		const char *dev_path;
+		const char *str;
+		struct udev_device *raw_dev; /* The device's hidraw udev node. */
+		struct udev_device *hid_dev; /* The device's HID udev node. */
+		struct udev_device *usb_dev; /* The device's USB udev node. */
+		struct udev_device *intf_dev; /* The device's interface (in the USB sense). */
+		unsigned short dev_vid;
+		unsigned short dev_pid;
+		char *serial_number_utf8 = NULL;
+		char *product_name_utf8 = NULL;
+		int bus_type;
+		int result;
+
+		/* Get the filename of the /sys entry for the device
+		   and create a udev_device object (dev) representing it */
+		sysfs_path = udev_list_entry_get_name(dev_list_entry);
+		raw_dev = udev_device_new_from_syspath(udev, sysfs_path);
+		dev_path = udev_device_get_devnode(raw_dev);
+
+		hid_dev = udev_device_get_parent_with_subsystem_devtype(
+			raw_dev,
+			"hid",
+			NULL);
+
+		if (!hid_dev) {
+			/* Unable to find parent hid device. */
+			goto next;
+		}
+
+		result = parse_uevent_info(
+			udev_device_get_sysattr_value(hid_dev, "uevent"),
+			&bus_type,
+			&dev_vid,
+			&dev_pid,
+			&serial_number_utf8,
+			&product_name_utf8);
+
+		if (!result) {
+			/* parse_uevent_info() failed for at least one field. */
+			goto next;
+		}
+
+		if (bus_type != BUS_USB && bus_type != BUS_BLUETOOTH) {
+			/* We only know how to handle USB and BT devices. */
+			goto next;
+		}
+
+		/* Check the VID/PID against the arguments */
+		if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+		    (product_id == 0x0 || product_id == dev_pid)) {
+			struct hid_device_info *tmp;
+
+			/* VID/PID match. Create the record. */
+			tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			prev_dev = cur_dev;
+			cur_dev = tmp;
+
+			/* Fill out the record */
+			cur_dev->next = NULL;
+			cur_dev->path = dev_path? strdup(dev_path): NULL;
+
+			/* VID/PID */
+			cur_dev->vendor_id = dev_vid;
+			cur_dev->product_id = dev_pid;
+
+			/* Serial Number */
+			cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
+
+			/* Release Number */
+			cur_dev->release_number = 0x0;
+
+			/* Interface Number */
+			cur_dev->interface_number = -1;
+
+			switch (bus_type) {
+				case BUS_USB:
+					/* The device pointed to by raw_dev contains information about
+					   the hidraw device. In order to get information about the
+					   USB device, get the parent device with the
+					   subsystem/devtype pair of "usb"/"usb_device". This will
+					   be several levels up the tree, but the function will find
+					   it. */
+					usb_dev = udev_device_get_parent_with_subsystem_devtype(
+							raw_dev,
+							"usb",
+							"usb_device");
+
+					if (!usb_dev) {
+						/* Free this device */
+						free(cur_dev->serial_number);
+						free(cur_dev->path);
+						free(cur_dev);
+
+						/* Take it off the device list. */
+						if (prev_dev) {
+							prev_dev->next = NULL;
+							cur_dev = prev_dev;
+						}
+						else {
+							cur_dev = root = NULL;
+						}
+
+						goto next;
+					}
+
+					/* Manufacturer and Product strings */
+					cur_dev->manufacturer_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_MANUFACTURER]);
+					cur_dev->product_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_PRODUCT]);
+
+					/* Release Number */
+					str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
+					cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
+
+					/* Get a handle to the interface's udev node. */
+					intf_dev = udev_device_get_parent_with_subsystem_devtype(
+							raw_dev,
+							"usb",
+							"usb_interface");
+					if (intf_dev) {
+						str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
+						cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
+					}
+
+					break;
+
+				case BUS_BLUETOOTH:
+					/* Manufacturer and Product strings */
+					cur_dev->manufacturer_string = wcsdup(L"");
+					cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
+
+					break;
+
+				default:
+					/* Unknown device type - this should never happen, as we
+					 * check for USB and Bluetooth devices above */
+					break;
+			}
+		}
+
+	next:
+		free(serial_number_utf8);
+		free(product_name_utf8);
+		udev_device_unref(raw_dev);
+		/* hid_dev, usb_dev and intf_dev don't need to be (and can't be)
+		   unref()d.  It will cause a double-free() error.  I'm not
+		   sure why.  */
+	}
+	/* Free the enumerator and udev objects. */
+	udev_enumerate_unref(enumerate);
+	udev_unref(udev);
+
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	/* Set global error to none */
+	register_global_error(NULL);
+
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	} else {
+		register_global_error("No such device");
+	}
+
+	hid_free_enumeration(devs);
+
+	return handle;
+}
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+	/* Set global error to none */
+	register_global_error(NULL);
+
+	hid_device *dev = NULL;
+
+	hid_init();
+
+	dev = new_hid_device();
+
+	/* OPEN HERE */
+	dev->device_handle = open(path, O_RDWR);
+
+	/* If we have a good handle, return it. */
+	if (dev->device_handle > 0) {
+		/* Set device error to none */
+		register_device_error(dev, NULL);
+
+		/* Get the report descriptor */
+		int res, desc_size = 0;
+		struct hidraw_report_descriptor rpt_desc;
+
+		memset(&rpt_desc, 0x0, sizeof(rpt_desc));
+
+		/* Get Report Descriptor Size */
+		res = ioctl(dev->device_handle, HIDIOCGRDESCSIZE, &desc_size);
+		if (res < 0)
+			register_device_error_format(dev, "ioctl (GRDESCSIZE): %s", strerror(errno));
+
+		/* Get Report Descriptor */
+		rpt_desc.size = desc_size;
+		res = ioctl(dev->device_handle, HIDIOCGRDESC, &rpt_desc);
+		if (res < 0) {
+			register_device_error_format(dev, "ioctl (GRDESC): %s", strerror(errno));
+		} else {
+			/* Determine if this device uses numbered reports. */
+			dev->uses_numbered_reports =
+				uses_numbered_reports(rpt_desc.value,
+				                      rpt_desc.size);
+		}
+
+		return dev;
+	}
+	else {
+		/* Unable to open any devices. */
+		register_global_error(strerror(errno));
+		free(dev);
+		return NULL;
+	}
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int bytes_written;
+
+	bytes_written = write(dev->device_handle, data, length);
+
+	register_device_error(dev, (bytes_written == -1)? strerror(errno): NULL);
+
+	return bytes_written;
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	/* Set device error to none */
+	register_device_error(dev, NULL);
+
+	int bytes_read;
+
+	if (milliseconds >= 0) {
+		/* Milliseconds is either 0 (non-blocking) or > 0 (contains
+		   a valid timeout). In both cases we want to call poll()
+		   and wait for data to arrive.  Don't rely on non-blocking
+		   operation (O_NONBLOCK) since some kernels don't seem to
+		   properly report device disconnection through read() when
+		   in non-blocking mode.  */
+		int ret;
+		struct pollfd fds;
+
+		fds.fd = dev->device_handle;
+		fds.events = POLLIN;
+		fds.revents = 0;
+		ret = poll(&fds, 1, milliseconds);
+		if (ret == 0) {
+			/* Timeout */
+			return ret;
+		}
+		if (ret == -1) {
+			/* Error */
+			register_device_error(dev, strerror(errno));
+			return ret;
+		}
+		else {
+			/* Check for errors on the file descriptor. This will
+			   indicate a device disconnection. */
+			if (fds.revents & (POLLERR | POLLHUP | POLLNVAL))
+				// We cannot use strerror() here as no -1 was returned from poll().
+				return -1;
+		}
+	}
+
+	bytes_read = read(dev->device_handle, data, length);
+	if (bytes_read < 0) {
+		if (errno == EAGAIN || errno == EINPROGRESS)
+			bytes_read = 0;
+		else
+			register_device_error(dev, strerror(errno));
+	}
+
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	/* Do all non-blocking in userspace using poll(), since it looks
+	   like there's a bug in the kernel in some versions where
+	   read() will not return -1 on disconnection of the USB device */
+
+	dev->blocking = !nonblock;
+	return 0; /* Success */
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res;
+
+	res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
+	if (res < 0)
+		register_device_error_format(dev, "ioctl (SFEATURE): %s", strerror(errno));
+
+	return res;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	int res;
+
+	res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
+	if (res < 0)
+		register_device_error_format(dev, "ioctl (GFEATURE): %s", strerror(errno));
+
+	return res;
+}
+
+// Not supported by Linux HidRaw yet
+int HID_API_EXPORT HID_API_CALL hid_get_input_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	return -1;
+}
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+
+	int ret = close(dev->device_handle);
+
+	register_global_error((ret == -1)? strerror(errno): NULL);
+
+	/* Free the device error message */
+	register_device_error(dev, NULL);
+
+	free(dev);
+}
+
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_device_string(dev, DEVICE_STRING_MANUFACTURER, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_device_string(dev, DEVICE_STRING_PRODUCT, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_device_string(dev, DEVICE_STRING_SERIAL, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+
+/* Passing in NULL means asking for the last global error message. */
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	if (dev) {
+		if (dev->last_error_str == NULL)
+			return L"Success";
+		return dev->last_error_str;
+	}
+
+	if (last_global_error_str == NULL)
+		return L"Success";
+	return last_global_error_str;
+}
+
+#endif

ThirdParty/hidapi/include/Windows/hid.cpp

@@ -0,0 +1,658 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ libusb/hidapi Team
+
+ Copyright 2023, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+		https://github.com/libusb/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include <wchar.h>
+
+ /* #480: this is to be refactored properly for v1.0 */
+#ifdef _WIN32
+#ifndef HID_API_NO_EXPORT_DEFINE
+#define HID_API_EXPORT __declspec(dllexport)
+#endif
+#endif
+#ifndef HID_API_EXPORT
+#define HID_API_EXPORT /**< API export macro */
+#endif
+/* To be removed in v1.0 */
+#define HID_API_CALL /**< API call macro */
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+/** @brief Static/compile-time major version of the library.
+
+	@ingroup API
+*/
+#define HID_API_VERSION_MAJOR 0
+/** @brief Static/compile-time minor version of the library.
+
+	@ingroup API
+*/
+#define HID_API_VERSION_MINOR 15
+/** @brief Static/compile-time patch version of the library.
+
+	@ingroup API
+*/
+#define HID_API_VERSION_PATCH 0
+
+/* Helper macros */
+#define HID_API_AS_STR_IMPL(x) #x
+#define HID_API_AS_STR(x) HID_API_AS_STR_IMPL(x)
+#define HID_API_TO_VERSION_STR(v1, v2, v3) HID_API_AS_STR(v1.v2.v3)
+
+/** @brief Coverts a version as Major/Minor/Patch into a number:
+	<8 bit major><16 bit minor><8 bit patch>.
+
+	This macro was added in version 0.12.0.
+
+	Convenient function to be used for compile-time checks, like:
+	@code{.c}
+	#if HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0)
+	@endcode
+
+	@ingroup API
+*/
+#define HID_API_MAKE_VERSION(mj, mn, p) (((mj) << 24) | ((mn) << 8) | (p))
+
+/** @brief Static/compile-time version of the library.
+
+	This macro was added in version 0.12.0.
+
+	@see @ref HID_API_MAKE_VERSION.
+
+	@ingroup API
+*/
+#define HID_API_VERSION HID_API_MAKE_VERSION(HID_API_VERSION_MAJOR, HID_API_VERSION_MINOR, HID_API_VERSION_PATCH)
+
+/** @brief Static/compile-time string version of the library.
+
+	@ingroup API
+*/
+#define HID_API_VERSION_STR HID_API_TO_VERSION_STR(HID_API_VERSION_MAJOR, HID_API_VERSION_MINOR, HID_API_VERSION_PATCH)
+
+/** @brief Maximum expected HID Report descriptor size in bytes.
+
+	Since version 0.13.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 13, 0)
+
+	@ingroup API
+*/
+#define HID_API_MAX_REPORT_DESCRIPTOR_SIZE 4096
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	/** A structure to hold the version numbers. */
+	struct hid_api_version {
+		int major; /**< major version number */
+		int minor; /**< minor version number */
+		int patch; /**< patch version number */
+	};
+
+	struct hid_device_;
+	typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+	/** @brief HID underlying bus types.
+
+		@ingroup API
+	*/
+	typedef enum {
+		/** Unknown bus type */
+		HID_API_BUS_UNKNOWN = 0x00,
+
+		/** USB bus
+		   Specifications:
+		   https://usb.org/hid */
+		HID_API_BUS_USB = 0x01,
+
+		/** Bluetooth or Bluetooth LE bus
+		   Specifications:
+		   https://www.bluetooth.com/specifications/specs/human-interface-device-profile-1-1-1/
+		   https://www.bluetooth.com/specifications/specs/hid-service-1-0/
+		   https://www.bluetooth.com/specifications/specs/hid-over-gatt-profile-1-0/ */
+		HID_API_BUS_BLUETOOTH = 0x02,
+
+		/** I2C bus
+		   Specifications:
+		   https://docs.microsoft.com/previous-versions/windows/hardware/design/dn642101(v=vs.85) */
+		HID_API_BUS_I2C = 0x03,
+
+		/** SPI bus
+		   Specifications:
+		   https://www.microsoft.com/download/details.aspx?id=103325 */
+		HID_API_BUS_SPI = 0x04,
+	} hid_bus_type;
+
+	/** hidapi info structure */
+	struct hid_device_info {
+		/** Platform-specific device path */
+		char* path;
+		/** Device Vendor ID */
+		unsigned short vendor_id;
+		/** Device Product ID */
+		unsigned short product_id;
+		/** Serial Number */
+		wchar_t* serial_number;
+		/** Device Release Number in binary-coded decimal,
+			also known as Device Version Number */
+		unsigned short release_number;
+		/** Manufacturer String */
+		wchar_t* manufacturer_string;
+		/** Product string */
+		wchar_t* product_string;
+		/** Usage Page for this Device/Interface
+			(Windows/Mac/hidraw only) */
+		unsigned short usage_page;
+		/** Usage for this Device/Interface
+			(Windows/Mac/hidraw only) */
+		unsigned short usage;
+		/** The USB interface which this logical device
+			represents.
+
+			Valid only if the device is a USB HID device.
+			Set to -1 in all other cases.
+		*/
+		int interface_number;
+
+		/** Pointer to the next device */
+		struct hid_device_info* next;
+
+		/** Underlying bus type
+			Since version 0.13.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 13, 0)
+		*/
+		hid_bus_type bus_type;
+	};
+
+
+	/** @brief Initialize the HIDAPI library.
+
+		This function initializes the HIDAPI library. Calling it is not
+		strictly necessary, as it will be called automatically by
+		hid_enumerate() and any of the hid_open_*() functions if it is
+		needed.  This function should be called at the beginning of
+		execution however, if there is a chance of HIDAPI handles
+		being opened by different threads simultaneously.
+
+		@ingroup API
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(NULL) to get the failure reason.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+	/** @brief Finalize the HIDAPI library.
+
+		This function frees all of the static data associated with
+		HIDAPI. It should be called at the end of execution to avoid
+		memory leaks.
+
+		@ingroup API
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+	/** @brief Enumerate the HID Devices.
+
+		This function returns a linked list of all the HID devices
+		attached to the system which match vendor_id and product_id.
+		If @p vendor_id is set to 0 then any vendor matches.
+		If @p product_id is set to 0 then any product matches.
+		If @p vendor_id and @p product_id are both set to 0, then
+		all HID devices will be returned.
+
+		@ingroup API
+		@param vendor_id The Vendor ID (VID) of the types of device
+			to open.
+		@param product_id The Product ID (PID) of the types of
+			device to open.
+
+		@returns
+			This function returns a pointer to a linked list of type
+			struct #hid_device_info, containing information about the HID devices
+			attached to the system,
+			or NULL in the case of failure or if no HID devices present in the system.
+			Call hid_error(NULL) to get the failure reason.
+
+		@note The returned value by this function must to be freed by calling hid_free_enumeration(),
+			  when not needed anymore.
+	*/
+	struct hid_device_info HID_API_EXPORT* HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+	/** @brief Free an enumeration Linked List
+
+		This function frees a linked list created by hid_enumerate().
+
+		@ingroup API
+		@param devs Pointer to a list of struct_device returned from
+					hid_enumerate().
+	*/
+	void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info* devs);
+
+	/** @brief Open a HID device using a Vendor ID (VID), Product ID
+		(PID) and optionally a serial number.
+
+		If @p serial_number is NULL, the first device with the
+		specified VID and PID is opened.
+
+		@ingroup API
+		@param vendor_id The Vendor ID (VID) of the device to open.
+		@param product_id The Product ID (PID) of the device to open.
+		@param serial_number The Serial Number of the device to open
+							 (Optionally NULL).
+
+		@returns
+			This function returns a pointer to a #hid_device object on
+			success or NULL on failure.
+			Call hid_error(NULL) to get the failure reason.
+
+		@note The returned object must be freed by calling hid_close(),
+			  when not needed anymore.
+	*/
+	HID_API_EXPORT hid_device* HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t* serial_number);
+
+	/** @brief Open a HID device by its path name.
+
+		The path name be determined by calling hid_enumerate(), or a
+		platform-specific path name can be used (eg: /dev/hidraw0 on
+		Linux).
+
+		@ingroup API
+		@param path The path name of the device to open
+
+		@returns
+			This function returns a pointer to a #hid_device object on
+			success or NULL on failure.
+			Call hid_error(NULL) to get the failure reason.
+
+		@note The returned object must be freed by calling hid_close(),
+			  when not needed anymore.
+	*/
+	HID_API_EXPORT hid_device* HID_API_CALL hid_open_path(const char* path);
+
+	/** @brief Write an Output report to a HID device.
+
+		The first byte of @p data[] must contain the Report ID. For
+		devices which only support a single report, this must be set
+		to 0x0. The remaining bytes contain the report data. Since
+		the Report ID is mandatory, calls to hid_write() will always
+		contain one more byte than the report contains. For example,
+		if a hid report is 16 bytes long, 17 bytes must be passed to
+		hid_write(), the Report ID (or 0x0, for devices with a
+		single report), followed by the report data (16 bytes). In
+		this example, the length passed in would be 17.
+
+		hid_write() will send the data on the first interrupt OUT
+		endpoint, if one exists. If it does not the behaviour is as
+		@ref hid_send_output_report
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data The data to send, including the report number as
+			the first byte.
+		@param length The length in bytes of the data to send.
+
+		@returns
+			This function returns the actual number of bytes written and
+			-1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_write(hid_device* dev, const unsigned char* data, size_t length);
+
+	/** @brief Read an Input report from a HID device with timeout.
+
+		Input reports are returned
+		to the host through the INTERRUPT IN endpoint. The first byte will
+		contain the Report number if the device uses numbered reports.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into.
+		@param length The number of bytes to read. For devices with
+			multiple reports, make sure to read an extra byte for
+			the report number.
+		@param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+		@returns
+			This function returns the actual number of bytes read and
+			-1 on error.
+			Call hid_error(dev) to get the failure reason.
+			If no packet was available to be read within
+			the timeout period, this function returns 0.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device* dev, unsigned char* data, size_t length, int milliseconds);
+
+	/** @brief Read an Input report from a HID device.
+
+		Input reports are returned
+		to the host through the INTERRUPT IN endpoint. The first byte will
+		contain the Report number if the device uses numbered reports.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into.
+		@param length The number of bytes to read. For devices with
+			multiple reports, make sure to read an extra byte for
+			the report number.
+
+		@returns
+			This function returns the actual number of bytes read and
+			-1 on error.
+			Call hid_error(dev) to get the failure reason.
+			If no packet was available to be read and
+			the handle is in non-blocking mode, this function returns 0.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_read(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Set the device handle to be non-blocking.
+
+		In non-blocking mode calls to hid_read() will return
+		immediately with a value of 0 if there is no data to be
+		read. In blocking mode, hid_read() will wait (block) until
+		there is data to read before returning.
+
+		Nonblocking can be turned on and off at any time.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param nonblock enable or not the nonblocking reads
+		 - 1 to enable nonblocking
+		 - 0 to disable nonblocking.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device* dev, int nonblock);
+
+	/** @brief Send a Feature report to the device.
+
+		Feature reports are sent over the Control endpoint as a
+		Set_Report transfer.  The first byte of @p data[] must
+		contain the Report ID. For devices which only support a
+		single report, this must be set to 0x0. The remaining bytes
+		contain the report data. Since the Report ID is mandatory,
+		calls to hid_send_feature_report() will always contain one
+		more byte than the report contains. For example, if a hid
+		report is 16 bytes long, 17 bytes must be passed to
+		hid_send_feature_report(): the Report ID (or 0x0, for
+		devices which do not use numbered reports), followed by the
+		report data (16 bytes). In this example, the length passed
+		in would be 17.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data The data to send, including the report number as
+			the first byte.
+		@param length The length in bytes of the data to send, including
+			the report number.
+
+		@returns
+			This function returns the actual number of bytes written and
+			-1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device* dev, const unsigned char* data, size_t length);
+
+	/** @brief Get a feature report from a HID device.
+
+		Set the first byte of @p data[] to the Report ID of the
+		report to be read.  Make sure to allow space for this
+		extra byte in @p data[]. Upon return, the first byte will
+		still contain the Report ID, and the report data will
+		start in data[1].
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into, including
+			the Report ID. Set the first byte of @p data[] to the
+			Report ID of the report to be read, or set it to zero
+			if your device does not use numbered reports.
+		@param length The number of bytes to read, including an
+			extra byte for the report ID. The buffer can be longer
+			than the actual report.
+
+		@returns
+			This function returns the number of bytes read plus
+			one for the report ID (which is still in the first
+			byte), or -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Send a Output report to the device.
+
+		Since version 0.15.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 15, 0)
+
+		Output reports are sent over the Control endpoint as a
+		Set_Report transfer.  The first byte of @p data[] must
+		contain the Report ID. For devices which only support a
+		single report, this must be set to 0x0. The remaining bytes
+		contain the report data. Since the Report ID is mandatory,
+		calls to hid_send_output_report() will always contain one
+		more byte than the report contains. For example, if a hid
+		report is 16 bytes long, 17 bytes must be passed to
+		hid_send_output_report(): the Report ID (or 0x0, for
+		devices which do not use numbered reports), followed by the
+		report data (16 bytes). In this example, the length passed
+		in would be 17.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data The data to send, including the report number as
+			the first byte.
+		@param length The length in bytes of the data to send, including
+			the report number.
+
+		@returns
+			This function returns the actual number of bytes written and
+			-1 on error.
+
+		@see @ref hid_write
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_send_output_report(hid_device* dev, const unsigned char* data, size_t length);
+
+	/** @brief Get a input report from a HID device.
+
+		Since version 0.10.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 10, 0)
+
+		Set the first byte of @p data[] to the Report ID of the
+		report to be read. Make sure to allow space for this
+		extra byte in @p data[]. Upon return, the first byte will
+		still contain the Report ID, and the report data will
+		start in data[1].
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into, including
+			the Report ID. Set the first byte of @p data[] to the
+			Report ID of the report to be read, or set it to zero
+			if your device does not use numbered reports.
+		@param length The number of bytes to read, including an
+			extra byte for the report ID. The buffer can be longer
+			than the actual report.
+
+		@returns
+			This function returns the number of bytes read plus
+			one for the report ID (which is still in the first
+			byte), or -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_get_input_report(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Close a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+	*/
+	void HID_API_EXPORT HID_API_CALL hid_close(hid_device* dev);
+
+	/** @brief Get The Manufacturer String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get The Product String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT_CALL hid_get_product_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get The Serial Number String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get The struct #hid_device_info from a HID device.
+
+		Since version 0.13.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 13, 0)
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+
+		@returns
+			This function returns a pointer to the struct #hid_device_info
+			for this hid_device, or NULL in the case of failure.
+			Call hid_error(dev) to get the failure reason.
+			This struct is valid until the device is closed with hid_close().
+
+		@note The returned object is owned by the @p dev, and SHOULD NOT be freed by the user.
+	*/
+	struct hid_device_info HID_API_EXPORT* HID_API_CALL hid_get_device_info(hid_device* dev);
+
+	/** @brief Get a string from a HID device, based on its string index.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string_index The index of the string to get.
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+			Call hid_error(dev) to get the failure reason.
+	*/
+	int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device* dev, int string_index, wchar_t* string, size_t maxlen);
+
+	/** @brief Get a report descriptor from a HID device.
+
+		Since version 0.14.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 14, 0)
+
+		User has to provide a preallocated buffer where descriptor will be copied to.
+		The recommended size for preallocated buffer is @ref HID_API_MAX_REPORT_DESCRIPTOR_SIZE bytes.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param buf The buffer to copy descriptor into.
+		@param buf_size The size of the buffer in bytes.
+
+		@returns
+			This function returns non-negative number of bytes actually copied, or -1 on error.
+	*/
+	int HID_API_EXPORT_CALL hid_get_report_descriptor(hid_device* dev, unsigned char* buf, size_t buf_size);
+
+	/** @brief Get a string describing the last error which occurred.
+
+		This function is intended for logging/debugging purposes.
+
+		This function guarantees to never return NULL.
+		If there was no error in the last function call -
+		the returned string clearly indicates that.
+
+		Any HIDAPI function that can explicitly indicate an execution failure
+		(e.g. by an error code, or by returning NULL) - may set the error string,
+		to be returned by this function.
+
+		Strings returned from hid_error() must not be freed by the user,
+		i.e. owned by HIDAPI library.
+		Device-specific error string may remain allocated at most until hid_close() is called.
+		Global error string may remain allocated at most until hid_exit() is called.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open(),
+		  or NULL to get the last non-device-specific error
+		  (e.g. for errors in hid_open() or hid_enumerate()).
+
+		@returns
+			A string describing the last error (if any).
+	*/
+	HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device* dev);
+
+	/** @brief Get a runtime version of the library.
+
+		This function is thread-safe.
+
+		@ingroup API
+
+		@returns
+			Pointer to statically allocated struct, that contains version.
+	*/
+	HID_API_EXPORT const  struct hid_api_version* HID_API_CALL hid_version(void);
+
+
+	/** @brief Get a runtime version string of the library.
+
+		This function is thread-safe.
+
+		@ingroup API
+
+		@returns
+			Pointer to statically allocated string, that contains version string.
+	*/
+	HID_API_EXPORT const char* HID_API_CALL hid_version_str(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

ThirdParty/hidapi/include/hidapi.h

@@ -0,0 +1,444 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+		https://github.com/libusb/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#pragma once
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include <wchar.h>
+
+#define HID_API_EXPORT SKYPORTAL_API
+#define HID_API_CALL
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+	struct hid_device_;
+	typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+	/** hidapi info structure */
+	struct hid_device_info {
+		/** Platform-specific device path */
+		char* path;
+		/** Device Vendor ID */
+		unsigned short vendor_id;
+		/** Device Product ID */
+		unsigned short product_id;
+		/** Serial Number */
+		wchar_t* serial_number;
+		/** Device Release Number in binary-coded decimal,
+			also known as Device Version Number */
+		unsigned short release_number;
+		/** Manufacturer String */
+		wchar_t* manufacturer_string;
+		/** Product string */
+		wchar_t* product_string;
+		/** Usage Page for this Device/Interface
+			(Windows/Mac only). */
+		unsigned short usage_page;
+		/** Usage for this Device/Interface
+			(Windows/Mac only).*/
+		unsigned short usage;
+		/** The USB interface which this logical device
+			represents.
+
+			* Valid on both Linux implementations in all cases.
+			* Valid on the Windows implementation only if the device
+			  contains more than one interface.
+			* Valid on the Mac implementation if and only if the device
+			  is a USB HID device. */
+		int interface_number;
+
+		/** Pointer to the next device */
+		struct hid_device_info* next;
+	};
+
+
+	/** @brief Initialize the HIDAPI library.
+
+		This function initializes the HIDAPI library. Calling it is not
+		strictly necessary, as it will be called automatically by
+		hid_enumerate() and any of the hid_open_*() functions if it is
+		needed.  This function should be called at the beginning of
+		execution however, if there is a chance of HIDAPI handles
+		being opened by different threads simultaneously.
+
+		@ingroup API
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+	/** @brief Finalize the HIDAPI library.
+
+		This function frees all of the static data associated with
+		HIDAPI. It should be called at the end of execution to avoid
+		memory leaks.
+
+		@ingroup API
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+	/** @brief Enumerate the HID Devices.
+
+		This function returns a linked list of all the HID devices
+		attached to the system which match vendor_id and product_id.
+		If @p vendor_id is set to 0 then any vendor matches.
+		If @p product_id is set to 0 then any product matches.
+		If @p vendor_id and @p product_id are both set to 0, then
+		all HID devices will be returned.
+
+		@ingroup API
+		@param vendor_id The Vendor ID (VID) of the types of device
+			to open.
+		@param product_id The Product ID (PID) of the types of
+			device to open.
+
+		@returns
+			This function returns a pointer to a linked list of type
+			struct #hid_device_info, containing information about the HID devices
+			attached to the system, or NULL in the case of failure. Free
+			this linked list by calling hid_free_enumeration().
+	*/
+	struct hid_device_info HID_API_EXPORT* HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+	/** @brief Free an enumeration Linked List
+
+		This function frees a linked list created by hid_enumerate().
+
+		@ingroup API
+		@param devs Pointer to a list of struct_device returned from
+				  hid_enumerate().
+	*/
+	void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info* devs);
+
+	/** @brief Open a HID device using a Vendor ID (VID), Product ID
+		(PID) and optionally a serial number.
+
+		If @p serial_number is NULL, the first device with the
+		specified VID and PID is opened.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param vendor_id The Vendor ID (VID) of the device to open.
+		@param product_id The Product ID (PID) of the device to open.
+		@param serial_number The Serial Number of the device to open
+						   (Optionally NULL).
+
+		@returns
+			This function returns a pointer to a #hid_device object on
+			success or NULL on failure.
+	*/
+	HID_API_EXPORT hid_device* HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t* serial_number);
+
+	/** @brief Open a HID device by its path name.
+
+		The path name be determined by calling hid_enumerate(), or a
+		platform-specific path name can be used (eg: /dev/hidraw0 on
+		Linux).
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param path The path name of the device to open
+
+		@returns
+			This function returns a pointer to a #hid_device object on
+			success or NULL on failure.
+	*/
+	HID_API_EXPORT hid_device* HID_API_CALL hid_open_path(const char* path);
+
+	/** @brief Write an Output report to a HID device.
+
+		The first byte of @p data[] must contain the Report ID. For
+		devices which only support a single report, this must be set
+		to 0x0. The remaining bytes contain the report data. Since
+		the Report ID is mandatory, calls to hid_write() will always
+		contain one more byte than the report contains. For example,
+		if a hid report is 16 bytes long, 17 bytes must be passed to
+		hid_write(), the Report ID (or 0x0, for devices with a
+		single report), followed by the report data (16 bytes). In
+		this example, the length passed in would be 17.
+
+		hid_write() will send the data on the first OUT endpoint, if
+		one exists. If it does not, it will send the data through
+		the Control Endpoint (Endpoint 0).
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data The data to send, including the report number as
+			the first byte.
+		@param length The length in bytes of the data to send.
+
+		@returns
+			This function returns the actual number of bytes written and
+			-1 on error.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_write(hid_device* dev, const unsigned char* data, size_t length);
+
+	/** @brief Read an Input report from a HID device with timeout.
+
+		Input reports are returned
+		to the host through the INTERRUPT IN endpoint. The first byte will
+		contain the Report number if the device uses numbered reports.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into.
+		@param length The number of bytes to read. For devices with
+			multiple reports, make sure to read an extra byte for
+			the report number.
+		@param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+		@returns
+			This function returns the actual number of bytes read and
+			-1 on error. If no packet was available to be read within
+			the timeout period, this function returns 0.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device* dev, unsigned char* data, size_t length, int milliseconds);
+
+	/** @brief Read an Input report from a HID device.
+
+		Input reports are returned
+		to the host through the INTERRUPT IN endpoint. The first byte will
+		contain the Report number if the device uses numbered reports.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into.
+		@param length The number of bytes to read. For devices with
+			multiple reports, make sure to read an extra byte for
+			the report number.
+
+		@returns
+			This function returns the actual number of bytes read and
+			-1 on error. If no packet was available to be read and
+			the handle is in non-blocking mode, this function returns 0.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_read(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Set the device handle to be non-blocking.
+
+		In non-blocking mode calls to hid_read() will return
+		immediately with a value of 0 if there is no data to be
+		read. In blocking mode, hid_read() will wait (block) until
+		there is data to read before returning.
+
+		Nonblocking can be turned on and off at any time.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param nonblock enable or not the nonblocking reads
+		 - 1 to enable nonblocking
+		 - 0 to disable nonblocking.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device* dev, int nonblock);
+
+	/** @brief Send a Feature report to the device.
+
+		Feature reports are sent over the Control endpoint as a
+		Set_Report transfer.  The first byte of @p data[] must
+		contain the Report ID. For devices which only support a
+		single report, this must be set to 0x0. The remaining bytes
+		contain the report data. Since the Report ID is mandatory,
+		calls to hid_send_feature_report() will always contain one
+		more byte than the report contains. For example, if a hid
+		report is 16 bytes long, 17 bytes must be passed to
+		hid_send_feature_report(): the Report ID (or 0x0, for
+		devices which do not use numbered reports), followed by the
+		report data (16 bytes). In this example, the length passed
+		in would be 17.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data The data to send, including the report number as
+			the first byte.
+		@param length The length in bytes of the data to send, including
+			the report number.
+
+		@returns
+			This function returns the actual number of bytes written and
+			-1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device* dev, const unsigned char* data, size_t length);
+
+	/** @brief Get a feature report from a HID device.
+
+		Set the first byte of @p data[] to the Report ID of the
+		report to be read.  Make sure to allow space for this
+		extra byte in @p data[]. Upon return, the first byte will
+		still contain the Report ID, and the report data will
+		start in data[1].
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param data A buffer to put the read data into, including
+			the Report ID. Set the first byte of @p data[] to the
+			Report ID of the report to be read, or set it to zero
+			if your device does not use numbered reports.
+		@param length The number of bytes to read, including an
+			extra byte for the report ID. The buffer can be longer
+			than the actual report.
+
+		@returns
+			This function returns the number of bytes read plus
+			one for the report ID (which is still in the first
+			byte), or -1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Get a input report from a HID device.
+
+		Set the first byte of @p data[] to the Report ID of the
+		report to be read. Make sure to allow space for this
+		extra byte in @p data[]. Upon return, the first byte will
+		still contain the Report ID, and the report data will
+		start in data[1].
+
+		@ingroup API
+		@param device A device handle returned from hid_open().
+		@param data A buffer to put the read data into, including
+			the Report ID. Set the first byte of @p data[] to the
+			Report ID of the report to be read, or set it to zero
+			if your device does not use numbered reports.
+		@param length The number of bytes to read, including an
+			extra byte for the report ID. The buffer can be longer
+			than the actual report.
+
+		@returns
+			This function returns the number of bytes read plus
+			one for the report ID (which is still in the first
+			byte), or -1 on error.
+	*/
+	int HID_API_EXPORT HID_API_CALL hid_get_input_report(hid_device* dev, unsigned char* data, size_t length);
+
+	/** @brief Close a HID device.
+
+		This function sets the return value of hid_error().
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+	*/
+	void HID_API_EXPORT HID_API_CALL hid_close(hid_device* dev);
+
+	/** @brief Get The Manufacturer String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get The Product String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT_CALL hid_get_product_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get The Serial Number String from a HID device.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device* dev, wchar_t* string, size_t maxlen);
+
+	/** @brief Get a string from a HID device, based on its string index.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open().
+		@param string_index The index of the string to get.
+		@param string A wide string buffer to put the data into.
+		@param maxlen The length of the buffer in multiples of wchar_t.
+
+		@returns
+			This function returns 0 on success and -1 on error.
+	*/
+	int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device* dev, int string_index, wchar_t* string, size_t maxlen);
+
+	/** @brief Get a string describing the last error which occurred.
+
+		Whether a function sets the last error is noted in its
+		documentation. These functions will reset the last error
+		to NULL before their execution.
+
+		Strings returned from hid_error() must not be freed by the user!
+
+		This function is thread-safe, and error messages are thread-local.
+
+		@ingroup API
+		@param dev A device handle returned from hid_open(),
+		  or NULL to get the last non-device-specific error
+		  (e.g. for errors in hid_open() itself).
+
+		@returns
+			This function returns a string containing the last error
+			which occurred or NULL if none has occurred.
+	*/
+	HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device* dev);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif