ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Cleanup GamePad code, pass in mainform dependency

This commit is contained in:
adelikat 2020-01-03 10:38:04 -06:00
parent 038f35f45e
commit 023da20cb9
5 changed files with 198 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
BizHawk.Client.EmuHawk/Input/GamePad.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using SlimDX;
using SlimDX.DirectInput;
@ -7,47 +8,47 @@ namespace BizHawk.Client.EmuHawk
{
public class GamePad
{
// ********************************** Static interface **********************************
private static readonly object SyncObj = new object();
private static readonly List<GamePad> Devices = new List<GamePad>();
private static DirectInput _directInput;
private static readonly object _syncObj = new object();
private static readonly List<GamePad> _devices = new List<GamePad>();
private static DirectInput _dinput;
public static void Initialize()
public static void Initialize(Control parent)
{
lock (_syncObj)
lock (SyncObj)
{
Cleanup();
_dinput = new DirectInput();
_directInput = new DirectInput();
foreach (DeviceInstance device in _dinput.GetDevices(DeviceClass.GameController, DeviceEnumerationFlags.AttachedOnly))
foreach (DeviceInstance device in _directInput.GetDevices(DeviceClass.GameController, DeviceEnumerationFlags.AttachedOnly))
{
Console.WriteLine("joydevice: {0} `{1}`", device.InstanceGuid, device.ProductName);
Console.WriteLine("joy device: {0} `{1}`", device.InstanceGuid, device.ProductName);
if (device.ProductName.Contains("XBOX 360"))
continue; // Don't input XBOX 360 controllers into here; we'll process them via XInput (there are limitations in some trigger axes when xbox pads go over xinput)
var joystick = new Joystick(_dinput, device.InstanceGuid);
joystick.SetCooperativeLevel(GlobalWin.MainForm.Handle, CooperativeLevel.Background | CooperativeLevel.Nonexclusive);
var joystick = new Joystick(_directInput, device.InstanceGuid);
joystick.SetCooperativeLevel(parent.Handle, CooperativeLevel.Background | CooperativeLevel.Nonexclusive);
foreach (DeviceObjectInstance deviceObject in joystick.GetObjects())
{
if ((deviceObject.ObjectType & ObjectDeviceType.Axis) != 0)
{
joystick.GetObjectPropertiesById((int)deviceObject.ObjectType).SetRange(-1000, 1000);
}
}
joystick.Acquire();
GamePad p = new GamePad(device.InstanceName, device.InstanceGuid, joystick, _devices.Count);
_devices.Add(p);
GamePad p = new GamePad(joystick, Devices.Count);
Devices.Add(p);
}
}
}
public static IEnumerable<GamePad> EnumerateDevices()
{
lock (_syncObj)
lock (SyncObj)
{
foreach (var device in _devices)
foreach (var device in Devices)
{
yield return device;
}
@ -56,9 +57,9 @@ namespace BizHawk.Client.EmuHawk
public static void UpdateAll()
{
lock (_syncObj)
lock (SyncObj)
{
foreach (var device in _devices)
foreach (var device in Devices)
{
device.Update();
}
@ -67,34 +68,31 @@ namespace BizHawk.Client.EmuHawk
public static void Cleanup()
{
lock (_syncObj)
lock (SyncObj)
{
foreach (var device in _devices)
foreach (var device in Devices)
{
device.joystick.Dispose();
device._joystick.Dispose();
}
_devices.Clear();
if (_dinput != null)
Devices.Clear();
if (_directInput != null)
{
_dinput.Dispose();
_dinput = null;
_directInput.Dispose();
_directInput = null;
}
}
}
// ********************************** Instance Members **********************************
readonly string name;
readonly Guid guid;
readonly Joystick joystick;
JoystickState state = new JoystickState();
private readonly Joystick _joystick;
private JoystickState _state = new JoystickState();
GamePad(string name, Guid guid, Joystick joystick, int index)
GamePad(Joystick joystick, int index)
{
this.name = name;
this.guid = guid;
this.joystick = joystick;
_joystick = joystick;
PlayerNumber = index + 1;
Update();
InitializeCallbacks();
@ -104,17 +102,21 @@ namespace BizHawk.Client.EmuHawk
{
try
{
if (joystick.Acquire().IsFailure)
if (_joystick.Acquire().IsFailure)
return;
}
catch
{
return;
}
if (joystick.Poll().IsFailure)
return;
state = joystick.GetCurrentState();
if (_joystick.Poll()
.IsFailure)
{
return;
}
_state = _joystick.GetCurrentState();
if (Result.Last.IsFailure)
// do something?
return;
@ -124,124 +126,125 @@ namespace BizHawk.Client.EmuHawk
{
var pis = typeof(JoystickState).GetProperties();
foreach (var pi in pis)
yield return new Tuple<string, float>(pi.Name, 10.0f * (float)(int)pi.GetValue(state, null));
{
yield return new Tuple<string, float>(pi.Name, 10.0f * (float)(int)pi.GetValue(_state, null));
}
}
/// <summary>FOR DEBUGGING ONLY</summary>
public JoystickState GetInternalState()
{
return state;
return _state;
}
public string Name { get { return name; } }
public Guid Guid { get { return guid; } }
public int PlayerNumber { get; private set; }
public int PlayerNumber { get; }
public string ButtonName(int index)
{
return names[index];
return _names[index];
}
public bool Pressed(int index)
{
return actions[index]();
return _actions[index]();
}
public int NumButtons { get; private set; }
private readonly List<string> names = new List<string>();
private readonly List<Func<bool>> actions = new List<Func<bool>>();
private readonly List<string> _names = new List<string>();
private readonly List<Func<bool>> _actions = new List<Func<bool>>();
void AddItem(string _name, Func<bool> callback)
private void AddItem(string name, Func<bool> callback)
{
names.Add(_name);
actions.Add(callback);
_names.Add(name);
_actions.Add(callback);
NumButtons++;
}
void InitializeCallbacks()
private void InitializeCallbacks()
{
const int dzp = 400;
const int dzn = -400;
names.Clear();
actions.Clear();
_names.Clear();
_actions.Clear();
NumButtons = 0;
AddItem("AccelerationX+", () => state.AccelerationX >= dzp);
AddItem("AccelerationX-", () => state.AccelerationX <= dzn);
AddItem("AccelerationY+", () => state.AccelerationY >= dzp);
AddItem("AccelerationY-", () => state.AccelerationY <= dzn);
AddItem("AccelerationZ+", () => state.AccelerationZ >= dzp);
AddItem("AccelerationZ-", () => state.AccelerationZ <= dzn);
AddItem("AngularAccelerationX+", () => state.AngularAccelerationX >= dzp);
AddItem("AngularAccelerationX-", () => state.AngularAccelerationX <= dzn);
AddItem("AngularAccelerationY+", () => state.AngularAccelerationY >= dzp);
AddItem("AngularAccelerationY-", () => state.AngularAccelerationY <= dzn);
AddItem("AngularAccelerationZ+", () => state.AngularAccelerationZ >= dzp);
AddItem("AngularAccelerationZ-", () => state.AngularAccelerationZ <= dzn);
AddItem("AngularVelocityX+", () => state.AngularVelocityX >= dzp);
AddItem("AngularVelocityX-", () => state.AngularVelocityX <= dzn);
AddItem("AngularVelocityY+", () => state.AngularVelocityY >= dzp);
AddItem("AngularVelocityY-", () => state.AngularVelocityY <= dzn);
AddItem("AngularVelocityZ+", () => state.AngularVelocityZ >= dzp);
AddItem("AngularVelocityZ-", () => state.AngularVelocityZ <= dzn);
AddItem("ForceX+", () => state.ForceX >= dzp);
AddItem("ForceX-", () => state.ForceX <= dzn);
AddItem("ForceY+", () => state.ForceY >= dzp);
AddItem("ForceY-", () => state.ForceY <= dzn);
AddItem("ForceZ+", () => state.ForceZ >= dzp);
AddItem("ForceZ-", () => state.ForceZ <= dzn);
AddItem("RotationX+", () => state.RotationX >= dzp);
AddItem("RotationX-", () => state.RotationX <= dzn);
AddItem("RotationY+", () => state.RotationY >= dzp);
AddItem("RotationY-", () => state.RotationY <= dzn);
AddItem("RotationZ+", () => state.RotationZ >= dzp);
AddItem("RotationZ-", () => state.RotationZ <= dzn);
AddItem("TorqueX+", () => state.TorqueX >= dzp);
AddItem("TorqueX-", () => state.TorqueX <= dzn);
AddItem("TorqueY+", () => state.TorqueY >= dzp);
AddItem("TorqueY-", () => state.TorqueY <= dzn);
AddItem("TorqueZ+", () => state.TorqueZ >= dzp);
AddItem("TorqueZ-", () => state.TorqueZ <= dzn);
AddItem("VelocityX+", () => state.VelocityX >= dzp);
AddItem("VelocityX-", () => state.VelocityX <= dzn);
AddItem("VelocityY+", () => state.VelocityY >= dzp);
AddItem("VelocityY-", () => state.VelocityY <= dzn);
AddItem("VelocityZ+", () => state.VelocityZ >= dzp);
AddItem("VelocityZ-", () => state.VelocityZ <= dzn);
AddItem("X+", () => state.X >= dzp);
AddItem("X-", () => state.X <= dzn);
AddItem("Y+", () => state.Y >= dzp);
AddItem("Y-", () => state.Y <= dzn);
AddItem("Z+", () => state.Z >= dzp);
AddItem("Z-", () => state.Z <= dzn);
AddItem("AccelerationX+", () => _state.AccelerationX >= dzp);
AddItem("AccelerationX-", () => _state.AccelerationX <= dzn);
AddItem("AccelerationY+", () => _state.AccelerationY >= dzp);
AddItem("AccelerationY-", () => _state.AccelerationY <= dzn);
AddItem("AccelerationZ+", () => _state.AccelerationZ >= dzp);
AddItem("AccelerationZ-", () => _state.AccelerationZ <= dzn);
AddItem("AngularAccelerationX+", () => _state.AngularAccelerationX >= dzp);
AddItem("AngularAccelerationX-", () => _state.AngularAccelerationX <= dzn);
AddItem("AngularAccelerationY+", () => _state.AngularAccelerationY >= dzp);
AddItem("AngularAccelerationY-", () => _state.AngularAccelerationY <= dzn);
AddItem("AngularAccelerationZ+", () => _state.AngularAccelerationZ >= dzp);
AddItem("AngularAccelerationZ-", () => _state.AngularAccelerationZ <= dzn);
AddItem("AngularVelocityX+", () => _state.AngularVelocityX >= dzp);
AddItem("AngularVelocityX-", () => _state.AngularVelocityX <= dzn);
AddItem("AngularVelocityY+", () => _state.AngularVelocityY >= dzp);
AddItem("AngularVelocityY-", () => _state.AngularVelocityY <= dzn);
AddItem("AngularVelocityZ+", () => _state.AngularVelocityZ >= dzp);
AddItem("AngularVelocityZ-", () => _state.AngularVelocityZ <= dzn);
AddItem("ForceX+", () => _state.ForceX >= dzp);
AddItem("ForceX-", () => _state.ForceX <= dzn);
AddItem("ForceY+", () => _state.ForceY >= dzp);
AddItem("ForceY-", () => _state.ForceY <= dzn);
AddItem("ForceZ+", () => _state.ForceZ >= dzp);
AddItem("ForceZ-", () => _state.ForceZ <= dzn);
AddItem("RotationX+", () => _state.RotationX >= dzp);
AddItem("RotationX-", () => _state.RotationX <= dzn);
AddItem("RotationY+", () => _state.RotationY >= dzp);
AddItem("RotationY-", () => _state.RotationY <= dzn);
AddItem("RotationZ+", () => _state.RotationZ >= dzp);
AddItem("RotationZ-", () => _state.RotationZ <= dzn);
AddItem("TorqueX+", () => _state.TorqueX >= dzp);
AddItem("TorqueX-", () => _state.TorqueX <= dzn);
AddItem("TorqueY+", () => _state.TorqueY >= dzp);
AddItem("TorqueY-", () => _state.TorqueY <= dzn);
AddItem("TorqueZ+", () => _state.TorqueZ >= dzp);
AddItem("TorqueZ-", () => _state.TorqueZ <= dzn);
AddItem("VelocityX+", () => _state.VelocityX >= dzp);
AddItem("VelocityX-", () => _state.VelocityX <= dzn);
AddItem("VelocityY+", () => _state.VelocityY >= dzp);
AddItem("VelocityY-", () => _state.VelocityY <= dzn);
AddItem("VelocityZ+", () => _state.VelocityZ >= dzp);
AddItem("VelocityZ-", () => _state.VelocityZ <= dzn);
AddItem("X+", () => _state.X >= dzp);
AddItem("X-", () => _state.X <= dzn);
AddItem("Y+", () => _state.Y >= dzp);
AddItem("Y-", () => _state.Y <= dzn);
AddItem("Z+", () => _state.Z >= dzp);
AddItem("Z-", () => _state.Z <= dzn);
// i don't know what the "Slider"s do, so they're omitted for the moment
for (int i = 0; i < state.GetButtons().Length; i++)
for (int i = 0; i < _state.GetButtons().Length; i++)
{
int j = i;
AddItem($"B{i + 1}", () => state.IsPressed(j));
AddItem($"B{i + 1}", () => _state.IsPressed(j));
}
for (int i = 0; i < state.GetPointOfViewControllers().Length; i++)
for (int i = 0; i < _state.GetPointOfViewControllers().Length; i++)
{
int j = i;
AddItem($"POV{i + 1}U",
() => { int t = state.GetPointOfViewControllers()[j]; return (t >= 0 && t <= 4500) || (t >= 31500 && t < 36000); });
() => { int t = _state.GetPointOfViewControllers()[j]; return (t >= 0 && t <= 4500) || (t >= 31500 && t < 36000); });
AddItem($"POV{i + 1}D",
() => { int t = state.GetPointOfViewControllers()[j]; return t >= 13500 && t <= 22500; });
() => { int t = _state.GetPointOfViewControllers()[j]; return t >= 13500 && t <= 22500; });
AddItem($"POV{i + 1}L",
() => { int t = state.GetPointOfViewControllers()[j]; return t >= 22500 && t <= 31500; });
() => { int t = _state.GetPointOfViewControllers()[j]; return t >= 22500 && t <= 31500; });
AddItem($"POV{i + 1}R",
() => { int t = state.GetPointOfViewControllers()[j]; return t >= 4500 && t <= 13500; });
() => { int t = _state.GetPointOfViewControllers()[j]; return t >= 4500 && t <= 13500; });
}
}
// Note that this does not appear to work at this time. I probably need to have more infos.
public void SetVibration(int left, int right)
{
int[] temp1, temp2;
// my first clue that it doesnt work is that LEFT and RIGHT _ARENT USED_
// my first clue that it doesn't work is that LEFT and RIGHT _AREN'T USED_
// I should just look for C++ examples instead of trying to look for SlimDX examples
var parameters = new EffectParameters
@ -253,9 +256,9 @@ namespace BizHawk.Client.EmuHawk
TriggerRepeatInterval = 0x2710,
Flags = EffectFlags.None
};
parameters.GetAxes(out temp1, out temp2);
parameters.GetAxes(out var temp1, out var temp2);
parameters.SetAxes(temp1, temp2);
var effect = new Effect(joystick, EffectGuid.ConstantForce);
var effect = new Effect(_joystick, EffectGuid.ConstantForce);
effect.SetParameters(parameters);
effect.Start(1);
}

176
BizHawk.Client.EmuHawk/Input/GamePad360.cs
View File

@ -3,29 +3,23 @@ using System.Collections.Generic;
using System.Runtime.InteropServices;
using BizHawk.Common;
using SlimDX.XInput;
#pragma warning disable 169
#pragma warning disable 414
namespace BizHawk.Client.EmuHawk
{
public class GamePad360
{
// ********************************** Static interface **********************************
private static readonly object _syncObj = new object();
private static readonly List<GamePad360> _devices = new List<GamePad360>();
private static readonly bool _isAvailable;
private static readonly object SyncObj = new object();
private static readonly List<GamePad360> Devices = new List<GamePad360>();
private static readonly bool IsAvailable;
delegate uint XInputGetStateExProcDelegate(uint dwUserIndex, out XINPUT_STATE state);
static bool HasGetInputStateEx;
static IntPtr LibraryHandle;
static XInputGetStateExProcDelegate XInputGetStateExProc;
private static readonly XInputGetStateExProcDelegate XInputGetStateExProc;
struct XINPUT_GAMEPAD
private struct XINPUT_GAMEPAD
{
public ushort wButtons;
public byte bLeftTrigger;
@ -36,7 +30,7 @@ namespace BizHawk.Client.EmuHawk
public short sThumbRY;
}
struct XINPUT_STATE
private struct XINPUT_STATE
{
public uint dwPacketNumber;
public XINPUT_GAMEPAD Gamepad;
@ -51,7 +45,6 @@ namespace BizHawk.Client.EmuHawk
var libraryHandle = llManager.LoadOrNull("xinput1_3.dll") ?? llManager.LoadOrNull("xinput1_4.dll");
if (libraryHandle != null)
{
HasGetInputStateEx = true;
XInputGetStateExProc = (XInputGetStateExProcDelegate) Marshal.GetDelegateForFunctionPointer(
Win32Imports.GetProcAddressOrdinal(libraryHandle.Value, new IntPtr(100)),
typeof(XInputGetStateExProcDelegate)
@ -59,15 +52,13 @@ namespace BizHawk.Client.EmuHawk
}
else
{
HasGetInputStateEx = false;
libraryHandle = llManager.LoadOrNull("xinput9_1_0.dll");
}
_isAvailable = libraryHandle != null;
LibraryHandle = libraryHandle ?? IntPtr.Zero;
IsAvailable = libraryHandle != null;
// don't remove this code. it's important to catch errors on systems with broken xinput installs.
// (probably, checking for the library was adequate, but let's not get rid of this anyway)
if (_isAvailable) _ = new Controller(UserIndex.One).IsConnected;
if (IsAvailable) _ = new Controller(UserIndex.One).IsConnected;
}
catch
{
@ -77,35 +68,35 @@ namespace BizHawk.Client.EmuHawk
public static void Initialize()
{
lock (_syncObj)
lock (SyncObj)
{
_devices.Clear();
Devices.Clear();
if (!_isAvailable)
if (!IsAvailable)
return;
//now, at this point, slimdx may be using one xinput, and we may be using another
//i'm not sure how slimdx picks its dll to bind to.
//now, at this point, SlimDX may be using one xinput, and we may be using another
//i'm not sure how SlimDX picks its dll to bind to.
//i'm not sure how troublesome this will be
//maybe we should get rid of slimdx for this altogether
//maybe we should get rid of SlimDX for this altogether
var c1 = new Controller(UserIndex.One);
var c2 = new Controller(UserIndex.Two);
var c3 = new Controller(UserIndex.Three);
var c4 = new Controller(UserIndex.Four);
if (c1.IsConnected) _devices.Add(new GamePad360(0, c1));
if (c2.IsConnected) _devices.Add(new GamePad360(1, c2));
if (c3.IsConnected) _devices.Add(new GamePad360(2, c3));
if (c4.IsConnected) _devices.Add(new GamePad360(3, c4));
if (c1.IsConnected) Devices.Add(new GamePad360(0, c1));
if (c2.IsConnected) Devices.Add(new GamePad360(1, c2));
if (c3.IsConnected) Devices.Add(new GamePad360(2, c3));
if (c4.IsConnected) Devices.Add(new GamePad360(3, c4));
}
}
public static IEnumerable<GamePad360> EnumerateDevices()
{
lock (_syncObj)
lock (SyncObj)
{
foreach (var device in _devices)
foreach (var device in Devices)
{
yield return device;
}
@ -114,9 +105,9 @@ namespace BizHawk.Client.EmuHawk
public static void UpdateAll()
{
lock (_syncObj)
lock (SyncObj)
{
foreach (var device in _devices)
foreach (var device in Devices)
{
device.Update();
}
@ -125,124 +116,117 @@ namespace BizHawk.Client.EmuHawk
// ********************************** Instance Members **********************************
readonly Controller controller;
uint index0;
XINPUT_STATE state;
private readonly Controller _controller;
private readonly uint _index0;
private XINPUT_STATE _state;
public int PlayerNumber { get { return (int)index0 + 1; } }
public int PlayerNumber => (int)_index0 + 1;
GamePad360(uint index0, Controller c)
{
this.index0 = index0;
controller = c;
this._index0 = index0;
_controller = c;
InitializeButtons();
Update();
}
public void Update()
{
if (controller.IsConnected == false)
if (_controller.IsConnected == false)
return;
if (XInputGetStateExProc != null)
{
state = new XINPUT_STATE();
XInputGetStateExProc(index0, out state);
_state = new XINPUT_STATE();
XInputGetStateExProc(_index0, out _state);
}
else
{
var slimstate = controller.GetState();
state.dwPacketNumber = slimstate.PacketNumber;
state.Gamepad.wButtons = (ushort)slimstate.Gamepad.Buttons;
state.Gamepad.sThumbLX = slimstate.Gamepad.LeftThumbX;
state.Gamepad.sThumbLY = slimstate.Gamepad.LeftThumbY;
state.Gamepad.sThumbRX = slimstate.Gamepad.RightThumbX;
state.Gamepad.sThumbRY = slimstate.Gamepad.RightThumbY;
state.Gamepad.bLeftTrigger = slimstate.Gamepad.LeftTrigger;
state.Gamepad.bRightTrigger = slimstate.Gamepad.RightTrigger;
var slimState = _controller.GetState();
_state.dwPacketNumber = slimState.PacketNumber;
_state.Gamepad.wButtons = (ushort)slimState.Gamepad.Buttons;
_state.Gamepad.sThumbLX = slimState.Gamepad.LeftThumbX;
_state.Gamepad.sThumbLY = slimState.Gamepad.LeftThumbY;
_state.Gamepad.sThumbRX = slimState.Gamepad.RightThumbX;
_state.Gamepad.sThumbRY = slimState.Gamepad.RightThumbY;
_state.Gamepad.bLeftTrigger = slimState.Gamepad.LeftTrigger;
_state.Gamepad.bRightTrigger = slimState.Gamepad.RightTrigger;
}
}
public IEnumerable<Tuple<string, float>> GetFloats()
{
var g = state.Gamepad;
var g = _state.Gamepad;
//constant for adapting a +/- 32768 range to a +/-10000-based range
const float f = 32768 / 10000.0f;
//since our whole input framework really only understands whole axes, let's make the triggers look like an axis
float ltrig = g.bLeftTrigger / 255.0f * 2 - 1;
float rtrig = g.bRightTrigger / 255.0f * 2 - 1;
ltrig *= 10000;
rtrig *= 10000;
float lTrig = g.bLeftTrigger / 255.0f * 2 - 1;
float rTrig = g.bRightTrigger / 255.0f * 2 - 1;
lTrig *= 10000;
rTrig *= 10000;
yield return new Tuple<string, float>("LeftThumbX", g.sThumbLX / f);
yield return new Tuple<string, float>("LeftThumbY", g.sThumbLY / f);
yield return new Tuple<string, float>("RightThumbX", g.sThumbRX / f);
yield return new Tuple<string, float>("RightThumbY", g.sThumbRY / f);
yield return new Tuple<string, float>("LeftTrigger", ltrig);
yield return new Tuple<string, float>("RightTrigger", rtrig);
yield break;
yield return new Tuple<string, float>("LeftTrigger", lTrig);
yield return new Tuple<string, float>("RightTrigger", rTrig);
}
public int NumButtons { get; private set; }
private readonly List<string> names = new List<string>();
private readonly List<Func<bool>> actions = new List<Func<bool>>();
private readonly List<string> _names = new List<string>();
private readonly List<Func<bool>> _actions = new List<Func<bool>>();
void InitializeButtons()
private void InitializeButtons()
{
const int dzp = 20000;
const int dzn = -20000;
const int dzt = 40;
AddItem("A", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.A) != 0);
AddItem("B", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.B) != 0);
AddItem("X", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.X) != 0);
AddItem("Y", () => (state.Gamepad.wButtons & unchecked((ushort)GamepadButtonFlags.Y)) != 0);
AddItem("Guide", () => (state.Gamepad.wButtons & 1024) != 0);
AddItem("A", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.A) != 0);
AddItem("B", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.B) != 0);
AddItem("X", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.X) != 0);
AddItem("Y", () => (_state.Gamepad.wButtons & unchecked((ushort)GamepadButtonFlags.Y)) != 0);
AddItem("Guide", () => (_state.Gamepad.wButtons & 1024) != 0);
AddItem("Start", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.Start) != 0);
AddItem("Back", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.Back) != 0);
AddItem("LeftThumb", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.LeftThumb) != 0);
AddItem("RightThumb", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.RightThumb) != 0);
AddItem("LeftShoulder", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.LeftShoulder) != 0);
AddItem("RightShoulder", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.RightShoulder) != 0);
AddItem("Start", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.Start) != 0);
AddItem("Back", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.Back) != 0);
AddItem("LeftThumb", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.LeftThumb) != 0);
AddItem("RightThumb", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.RightThumb) != 0);
AddItem("LeftShoulder", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.LeftShoulder) != 0);
AddItem("RightShoulder", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.RightShoulder) != 0);
AddItem("DpadUp", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadUp) != 0);
AddItem("DpadDown", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadDown) != 0);
AddItem("DpadLeft", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadLeft) != 0);
AddItem("DpadRight", () => (state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadRight) != 0);
AddItem("DpadUp", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadUp) != 0);
AddItem("DpadDown", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadDown) != 0);
AddItem("DpadLeft", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadLeft) != 0);
AddItem("DpadRight", () => (_state.Gamepad.wButtons & (ushort)GamepadButtonFlags.DPadRight) != 0);
AddItem("LStickUp", () => state.Gamepad.sThumbLY >= dzp);
AddItem("LStickDown", () => state.Gamepad.sThumbLY <= dzn);
AddItem("LStickLeft", () => state.Gamepad.sThumbLX <= dzn);
AddItem("LStickRight", () => state.Gamepad.sThumbLX >= dzp);
AddItem("LStickUp", () => _state.Gamepad.sThumbLY >= dzp);
AddItem("LStickDown", () => _state.Gamepad.sThumbLY <= dzn);
AddItem("LStickLeft", () => _state.Gamepad.sThumbLX <= dzn);
AddItem("LStickRight", () => _state.Gamepad.sThumbLX >= dzp);
AddItem("RStickUp", () => state.Gamepad.sThumbRY >= dzp);
AddItem("RStickDown", () => state.Gamepad.sThumbRY <= dzn);
AddItem("RStickLeft", () => state.Gamepad.sThumbRX <= dzn);
AddItem("RStickRight", () => state.Gamepad.sThumbRX >= dzp);
AddItem("RStickUp", () => _state.Gamepad.sThumbRY >= dzp);
AddItem("RStickDown", () => _state.Gamepad.sThumbRY <= dzn);
AddItem("RStickLeft", () => _state.Gamepad.sThumbRX <= dzn);
AddItem("RStickRight", () => _state.Gamepad.sThumbRX >= dzp);
AddItem("LeftTrigger", () => state.Gamepad.bLeftTrigger > dzt);
AddItem("RightTrigger", () => state.Gamepad.bRightTrigger > dzt);
AddItem("LeftTrigger", () => _state.Gamepad.bLeftTrigger > dzt);
AddItem("RightTrigger", () => _state.Gamepad.bRightTrigger > dzt);
}
void AddItem(string name, Func<bool> pressed)
private void AddItem(string name, Func<bool> pressed)
{
names.Add(name);
actions.Add(pressed);
_names.Add(name);
_actions.Add(pressed);
NumButtons++;
}
public string ButtonName(int index)
{
return names[index];
}
public string ButtonName(int index) => _names[index];
public bool Pressed(int index)
{
return actions[index]();
}
public bool Pressed(int index) => _actions[index]();
}
}

2
BizHawk.Client.EmuHawk/Input/Input.cs
View File

@ -138,7 +138,7 @@ namespace BizHawk.Client.EmuHawk
{
KeyInput.Initialize(parent);
IPCKeyInput.Initialize();
GamePad.Initialize();
GamePad.Initialize(parent);
GamePad360.Initialize();
}
Instance = new Input();

2
BizHawk.Client.EmuHawk/MainForm.cs
View File

@ -2769,7 +2769,7 @@ namespace BizHawk.Client.EmuHawk
switch (m.Msg)
{
case WmDeviceChange:
GamePad.Initialize();
GamePad.Initialize(this);
GamePad360.Initialize();
break;
}

2
BizHawk.sln.DotSettings
View File

@ -394,6 +394,8 @@
<s:Boolean x:Key="/Default/UserDictionary/Words/=Winform/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=winforms/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=WSWAN/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=XBOX/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=xinput/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=Xjin/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=Yabause/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=Zipheader/@EntryIndexedValue">True</s:Boolean>