static InputDeviceStyle DetectDeviceStyle(UnityInput.InputDevice unityDevice) { switch (unityDevice) { case UnityInput.XInput.XInputController _: return(InputDeviceStyle.XboxOne); case UnityInput.DualShock.DualShockGamepad _: return(InputDeviceStyle.PlayStation4); #if UNITY_EDITOR || UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || UNITY_WSA case UnityInput.Switch.SwitchProControllerHID _: return(InputDeviceStyle.NintendoSwitch); #endif #if UNITY_EDITOR || UNITY_IOS || UNITY_TVOS case UnityInput.iOS.iOSGameController _: return(InputDeviceStyle.AppleMFi); #endif #if (UNITY_STANDALONE || UNITY_EDITOR) && UNITY_ENABLE_STEAM_CONTROLLER_SUPPORT case UnityInput.Steam.SteamController _: return(InputDeviceStyle.Steam); #endif default: return(InputDeviceStyle.Unknown); } }
void OnDeviceChanged(UnityEngine.InputSystem.InputDevice device, InputDeviceChange change) { if (change == InputDeviceChange.Added) { leftTouchController = (OculusTouchController)OculusTouchController.leftHand; rightTouchController = (OculusTouchController)OculusTouchController.rightHand; hmd = InputSystem.GetDevice <OculusHMD>(); } }
void DetachDevice(UnityInput.InputDevice unityDevice) { NewUnityInputDevice inputDevice; if (internalDevices.TryGetValue(unityDevice.deviceId, out inputDevice)) { internalDevices.Remove(unityDevice.deviceId); InputManager.DetachDevice(inputDevice); } }
private DemoPlayerController FindPlayerControllerForDevice(InputDevice device) { var user = InputUser.FindUserPairedToDevice(device); if (user == null) { return(null); } return(FindPlayerControllerForUser(user.Value)); }
void OnInputSystemOnDeviceChange(UnityInput.InputDevice unityDevice, UnityInput.InputDeviceChange inputDeviceChange) { // TODO: Not 100% sure if we also need to handle some of the other events. switch (inputDeviceChange) { case UnityInput.InputDeviceChange.Added: AttachDevice(unityDevice); break; case UnityInput.InputDeviceChange.Removed: DetachDevice(unityDevice); break; } }
public Controller(int number, string name, Color color, Inputs.InputDevice device, Inputs.InputControlScheme scheme) { _name = name; _color = color; _number = number; _device = device; //_user = Inputs.Users.InputUser.CreateUserWithoutPairedDevices(); //Inputs.Users.InputUser.PerformPairingWithDevice(_device, _user); // Each player gets a separate action setup. This makes the state of actions and bindings // local to each player and also ensures we're not stepping on the action setup used by // DemoGame itself for the main menu (where we are not using control schemes and just blindly // bind to whatever devices are available locally). _scheme = scheme; _actionMap = new ActionMap(); _actionMap.bindingMask = new Inputs.InputBinding { groups = _scheme.bindingGroup }; Enable(); }
void AttachDevice(UnityInput.InputDevice unityDevice) { var unityGamepad = unityDevice as UnityInput.Gamepad; if (unityGamepad != null) { if (internalDevices.ContainsKey(unityDevice.deviceId)) { return; } var inputDevice = new NewUnityInputDevice(unityGamepad); internalDevices.Add(unityDevice.deviceId, inputDevice); InputManager.AttachDevice(inputDevice); } // else // { // Debug.Log( $"Discarding device: {unityDevice.displayName}" ); // } }
/// <summary> /// Called when there's a change in the input user setup in the system. /// </summary> /// <param name="user"></param> /// <param name="change"></param> /// <param name="device"></param> private void OnUserChange(InputUser user, InputUserChange change, InputDevice device) { var player = FindPlayerControllerForUser(user); switch (change) { // A player has switched accounts. This will only happen on platforms that have user account // management (PS4, Xbox, Switch). On PS4, for example, this can happen at any time by the // player pressing the PS4 button and switching accounts. We simply update the information // we display for the player's active user account. case InputUserChange.AccountChanged: { if (player != null) { player.OnUserAccountChanged(); } break; } // If the user has canceled account selection, we remove the user if there's no devices // already paired to it. This usually happens when a player initiates a join on a device on // Xbox or Switch, has the account picker come up, but then cancels instead of making an // account selection. In this case, we want to cancel the join. // NOTE: We are only adding DemoPlayerControllers once device pairing is complete case InputUserChange.AccountSelectionCanceled: { if (user.pairedDevices.Count == 0) { Debug.Assert(FindPlayerControllerForUser(user) == null); user.UnpairDevicesAndRemoveUser(); } break; } // An InputUser gained a new device. If we're in the lobby and don't yet have a player // for the user, it means a new player has joined. We don't join players until they have // a device paired to them which is why we ignore InputUserChange.Added and only react // to InputUserChange.DevicePaired instead. case InputUserChange.DevicePaired: { if (state == State.InLobby && player == null) { OnPlayerJoins(user); } else if (player != null) { player.OnDevicesOrBindingsHaveChanged(); } break; } // Some player ran out of battery or unplugged a wired device. case InputUserChange.DeviceLost: { Debug.Assert(player != null); player.OnDeviceLost(); ////REVIEW: should we unjoin a user when losing devices in the lobby? ////TODO: we need a way for other players to be able to resolve the situation // If we're currently in-game, we pause the game until the player has re-gained control. if (isInGame) { PauseGame(); } break; } // Some player has customized controls or had previously customized controls loaded. case InputUserChange.BindingsChanged: { player.OnDevicesOrBindingsHaveChanged(); break; } } }
public void AssociateInputDeviceWithUser(InputDevice device, ulong userHandle, string userName = null, string userId = null) { AssociateInputDeviceWithUser(device.deviceId, userHandle, userName, userId); }
public void SetDeviceCommandCallback(InputDevice device, DeviceCommandCallback callback) { SetDeviceCommandCallback(device.deviceId, callback); }
private unsafe void OnEvent(InputEventPtr eventPtr, InputDevice device) { // Ignore if not a state event. if (!eventPtr.IsA <StateEvent>() && !eventPtr.IsA <DeltaStateEvent>()) { return; } // Go through controls and see if there's anything interesting in the event. var controls = device.allControls; var controlCount = controls.Count; var haveChangedCandidates = false; for (var i = 0; i < controlCount; ++i) { var control = controls[i]; // Skip controls that have no state in the event. var statePtr = control.GetStatePtrFromStateEvent(eventPtr); if (statePtr == null) { continue; } // If the control that cancels has been actuated, abort the operation now. if (!string.IsNullOrEmpty(m_CancelBinding) && InputControlPath.Matches(m_CancelBinding, control) && !control.CheckStateIsAtDefault(statePtr) && control.HasValueChangeInState(statePtr)) { OnCancel(); break; } // Skip noisy controls. if (control.noisy && (m_Flags & Flags.DontIgnoreNoisyControls) == 0) { continue; } // If controls have to match a certain path, check if this one does. if (m_IncludePathCount > 0 && !HavePathMatch(control, m_IncludePaths, m_IncludePathCount)) { continue; } // If controls must not match certain path, make sure the control doesn't. if (m_ExcludePathCount > 0 && HavePathMatch(control, m_ExcludePaths, m_ExcludePathCount)) { continue; } // If we're expecting controls of a certain type, skip if control isn't of // the right type. if (m_ControlType != null && !m_ControlType.IsInstanceOfType(control)) { continue; } // If we're expecting controls to be based on a specific layout, skip if control // isn't based on that layout. if (!m_ExpectedLayout.IsEmpty() && m_ExpectedLayout != control.m_Layout && !InputControlLayout.s_Layouts.IsBasedOn(m_ExpectedLayout, control.m_Layout)) { continue; } // Skip controls that are in their default state. // NOTE: This is the cheapest check with respect to looking at actual state. So // do this first before looking further at the state. if (control.CheckStateIsAtDefault(statePtr)) { continue; } // Skip controls that have no effective value change. // NOTE: This will run the full processor stack and is more involved. if (!control.HasValueChangeInState(statePtr)) { continue; } // If we have a magnitude threshold, see if control passes it. var magnitude = -1f; if (m_MagnitudeThreshold >= 0f) { magnitude = control.EvaluateMagnitude(statePtr); if (magnitude >= 0 && magnitude < m_MagnitudeThreshold) { continue; // No, so skip. } } // Compute score. float score; if (m_OnComputeScore != null) { score = m_OnComputeScore(control, eventPtr); } else { score = magnitude; // We don't want synthetic controls to not be bindable at all but they should // generally cede priority to controls that aren't synthetic. So we bump all // scores of controls that aren't synthetic. if (!control.synthetic) { score += 1f; } } // Control is a candidate. // See if we already singled the control out as a potential candidate. var candidateIndex = m_Candidates.IndexOf(control); if (candidateIndex != -1) { // Yes, we did. So just check whether it became a better candidate than before. if (m_Scores[candidateIndex] < score) { haveChangedCandidates = true; m_Scores[candidateIndex] = score; if (m_WaitSecondsAfterMatch > 0) { m_LastMatchTime = InputRuntime.s_Instance.currentTime; } } } else { // No, so add it. var candidateCount = m_Candidates.Count; m_Candidates.Add(control); ArrayHelpers.AppendWithCapacity(ref m_Scores, ref candidateCount, score); haveChangedCandidates = true; if (m_WaitSecondsAfterMatch > 0) { m_LastMatchTime = InputRuntime.s_Instance.currentTime; } } } if (haveChangedCandidates && !canceled) { // If we have a callback that wants to control matching, leave it to the callback to decide // whether the rebind is complete or not. Otherwise, just complete. if (m_OnPotentialMatch != null) { SortCandidatesByScore(); m_OnPotentialMatch(this); } else if (m_WaitSecondsAfterMatch <= 0) { OnComplete(); } else { SortCandidatesByScore(); } } }
private void SendDevice(InputDevice device) { var message = NewDeviceMsg.Create(device); Send(message); }
/// <summary> /// Set reference to point to one specific device. /// </summary> /// <param name="device"></param> public void Set(InputDevice device) { throw new NotImplementedException(); }