public void State_CanWaitForStateChangeWithinGivenAmountOfTime()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
var monitorFired = false;
var timeoutFired = false;
double? receivedTime = null;
int? receivedTimerIndex = null;
InputControl receivedControl = null;
var monitor = InputSystem.AddStateChangeMonitor(gamepad.leftStick,
(control, time, monitorIndex) =>
{
Assert.That(!monitorFired);
monitorFired = true;
}, timerExpiredCallback:
(control, time, monitorIndex, timerIndex) =>
{
Assert.That(!timeoutFired);
timeoutFired = true;
receivedTime = time;
receivedTimerIndex = timerIndex;
receivedControl = control;
});
// Add and immediately expire timeout.
InputSystem.AddStateChangeMonitorTimeout(gamepad.leftStick, monitor, testRuntime.currentTime + 1,
timerIndex: 1234);
testRuntime.currentTime += 2;
InputSystem.Update();
Assert.That(timeoutFired);
Assert.That(!monitorFired);
Assert.That(receivedTimerIndex.Value, Is.EqualTo(1234));
Assert.That(receivedTime.Value, Is.EqualTo(testRuntime.currentTime).Within(0.00001));
Assert.That(receivedControl, Is.SameAs(gamepad.leftStick));
timeoutFired = false;
receivedTimerIndex = null;
receivedTime = null;
// Add timeout and obsolete it by state change. Then advance past timeout time
// and make sure we *don't* get a notification.
InputSystem.AddStateChangeMonitorTimeout(gamepad.leftStick, monitor, testRuntime.currentTime + 1,
timerIndex: 4321);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = Vector2.one
});
InputSystem.Update();
Assert.That(monitorFired);
Assert.That(!timeoutFired);
testRuntime.currentTime += 2;
InputSystem.Update();
Assert.That(!timeoutFired);
// Add and remove timeout. Then advance past timeout time and make sure we *don't*
// get a notification.
InputSystem.AddStateChangeMonitorTimeout(gamepad.leftStick, monitor, testRuntime.currentTime + 1,
timerIndex: 1423);
InputSystem.RemoveStateChangeMonitorTimeout(monitor, timerIndex: 1423);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = Vector2.one
});
InputSystem.Update();
Assert.That(!timeoutFired);
}
public void Remote_CanConnectInputSystemsOverEditorPlayerConnection()
{
#if UNITY_EDITOR
// In the editor, RemoteInputPlayerConnection is a scriptable singleton. Creating multiple instances of it
// will cause an error messages - but will work nevertheless, so we expect those errors to let us run the test.
// We call RemoteInputPlayerConnection.instance once to make sure that we an instance is created, and we get
// a deterministic number of two errors.
var instance = RemoteInputPlayerConnection.instance;
UnityEngine.TestTools.LogAssert.Expect(LogType.Error, "ScriptableSingleton already exists. Did you query the singleton in a constructor?");
UnityEngine.TestTools.LogAssert.Expect(LogType.Error, "ScriptableSingleton already exists. Did you query the singleton in a constructor?");
#endif
var connectionToEditor = ScriptableObject.CreateInstance <RemoteInputPlayerConnection>();
var connectionToPlayer = ScriptableObject.CreateInstance <RemoteInputPlayerConnection>();
connectionToEditor.name = "ConnectionToEditor";
connectionToPlayer.name = "ConnectionToPlayer";
var fakeEditorConnection = new FakePlayerConnection {
playerId = 0
};
var fakePlayerConnection = new FakePlayerConnection {
playerId = 1
};
fakeEditorConnection.otherEnd = fakePlayerConnection;
fakePlayerConnection.otherEnd = fakeEditorConnection;
var observerEditor = new RemoteTestObserver();
var observerPlayer = new RemoteTestObserver();
// In the Unity API, "PlayerConnection" is the connection to the editor
// and "EditorConnection" is the connection to the player. Seems counter-intuitive.
connectionToEditor.Bind(fakePlayerConnection, true);
connectionToPlayer.Bind(fakeEditorConnection, true);
// Bind a local remote on the player side.
var local = new InputRemoting(InputSystem.s_Manager);
local.Subscribe(connectionToEditor);
connectionToEditor.Subscribe(local);
connectionToPlayer.Subscribe(observerEditor);
connectionToEditor.Subscribe(observerPlayer);
fakeEditorConnection.Send(RemoteInputPlayerConnection.kStartSendingMsg, null);
var device = InputSystem.AddDevice <Gamepad>();
InputSystem.QueueStateEvent(device, new GamepadState());
InputSystem.Update();
InputSystem.RemoveDevice(device);
fakeEditorConnection.Send(RemoteInputPlayerConnection.kStopSendingMsg, null);
// We should not obseve any messages for these, as we stopped sending!
device = InputSystem.AddDevice <Gamepad>();
InputSystem.QueueStateEvent(device, new GamepadState());
InputSystem.Update();
InputSystem.RemoveDevice(device);
fakeEditorConnection.DisconnectAll();
////TODO: make sure that we also get the connection sequence right and send our initial layouts and devices
Assert.That(observerEditor.messages, Has.Count.EqualTo(5));
Assert.That(observerEditor.messages[0].type, Is.EqualTo(InputRemoting.MessageType.Connect));
Assert.That(observerEditor.messages[1].type, Is.EqualTo(InputRemoting.MessageType.NewDevice));
Assert.That(observerEditor.messages[2].type, Is.EqualTo(InputRemoting.MessageType.NewEvents));
Assert.That(observerEditor.messages[3].type, Is.EqualTo(InputRemoting.MessageType.RemoveDevice));
Assert.That(observerEditor.messages[4].type, Is.EqualTo(InputRemoting.MessageType.Disconnect));
Assert.That(observerPlayer.messages, Has.Count.EqualTo(3));
Assert.That(observerPlayer.messages[0].type, Is.EqualTo(InputRemoting.MessageType.Connect));
Assert.That(observerPlayer.messages[1].type, Is.EqualTo(InputRemoting.MessageType.StartSending));
Assert.That(observerPlayer.messages[2].type, Is.EqualTo(InputRemoting.MessageType.StopSending));
ScriptableObject.Destroy(connectionToEditor);
ScriptableObject.Destroy(connectionToPlayer);
}
public void Devices_SupportsSwitchNpad()
{
var device = InputSystem.AddDevice(
new InputDeviceDescription
{
interfaceName = "Switch",
manufacturer = "Nintendo",
product = "Wireless Controller",
});
Assert.That(device, Is.TypeOf <NPad>());
var controller = (NPad)device;
InputSystem.QueueStateEvent(controller,
new NPadInputState
{
leftStick = new Vector2(0.123f, 0.456f),
rightStick = new Vector2(0.789f, 0.987f),
acceleration = new Vector3(0.987f, 0.654f, 0.321f),
attitude = new Quaternion(0.111f, 0.222f, 0.333f, 0.444f),
angularVelocity = new Vector3(0.444f, 0.555f, 0.666f),
});
InputSystem.Update();
Assert.That(controller.leftStick.x.ReadValue(), Is.EqualTo(0.123).Within(0.00001));
Assert.That(controller.leftStick.y.ReadValue(), Is.EqualTo(0.456).Within(0.00001));
Assert.That(controller.rightStick.x.ReadValue(), Is.EqualTo(0.789).Within(0.00001));
Assert.That(controller.rightStick.y.ReadValue(), Is.EqualTo(0.987).Within(0.00001));
Assert.That(controller.acceleration.x.ReadValue(), Is.EqualTo(0.987).Within(0.00001));
Assert.That(controller.acceleration.y.ReadValue(), Is.EqualTo(0.654).Within(0.00001));
Assert.That(controller.acceleration.z.ReadValue(), Is.EqualTo(0.321).Within(0.00001));
Quaternion attitude = controller.attitude.ReadValue();
Assert.That(attitude.x, Is.EqualTo(0.111).Within(0.00001));
Assert.That(attitude.y, Is.EqualTo(0.222).Within(0.00001));
Assert.That(attitude.z, Is.EqualTo(0.333).Within(0.00001));
Assert.That(attitude.w, Is.EqualTo(0.444).Within(0.00001));
Assert.That(controller.angularVelocity.x.ReadValue(), Is.EqualTo(0.444).Within(0.00001));
Assert.That(controller.angularVelocity.y.ReadValue(), Is.EqualTo(0.555).Within(0.00001));
Assert.That(controller.angularVelocity.z.ReadValue(), Is.EqualTo(0.666).Within(0.00001));
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.A), controller.buttonEast);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.B), controller.buttonSouth);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.X), controller.buttonNorth);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.Y), controller.buttonWest);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.StickL), controller.leftStickButton);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.StickR), controller.rightStickButton);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.L), controller.leftShoulder);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.R), controller.rightShoulder);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.ZL), controller.leftTrigger);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.ZR), controller.rightTrigger);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.Plus), controller.startButton);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.Minus), controller.selectButton);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.LSL), controller.leftSL);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.LSR), controller.leftSR);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.RSL), controller.rightSL);
AssertButtonPress(controller, new NPadInputState().WithButton(NPadInputState.Button.RSR), controller.rightSR);
}
public void Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
{
var keyboard = InputSystem.AddDevice <Keyboard>();
var asset = ScriptableObject.CreateInstance <InputActionAsset>();
var actionMap = asset.AddActionMap("map");
var action = actionMap.AddAction("action", binding: "<Keyboard>/a");
var canvasGO = new GameObject();
canvasGO.SetActive(false);
canvasGO.AddComponent <Canvas>();
// Set up UI input module.
var eventSystemGO = new GameObject();
eventSystemGO.SetActive(false);
var eventSystem = eventSystemGO.AddComponent <TestEventSystem>();
var uiInputModule = eventSystemGO.AddComponent <InputSystemUIInputModule>();
var inputActions = new DefaultInputActions().asset;
uiInputModule.actionsAsset = inputActions;
uiInputModule.submit = InputActionReference.Create(inputActions["submit"]);
var bindingButtonGO = new GameObject();
bindingButtonGO.transform.parent = canvasGO.transform;
var bindingButton = bindingButtonGO.AddComponent <Button>();
var bindingLabelGO = new GameObject();
bindingLabelGO.transform.parent = bindingButtonGO.transform;
var bindingLabel = bindingLabelGO.AddComponent <Text>();
var rebind = bindingButtonGO.AddComponent <RebindActionUI>();
rebind.bindingId = action.bindings[0].id.ToString();
rebind.actionReference = InputActionReference.Create(action);
rebind.bindingText = bindingLabel;
bindingButton.onClick.AddListener(rebind.StartInteractiveRebind);
canvasGO.SetActive(true);
eventSystemGO.SetActive(true);
eventSystem.SetSelectedGameObject(bindingButtonGO);
eventSystem.InvokeUpdate(); // Initial update switches the input module.
Assert.That(rebind.ongoingRebind, Is.Null);
Assert.That(bindingLabel.text, Is.EqualTo("A"));
// As soon as the submit hits, the rebind starts -- which in turn enables suppression
// of events. This means that the enter key release event will not reach the UI. The
// UI should be fine with that.
PressAndRelease(keyboard.enterKey);
eventSystem.InvokeUpdate();
Assert.That(rebind.ongoingRebind, Is.Not.Null);
Assert.That(rebind.ongoingRebind.started, Is.True);
Assert.That(rebind.ongoingRebind.candidates, Is.Empty);
Assert.That(bindingLabel.text, Is.EqualTo("<Waiting...>"));
Assert.That(inputActions["submit"].inProgress, Is.False);
Press(keyboard.bKey);
eventSystem.InvokeUpdate();
Assert.That(rebind.ongoingRebind, Is.Not.Null);
Assert.That(rebind.ongoingRebind.started, Is.True);
Assert.That(rebind.ongoingRebind.candidates, Is.EquivalentTo(new[] { keyboard.bKey }));
Assert.That(bindingLabel.text, Is.EqualTo("<Waiting...>"));
Assert.That(inputActions["submit"].inProgress, Is.False);
// Expire rebind wait time.
currentTime += 1;
InputSystem.Update();
Assert.That(rebind.ongoingRebind, Is.Null);
Assert.That(bindingLabel.text, Is.EqualTo("B"));
Assert.That(inputActions["submit"].inProgress, Is.False);
// Start another rebind via "Submit".
PressAndRelease(keyboard.enterKey);
eventSystem.InvokeUpdate();
Assert.That(rebind.ongoingRebind, Is.Not.Null);
Assert.That(rebind.ongoingRebind.started, Is.True);
Assert.That(rebind.ongoingRebind.candidates, Is.Empty);
Assert.That(bindingLabel.text, Is.EqualTo("<Waiting...>"));
}
public unsafe void Events_AreTimeslicedByDefault()
{
runtime.fixedUpdateIntervalInSeconds = 1.0 / 60; // 60 FPS.
var gamepad = InputSystem.AddDevice <Gamepad>();
var receivedEvents = new List <InputEvent>();
InputSystem.onEvent +=
eventPtr => receivedEvents.Add(*eventPtr.ToPointer());
// First fixed update should just take everything.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.1234f
}, 1);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.2345f
}, 2);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.3456f
}, 2.9);
runtime.currentTime = 3;
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(3));
Assert.That(receivedEvents[0].time, Is.EqualTo(1).Within(0.00001));
Assert.That(receivedEvents[1].time, Is.EqualTo(2).Within(0.00001));
Assert.That(receivedEvents[2].time, Is.EqualTo(2.9).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.3456).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
Assert.That(InputUpdate.s_LastFixedUpdateTime, Is.EqualTo(3).Within(0.0001));
receivedEvents.Clear();
// From now on, fixed updates should only take what falls in their slice.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.1234f
}, 3 + 0.001);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.2345f
}, 3 + 0.002);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.3456f
}, 3 + 1.0 / 60 + 0.001);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.4567f
}, 3 + 2 * (1.0 / 60) + 0.001);
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(2));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 0.001).Within(0.00001));
Assert.That(receivedEvents[1].time, Is.EqualTo(3 + 0.002).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.2345).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.EqualTo(2));
Assert.That(InputUpdate.s_LastFixedUpdateTime, Is.EqualTo(3 + 1.0 / 60).Within(0.0001));
receivedEvents.Clear();
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(1));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 1.0 / 60 + 0.001).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.3456).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.EqualTo(1));
Assert.That(InputUpdate.s_LastFixedUpdateTime, Is.EqualTo(3 + 2 * (1.0 / 60)).Within(0.0001));
receivedEvents.Clear();
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(1));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 2 * (1.0 / 60) + 0.001).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.4567).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
Assert.That(InputUpdate.s_LastFixedUpdateTime, Is.EqualTo(3 + 3 * (1.0 / 60)).Within(0.0001));
receivedEvents.Clear();
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.Zero);
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.4567).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
Assert.That(InputUpdate.s_LastFixedUpdateTime, Is.EqualTo(3 + 4 * (1.0 / 60)).Within(0.0001));
}
private void SetupInputControl()
{
Debug.Assert(m_Control == null);
Debug.Assert(m_NextControlOnDevice == null);
Debug.Assert(!m_InputEventPtr.valid);
// Nothing to do if we don't have a control path.
if (string.IsNullOrEmpty(m_ControlPath))
{
return;
}
// Determine what type of device to work with.
var layoutName = InputControlPath.TryGetDeviceLayout(m_ControlPath);
if (layoutName == null)
{
Debug.LogError(
string.Format(
"Cannot determine device layout to use based on control path '{0}' used in {1} component",
m_ControlPath, GetType().Name), this);
return;
}
// Try to find existing on-screen device that matches.
var internedLayoutName = new InternedString(layoutName);
var deviceInfoIndex = -1;
for (var i = 0; i < s_OnScreenDevices.length; ++i)
{
if (s_OnScreenDevices[i].device.m_Layout == internedLayoutName)
{
deviceInfoIndex = i;
break;
}
}
// If we don't have a matching one, create a new one.
InputDevice device;
if (deviceInfoIndex == -1)
{
// Try to create device.
try
{
device = InputSystem.AddDevice(layoutName);
}
catch (Exception exception)
{
Debug.LogError(string.Format("Could not create device with layout '{0}' used in '{1}' component", layoutName,
GetType().Name));
Debug.LogException(exception);
return;
}
// Create event buffer.
InputEventPtr eventPtr;
var buffer = StateEvent.From(device, out eventPtr, Allocator.Persistent);
// Add to list.
deviceInfoIndex = s_OnScreenDevices.Append(new OnScreenDeviceInfo
{
eventPtr = eventPtr,
buffer = buffer,
device = device,
});
}
else
{
device = s_OnScreenDevices[deviceInfoIndex].device;
}
// Try to find control on device.
m_Control = InputControlPath.TryFindControl(device, m_ControlPath);
if (m_Control == null)
{
Debug.LogError(
string.Format(
"Cannot find control with path '{0}' on device of type '{1}' referenced by component '{2}'",
m_ControlPath, layoutName, GetType().Name), this);
// Remove the device, if we just created one.
if (s_OnScreenDevices[deviceInfoIndex].firstControl == null)
{
s_OnScreenDevices[deviceInfoIndex].Destroy();
s_OnScreenDevices.RemoveAt(deviceInfoIndex);
}
return;
}
m_InputEventPtr = s_OnScreenDevices[deviceInfoIndex].eventPtr;
// We have all we need. Permanently add us.
s_OnScreenDevices[deviceInfoIndex] =
s_OnScreenDevices[deviceInfoIndex].AddControl(this);
}
public void Users_CanDetectChangeInBindings()
{
var actions = new InputActionMap();
var action = actions.AddAction("action", binding: "<Gamepad>/leftTrigger");
action.Enable();
var gamepad1 = InputSystem.AddDevice <Gamepad>();
var user = InputUser.PerformPairingWithDevice(gamepad1);
user.AssociateActionsWithUser(actions);
InputUser? receivedUser = null;
InputUserChange?receivedChange = null;
InputDevice receivedDevice = null;
InputUser.onChange +=
(u, c, d) =>
{
if (c != InputUserChange.ControlsChanged)
{
return;
}
Assert.That(receivedUser, Is.Null);
Assert.That(receivedChange, Is.Null);
Assert.That(receivedDevice, Is.Null);
receivedUser = u;
receivedChange = c;
receivedDevice = d;
};
// Rebind.
action.ApplyBindingOverride("<Gamepad>/rightTrigger");
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(user));
Assert.That(receivedDevice, Is.Null);
receivedChange = null;
receivedUser = null;
receivedDevice = null;
// Pair new device.
var gamepad2 = InputSystem.AddDevice <Gamepad>();
InputUser.PerformPairingWithDevice(gamepad2, user: user);
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(user));
Assert.That(receivedDevice, Is.Null);
receivedChange = null;
receivedUser = null;
receivedDevice = null;
// Unpair device.
user.UnpairDevice(gamepad1);
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(user));
Assert.That(receivedDevice, Is.Null);
receivedChange = null;
receivedUser = null;
receivedDevice = null;
// Remove user and then add new one.
var oldUser = user;
user.UnpairDevicesAndRemoveUser();
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(oldUser));
Assert.That(receivedDevice, Is.Null);
receivedChange = null;
receivedUser = null;
receivedDevice = null;
user = InputUser.PerformPairingWithDevice(gamepad1);
user.AssociateActionsWithUser(actions);
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(user));
Assert.That(receivedDevice, Is.Null);
receivedChange = null;
receivedUser = null;
receivedDevice = null;
action.ApplyBindingOverride("<Gamepad>/leftTrigger");
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlsChanged));
Assert.That(receivedUser, Is.EqualTo(user));
Assert.That(receivedDevice, Is.Null);
}
private void FixedUpdate()
{
if (Gamepad.current != null)
{
currentGamepad = Gamepad.current;
if (currentGamepad.selectButton.wasPressedThisFrame)
{
m_GameFlowManager.OnJoin();
}
}
var allGamepads = Gamepad.all;
Debug.Log(allGamepads.Count);
currentKeyboard = Keyboard.current;
InputSystem.onDeviceChange +=
(device, change) =>
{
switch (change)
{
case InputDeviceChange.Added:
// New Device
if (device != null)
{
Debug.LogWarning("New device added: " + device);
InputSystem.AddDevice(device);
for (int i = 0; i < Gamepad.all.Count; ++i)
{
if (device == Gamepad.all.ToArray()[i])
{
currentGamepad = Gamepad.all.ToArray()[i];
}
}
//If on touchscreen and gamepad is connected
//Disable touch controls and use gamepad
//Do vice versa
}
break;
case InputDeviceChange.Disconnected:
// Device got unplugged
Debug.LogWarning("Device is disconnected: " + device);
//InputSystem.Dis
break;
case InputDeviceChange.Reconnected:
// Plugged back in
Debug.LogWarning("Device reconnected: " + device);
break;
case InputDeviceChange.Removed:
// Remove from Input System entirely; by default, devices stay in the system once discovered
//Debug.LogWarning("Device removed: " + device);
InputSystem.RemoveDevice(device);
break;
default:
// See InputDeviceChange reference for other event types.
break;
}
};
if (!m_GameFlowManager)
{
m_GameFlowManager = FindObjectOfType <GameFlowManager>();
}
}
public void Users_CanBeMonitoredForChanges()
{
InputUser.Add(new TestUser()); // Noise.
InputUser.Add(new TestUser()); // Noise.
var user = new TestUser();
IInputUser receivedUser = null;
InputUserChange?receivedChange = null;
InputUser.onChange +=
(usr, change) =>
{
Assert.That(receivedChange == null);
receivedUser = usr;
receivedChange = change;
};
// Added.
InputUser.Add(user);
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.Added));
receivedUser = null;
receivedChange = null;
// NameChanged.
user.SetUserName("NewName");
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.NameChanged));
receivedUser = null;
receivedChange = null;
// Same name, no notification.
user.SetUserName("NewName");
Assert.That(receivedChange, Is.Null);
// DevicesChanged.
var device = InputSystem.AddDevice <Gamepad>();
user.AssignInputDevice(device);
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.DevicesChanged));
receivedUser = null;
receivedChange = null;
// Same device, no notification.
user.AssignInputDevice(device);
Assert.That(receivedChange, Is.Null);
// DevicesChanges, removed.
user.ClearAssignedInputDevices();
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.DevicesChanged));
receivedUser = null;
receivedChange = null;
// ControlSchemeChanged.
user.AssignControlScheme("gamepad");
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.ControlSchemeChanged));
receivedUser = null;
receivedChange = null;
// Same control scheme, no notification.
user.AssignControlScheme("gamepad");
Assert.That(receivedChange, Is.Null);
// Removed.
InputUser.Remove(user);
Assert.That(receivedUser, Is.SameAs(user));
Assert.That(receivedChange, Is.EqualTo(InputUserChange.Removed));
////TODO: actions
////TODO: activate, passivate
}
private static void OnUpdate(InputUpdateType updateType)
{
if (api == null)
{
return;
}
// Update controller state.
api.RunFrame();
// Check if we have any new controllers have appeared.
if (s_ConnectedControllers == null)
{
s_ConnectedControllers = new SteamHandle <SteamController> [STEAM_CONTROLLER_MAX_COUNT];
}
var numConnectedControllers = api.GetConnectedControllers(s_ConnectedControllers);
for (var i = 0; i < numConnectedControllers; ++i)
{
var handle = s_ConnectedControllers[i];
// See if we already have a device for this one.
if (s_InputDevices != null)
{
SteamController existingDevice = null;
for (var n = 0; n < s_InputDeviceCount; ++n)
{
if (s_InputDevices[n].steamControllerHandle == handle)
{
existingDevice = s_InputDevices[n];
break;
}
}
// Yes, we do.
if (existingDevice != null)
{
continue;
}
}
////FIXME: this should not create garbage
// No, so create a new device.
var controllerLayouts = InputSystem.ListLayoutsBasedOn("SteamController");
foreach (var layout in controllerLayouts)
{
// Rather than directly creating a device with the layout, let it go through
// the usual matching process.
var device = InputSystem.AddDevice(new InputDeviceDescription
{
interfaceName = SteamController.kSteamInterface,
product = layout
});
// Make sure it's a SteamController we got.
var steamDevice = device as SteamController;
if (steamDevice == null)
{
Debug.LogError(string.Format(
"InputDevice created from layout '{0}' based on the 'SteamController' layout is not a SteamController",
device.layout));
continue;
}
// Resolve the controller's actions.
steamDevice.InvokeResolveSteamActions();
// Assign it the Steam controller handle.
steamDevice.steamControllerHandle = handle;
ArrayHelpers.AppendWithCapacity(ref s_InputDevices, ref s_InputDeviceCount, steamDevice);
}
}
// Update all controllers we have.
for (var i = 0; i < s_InputDeviceCount; ++i)
{
var device = s_InputDevices[i];
var handle = device.steamControllerHandle;
// Check if the device still exists.
var stillExists = false;
for (var n = 0; n < numConnectedControllers; ++n)
{
if (s_ConnectedControllers[n] == handle)
{
stillExists = true;
break;
}
}
// If not, remove it.
if (!stillExists)
{
ArrayHelpers.EraseAtByMovingTail(s_InputDevices, ref s_InputDeviceCount, i);
////REVIEW: should this rather queue a device removal event?
InputSystem.RemoveDevice(device);
--i;
continue;
}
////TODO: support polling Steam controllers on an async polling thread adhering to InputSystem.pollingFrequency
// Otherwise, update it.
device.InvokeUpdate();
}
}
protected override void ContextClickedItem(int id)
{
var item = FindItem(id, rootItem);
if (item == null)
{
return;
}
if (item is DeviceItem deviceItem)
{
var menu = new GenericMenu();
menu.AddItem(Contents.openDebugView, false, () => InputDeviceDebuggerWindow.CreateOrShowExisting(deviceItem.device));
menu.AddItem(Contents.copyDeviceDescription, false,
() => EditorGUIUtility.systemCopyBuffer = deviceItem.device.description.ToJson());
menu.AddItem(Contents.removeDevice, false, () => InputSystem.RemoveDevice(deviceItem.device));
if (deviceItem.device.enabled)
{
menu.AddItem(Contents.disableDevice, false, () => InputSystem.DisableDevice(deviceItem.device));
}
else
{
menu.AddItem(Contents.enableDevice, false, () => InputSystem.EnableDevice(deviceItem.device));
}
menu.ShowAsContext();
}
if (item is UnsupportedDeviceItem unsupportedDeviceItem)
{
var menu = new GenericMenu();
menu.AddItem(Contents.copyDeviceDescription, false,
() => EditorGUIUtility.systemCopyBuffer = unsupportedDeviceItem.description.ToJson());
menu.ShowAsContext();
}
if (item is LayoutItem layoutItem)
{
var layout = EditorInputControlLayoutCache.TryGetLayout(layoutItem.layoutName);
if (layout != null)
{
var menu = new GenericMenu();
menu.AddItem(Contents.copyLayoutAsJSON, false,
() => EditorGUIUtility.systemCopyBuffer = layout.ToJson());
if (layout.isDeviceLayout)
{
menu.AddItem(Contents.createDeviceFromLayout, false,
() => InputSystem.AddDevice(layout.name));
menu.AddItem(Contents.generateCodeFromLayout, false, () =>
{
var fileName = EditorUtility.SaveFilePanel("Generate InputDevice Code", "", "Fast" + layoutItem.layoutName, "cs");
var isInAssets = fileName.StartsWith(Application.dataPath, StringComparison.OrdinalIgnoreCase);
if (isInAssets)
{
fileName = "Assets/" + fileName.Substring(Application.dataPath.Length + 1);
}
if (!string.IsNullOrEmpty(fileName))
{
var code = InputLayoutCodeGenerator.GenerateCodeFileForDeviceLayout(layoutItem.layoutName, fileName, prefix: "Fast");
File.WriteAllText(fileName, code);
if (isInAssets)
{
AssetDatabase.Refresh();
}
}
});
}
menu.ShowAsContext();
}
}
}
public void Actions_CanPerformPressInteraction()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
// We add a second input device (and bind to it), to test that the binding
// conflict resolution will not interfere with the interaction handling.
InputSystem.AddDevice <Keyboard>();
// Test all three press behaviors concurrently.
var pressOnlyAction = new InputAction("PressOnly", binding: "<Gamepad>/buttonSouth", interactions: "press");
pressOnlyAction.AddBinding("<Keyboard>/a");
var releaseOnlyAction = new InputAction("ReleaseOnly", binding: "<Gamepad>/buttonSouth", interactions: "press(behavior=1)");
releaseOnlyAction.AddBinding("<Keyboard>/s");
var pressAndReleaseAction = new InputAction("PressAndRelease", binding: "<Gamepad>/buttonSouth", interactions: "press(behavior=2)");
pressAndReleaseAction.AddBinding("<Keyboard>/d");
pressOnlyAction.Enable();
releaseOnlyAction.Enable();
pressAndReleaseAction.Enable();
using (var trace = new InputActionTrace())
{
trace.SubscribeToAll();
runtime.currentTime = 1;
Press(gamepad.buttonSouth);
var actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(5));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(releaseOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
trace.Clear();
runtime.currentTime = 2;
Release(gamepad.buttonSouth);
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(3));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(releaseOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(1));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(0));
trace.Clear();
runtime.currentTime = 5;
Press(gamepad.buttonSouth);
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(5));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(pressAndReleaseAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Performed).And.With.Property("duration")
.EqualTo(0));
Assert.That(actions,
Has.Exactly(1).With.Property("action").SameAs(releaseOnlyAction).And.With.Property("phase")
.EqualTo(InputActionPhase.Started).And.With.Property("duration")
.EqualTo(0));
}
}
public void Actions_CanPerformDoubleTapInteraction()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
runtime.advanceTimeEachDynamicUpdate = 0;
var action = new InputAction(binding: "<Gamepad>/buttonSouth", interactions: "multitap(tapTime=0.5,tapDelay=0.75,tapCount=2)");
action.Enable();
using (var trace = new InputActionTrace())
{
trace.SubscribeTo(action);
// Press button.
runtime.currentTime = 1;
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 1);
InputSystem.Update();
var actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(1));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Started));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(1).Within(0.00001));
trace.Clear();
// Release before tap time and make sure the double tap cancels.
runtime.currentTime = 12;
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 1.75);
InputSystem.Update();
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(1));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Canceled));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(1.75).Within(0.00001));
trace.Clear();
// Press again and then release before tap time. Should see only the start from
// the initial press.
runtime.currentTime = 2.5;
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 2);
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 2.25);
InputSystem.Update();
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(1));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Started));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(2).Within(0.00001));
Assert.That(actions[0].ReadValue <float>(), Is.EqualTo(1).Within(0.00001));
trace.Clear();
// Wait for longer than tapDelay and make sure we're seeing a cancellation.
runtime.currentTime = 4;
InputSystem.Update();
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(1));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Canceled));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(4).Within(0.00001));
Assert.That(actions[0].ReadValue <float>(), Is.EqualTo(0).Within(0.00001));// Button isn't pressed currently.
trace.Clear();
// Now press and release within tap time. Then press again within delay time but release
// only after tap time. Should we started and canceled.
runtime.currentTime = 6;
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 4.7);
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 4.9);
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 5);
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 5.9);
InputSystem.Update();
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(2));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Started));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(4.7).Within(0.00001));
Assert.That(actions[0].ReadValue <float>(), Is.EqualTo(1).Within(0.00001));
Assert.That(actions[1].phase, Is.EqualTo(InputActionPhase.Canceled));
Assert.That(actions[1].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[1].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[1].time, Is.EqualTo(5.9).Within(0.00001));
Assert.That(actions[1].ReadValue <float>(), Is.EqualTo(0).Within(0.00001));
trace.Clear();
// Finally perform a full, proper double tap cycle.
runtime.currentTime = 8;
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 7);
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 7.25);
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 7.5);
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 7.75);
InputSystem.Update();
actions = trace.ToArray();
Assert.That(actions, Has.Length.EqualTo(2));
Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Started));
Assert.That(actions[0].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[0].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[0].time, Is.EqualTo(7).Within(0.00001));
Assert.That(actions[0].ReadValue <float>(), Is.EqualTo(1).Within(0.00001));
Assert.That(actions[1].phase, Is.EqualTo(InputActionPhase.Performed));
Assert.That(actions[1].interaction, Is.TypeOf <MultiTapInteraction>());
Assert.That(actions[1].control, Is.SameAs(gamepad.buttonSouth));
Assert.That(actions[1].time, Is.EqualTo(7.75).Within(0.00001));
Assert.That(actions[1].ReadValue <float>(), Is.Zero.Within(0.00001));
}
}
public void Actions_CanPerformHoldInteraction()
{
const int timeOffset = 123;
runtime.currentTimeOffsetToRealtimeSinceStartup = timeOffset;
runtime.currentTime = 10 + timeOffset;
var gamepad = InputSystem.AddDevice <Gamepad>();
var performedReceivedCalls = 0;
InputAction performedAction = null;
InputControl performedControl = null;
var startedReceivedCalls = 0;
InputAction startedAction = null;
InputControl startedControl = null;
var canceledReceivedCalls = 0;
InputAction canceledAction = null;
InputControl canceledControl = null;
var action = new InputAction(binding: "<Gamepad>/{primaryAction}", interactions: "hold(duration=0.4)");
action.performed +=
ctx =>
{
++performedReceivedCalls;
performedAction = ctx.action;
performedControl = ctx.control;
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Performed));
Assert.That(ctx.duration, Is.GreaterThanOrEqualTo(0.4));
};
action.started +=
ctx =>
{
++startedReceivedCalls;
startedAction = ctx.action;
startedControl = ctx.control;
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Started));
Assert.That(ctx.duration, Is.EqualTo(0.0));
};
action.canceled +=
ctx =>
{
++canceledReceivedCalls;
canceledAction = ctx.action;
canceledControl = ctx.control;
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Canceled));
Assert.That(ctx.duration, Is.GreaterThan(0.0));
Assert.That(ctx.duration, Is.LessThan(0.4));
};
action.Enable();
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 10.0);
InputSystem.Update();
Assert.That(startedReceivedCalls, Is.EqualTo(1));
Assert.That(performedReceivedCalls, Is.Zero);
Assert.That(canceledReceivedCalls, Is.Zero);
Assert.That(startedAction, Is.SameAs(action));
Assert.That(startedControl, Is.SameAs(gamepad.buttonSouth));
startedReceivedCalls = 0;
InputSystem.QueueStateEvent(gamepad, new GamepadState(), 10.25);
InputSystem.Update();
Assert.That(startedReceivedCalls, Is.Zero);
Assert.That(performedReceivedCalls, Is.Zero);
Assert.That(canceledReceivedCalls, Is.EqualTo(1));
Assert.That(canceledAction, Is.SameAs(action));
Assert.That(canceledControl, Is.SameAs(gamepad.buttonSouth));
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Waiting));
canceledReceivedCalls = 0;
InputSystem.QueueStateEvent(gamepad, new GamepadState().WithButton(GamepadButton.South), 10.5);
InputSystem.Update();
Assert.That(startedReceivedCalls, Is.EqualTo(1));
Assert.That(performedReceivedCalls, Is.Zero);
Assert.That(canceledReceivedCalls, Is.Zero);
Assert.That(startedAction, Is.SameAs(action));
Assert.That(startedControl, Is.SameAs(gamepad.buttonSouth));
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Started));
startedReceivedCalls = 0;
runtime.currentTime = 10.75 + timeOffset;
InputSystem.Update();
Assert.That(startedReceivedCalls, Is.Zero);
Assert.That(performedReceivedCalls, Is.Zero);
Assert.That(canceledReceivedCalls, Is.Zero);
Assert.That(startedAction, Is.SameAs(action));
Assert.That(startedControl, Is.SameAs(gamepad.buttonSouth));
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Started));
runtime.currentTime = 11 + timeOffset;
InputSystem.Update();
Assert.That(startedReceivedCalls, Is.Zero);
Assert.That(performedReceivedCalls, Is.EqualTo(1));
Assert.That(canceledReceivedCalls, Is.Zero);
Assert.That(performedAction, Is.SameAs(action));
Assert.That(performedControl, Is.SameAs(gamepad.buttonSouth));
Assert.That(action.phase, Is.EqualTo(InputActionPhase.Waiting));
}
public void Devices_SupportsDualShockOnPS4()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
deviceClass = "PS4DualShockGamepad", ////REVIEW: this should be the product name instead
interfaceName = "PS4"
});
Assert.That(device, Is.AssignableTo <DualShockGamepad>());
var gamepad = (DualShockGamepad)device;
InputSystem.QueueStateEvent(gamepad,
new DualShockGamepadStatePS4
{
buttons = 0xffffffff,
leftStick = new Vector2(0.123f, 0.456f),
rightStick = new Vector2(0.789f, 0.234f),
leftTrigger = 0.567f,
rightTrigger = 0.891f,
acceleration = new Vector3(0.987f, 0.654f, 0.321f),
orientation = new Quaternion(0.111f, 0.222f, 0.333f, 0.444f),
angularVelocity = new Vector3(0.444f, 0.555f, 0.666f),
touch0 = new PS4Touch
{
touchId = 123,
position = new Vector2(0.231f, 0.342f)
},
touch1 = new PS4Touch
{
touchId = 456,
position = new Vector2(0.453f, 0.564f)
},
});
InputSystem.Update();
Assert.That(gamepad.squareButton.isPressed);
Assert.That(gamepad.triangleButton.isPressed);
Assert.That(gamepad.circleButton.isPressed);
Assert.That(gamepad.crossButton.isPressed);
Assert.That(gamepad.buttonSouth.isPressed);
Assert.That(gamepad.buttonNorth.isPressed);
Assert.That(gamepad.buttonEast.isPressed);
Assert.That(gamepad.buttonWest.isPressed);
Assert.That(gamepad.leftStickButton.isPressed);
Assert.That(gamepad.rightStickButton.isPressed);
Assert.That(gamepad.L3.isPressed);
Assert.That(gamepad.R3.isPressed);
Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(0.123).Within(0.00001));
Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(0.456).Within(0.00001));
Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(0.789).Within(0.00001));
Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(0.234).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.567).Within(0.00001));
Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(0.891).Within(0.00001));
Assert.That(gamepad.acceleration.x.ReadValue(), Is.EqualTo(0.987).Within(0.00001));
Assert.That(gamepad.acceleration.y.ReadValue(), Is.EqualTo(0.654).Within(0.00001));
Assert.That(gamepad.acceleration.z.ReadValue(), Is.EqualTo(0.321).Within(0.00001));
Quaternion orientation = gamepad.orientation.ReadValue();
Assert.That(orientation.x, Is.EqualTo(0.111).Within(0.00001));
Assert.That(orientation.y, Is.EqualTo(0.222).Within(0.00001));
Assert.That(orientation.z, Is.EqualTo(0.333).Within(0.00001));
Assert.That(orientation.w, Is.EqualTo(0.444).Within(0.00001));
Assert.That(gamepad.angularVelocity.x.ReadValue(), Is.EqualTo(0.444).Within(0.00001));
Assert.That(gamepad.angularVelocity.y.ReadValue(), Is.EqualTo(0.555).Within(0.00001));
Assert.That(gamepad.angularVelocity.z.ReadValue(), Is.EqualTo(0.666).Within(0.00001));
////TODO: touch
}
public void Controls_CanKeepListsOfControls_WithoutAllocatingGCMemory()
{
InputSystem.AddDevice <Mouse>(); // Noise.
var gamepad = InputSystem.AddDevice <Gamepad>();
var keyboard = InputSystem.AddDevice <Keyboard>();
var list = default(InputControlList <InputControl>);
Assert.That(() => { list = new InputControlList <InputControl>(); }, Is.Not.AllocatingGCMemory());
try
{
Assert.That(list.Count, Is.Zero);
Assert.That(list.ToArray(), Is.Empty);
Assert.That(() => list[0], Throws.TypeOf <ArgumentOutOfRangeException>());
list.Capacity = 4;
Assert.That(() =>
{
list.Add(gamepad.leftStick);
list.Add(null); // Permissible to add null entry.
list.Add(keyboard.spaceKey);
list.Add(keyboard);
}, Is.Not.AllocatingGCMemory());
Assert.That(list.Count, Is.EqualTo(4));
Assert.That(list.Capacity, Is.EqualTo(4));
Assert.That(list[0], Is.SameAs(gamepad.leftStick));
Assert.That(list[1], Is.Null);
Assert.That(list[2], Is.SameAs(keyboard.spaceKey));
Assert.That(list[3], Is.SameAs(keyboard));
Assert.That(() => list[4], Throws.TypeOf <ArgumentOutOfRangeException>());
Assert.That(list.ToArray(),
Is.EquivalentTo(new InputControl[] { gamepad.leftStick, null, keyboard.spaceKey, keyboard }));
Assert.That(list.Contains(gamepad.leftStick));
Assert.That(list.Contains(null));
Assert.That(list.Contains(keyboard.spaceKey));
Assert.That(list.Contains(keyboard));
Assert.That(() =>
{
list.RemoveAt(1);
list.Remove(keyboard);
}, Is.Not.AllocatingGCMemory());
Assert.That(list.Count, Is.EqualTo(2));
Assert.That(list.Capacity, Is.EqualTo(4));
Assert.That(list[0], Is.SameAs(gamepad.leftStick));
Assert.That(list[1], Is.SameAs(keyboard.spaceKey));
Assert.That(() => list[2], Throws.TypeOf <ArgumentOutOfRangeException>());
Assert.That(list.ToArray(), Is.EquivalentTo(new InputControl[] { gamepad.leftStick, keyboard.spaceKey }));
Assert.That(list.Contains(gamepad.leftStick));
Assert.That(!list.Contains(null));
Assert.That(list.Contains(keyboard.spaceKey));
Assert.That(!list.Contains(keyboard));
list.AddRange(new InputControl[] { keyboard.aKey, keyboard.bKey }, count: 1, destinationIndex: 0);
Assert.That(list.Count, Is.EqualTo(3));
Assert.That(list.Capacity, Is.EqualTo(4));
Assert.That(list,
Is.EquivalentTo(new InputControl[]
{ keyboard.aKey, gamepad.leftStick, keyboard.spaceKey }));
list.AddRange(new InputControl[] { keyboard.bKey, keyboard.cKey });
Assert.That(list.Count, Is.EqualTo(5));
Assert.That(list.Capacity, Is.EqualTo(10));
Assert.That(list,
Is.EquivalentTo(new InputControl[]
{ keyboard.aKey, gamepad.leftStick, keyboard.spaceKey, keyboard.bKey, keyboard.cKey }));
using (var toAdd = new InputControlList <InputControl>(gamepad.buttonNorth, gamepad.buttonEast, gamepad.buttonWest))
list.AddSlice(toAdd, count: 1, destinationIndex: 1, sourceIndex: 2);
Assert.That(list.Count, Is.EqualTo(6));
Assert.That(list.Capacity, Is.EqualTo(10));
Assert.That(list,
Is.EquivalentTo(new InputControl[]
{ keyboard.aKey, gamepad.buttonWest, gamepad.leftStick, keyboard.spaceKey, keyboard.bKey, keyboard.cKey }));
list[0] = keyboard.zKey;
Assert.That(list,
Is.EquivalentTo(new InputControl[]
{ keyboard.zKey, gamepad.buttonWest, gamepad.leftStick, keyboard.spaceKey, keyboard.bKey, keyboard.cKey }));
list.Clear();
Assert.That(list.Count, Is.Zero);
Assert.That(list.Capacity, Is.EqualTo(10));
Assert.That(list.ToArray(), Is.Empty);
Assert.That(() => list[0], Throws.TypeOf <ArgumentOutOfRangeException>());
Assert.That(!list.Contains(gamepad.leftStick));
Assert.That(!list.Contains(null));
Assert.That(!list.Contains(keyboard.spaceKey));
Assert.That(!list.Contains(keyboard));
}
finally
{
list.Dispose();
}
}
public void Devices_SupportsAndroidGamepad()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
interfaceName = "Android",
deviceClass = "AndroidGameController",
capabilities = new AndroidDeviceCapabilities
{
inputSources = AndroidInputSource.Gamepad | AndroidInputSource.Joystick,
}.ToJson()
});
Assert.That(device, Is.TypeOf <AndroidGamepad>());
var controller = (AndroidGamepad)device;
var leftStick = new Vector2(0.789f, 0.987f);
var rightStick = new Vector2(0.654f, 0.321f);
// Note: Regarding triggers, android sends different events depending to which device the controller is connected.
// For ex., when NVIDIA shield controller when connected to Shield Console, triggers generate events:
// Left Trigger -> AndroidAxis.Brake, AndroidAxis.LtTrigger
// Right Trigger -> AndroidAxis.Gas, AndroidAxis.RtTrigger
// BUT
// when NVIDIA shield controller when connected to Samsung phone, triggers generate events:
// Left Trigger -> AndroidAxis.Brake
// Right Trigger -> AndroidAxis.Gas
//
// This is why we're only reading and validating that events are correctly processed from AndroidAxis.Brake & AndroidAxis.Gas
InputSystem.QueueStateEvent(controller,
new AndroidGameControllerState()
.WithAxis(AndroidAxis.Brake, 0.123f)
.WithAxis(AndroidAxis.Gas, 0.456f)
.WithAxis(AndroidAxis.X, leftStick.x)
.WithAxis(AndroidAxis.Y, leftStick.y)
.WithAxis(AndroidAxis.Z, rightStick.x)
.WithAxis(AndroidAxis.Rz, rightStick.y));
InputSystem.Update();
var leftStickDeadzone = controller.leftStick.TryGetProcessor <StickDeadzoneProcessor>();
var rightStickDeadzone = controller.leftStick.TryGetProcessor <StickDeadzoneProcessor>();
// Y is upside down on Android.
Assert.That(controller.leftStick.ReadValue(), Is.EqualTo(leftStickDeadzone.Process(new Vector2(leftStick.x, -leftStick.y))));
Assert.That(controller.rightStick.ReadValue(), Is.EqualTo(rightStickDeadzone.Process(new Vector2(rightStick.x, -rightStick.y))));
Assert.That(controller.leftStick.left.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.leftStick.right.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(leftStick.x)));
Assert.That(controller.leftStick.up.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.leftStick.down.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(leftStick.y)));
Assert.That(controller.rightStick.left.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.rightStick.right.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(rightStick.x)));
Assert.That(controller.rightStick.up.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.rightStick.down.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(rightStick.y)));
Assert.That(controller.leftTrigger.ReadValue(), Is.EqualTo(0.123).Within(0.000001));
Assert.That(controller.rightTrigger.ReadValue(), Is.EqualTo(0.456).Within(0.000001));
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonA), controller.buttonSouth);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonX), controller.buttonWest);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonY), controller.buttonNorth);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonB), controller.buttonEast);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonThumbl), controller.leftStickButton);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonThumbr), controller.rightStickButton);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonL1), controller.leftShoulder);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonR1), controller.rightShoulder);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonStart), controller.startButton);
AssertButtonPress(controller, new AndroidGameControllerState().WithButton(AndroidKeyCode.ButtonSelect), controller.selectButton);
// Move sticks to opposite directions
InputSystem.QueueStateEvent(controller,
new AndroidGameControllerState()
.WithAxis(AndroidAxis.X, -leftStick.x)
.WithAxis(AndroidAxis.Y, -leftStick.y)
.WithAxis(AndroidAxis.Z, -rightStick.x)
.WithAxis(AndroidAxis.Rz, -rightStick.y));
InputSystem.Update();
Assert.That(controller.leftStick.left.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(leftStick.x)));
Assert.That(controller.leftStick.right.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.leftStick.up.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(leftStick.y)));
Assert.That(controller.leftStick.down.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.rightStick.left.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(rightStick.x)));
Assert.That(controller.rightStick.right.ReadValue(), Is.EqualTo(0.0f));
Assert.That(controller.rightStick.up.ReadValue(), Is.EqualTo(new AxisDeadzoneProcessor().Process(rightStick.y)));
Assert.That(controller.rightStick.down.ReadValue(), Is.EqualTo(0.0f));
}
public void Controls_DpadVectorsAreCircular()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
// Up.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
buttons = 1 << (int)GamepadState.Button.DpadUp
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue(), Is.EqualTo(Vector2.up));
// Up left.
InputSystem.QueueStateEvent(gamepad,
new GamepadState
{
buttons = 1 << (int)GamepadState.Button.DpadUp | 1 << (int)GamepadState.Button.DpadLeft
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue().x, Is.EqualTo((Vector2.up + Vector2.left).normalized.x).Within(0.00001));
Assert.That(gamepad.dpad.ReadValue().y, Is.EqualTo((Vector2.up + Vector2.left).normalized.y).Within(0.00001));
// Left.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
buttons = 1 << (int)GamepadState.Button.DpadLeft
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue(), Is.EqualTo(Vector2.left));
// Down left.
InputSystem.QueueStateEvent(gamepad,
new GamepadState
{
buttons = 1 << (int)GamepadState.Button.DpadDown | 1 << (int)GamepadState.Button.DpadLeft
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue().x, Is.EqualTo((Vector2.down + Vector2.left).normalized.x).Within(0.00001));
Assert.That(gamepad.dpad.ReadValue().y, Is.EqualTo((Vector2.down + Vector2.left).normalized.y).Within(0.00001));
// Down.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
buttons = 1 << (int)GamepadState.Button.DpadDown
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue(), Is.EqualTo(Vector2.down));
// Down right.
InputSystem.QueueStateEvent(gamepad,
new GamepadState
{
buttons = 1 << (int)GamepadState.Button.DpadDown | 1 << (int)GamepadState.Button.DpadRight
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue().x,
Is.EqualTo((Vector2.down + Vector2.right).normalized.x).Within(0.00001));
Assert.That(gamepad.dpad.ReadValue().y,
Is.EqualTo((Vector2.down + Vector2.right).normalized.y).Within(0.00001));
// Right.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
buttons = 1 << (int)GamepadState.Button.DpadRight
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue(), Is.EqualTo(Vector2.right));
// Up right.
InputSystem.QueueStateEvent(gamepad,
new GamepadState
{
buttons = 1 << (int)GamepadState.Button.DpadUp | 1 << (int)GamepadState.Button.DpadRight
});
InputSystem.Update();
Assert.That(gamepad.dpad.ReadValue().x, Is.EqualTo((Vector2.up + Vector2.right).normalized.x).Within(0.00001));
Assert.That(gamepad.dpad.ReadValue().y, Is.EqualTo((Vector2.up + Vector2.right).normalized.y).Within(0.00001));
}
private void Start()
{
keyboard = InputSystem.AddDevice <Keyboard>();
}
public void Components_CanUpdateGameObjectTransformThroughTrackedPoseDriver()
{
var testpos = new Vector3(1.0f, 2.0f, 3.0f);
var testrot = new Quaternion(0.09853293f, 0.09853293f, 0.09853293f, 0.9853293f);
var go = new GameObject();
var tpd1 = go.AddComponent <TrackedPoseDriver>();
var tpd = tpd1;
var device = InputSystem.AddDevice <TestHMD>();
InputEventPtr stateEvent;
using (StateEvent.From(device, out stateEvent))
{
var positionAction = new InputAction();
positionAction.AddBinding("<TestHMD>/vector3");
var rotationAction = new InputAction();
rotationAction.AddBinding("<TestHMD>/quaternion");
tpd.positionAction = positionAction;
tpd.rotationAction = rotationAction;
// before render only
var go1 = tpd.gameObject;
go1.transform.position = Vector3.zero;
go1.transform.rotation = new Quaternion(0, 0, 0, 0);
tpd.updateType = TrackedPoseDriver.UpdateType.BeforeRender;
tpd.trackingType = TrackedPoseDriver.TrackingType.RotationAndPosition;
device.quaternion.WriteValueIntoEvent(testrot, stateEvent);
device.vector3.WriteValueIntoEvent(testpos, stateEvent);
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.Dynamic);
Assert.That(tpd.gameObject.transform.position, Is.Not.EqualTo(testpos));
Assert.That(!tpd.gameObject.transform.rotation.Equals(testrot));
var go2 = tpd.gameObject;
go2.transform.position = Vector3.zero;
go2.transform.rotation = new Quaternion(0, 0, 0, 0);
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.BeforeRender);
Assert.That(tpd.gameObject.transform.position, Is.EqualTo(testpos));
Assert.That(tpd.gameObject.transform.rotation.Equals(testrot));
// update only
var go3 = tpd.gameObject;
go3.transform.position = Vector3.zero;
go3.transform.rotation = new Quaternion(0, 0, 0, 0);
tpd.updateType = TrackedPoseDriver.UpdateType.Update;
tpd.trackingType = TrackedPoseDriver.TrackingType.RotationAndPosition;
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.Dynamic);
Assert.That(tpd.gameObject.transform.position, Is.EqualTo(testpos));
Assert.That(tpd.gameObject.transform.rotation.Equals(testrot));
GameObject go4 = tpd.gameObject;
go4.transform.position = Vector3.zero;
go4.transform.rotation = new Quaternion(0, 0, 0, 0);
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.BeforeRender);
Assert.That(tpd.gameObject.transform.position, Is.Not.EqualTo(testpos));
Assert.That(!tpd.gameObject.transform.rotation.Equals(testrot));
// check the rot/pos case also Update AND Render.
tpd.updateType = TrackedPoseDriver.UpdateType.UpdateAndBeforeRender;
tpd.trackingType = TrackedPoseDriver.TrackingType.PositionOnly;
var go5 = tpd.gameObject;
go5.transform.position = Vector3.zero;
go5.transform.rotation = new Quaternion(0, 0, 0, 0);
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.Dynamic);
Assert.That(tpd.gameObject.transform.position, Is.EqualTo(testpos));
Assert.That(!tpd.gameObject.transform.rotation.Equals(testrot));
tpd.trackingType = TrackedPoseDriver.TrackingType.RotationOnly;
var go6 = tpd.gameObject;
go6.transform.position = Vector3.zero;
go6.transform.rotation = new Quaternion(0, 0, 0, 0);
InputSystem.QueueEvent(stateEvent);
InputSystem.Update(InputUpdateType.BeforeRender);
Assert.That(tpd.gameObject.transform.position, Is.Not.EqualTo(testpos));
Assert.That(tpd.gameObject.transform.rotation.Equals(testrot));
}
}
public void Users_CanDetectUseOfUnpairedDevice()
{
// Instead of adding a standard Gamepad, add a custom one that has a noisy gyro
// control added to it so that we can test whether the system can differentiate the
// noise of the gyro from real user input.
const string gamepadWithNoisyGyro = @"
{
""name"" : ""GamepadWithNoisyGyro"",
""extend"" : ""Gamepad"",
""controls"" : [
{ ""name"" : ""gyro"", ""layout"" : ""Quaternion"", ""noisy"" : true }
]
}
";
++InputUser.listenForUnpairedDeviceActivity;
var receivedControls = new List <InputControl>();
InputUser.onUnpairedDeviceUsed +=
(control, eventPtr) => { receivedControls.Add(control); };
InputSystem.RegisterLayout(gamepadWithNoisyGyro);
var gamepad = (Gamepad)InputSystem.AddDevice("GamepadWithNoisyGyro");
// First send some noise on the gyro.
Set((QuaternionControl)gamepad["gyro"], new Quaternion(1, 2, 3, 4));
Assert.That(receivedControls, Is.Empty);
// Now send some real interaction.
PressAndRelease(gamepad.buttonSouth);
Assert.That(receivedControls, Is.EquivalentTo(new[] { gamepad.aButton }));
receivedControls.Clear();
// Now pair the device to a user and try the same thing again.
var user = InputUser.PerformPairingWithDevice(gamepad);
PressAndRelease(gamepad.buttonEast);
Assert.That(receivedControls, Is.Empty);
receivedControls.Clear();
// Unpair the device and turn off the feature to make sure we're not getting a notification.
user.UnpairDevice(gamepad);
--InputUser.listenForUnpairedDeviceActivity;
PressAndRelease(gamepad.buttonSouth);
Assert.That(receivedControls, Is.Empty);
// Turn it back on and actuate two controls on the gamepad. Make sure we get *both* actuations.
// NOTE: This is important for when use of an unpaired device only does something when certain
// controls are used but doesn't do anything if others are used. For example, if the use
// of unpaired devices is driving player joining logic but only button presses lead to joins,
// then if we were to only send the first actuation we come across, it may be for an
// irrelevant control (e.g. sticks on gamepad).
++InputUser.listenForUnpairedDeviceActivity;
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = new Vector2(1, 0)
}.WithButton(GamepadButton.A));
InputSystem.Update();
Assert.That(receivedControls, Has.Count.EqualTo(2));
Assert.That(receivedControls, Has.Exactly(1).SameAs(gamepad.leftStick.x));
Assert.That(receivedControls, Has.Exactly(1).SameAs(gamepad.aButton));
}
public void Devices_SupportXboxWirelessControllerOnOSX()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
interfaceName = "HID",
product = "Xbox One Wireless Controller",
manufacturer = "Microsoft"
});
Assert.That(device, Is.AssignableTo <XInputController>());
Assert.That(device, Is.AssignableTo <XboxOneGampadMacOSWireless>());
var gamepad = (XboxOneGampadMacOSWireless)device;
InputSystem.QueueStateEvent(gamepad,
new XInputControllerWirelessOSXState
{
leftStickX = 65535,
leftStickY = 0,
rightStickX = 65535,
rightStickY = 0,
leftTrigger = 1023,
rightTrigger = 1023,
});
InputSystem.Update();
Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.up.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.down.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.leftStick.right.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.left.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.up.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.down.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.rightStick.right.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.left.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(1));
Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(1));
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.A), gamepad.aButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.A), gamepad.buttonSouth);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.B), gamepad.bButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.B), gamepad.buttonEast);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.X), gamepad.xButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.X), gamepad.buttonWest);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Y), gamepad.yButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Y), gamepad.buttonNorth);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithDpad(5), gamepad.dpad.down);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithDpad(1), gamepad.dpad.up);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithDpad(7), gamepad.dpad.left);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithDpad(3), gamepad.dpad.right);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.LeftThumbstickPress), gamepad.leftStickButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.RightThumbstickPress), gamepad.rightStickButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.LeftShoulder), gamepad.leftShoulder);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.RightShoulder), gamepad.rightShoulder);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Start), gamepad.menu);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Start), gamepad.startButton);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Select), gamepad.view);
AssertButtonPress(gamepad, XInputControllerWirelessOSXState.defaultState.WithButton(XInputControllerWirelessOSXState.Button.Select), gamepad.selectButton);
// Test to make sure that the default state is not set to input values of 0, but to the center of the sticks
InputSystem.QueueStateEvent(gamepad,
new XInputControllerWirelessOSXState
{
leftStickX = 0,
leftStickY = 0,
rightStickX = 0,
rightStickY = 0,
leftTrigger = 0,
rightTrigger = 0,
});
InputSystem.Update();
Assert.That(gamepad.leftStick.IsActuated());
Assert.That(gamepad.leftStick.x.IsActuated());
Assert.That(gamepad.leftStick.CheckStateIsAtDefault(), Is.False);
Assert.That(gamepad.leftStick.x.CheckStateIsAtDefault(), Is.False);
Assert.That(gamepad.leftTrigger.IsActuated(), Is.False);
Assert.That(gamepad.leftTrigger.CheckStateIsAtDefault());
}
public unsafe void Events_AreTimeslicedByDefault()
{
InputSystem.settings.updateMode = InputSettings.UpdateMode.ProcessEventsInFixedUpdate;
runtime.currentTimeForFixedUpdate = 1;
var gamepad = InputSystem.AddDevice <Gamepad>();
var receivedEvents = new List <InputEvent>();
InputSystem.onEvent +=
(eventPtr, _) => receivedEvents.Add(*eventPtr.data);
// First fixed update should just take everything.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.1234f
}, 1);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.2345f
}, 2);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.3456f
}, 2.9);
runtime.currentTimeForFixedUpdate = 3;
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(3));
Assert.That(receivedEvents[0].time, Is.EqualTo(1).Within(0.00001));
Assert.That(receivedEvents[1].time, Is.EqualTo(2).Within(0.00001));
Assert.That(receivedEvents[2].time, Is.EqualTo(2.9).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.3456).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
receivedEvents.Clear();
runtime.currentTimeForFixedUpdate += 1 / 60.0f;
// From now on, fixed updates should only take what falls in their slice.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.1234f
}, 3 + 0.001);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.2345f
}, 3 + 0.002);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.3456f
}, 3 + 1.0 / 60 + 0.001);
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftTrigger = 0.4567f
}, 3 + 2 * (1.0 / 60) + 0.001);
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(2));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 0.001).Within(0.00001));
Assert.That(receivedEvents[1].time, Is.EqualTo(3 + 0.002).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.2345).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.EqualTo(2));
receivedEvents.Clear();
runtime.currentTimeForFixedUpdate += 1 / 60.0f;
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(1));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 1.0 / 60 + 0.001).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.3456).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.EqualTo(1));
receivedEvents.Clear();
runtime.currentTimeForFixedUpdate += 1 / 60.0f;
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.EqualTo(1));
Assert.That(receivedEvents[0].time, Is.EqualTo(3 + 2 * (1.0 / 60) + 0.001).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.4567).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
receivedEvents.Clear();
runtime.currentTimeForFixedUpdate += 1 / 60.0f;
InputSystem.Update(InputUpdateType.Fixed);
Assert.That(receivedEvents, Has.Count.Zero);
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(0.4567).Within(0.00001));
Assert.That(InputUpdate.s_LastUpdateRetainedEventCount, Is.Zero);
}
public void Devices_SupportXboxControllerOnOSX()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
interfaceName = "HID",
product = "Xbox One Wired Controller",
manufacturer = "Microsoft"
});
Assert.That(device, Is.AssignableTo <XInputController>());
Assert.That(device, Is.AssignableTo <XboxGamepadMacOS>());
var gamepad = (XboxGamepadMacOS)device;
InputSystem.QueueStateEvent(gamepad,
new XInputControllerOSXState
{
leftStickX = 32767,
leftStickY = -32767,
rightStickX = 32767,
rightStickY = -32767,
leftTrigger = 255,
rightTrigger = 255,
});
InputSystem.Update();
Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.up.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.down.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.leftStick.right.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.leftStick.left.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.up.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.down.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.rightStick.right.ReadValue(), Is.EqualTo(0.9999).Within(0.001));
Assert.That(gamepad.rightStick.left.ReadValue(), Is.EqualTo(0.0).Within(0.001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(1));
Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(1));
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.A), gamepad.aButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.A), gamepad.buttonSouth);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.B), gamepad.bButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.B), gamepad.buttonEast);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.X), gamepad.xButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.X), gamepad.buttonWest);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Y), gamepad.yButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Y), gamepad.buttonNorth);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.DPadDown), gamepad.dpad.down);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.DPadUp), gamepad.dpad.up);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.DPadLeft), gamepad.dpad.left);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.DPadRight), gamepad.dpad.right);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.LeftThumbstickPress), gamepad.leftStickButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.RightThumbstickPress), gamepad.rightStickButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.LeftShoulder), gamepad.leftShoulder);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.RightShoulder), gamepad.rightShoulder);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Start), gamepad.menu);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Start), gamepad.startButton);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Select), gamepad.view);
AssertButtonPress(gamepad, new XInputControllerOSXState().WithButton(XInputControllerOSXState.Button.Select), gamepad.selectButton);
}
public void Analytics_ReceivesStartupEventOnFirstUpdate()
{
string receivedName = null;
object receivedData = null;
testRuntime.onSendAnalyticsEvent =
(name, data) =>
{
Assert.That(receivedName, Is.Null);
receivedName = name;
receivedData = data;
};
// Add some data to the system.
testRuntime.ReportNewInputDevice(new InputDeviceDescription
{
product = "TestProductA",
manufacturer = "TestManufacturerA",
deviceClass = "Mouse",
interfaceName = "TestA"
}.ToJson());
testRuntime.ReportNewInputDevice(new InputDeviceDescription
{
product = "TestProductB",
manufacturer = "TestManufacturerB",
deviceClass = "Keyboard",
interfaceName = "TestB"
}.ToJson());
testRuntime.ReportNewInputDevice(new InputDeviceDescription
{
product = "TestProductC",
manufacturer = "TestManufacturerC",
deviceClass = "Unknown",
interfaceName = "Other"
}.ToJson());
InputSystem.AddDevice <Gamepad>();
InputSystem.Update();
Assert.That(receivedName, Is.EqualTo(InputAnalytics.kEventStartup));
Assert.That(receivedData, Is.TypeOf <InputAnalytics.StartupEventData>());
var startupData = (InputAnalytics.StartupEventData)receivedData;
Assert.That(startupData.version, Is.EqualTo(InputSystem.version.ToString()));
Assert.That(startupData.devices, Is.Not.Null.And.Length.EqualTo(3));
Assert.That(startupData.unrecognized_devices, Is.Not.Null.And.Length.EqualTo(1));
Assert.That(startupData.devices[0].product, Is.Null);
Assert.That(startupData.devices[0].@interface, Is.Null);
Assert.That(startupData.devices[0].layout, Is.EqualTo("Gamepad"));
Assert.That(startupData.devices[0].native, Is.False);
Assert.That(startupData.devices[1].product, Is.EqualTo("TestManufacturerA TestProductA"));
Assert.That(startupData.devices[1].@interface, Is.EqualTo("TestA"));
Assert.That(startupData.devices[1].layout, Is.EqualTo("Mouse"));
Assert.That(startupData.devices[1].native, Is.True);
Assert.That(startupData.devices[2].product, Is.EqualTo("TestManufacturerB TestProductB"));
Assert.That(startupData.devices[2].@interface, Is.EqualTo("TestB"));
Assert.That(startupData.devices[2].layout, Is.EqualTo("Keyboard"));
Assert.That(startupData.devices[2].native, Is.True);
Assert.That(startupData.unrecognized_devices[0].product, Is.EqualTo("TestManufacturerC TestProductC"));
Assert.That(startupData.unrecognized_devices[0].@interface, Is.EqualTo("Other"));
Assert.That(startupData.unrecognized_devices[0].layout, Is.EqualTo("Unknown"));
Assert.That(startupData.unrecognized_devices[0].native, Is.True);
}
public void LoadScene()
{
// Load game scene
SceneManager.LoadScene(SceneName.SAVE_ONE_BALL_SCENE);
keyboard = InputSystem.AddDevice <Keyboard>();
}
public virtual InputDevice AddDevice(string layout, string name = null, string variants = null)
{
return(InputSystem.AddDevice(layout, name, variants));
}
public void Devices_SupportsDualShockAsHID()
{
#if !UNITY_WSA
var device = InputSystem.AddDevice(new InputDeviceDescription
{
product = "Wireless Controller",
manufacturer = "Sony Interactive Entertainment",
interfaceName = "HID",
});
#else // UWP requires different query logic (manufacture not available)
var device = InputSystem.AddDevice(new InputDeviceDescription
{
product = "Wireless Controller",
interfaceName = "HID",
capabilities = new HID.HIDDeviceDescriptor
{
vendorId = 0x054C, // Sony
}.ToJson()
});
#endif
Assert.That(device, Is.AssignableTo <DualShockGamepad>());
var gamepad = (DualShockGamepad)device;
InputSystem.QueueStateEvent(gamepad,
new DualShockHIDInputReport
{
leftStickX = 32,
leftStickY = 64,
rightStickX = 128,
rightStickY = 255,
leftTrigger = 20,
rightTrigger = 40,
buttons1 = 0xf7, // Low order 4 bits is Dpad but effectively uses only 3 bits.
buttons2 = 0xff,
buttons3 = 0xff
});
InputSystem.Update();
Assert.That(gamepad.leftStick.x.ReadValue(), Is.EqualTo(NormalizeProcessor.Normalize(32 / 255.0f, 0f, 1f, 0.5f)).Within(0.00001));
Assert.That(gamepad.leftStick.y.ReadValue(), Is.EqualTo(-NormalizeProcessor.Normalize(64 / 255.0f, 0f, 1f, 0.5f)).Within(0.00001));
Assert.That(gamepad.rightStick.x.ReadValue(), Is.EqualTo(NormalizeProcessor.Normalize(128 / 255.0f, 0f, 1f, 0.5f)).Within(0.00001));
Assert.That(gamepad.rightStick.y.ReadValue(), Is.EqualTo(-NormalizeProcessor.Normalize(255 / 255.0f, 0f, 1f, 0.5f)).Within(0.00001));
Assert.That(gamepad.leftTrigger.ReadValue(), Is.EqualTo(NormalizeProcessor.Normalize(20 / 255.0f, 0f, 1f, 0f)).Within(0.00001));
Assert.That(gamepad.rightTrigger.ReadValue(), Is.EqualTo(NormalizeProcessor.Normalize(40 / 255.0f, 0f, 1f, 0f)).Within(0.00001));
////TODO: test button presses individually
Assert.That(gamepad.buttonSouth.isPressed);
Assert.That(gamepad.buttonEast.isPressed);
Assert.That(gamepad.buttonWest.isPressed);
Assert.That(gamepad.buttonNorth.isPressed);
Assert.That(gamepad.squareButton.isPressed);
Assert.That(gamepad.triangleButton.isPressed);
Assert.That(gamepad.circleButton.isPressed);
Assert.That(gamepad.crossButton.isPressed);
Assert.That(gamepad.startButton.isPressed);
Assert.That(gamepad.selectButton.isPressed);
Assert.That(gamepad.dpad.up.isPressed); // Dpad uses enumerated values, not a bitfield; 0x7 is up left.
Assert.That(gamepad.dpad.down.isPressed, Is.False);
Assert.That(gamepad.dpad.left.isPressed);
Assert.That(gamepad.dpad.right.isPressed, Is.False);
Assert.That(gamepad.leftShoulder.isPressed);
Assert.That(gamepad.rightShoulder.isPressed);
Assert.That(gamepad.leftStickButton.isPressed);
Assert.That(gamepad.rightStickButton.isPressed);
Assert.That(gamepad.touchpadButton.isPressed);
// Sensors not (yet?) supported. Needs figuring out how to interpret the HID data.
}
public unsafe void Devices_CanSetNPadVibrationMotorValues()
{
var controller = InputSystem.AddDevice <NPad>();
NPadDeviceIOCTLOutputCommand?receivedCommand = null;
unsafe
{
runtime.SetDeviceCommandCallback(controller.id,
(id, commandPtr) =>
{
if (commandPtr->type == NPadDeviceIOCTLOutputCommand.Type)
{
Assert.That(receivedCommand.HasValue, Is.False);
receivedCommand = *((NPadDeviceIOCTLOutputCommand *)commandPtr);
return(1);
}
Assert.Fail("Received wrong type of command");
return(InputDeviceCommand.kGenericFailure);
});
}
controller.SetMotorSpeeds(0.1234f, 0.5678f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.positionFlags, Is.EqualTo(0xFF));
Assert.That(receivedCommand.Value.amplitudeLow, Is.EqualTo(0.1234f));
Assert.That(receivedCommand.Value.frequencyLow, Is.EqualTo(NPadDeviceIOCTLOutputCommand.kDefaultFrequencyLow));
Assert.That(receivedCommand.Value.amplitudeHigh, Is.EqualTo(0.5678f));
Assert.That(receivedCommand.Value.frequencyHigh, Is.EqualTo(NPadDeviceIOCTLOutputCommand.kDefaultFrequencyHigh));
receivedCommand = null;
controller.SetMotorSpeeds(0.1234f, 56.78f, 0.9012f, 345.6f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.positionFlags, Is.EqualTo(0xFF));
Assert.That(receivedCommand.Value.amplitudeLow, Is.EqualTo(0.1234f));
Assert.That(receivedCommand.Value.frequencyLow, Is.EqualTo(56.78f));
Assert.That(receivedCommand.Value.amplitudeHigh, Is.EqualTo(0.9012f));
Assert.That(receivedCommand.Value.frequencyHigh, Is.EqualTo(345.6f));
receivedCommand = null;
controller.SetMotorSpeedLeft(0.1234f, 56.78f, 0.9012f, 345.6f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.positionFlags, Is.EqualTo(0x02));
Assert.That(receivedCommand.Value.amplitudeLow, Is.EqualTo(0.1234f));
Assert.That(receivedCommand.Value.frequencyLow, Is.EqualTo(56.78f));
Assert.That(receivedCommand.Value.amplitudeHigh, Is.EqualTo(0.9012f));
Assert.That(receivedCommand.Value.frequencyHigh, Is.EqualTo(345.6f));
receivedCommand = null;
controller.SetMotorSpeedRight(0.1234f, 56.78f, 0.9012f, 345.6f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.positionFlags, Is.EqualTo(0x04));
Assert.That(receivedCommand.Value.amplitudeLow, Is.EqualTo(0.1234f));
Assert.That(receivedCommand.Value.frequencyLow, Is.EqualTo(56.78f));
Assert.That(receivedCommand.Value.amplitudeHigh, Is.EqualTo(0.9012f));
Assert.That(receivedCommand.Value.frequencyHigh, Is.EqualTo(345.6f));
}
public void State_CanSetUpMonitorsForStateChanges()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
var monitorFired = false;
InputControl receivedControl = null;
double? receivedTime = null;
var monitor = InputSystem.AddStateChangeMonitor(gamepad.leftStick,
(control, time, monitorIndex) =>
{
Assert.That(!monitorFired);
monitorFired = true;
receivedControl = control;
receivedTime = time;
});
// Left stick only.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = new Vector2(0.5f, 0.5f)
}, 0.5);
InputSystem.Update();
Assert.That(monitorFired, Is.True);
Assert.That(receivedControl, Is.SameAs(gamepad.leftStick));
Assert.That(receivedTime.Value, Is.EqualTo(0.5).Within(0.000001));
monitorFired = false;
receivedControl = null;
receivedTime = 0;
// Left stick again but with no value change.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = new Vector2(0.5f, 0.5f)
}, 0.6);
InputSystem.Update();
Assert.That(monitorFired, Is.False);
// Left and right stick.
InputSystem.QueueStateEvent(gamepad,
new GamepadState {
rightStick = new Vector2(0.75f, 0.75f), leftStick = new Vector2(0.75f, 0.75f)
}, 0.7);
InputSystem.Update();
Assert.That(monitorFired, Is.True);
Assert.That(receivedControl, Is.SameAs(gamepad.leftStick));
Assert.That(receivedTime.Value, Is.EqualTo(0.7).Within(0.000001));
monitorFired = false;
receivedControl = null;
receivedTime = 0;
// Right stick only.
InputSystem.QueueStateEvent(gamepad,
new GamepadState {
rightStick = new Vector2(0.5f, 0.5f), leftStick = new Vector2(0.75f, 0.75f)
}, 0.8);
InputSystem.Update();
Assert.That(monitorFired, Is.False);
// Component control of left stick.
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = new Vector2(0.75f, 0.5f)
}, 0.9);
InputSystem.Update();
Assert.That(monitorFired, Is.True);
////REVIEW: do we want to be able to detect the child control that actually changed? could be multiple, though
Assert.That(receivedControl, Is.SameAs(gamepad.leftStick));
Assert.That(receivedTime.Value, Is.EqualTo(0.9).Within(0.000001));
// Remove state monitor and change leftStick again.
InputSystem.RemoveStateChangeMonitor(gamepad.leftStick, monitor);
monitorFired = false;
receivedControl = null;
receivedTime = 0;
InputSystem.QueueStateEvent(gamepad, new GamepadState {
leftStick = new Vector2(0.0f, 0.0f)
}, 1.0);
InputSystem.Update();
Assert.That(monitorFired, Is.False);
}
