Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
My tweaks to multi-device polling code by Jake Stookey (http://www.jstookey.com/arcade/rawmouse/)
//================================================================
//
// raw_mouse.c - Win XP access to multiple mice via raw input
//
// To do:
//
// - Improve the method for weeding out the RDP Mouse. Find "status bits" (see below).
//
//================================================================
#define _WIN32_WINNT 0x501 // This specifies WinXP or later - it is needed to access rawmouse from the user32.dll
#include "stdafx.h"
#include <stdlib.h>
#include <malloc.h>
#include <windows.h>
#include <stdio.h>
#include "raw_mouse.h"
#include "hidusage.h"
//============================================================
// Dynamically linked functions from rawinput
//============================================================
typedef WINUSERAPI INT(WINAPI *pGetRawInputDeviceList)(OUT PRAWINPUTDEVICELIST pRawInputDeviceList, IN OUT PINT puiNumDevices, IN UINT cbSize);
typedef WINUSERAPI INT(WINAPI *pGetRawInputData)(IN HRAWINPUT hRawInput, IN UINT uiCommand, OUT LPVOID pData, IN OUT PINT pcbSize, IN UINT cbSizeHeader);
typedef WINUSERAPI INT(WINAPI *pGetRawInputDeviceInfoA)(IN HANDLE hDevice, IN UINT uiCommand, OUT LPVOID pData, IN OUT PINT pcbSize);
typedef WINUSERAPI BOOL(WINAPI *pRegisterRawInputDevices)(IN PCRAWINPUTDEVICE pRawInputDevices, IN UINT uiNumDevices, IN UINT cbSize);
pGetRawInputDeviceList _GRIDL;
pGetRawInputData _GRID;
pGetRawInputDeviceInfoA _GRIDIA;
pRegisterRawInputDevices _RRID;
int nraw_mouse_count;
int nraw_keyboard_count;
//============================================================
// PARAMETERS
//============================================================
#define RAW_SYS_MOUSE 0 // The sys mouse combines all the other usb mice into one
#define MAX_RAW_MOUSE_BUTTONS 3
//============================================================
// DATA TYPES
//============================================================
typedef struct STRUCT_RAW_MOUSE {
// Identifier for the mouse. WM_INPUT passes the device HANDLE as lparam when registering a mousemove
HANDLE device_handle;
// VD: may as well
char* device_name;
// The running tally of mouse moves received from WM_INPUT (mouse delta).
// Calling get_raw_mouse_[x | y] will reset the value so that every time
// get_raw_mouse_[x | y] is called, the relative value from the last time
// get_raw_mouse_[x | y] was called will be returned.
ULONG x;
ULONG y;
ULONG z;
// Used to determine if the HID is using absolute mode or relative mode
// The Act Labs PC USB Light Gun is absolute mode (returns screen coordinates)
// and mice are relative mode (returns delta)
// NOTE: this value isn't updated until the device registers a WM_INPUT message
BOOL is_absolute;
// This indicates if the coordinates are coming from a multi-monitor setup
// NOTE: this value isn't updated until the device registers a WM_INPUT message
BOOL is_virtual_desktop;
int buttonpressed[MAX_RAW_MOUSE_BUTTONS];
// Identifying the name of the button may be useful in the future as a way to
// use a mousewheel as a button and other neat tricks (button name: "wheel up", "wheel down")
// -- not a bad way to look at it for a rotary joystick
char *button_name[MAX_RAW_MOUSE_BUTTONS];
} RAW_MOUSE, *PRAW_MOUSE;
// VD: simpler in comparison
typedef struct STRUCT_RAW_KEYBOARD {
HANDLE device_handle;
char* device_name;
// Event uses ushort but I'm not seeing any keycodes>=256
bool keysdown[256];
} RAW_KEYBOARD, *PRAW_KEYBOARD;
//============================================================
// LOCAL VARIABLES
//============================================================
// Pointer to our array of raw mice. Created by called init_raw_mouse()
static PRAW_MOUSE raw_mice;
static PRAW_KEYBOARD raw_keyboards;
static BOOL include_sys_mouse;
static BOOL include_rdp_mouse;
static BOOL include_individual_mice;
static int excluded_sysmouse_devices_count;
//============================================================
// PROTOTYPES
//============================================================
// A weak solution to weeding out the Terminal Services virtual mouse from the list of devices.
// I read somewhere that you shouldn't trust the device name's format. In other words, you shouldn't do what I'm doing.
// Here's the quote from http://www.jsiinc.com/SUBJ/tip4600/rh4628.htm:
// "Note that you should not make any programmatic assumption about how an instance ID is formatted.
// To determine root devices, you can check device status bits."
// So tell me, what are these (how you say) "status bits" and where can I get some?
static BOOL is_rm_rdp_mouse(char cDeviceString[]);
static BOOL read_raw_input(PRAWINPUT);
// register to reviece WM_INPUT messages in WNDPROC
static BOOL register_raw_mouse(void);
//============================================================
// raw_mouse_count
//============================================================
int raw_mouse_count() {
return nraw_mouse_count;
}
//============================================================
// is_rm_rdp_mouse
//============================================================
static BOOL is_rm_rdp_mouse(char cDeviceString[])
{
int i;
char cRDPString[] = "\\??\\Root#RDP_MOU#0000#";
if (strlen(cDeviceString) < 22) {
return 0;
}
for (i = 0; i < 22; i++) {
if (cRDPString[i] != cDeviceString[i]) {
return 0;
}
}
return 1;
}
//============================================================
// init_raw_mouse
//============================================================
BOOL init_raw_mouse(int in_flags)
{
BOOL in_include_individual_mice = (in_flags & 1) != 0;
BOOL in_include_sys_mouse = (in_flags & 2) != 0;
BOOL in_include_rdp_mouse = (in_flags & 4) != 0;
BOOL in_include_keyboards = (in_flags & 8) != 0;
// "0" to exclude, "1" to include
int nInputDevices, i, j;
PRAWINPUTDEVICELIST pRawInputDeviceList;
static BOOL bHasBeenInitialized = 0;
int nSize;
char *psName;
char buffer[80];
// Return 0 if rawinput is not available
HMODULE user32 = LoadLibrary("user32.dll");
if (!user32) return 0;
_RRID = (pRegisterRawInputDevices)GetProcAddress(user32, "RegisterRawInputDevices");
if (!_RRID) return 0;
_GRIDL = (pGetRawInputDeviceList)GetProcAddress(user32, "GetRawInputDeviceList");
if (!_GRIDL) return 0;
_GRIDIA = (pGetRawInputDeviceInfoA)GetProcAddress(user32, "GetRawInputDeviceInfoA");
if (!_GRIDIA) return 0;
_GRID = (pGetRawInputData)GetProcAddress(user32, "GetRawInputData");
if (!_GRID) return 0;
excluded_sysmouse_devices_count = 0;
nraw_mouse_count = 0;
if (bHasBeenInitialized) {
fprintf(stderr, "WARNING: rawmouse init called after initialization already completed.");
bHasBeenInitialized = 1;
return 0;
}
include_sys_mouse = in_include_sys_mouse;
include_rdp_mouse = in_include_rdp_mouse;
include_individual_mice = in_include_individual_mice;
// 1st call to GetRawInputDeviceList: Pass NULL to get the number of devices.
if (/* GetRawInputDeviceList */ (*_GRIDL)(NULL, &nInputDevices, sizeof(RAWINPUTDEVICELIST)) != 0) {
fprintf(stderr, "ERROR: Unable to count raw input devices.\n");
return 0;
}
// Allocate the array to hold the DeviceList
if ((pRawInputDeviceList = (PRAWINPUTDEVICELIST)malloc(sizeof(RAWINPUTDEVICELIST) * nInputDevices)) == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for raw input device list.\n");
return 0;
}
// 2nd call to GetRawInputDeviceList: Pass the pointer to our DeviceList and GetRawInputDeviceList() will fill the array
if (/* GetRawInputDeviceList */ (*_GRIDL)(pRawInputDeviceList, &nInputDevices, sizeof(RAWINPUTDEVICELIST)) == -1) {
fprintf(stderr, "ERROR: Unable to get raw input device list.\n");
return 0;
}
// Loop through all devices and count the mice
for (i = 0; i < nInputDevices; i++) {
auto t = pRawInputDeviceList[i].dwType;
if (t == RIM_TYPEMOUSE || t == RIM_TYPEKEYBOARD && in_include_keyboards) {
/* Get the device name and use it to determine if it's the RDP Terminal Services virtual device. */
// 1st call to GetRawInputDeviceInfo: Pass NULL to get the size of the device name
if (/* GetRawInputDeviceInfo */ (*_GRIDIA)(pRawInputDeviceList[i].hDevice, RIDI_DEVICENAME, NULL, &nSize) != 0) {
fprintf(stderr, "ERROR: Unable to get size of raw input device name.\n");
return 0;
}
// Allocate the array to hold the name
if ((psName = (char *)malloc(sizeof(TCHAR) * nSize)) == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for device name.\n");
return 0;
}
// 2nd call to GetRawInputDeviceInfo: Pass our pointer to get the device name
if ((int)/* GetRawInputDeviceInfo */ (*_GRIDIA)(pRawInputDeviceList[i].hDevice, RIDI_DEVICENAME, psName, &nSize) < 0) {
fprintf(stderr, "ERROR: Unable to get raw input device name.\n");
return 0;
}
if (t == RIM_TYPEKEYBOARD) {
// VD: IDK how RDP keyboards are named, I'm not going to test this right now
nraw_keyboard_count++;
} else {
// Count this mouse for allocation if it's not an RDP mouse or if we want to include the rdp mouse
if (is_rm_rdp_mouse(psName)) {
if (include_rdp_mouse) nraw_mouse_count++;
} else { // It's an ordinary mouse
nraw_mouse_count++;
if (!include_individual_mice) excluded_sysmouse_devices_count++; // Don't count this in the final nraw_mouse_count value
}
}
}
}
if (include_sys_mouse)
nraw_mouse_count++;
// Allocate the array for the raw mice
if ((raw_mice = (PRAW_MOUSE)malloc(sizeof(RAW_MOUSE) * nraw_mouse_count)) == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for raw input mice.\n");
return 0;
}
if ((raw_keyboards = (PRAW_KEYBOARD)malloc(sizeof(RAW_KEYBOARD) * nraw_keyboard_count)) == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for raw input keyboards.\n");
return 0;
}
// Define the sys mouse
int currentmouse = 0;
if (include_sys_mouse) {
raw_mice[RAW_SYS_MOUSE].device_handle = 0;
raw_mice[RAW_SYS_MOUSE].x = 0;
raw_mice[RAW_SYS_MOUSE].y = 0;
raw_mice[RAW_SYS_MOUSE].z = 0;
raw_mice[RAW_SYS_MOUSE].is_absolute = 0;
raw_mice[RAW_SYS_MOUSE].is_virtual_desktop = 0;
currentmouse++;
}
int currentkeyboard = 0;
// Loop through all devices and set the device handles and initialize the mouse values
for (i = 0; i < nInputDevices; i++) {
DWORD dwType = pRawInputDeviceList[i].dwType;
if (dwType == RIM_TYPEMOUSE || dwType == RIM_TYPEKEYBOARD && in_include_keyboards) {
// 1st call to GetRawInputDeviceInfo: Pass NULL to get the size of the device name
if (/* GetRawInputDeviceInfo */ (*_GRIDIA)(pRawInputDeviceList[i].hDevice, RIDI_DEVICENAME, NULL, &nSize) != 0) {
fprintf(stderr, "ERROR: Unable to get size of raw input device name (2).\n");
return 0;
}
// Allocate the array to hold the name
if ((psName = (char *)malloc(sizeof(TCHAR) * nSize)) == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for raw input device name (2).\n");
return 0;
}
// 2nd call to GetRawInputDeviceInfo: Pass our pointer to get the device name
if ((int)/* GetRawInputDeviceInfo */ (*_GRIDIA)(pRawInputDeviceList[i].hDevice, RIDI_DEVICENAME, psName, &nSize) < 0) {
fprintf(stderr, "ERROR: Unable to get raw input device name (2).\n");
return 0;
}
if (dwType == RIM_TYPEKEYBOARD) {
raw_keyboards[currentkeyboard].device_handle = pRawInputDeviceList[i].hDevice;
raw_keyboards[currentkeyboard].device_name = psName;
for (int k = 0; k < 256; k++) {
raw_keyboards[currentkeyboard].keysdown[k] = false;
}
currentkeyboard++;
} else {
// Add this mouse to the array if it's not an RDPMouse or if we wish to include the RDP mouse
if ((!is_rm_rdp_mouse(psName)) || include_rdp_mouse) {
raw_mice[currentmouse].device_handle = pRawInputDeviceList[i].hDevice;
raw_mice[currentmouse].device_name = psName;
raw_mice[currentmouse].x = 0;
raw_mice[currentmouse].y = 0;
raw_mice[currentmouse].z = 0;
raw_mice[currentmouse].is_absolute = 0;
raw_mice[currentmouse].is_virtual_desktop = 0;
currentmouse++;
}
}
}
}
// free the RAWINPUTDEVICELIST
free(pRawInputDeviceList);
for (i = 0; i < nraw_mouse_count; i++) {
for (j = 0; j < MAX_RAW_MOUSE_BUTTONS; j++) {
raw_mice[i].buttonpressed[j] = 0;
// Create the name for this button
sprintf(buffer, "Button %i", j);
raw_mice[i].button_name[j] = (char *)malloc(strlen(buffer) + 1);
sprintf(raw_mice[i].button_name[j], "%s", buffer);
}
}
nraw_mouse_count -= excluded_sysmouse_devices_count;
// finally, register to recieve raw input WM_INPUT messages
if (!register_raw_mouse()) {
fprintf(stderr, "ERROR: Unable to register raw input (2).\n");
return 0;
}
bHasBeenInitialized = 1;
return 1;
}
//============================================================
// register_raw_mouse
//============================================================
BOOL register_raw_mouse(void)
{
// This function registers to receive the WM_INPUT messages
RAWINPUTDEVICE Rid[2]; // Register only for mouse messages from wm_input.
//register to get wm_input messages
Rid[0].usUsagePage = HID_USAGE_PAGE_GENERIC;
Rid[0].usUsage = HID_USAGE_GENERIC_MOUSE;
Rid[0].dwFlags = 0;// RIDEV_NOLEGACY; // adds HID mouse and also ignores legacy mouse messages
Rid[0].hwndTarget = NULL;
Rid[1].usUsagePage = HID_USAGE_PAGE_GENERIC;
Rid[1].usUsage = HID_USAGE_GENERIC_KEYBOARD;
Rid[1].dwFlags = 0;// RIDEV_NOLEGACY; // adds HID mouse and also ignores legacy mouse messages
Rid[1].hwndTarget = NULL;
// Register to receive the WM_INPUT message for any change in mouse (buttons, wheel, and movement will all generate the same message)
if (!/* RegisterRawInputDevices*/ (*_RRID)(Rid, 2, sizeof(Rid[0])))
return 0;
return 1;
}
//============================================================
// destroy_raw_mouse
//============================================================
void destroy_raw_mouse(void)
{
free(raw_mice);
}
//============================================================
// read_raw_input
//============================================================
BOOL read_raw_input(PRAWINPUT raw)
{
//printf("t=%d\n", raw->header.dwType); fflush(stdout);
// mouse 0 is sysmouse, so if there is not sysmouse start loop @0
int i = 0;
if (include_sys_mouse) i++;
for (; i < (nraw_mouse_count + excluded_sysmouse_devices_count); i++) {
if (raw_mice[i].device_handle == raw->header.hDevice)
{
// Update the values for the specified mouse
if (include_individual_mice) {
if (raw_mice[i].is_absolute) {
raw_mice[i].x = raw->data.mouse.lLastX;
raw_mice[i].y = raw->data.mouse.lLastY;
} else { // relative
raw_mice[i].x += raw->data.mouse.lLastX;
raw_mice[i].y += raw->data.mouse.lLastY;
}
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_1_DOWN) raw_mice[i].buttonpressed[0] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_1_UP) raw_mice[i].buttonpressed[0] = 0;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_2_DOWN) raw_mice[i].buttonpressed[1] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_2_UP) raw_mice[i].buttonpressed[1] = 0;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_3_DOWN) raw_mice[i].buttonpressed[2] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_3_UP) raw_mice[i].buttonpressed[2] = 0;
if (raw->data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE) raw_mice[i].is_absolute = 1;
else if (raw->data.mouse.usFlags & MOUSE_MOVE_RELATIVE) raw_mice[i].is_absolute = 0;
if (raw->data.mouse.usFlags & MOUSE_VIRTUAL_DESKTOP) raw_mice[i].is_virtual_desktop = 1;
else raw_mice[i].is_virtual_desktop = 0;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_WHEEL) { // If the current message has a mouse_wheel message
if ((SHORT)raw->data.mouse.usButtonData > 0) {
raw_mice[i].z++;
}
if ((SHORT)raw->data.mouse.usButtonData < 0) {
raw_mice[i].z--;
}
}
}
// Feed the values for every mouse into the system mouse
if (include_sys_mouse) {
if (raw_mice[i].is_absolute) {
raw_mice[RAW_SYS_MOUSE].x = raw->data.mouse.lLastX;
raw_mice[RAW_SYS_MOUSE].y = raw->data.mouse.lLastY;
} else { // relative
raw_mice[RAW_SYS_MOUSE].x += raw->data.mouse.lLastX;
raw_mice[RAW_SYS_MOUSE].y += raw->data.mouse.lLastY;
}
// This is innacurate: If 2 mice have their buttons down and I lift up on one, this will register the
// system mouse as being "up". I checked out on my windows desktop, and Microsoft was just as
// lazy as I'm going to be. Drag an icon with the 2 left mouse buttons held down & let go of one.
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_1_DOWN) raw_mice[RAW_SYS_MOUSE].buttonpressed[0] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_1_UP) raw_mice[RAW_SYS_MOUSE].buttonpressed[0] = 0;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_2_DOWN) raw_mice[RAW_SYS_MOUSE].buttonpressed[1] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_2_UP) raw_mice[RAW_SYS_MOUSE].buttonpressed[1] = 0;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_3_DOWN) raw_mice[RAW_SYS_MOUSE].buttonpressed[2] = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_BUTTON_3_UP) raw_mice[RAW_SYS_MOUSE].buttonpressed[2] = 0;
// If an absolute mouse is triggered, sys mouse will be considered absolute till the end of time.
if (raw->data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE) raw_mice[RAW_SYS_MOUSE].is_absolute = 1;
// Same goes for virtual desktop
if (raw->data.mouse.usFlags & MOUSE_VIRTUAL_DESKTOP) raw_mice[RAW_SYS_MOUSE].is_virtual_desktop = 1;
if (raw->data.mouse.usButtonFlags & RI_MOUSE_WHEEL) { // If the current message has a mouse_wheel message
if ((SHORT)raw->data.mouse.usButtonData > 0) {
raw_mice[RAW_SYS_MOUSE].z++;
}
if ((SHORT)raw->data.mouse.usButtonData < 0) {
raw_mice[RAW_SYS_MOUSE].z--;
}
}
}
}
}
for (i = 0; i < nraw_keyboard_count; i++) {
if (raw_keyboards[i].device_handle != raw->header.hDevice) continue;
int key = raw->data.keyboard.VKey;
if (key < 0 || key >= 0x100) continue;
switch (raw->data.keyboard.Message) {
case WM_KEYDOWN:
if (!raw_keyboards[i].keysdown[key]) {
//printf("key %d pressed on kb %d", key, i); fflush(stdout);
raw_keyboards[i].keysdown[key] = true;
}
break;
case WM_KEYUP:
//printf("key %d released on kb %d", key, i); fflush(stdout);
raw_keyboards[i].keysdown[key] = false;
break;
}
}
return 1;
}
//============================================================
// is_raw_mouse_button_pressed
//============================================================
BOOL is_raw_mouse_button_pressed(int mousenum, int buttonnum) {
// It's ok to ask if buttons are pressed for unitialized mice - just tell 'em no button's pressed
if (mousenum >= nraw_mouse_count || buttonnum >= MAX_RAW_MOUSE_BUTTONS || raw_mice == NULL) return 0;
return (raw_mice[mousenum].buttonpressed[buttonnum]);
}
//============================================================
// is_raw_mouse_absolute
//============================================================
BOOL is_raw_mouse_absolute(int mousenum)
{
return (raw_mice[mousenum].is_absolute);
}
//============================================================
// is_raw_mouse_virtual_desktop
//============================================================
BOOL is_raw_mouse_virtual_desktop(int mousenum)
{
return (raw_mice[mousenum].is_virtual_desktop);
}
//============================================================
// get_raw_mouse_button_name
//============================================================
char *get_raw_mouse_button_name(int mousenum, int buttonnum) {
if (mousenum >= nraw_mouse_count || buttonnum >= MAX_RAW_MOUSE_BUTTONS || raw_mice == NULL) return NULL;
return (raw_mice[mousenum].button_name[buttonnum]);
}
//============================================================
// add_to_raw_mouse_x_and_y
//============================================================
BOOL add_to_raw_mouse_x_and_y(HANDLE in_device_handle)
{
// When the WM_INPUT message is received, the lparam must be passed to this function to keep a running tally of
// every mouse moves to maintain accurate results for get_raw_mouse_?_delta().
// This function will take the HANDLE of the device and find the device in the raw_mice arrayand add the
// x and y mousemove values according to the information stored in the RAWINPUT structure.
LPBYTE lpb;
int dwSize;
if (/* GetRawInputData */(*_GRID)((HRAWINPUT)in_device_handle, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)) == -1) {
fprintf(stderr, "ERROR: Unable to add to get size of raw input header.\n");
return 0;
}
lpb = (LPBYTE)malloc(sizeof(LPBYTE) * dwSize);
if (lpb == NULL) {
fprintf(stderr, "ERROR: Unable to allocate memory for raw input header.\n");
return 0;
}
if (/* GetRawInputData */(*_GRID)((HRAWINPUT)in_device_handle, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize) {
fprintf(stderr, "ERROR: Unable to add to get raw input header.\n");
return 0;
}
read_raw_input((RAWINPUT*)lpb);
free(lpb);
return 1;
}
//============================================================
// get_raw_mouse_x_delta
//============================================================
ULONG get_raw_mouse_x_delta(int mousenum)
{
ULONG nReturn = 0;
if (raw_mice != NULL && mousenum < nraw_mouse_count) {
nReturn = raw_mice[mousenum].x;
if (!raw_mice[mousenum].is_absolute) raw_mice[mousenum].x = 0;
}
return nReturn;
}
//============================================================
// get_raw_mouse_y_delta
//============================================================
ULONG get_raw_mouse_y_delta(int mousenum)
{
ULONG nReturn = 0;
if (raw_mice != NULL && mousenum < nraw_mouse_count) {
nReturn = raw_mice[mousenum].y;
if (!raw_mice[mousenum].is_absolute) raw_mice[mousenum].y = 0;
}
return nReturn;
}
//============================================================
// get_raw_mouse_z_delta
//============================================================
ULONG get_raw_mouse_z_delta(int mousenum)
{
ULONG nReturn = 0;
if (raw_mice != NULL && mousenum < nraw_mouse_count) {
nReturn = raw_mice[mousenum].z;
if (!raw_mice[mousenum].is_absolute) raw_mice[mousenum].z = 0;
}
return nReturn;
}
// VD: keyboard additions
char* get_raw_mouse_device_name(int mousenum) {
return raw_mice[mousenum].device_name;
}
int raw_keyboard_count() {
return nraw_keyboard_count;
}
BOOL is_raw_keyboard_button_pressed(int kb, int key) {
return raw_keyboards[kb].keysdown[key];
}
// out is an array filled with bit flags (1: down, 2: pressed, 4: released)
// and this should only be called once per frame for that reason
BOOL get_raw_keyboard_buttons(int kb, char* out) {
for (int k = 0; k < 256; k++) {
bool v0 = (out[k] & 1) != 0;
bool v1 = raw_keyboards[kb].keysdown[k];
char v = v1 ? 1 : 0;
if (v1 && !v0) v |= 2;
if (!v1 && v0) v |= 4;
out[k] = v;
}
return true;
}
char* get_raw_keyboard_device_name(int index) {
return raw_keyboards[index].device_name;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.