mirror of
https://github.com/Ryujinx/Opentk.git
synced 2024-12-27 08:35:32 +00:00
442 lines
17 KiB
C#
Executable file
442 lines
17 KiB
C#
Executable file
#region License
|
|
//
|
|
// The Open Toolkit Library License
|
|
//
|
|
// Copyright (c) 2006 - 2010 the Open Toolkit library.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights to
|
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
// the Software, and to permit persons to whom the Software is furnished to do
|
|
// so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
// OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime.InteropServices;
|
|
using OpenTK.Input;
|
|
|
|
namespace OpenTK.Platform.MacOS
|
|
{
|
|
using Carbon;
|
|
using CFAllocatorRef = System.IntPtr;
|
|
using CFDictionaryRef = System.IntPtr;
|
|
using CFIndex = System.IntPtr;
|
|
using CFRunLoop = System.IntPtr;
|
|
using CFString = System.IntPtr;
|
|
using CFStringRef = System.IntPtr; // Here used interchangeably with the CFString
|
|
using CFTypeRef = System.IntPtr;
|
|
using IOHIDDeviceRef = System.IntPtr;
|
|
using IOHIDElementRef = System.IntPtr;
|
|
using IOHIDManagerRef = System.IntPtr;
|
|
using IOHIDValueRef = System.IntPtr;
|
|
using IOOptionBits = System.IntPtr;
|
|
using IOReturn = System.IntPtr;
|
|
|
|
class HIDInput : IMouseDriver2
|
|
{
|
|
#region Fields
|
|
|
|
readonly IOHIDManagerRef hidmanager;
|
|
|
|
readonly Dictionary<IntPtr, MouseState> MouseDevices =
|
|
new Dictionary<IntPtr, MouseState>(new IntPtrEqualityComparer());
|
|
readonly Dictionary<int, IntPtr> MouseIndexToDevice =
|
|
new Dictionary<int, IntPtr>();
|
|
|
|
readonly CFRunLoop RunLoop = CF.CFRunLoopGetMain();
|
|
readonly CFString InputLoopMode = CF.RunLoopModeDefault;
|
|
readonly CFDictionary DeviceTypes = new CFDictionary();
|
|
|
|
readonly NativeMethods.IOHIDDeviceCallback HandleDeviceAdded;
|
|
readonly NativeMethods.IOHIDDeviceCallback HandleDeviceRemoved;
|
|
readonly NativeMethods.IOHIDValueCallback HandleDeviceValueReceived;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public HIDInput()
|
|
{
|
|
Debug.Print("Using {0}.", typeof(HIDInput).Name);
|
|
|
|
HandleDeviceAdded = DeviceAdded;
|
|
HandleDeviceRemoved = DeviceRemoved;
|
|
HandleDeviceValueReceived = DeviceValueReceived;
|
|
|
|
hidmanager = CreateHIDManager();
|
|
RegisterHIDCallbacks(hidmanager);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Members
|
|
|
|
IOHIDManagerRef CreateHIDManager()
|
|
{
|
|
return NativeMethods.IOHIDManagerCreate(IntPtr.Zero, IntPtr.Zero);
|
|
}
|
|
|
|
// Registers callbacks for device addition and removal. These callbacks
|
|
// are called when we run the loop in CheckDevicesMode
|
|
void RegisterHIDCallbacks(IOHIDManagerRef hidmanager)
|
|
{
|
|
NativeMethods.IOHIDManagerRegisterDeviceMatchingCallback(
|
|
hidmanager, HandleDeviceAdded, IntPtr.Zero);
|
|
NativeMethods.IOHIDManagerRegisterDeviceRemovalCallback(
|
|
hidmanager, HandleDeviceRemoved, IntPtr.Zero);
|
|
NativeMethods.IOHIDManagerScheduleWithRunLoop(hidmanager,
|
|
RunLoop, InputLoopMode);
|
|
|
|
NativeMethods.IOHIDManagerSetDeviceMatching(hidmanager, DeviceTypes.Ref);
|
|
NativeMethods.IOHIDManagerOpen(hidmanager, IOOptionBits.Zero);
|
|
}
|
|
|
|
void DeviceAdded(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device)
|
|
{
|
|
Debug.Print("Device {0} discovered", device);
|
|
|
|
if (NativeMethods.IOHIDDeviceOpen(device, IOOptionBits.Zero) == IOReturn.Zero)
|
|
{
|
|
Debug.Print("Device {0} connected", device);
|
|
|
|
if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse))
|
|
{
|
|
MouseState state = new MouseState();
|
|
state.IsConnected = true;
|
|
MouseIndexToDevice.Add(MouseDevices.Count, device);
|
|
MouseDevices.Add(device, state);
|
|
}
|
|
|
|
NativeMethods.IOHIDDeviceRegisterInputValueCallback(device,
|
|
HandleDeviceValueReceived, IntPtr.Zero);
|
|
NativeMethods.IOHIDDeviceScheduleWithRunLoop(device, RunLoop, InputLoopMode);
|
|
}
|
|
}
|
|
|
|
void DeviceRemoved(IntPtr context, IOReturn res, IntPtr sender, IOHIDDeviceRef device)
|
|
{
|
|
Debug.Print("Device {0} disconnected", device);
|
|
|
|
if (NativeMethods.IOHIDDeviceConformsTo(device, HIDPage.GenericDesktop, (int)HIDUsageGD.Mouse) &&
|
|
MouseDevices.ContainsKey(device))
|
|
{
|
|
// Keep the device in case it comes back later on
|
|
MouseState state = MouseDevices[device];
|
|
state.IsConnected = false;
|
|
MouseDevices[device] = state;
|
|
}
|
|
|
|
NativeMethods.IOHIDDeviceRegisterInputValueCallback(device, null, IntPtr.Zero);
|
|
NativeMethods.IOHIDDeviceUnscheduleWithRunLoop(device, RunLoop, InputLoopMode);
|
|
}
|
|
|
|
void DeviceValueReceived(IntPtr context, IOReturn res, IntPtr sender, IOHIDValueRef val)
|
|
{
|
|
MouseState mouse;
|
|
if (MouseDevices.TryGetValue(sender, out mouse))
|
|
{
|
|
MouseDevices[sender] = UpdateMouse(mouse, val);
|
|
}
|
|
}
|
|
|
|
static MouseState UpdateMouse(MouseState state, IOHIDValueRef val)
|
|
{
|
|
IOHIDElementRef elem = NativeMethods.IOHIDValueGetElement(val);
|
|
int v_int = NativeMethods.IOHIDValueGetIntegerValue(val).ToInt32();
|
|
//double v_physical = NativeMethods.IOHIDValueGetScaledValue(val, IOHIDValueScaleType.Physical);
|
|
//double v_calbrated = NativeMethods.IOHIDValueGetScaledValue(val, IOHIDValueScaleType.Calibrated);
|
|
HIDPage page = NativeMethods.IOHIDElementGetUsagePage(elem);
|
|
int usage = NativeMethods.IOHIDElementGetUsage(elem);
|
|
|
|
switch (page)
|
|
{
|
|
case HIDPage.GenericDesktop:
|
|
switch ((HIDUsageGD)usage)
|
|
{
|
|
case HIDUsageGD.X:
|
|
state.X += v_int;
|
|
break;
|
|
|
|
case HIDUsageGD.Y:
|
|
state.Y += v_int;
|
|
break;
|
|
|
|
case HIDUsageGD.Wheel:
|
|
state.WheelPrecise += v_int;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case HIDPage.Button:
|
|
state[OpenTK.Input.MouseButton.Left + usage - 1] = v_int == 1;
|
|
break;
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IMouseDriver2 Members
|
|
|
|
public MouseState GetState()
|
|
{
|
|
MouseState master = new MouseState();
|
|
foreach (KeyValuePair<IntPtr, MouseState> item in MouseDevices)
|
|
{
|
|
master.MergeBits(item.Value);
|
|
}
|
|
|
|
return master;
|
|
}
|
|
|
|
public MouseState GetState(int index)
|
|
{
|
|
IntPtr device;
|
|
if (MouseIndexToDevice.TryGetValue(index, out device))
|
|
{
|
|
return MouseDevices[device];
|
|
}
|
|
|
|
return new MouseState();
|
|
}
|
|
|
|
public void SetPosition(double x, double y)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region NativeMethods
|
|
|
|
class NativeMethods
|
|
{
|
|
const string hid = "/System/Library/Frameworks/IOKit.framework/Versions/Current/IOKit";
|
|
public static readonly CFString IOHIDDeviceUsageKey = CF.CFSTR("DeviceUsage");
|
|
public static readonly CFString IOHIDDeviceUsagePageKey = CF.CFSTR("DeviceUsagePage");
|
|
public static readonly CFString IOHIDDeviceUsagePairsKey = CF.CFSTR("DeviceUsagePairs");
|
|
|
|
[DllImport(hid)]
|
|
public static extern IOHIDManagerRef IOHIDManagerCreate(
|
|
CFAllocatorRef allocator, IOOptionBits options) ;
|
|
|
|
// This routine will be called when a new (matching) device is connected.
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDManagerRegisterDeviceMatchingCallback(
|
|
IOHIDManagerRef inIOHIDManagerRef,
|
|
IOHIDDeviceCallback inIOHIDDeviceCallback,
|
|
IntPtr inContext);
|
|
|
|
// This routine will be called when a (matching) device is disconnected.
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDManagerRegisterDeviceRemovalCallback(
|
|
IOHIDManagerRef inIOHIDManagerRef,
|
|
IOHIDDeviceCallback inIOHIDDeviceCallback,
|
|
IntPtr inContext);
|
|
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDManagerScheduleWithRunLoop(
|
|
IOHIDManagerRef inIOHIDManagerRef,
|
|
CFRunLoop inCFRunLoop,
|
|
CFString inCFRunLoopMode);
|
|
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDManagerSetDeviceMatching(
|
|
IOHIDManagerRef manager,
|
|
CFDictionaryRef matching) ;
|
|
|
|
[DllImport(hid)]
|
|
public static extern IOReturn IOHIDManagerOpen(
|
|
IOHIDManagerRef manager,
|
|
IOOptionBits options) ;
|
|
|
|
[DllImport(hid)]
|
|
public static extern IOReturn IOHIDDeviceOpen(
|
|
IOHIDDeviceRef manager,
|
|
IOOptionBits opts);
|
|
|
|
[DllImport(hid)]
|
|
public static extern CFTypeRef IOHIDDeviceGetProperty(
|
|
IOHIDDeviceRef device,
|
|
CFStringRef key);
|
|
|
|
[DllImport(hid)]
|
|
public static extern bool IOHIDDeviceConformsTo(
|
|
IOHIDDeviceRef inIOHIDDeviceRef, // IOHIDDeviceRef for the HID device
|
|
HIDPage inUsagePage, // the usage page to test conformance with
|
|
int inUsage); // the usage to test conformance with
|
|
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDDeviceRegisterInputValueCallback(
|
|
IOHIDDeviceRef device,
|
|
IOHIDValueCallback callback,
|
|
IntPtr context);
|
|
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDDeviceScheduleWithRunLoop(
|
|
IOHIDDeviceRef device,
|
|
CFRunLoop inCFRunLoop,
|
|
CFString inCFRunLoopMode);
|
|
|
|
[DllImport(hid)]
|
|
public static extern void IOHIDDeviceUnscheduleWithRunLoop(
|
|
IOHIDDeviceRef device,
|
|
CFRunLoop inCFRunLoop,
|
|
CFString inCFRunLoopMode);
|
|
|
|
[DllImport(hid)]
|
|
public static extern IOHIDElementRef IOHIDValueGetElement(IOHIDValueRef @value);
|
|
|
|
[DllImport(hid)]
|
|
public static extern CFIndex IOHIDValueGetIntegerValue(IOHIDValueRef @value);
|
|
|
|
[DllImport(hid)]
|
|
public static extern double IOHIDValueGetScaledValue(
|
|
IOHIDValueRef @value,
|
|
IOHIDValueScaleType type) ;
|
|
|
|
[DllImport(hid)]
|
|
public static extern int IOHIDElementGetUsage(IOHIDElementRef elem);
|
|
|
|
[DllImport(hid)]
|
|
public static extern HIDPage IOHIDElementGetUsagePage(IOHIDElementRef elem);
|
|
|
|
public delegate void IOHIDDeviceCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDDeviceRef device);
|
|
public delegate void IOHIDValueCallback(IntPtr ctx, IOReturn res, IntPtr sender, IOHIDValueRef val);
|
|
}
|
|
|
|
enum IOHIDValueScaleType
|
|
{
|
|
Physical, // [device min, device max]
|
|
Calibrated // [-1, +1]
|
|
}
|
|
|
|
enum HIDPage
|
|
{
|
|
Undefined = 0x00,
|
|
GenericDesktop = 0x01,
|
|
Simulation = 0x02,
|
|
VR = 0x03,
|
|
Sport = 0x04,
|
|
Game = 0x05,
|
|
/* Reserved 0x06 */
|
|
KeyboardOrKeypad = 0x07, /* USB Device Class Definition for Human Interface Devices (HID). Note: the usage type for all key codes is Selector (Sel). */
|
|
LEDs = 0x08,
|
|
Button = 0x09,
|
|
Ordinal = 0x0A,
|
|
Telephony = 0x0B,
|
|
Consumer = 0x0C,
|
|
Digitizer = 0x0D,
|
|
/* Reserved 0x0E */
|
|
PID = 0x0F, /* USB Physical Interface Device definitions for force feedback and related devices. */
|
|
Unicode = 0x10,
|
|
/* Reserved 0x11 - 0x13 */
|
|
AlphanumericDisplay = 0x14,
|
|
/* Reserved 0x15 - 0x7F */
|
|
/* Monitor 0x80 - 0x83 USB Device Class Definition for Monitor Devices */
|
|
/* Power 0x84 - 0x87 USB Device Class Definition for Power Devices */
|
|
PowerDevice = 0x84, /* Power Device Page */
|
|
BatterySystem = 0x85, /* Battery System Page */
|
|
/* Reserved 0x88 - 0x8B */
|
|
BarCodeScanner = 0x8C, /* (Point of Sale) USB Device Class Definition for Bar Code Scanner Devices */
|
|
WeighingDevice = 0x8D, /* (Point of Sale) USB Device Class Definition for Weighing Devices */
|
|
Scale = 0x8D, /* (Point of Sale) USB Device Class Definition for Scale Devices */
|
|
MagneticStripeReader = 0x8E,
|
|
/* ReservedPointofSalepages 0x8F */
|
|
CameraControl = 0x90, /* USB Device Class Definition for Image Class Devices */
|
|
Arcade = 0x91, /* OAAF Definitions for arcade and coinop related Devices */
|
|
/* Reserved 0x92 - 0xFEFF */
|
|
/* VendorDefined 0xFF00 - 0xFFFF */
|
|
VendorDefinedStart = 0xFF00
|
|
}
|
|
|
|
// Generic desktop usage
|
|
enum HIDUsageGD
|
|
{
|
|
Pointer = 0x01, /* Physical Collection */
|
|
Mouse = 0x02, /* Application Collection */
|
|
/* 0x03 Reserved */
|
|
Joystick = 0x04, /* Application Collection */
|
|
GamePad = 0x05, /* Application Collection */
|
|
Keyboard = 0x06, /* Application Collection */
|
|
Keypad = 0x07, /* Application Collection */
|
|
MultiAxisController = 0x08, /* Application Collection */
|
|
/* 0x09 - 0x2F Reserved */
|
|
X = 0x30, /* Dynamic Value */
|
|
Y = 0x31, /* Dynamic Value */
|
|
Z = 0x32, /* Dynamic Value */
|
|
Rx = 0x33, /* Dynamic Value */
|
|
Ry = 0x34, /* Dynamic Value */
|
|
Rz = 0x35, /* Dynamic Value */
|
|
Slider = 0x36, /* Dynamic Value */
|
|
Dial = 0x37, /* Dynamic Value */
|
|
Wheel = 0x38, /* Dynamic Value */
|
|
Hatswitch = 0x39, /* Dynamic Value */
|
|
CountedBuffer = 0x3A, /* Logical Collection */
|
|
ByteCount = 0x3B, /* Dynamic Value */
|
|
MotionWakeup = 0x3C, /* One-Shot Control */
|
|
Start = 0x3D, /* On/Off Control */
|
|
Select = 0x3E, /* On/Off Control */
|
|
/* 0x3F Reserved */
|
|
Vx = 0x40, /* Dynamic Value */
|
|
Vy = 0x41, /* Dynamic Value */
|
|
Vz = 0x42, /* Dynamic Value */
|
|
Vbrx = 0x43, /* Dynamic Value */
|
|
Vbry = 0x44, /* Dynamic Value */
|
|
Vbrz = 0x45, /* Dynamic Value */
|
|
Vno = 0x46, /* Dynamic Value */
|
|
/* 0x47 - 0x7F Reserved */
|
|
SystemControl = 0x80, /* Application Collection */
|
|
SystemPowerDown = 0x81, /* One-Shot Control */
|
|
SystemSleep = 0x82, /* One-Shot Control */
|
|
SystemWakeUp = 0x83, /* One-Shot Control */
|
|
SystemContextMenu = 0x84, /* One-Shot Control */
|
|
SystemMainMenu = 0x85, /* One-Shot Control */
|
|
SystemAppMenu = 0x86, /* One-Shot Control */
|
|
SystemMenuHelp = 0x87, /* One-Shot Control */
|
|
SystemMenuExit = 0x88, /* One-Shot Control */
|
|
SystemMenu = 0x89, /* Selector */
|
|
SystemMenuRight = 0x8A, /* Re-Trigger Control */
|
|
SystemMenuLeft = 0x8B, /* Re-Trigger Control */
|
|
SystemMenuUp = 0x8C, /* Re-Trigger Control */
|
|
SystemMenuDown = 0x8D, /* Re-Trigger Control */
|
|
/* 0x8E - 0x8F Reserved */
|
|
DPadUp = 0x90, /* On/Off Control */
|
|
DPadDown = 0x91, /* On/Off Control */
|
|
DPadRight = 0x92, /* On/Off Control */
|
|
DPadLeft = 0x93, /* On/Off Control */
|
|
/* 0x94 - 0xFFFF Reserved */
|
|
Reserved = 0xFFFF
|
|
}
|
|
|
|
enum HIDButton
|
|
{
|
|
Button_1 = 0x01, /* (primary/trigger) */
|
|
Button_2 = 0x02, /* (secondary) */
|
|
Button_3 = 0x03, /* (tertiary) */
|
|
Button_4 = 0x04, /* 4th button */
|
|
/* ... */
|
|
Button_65535 = 0xFFFF
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|