diff options
Diffstat (limited to 'Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs')
| -rw-r--r-- | Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs | 1415 |
1 files changed, 1415 insertions, 0 deletions
diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs new file mode 100644 index 0000000..02245ab --- /dev/null +++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs @@ -0,0 +1,1415 @@ +using System; +using System.Collections.Generic; +using Rewired.Components; +using Rewired.UI; +using Rewired.Utils; +using UnityEngine; +using UnityEngine.EventSystems; +using UnityEngine.Serialization; + +namespace Rewired.Integration.UnityUI; + +[AddComponentMenu("Rewired/Rewired Standalone Input Module")] +public sealed class RewiredStandaloneInputModule : RewiredPointerInputModule +{ + [Serializable] + public class PlayerSetting + { + public int playerId; + + public List<Rewired.Components.PlayerMouse> playerMice = new List<Rewired.Components.PlayerMouse>(); + + public PlayerSetting() + { + } + + private PlayerSetting(PlayerSetting other) + { + if (other == null) + { + throw new ArgumentNullException("other"); + } + playerId = other.playerId; + playerMice = new List<Rewired.Components.PlayerMouse>(); + if (other.playerMice == null) + { + return; + } + foreach (Rewired.Components.PlayerMouse item in other.playerMice) + { + playerMice.Add(item); + } + } + + public PlayerSetting Clone() + { + return new PlayerSetting(this); + } + } + + private const string DEFAULT_ACTION_MOVE_HORIZONTAL = "UIHorizontal"; + + private const string DEFAULT_ACTION_MOVE_VERTICAL = "UIVertical"; + + private const string DEFAULT_ACTION_SUBMIT = "UISubmit"; + + private const string DEFAULT_ACTION_CANCEL = "UICancel"; + + [Tooltip("(Optional) Link the Rewired Input Manager here for easier access to Player ids, etc.")] + [SerializeField] + private InputManager_Base rewiredInputManager; + + [SerializeField] + [Tooltip("Use all Rewired game Players to control the UI. This does not include the System Player. If enabled, this setting overrides individual Player Ids set in Rewired Player Ids.")] + private bool useAllRewiredGamePlayers; + + [SerializeField] + [Tooltip("Allow the Rewired System Player to control the UI.")] + private bool useRewiredSystemPlayer; + + [SerializeField] + [Tooltip("A list of Player Ids that are allowed to control the UI. If Use All Rewired Game Players = True, this list will be ignored.")] + private int[] rewiredPlayerIds = new int[1]; + + [SerializeField] + [Tooltip("Allow only Players with Player.isPlaying = true to control the UI.")] + private bool usePlayingPlayersOnly; + + [SerializeField] + [Tooltip("Player Mice allowed to interact with the UI. Each Player that owns a Player Mouse must also be allowed to control the UI or the Player Mouse will not function.")] + private List<Rewired.Components.PlayerMouse> playerMice = new List<Rewired.Components.PlayerMouse>(); + + [SerializeField] + [Tooltip("Makes an axis press always move only one UI selection. Enable if you do not want to allow scrolling through UI elements by holding an axis direction.")] + private bool moveOneElementPerAxisPress; + + [SerializeField] + [Tooltip("If enabled, Action Ids will be used to set the Actions. If disabled, string names will be used to set the Actions.")] + private bool setActionsById; + + [SerializeField] + [Tooltip("Id of the horizontal Action for movement (if axis events are used).")] + private int horizontalActionId = -1; + + [SerializeField] + [Tooltip("Id of the vertical Action for movement (if axis events are used).")] + private int verticalActionId = -1; + + [SerializeField] + [Tooltip("Id of the Action used to submit.")] + private int submitActionId = -1; + + [SerializeField] + [Tooltip("Id of the Action used to cancel.")] + private int cancelActionId = -1; + + [SerializeField] + [Tooltip("Name of the horizontal axis for movement (if axis events are used).")] + private string m_HorizontalAxis = "UIHorizontal"; + + [SerializeField] + [Tooltip("Name of the vertical axis for movement (if axis events are used).")] + private string m_VerticalAxis = "UIVertical"; + + [SerializeField] + [Tooltip("Name of the action used to submit.")] + private string m_SubmitButton = "UISubmit"; + + [SerializeField] + [Tooltip("Name of the action used to cancel.")] + private string m_CancelButton = "UICancel"; + + [SerializeField] + [Tooltip("Number of selection changes allowed per second when a movement button/axis is held in a direction.")] + private float m_InputActionsPerSecond = 10f; + + [SerializeField] + [Tooltip("Delay in seconds before vertical/horizontal movement starts repeating continouously when a movement direction is held.")] + private float m_RepeatDelay; + + [SerializeField] + [Tooltip("Allows the mouse to be used to select elements.")] + private bool m_allowMouseInput = true; + + [SerializeField] + [Tooltip("Allows the mouse to be used to select elements if the device also supports touch control.")] + private bool m_allowMouseInputIfTouchSupported = true; + + [SerializeField] + [Tooltip("Allows touch input to be used to select elements.")] + private bool m_allowTouchInput = true; + + [SerializeField] + [Tooltip("Deselects the current selection on mouse/touch click when the pointer is not over a selectable object.")] + private bool m_deselectIfBackgroundClicked = true; + + [SerializeField] + [Tooltip("Deselects the current selection on mouse/touch click before selecting the next object.")] + private bool m_deselectBeforeSelecting = true; + + [SerializeField] + [FormerlySerializedAs("m_AllowActivationOnMobileDevice")] + [Tooltip("Forces the module to always be active.")] + private bool m_ForceModuleActive; + + [NonSerialized] + private int[] playerIds; + + private bool recompiling; + + [NonSerialized] + private bool isTouchSupported; + + [NonSerialized] + private double m_PrevActionTime; + + [NonSerialized] + private Vector2 m_LastMoveVector; + + [NonSerialized] + private int m_ConsecutiveMoveCount; + + [NonSerialized] + private bool m_HasFocus = true; + + public InputManager_Base RewiredInputManager + { + get + { + return rewiredInputManager; + } + set + { + rewiredInputManager = value; + } + } + + public bool UseAllRewiredGamePlayers + { + get + { + return useAllRewiredGamePlayers; + } + set + { + bool num = value != useAllRewiredGamePlayers; + useAllRewiredGamePlayers = value; + if (num) + { + SetupRewiredVars(); + } + } + } + + public bool UseRewiredSystemPlayer + { + get + { + return useRewiredSystemPlayer; + } + set + { + bool num = value != useRewiredSystemPlayer; + useRewiredSystemPlayer = value; + if (num) + { + SetupRewiredVars(); + } + } + } + + public int[] RewiredPlayerIds + { + get + { + return (int[])rewiredPlayerIds.Clone(); + } + set + { + rewiredPlayerIds = ((value != null) ? ((int[])value.Clone()) : new int[0]); + SetupRewiredVars(); + } + } + + public bool UsePlayingPlayersOnly + { + get + { + return usePlayingPlayersOnly; + } + set + { + usePlayingPlayersOnly = value; + } + } + + public List<Rewired.Components.PlayerMouse> PlayerMice + { + get + { + return new List<Rewired.Components.PlayerMouse>(playerMice); + } + set + { + if (value == null) + { + playerMice = new List<Rewired.Components.PlayerMouse>(); + SetupRewiredVars(); + } + else + { + playerMice = new List<Rewired.Components.PlayerMouse>(value); + SetupRewiredVars(); + } + } + } + + public bool MoveOneElementPerAxisPress + { + get + { + return moveOneElementPerAxisPress; + } + set + { + moveOneElementPerAxisPress = value; + } + } + + public bool allowMouseInput + { + get + { + return m_allowMouseInput; + } + set + { + m_allowMouseInput = value; + } + } + + public bool allowMouseInputIfTouchSupported + { + get + { + return m_allowMouseInputIfTouchSupported; + } + set + { + m_allowMouseInputIfTouchSupported = value; + } + } + + public bool allowTouchInput + { + get + { + return m_allowTouchInput; + } + set + { + m_allowTouchInput = value; + } + } + + public bool deselectIfBackgroundClicked + { + get + { + return m_deselectIfBackgroundClicked; + } + set + { + m_deselectIfBackgroundClicked = value; + } + } + + private bool deselectBeforeSelecting + { + get + { + return m_deselectBeforeSelecting; + } + set + { + m_deselectBeforeSelecting = value; + } + } + + public bool SetActionsById + { + get + { + return setActionsById; + } + set + { + if (setActionsById != value) + { + setActionsById = value; + SetupRewiredVars(); + } + } + } + + public int HorizontalActionId + { + get + { + return horizontalActionId; + } + set + { + if (value != horizontalActionId) + { + horizontalActionId = value; + if (ReInput.isReady) + { + m_HorizontalAxis = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty); + } + } + } + } + + public int VerticalActionId + { + get + { + return verticalActionId; + } + set + { + if (value != verticalActionId) + { + verticalActionId = value; + if (ReInput.isReady) + { + m_VerticalAxis = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty); + } + } + } + } + + public int SubmitActionId + { + get + { + return submitActionId; + } + set + { + if (value != submitActionId) + { + submitActionId = value; + if (ReInput.isReady) + { + m_SubmitButton = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty); + } + } + } + } + + public int CancelActionId + { + get + { + return cancelActionId; + } + set + { + if (value != cancelActionId) + { + cancelActionId = value; + if (ReInput.isReady) + { + m_CancelButton = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty); + } + } + } + } + + protected override bool isMouseSupported + { + get + { + if (!base.isMouseSupported) + { + return false; + } + if (!m_allowMouseInput) + { + return false; + } + if (!isTouchSupported) + { + return true; + } + return m_allowMouseInputIfTouchSupported; + } + } + + private bool isTouchAllowed => m_allowTouchInput; + + [Obsolete("allowActivationOnMobileDevice has been deprecated. Use forceModuleActive instead")] + public bool allowActivationOnMobileDevice + { + get + { + return m_ForceModuleActive; + } + set + { + m_ForceModuleActive = value; + } + } + + public bool forceModuleActive + { + get + { + return m_ForceModuleActive; + } + set + { + m_ForceModuleActive = value; + } + } + + public float inputActionsPerSecond + { + get + { + return m_InputActionsPerSecond; + } + set + { + m_InputActionsPerSecond = value; + } + } + + public float repeatDelay + { + get + { + return m_RepeatDelay; + } + set + { + m_RepeatDelay = value; + } + } + + public string horizontalAxis + { + get + { + return m_HorizontalAxis; + } + set + { + if (!(m_HorizontalAxis == value)) + { + m_HorizontalAxis = value; + if (ReInput.isReady) + { + horizontalActionId = ReInput.mapping.GetActionId(value); + } + } + } + } + + public string verticalAxis + { + get + { + return m_VerticalAxis; + } + set + { + if (!(m_VerticalAxis == value)) + { + m_VerticalAxis = value; + if (ReInput.isReady) + { + verticalActionId = ReInput.mapping.GetActionId(value); + } + } + } + } + + public string submitButton + { + get + { + return m_SubmitButton; + } + set + { + if (!(m_SubmitButton == value)) + { + m_SubmitButton = value; + if (ReInput.isReady) + { + submitActionId = ReInput.mapping.GetActionId(value); + } + } + } + } + + public string cancelButton + { + get + { + return m_CancelButton; + } + set + { + if (!(m_CancelButton == value)) + { + m_CancelButton = value; + if (ReInput.isReady) + { + cancelActionId = ReInput.mapping.GetActionId(value); + } + } + } + } + + private RewiredStandaloneInputModule() + { + } + + protected override void Awake() + { + base.Awake(); + isTouchSupported = base.defaultTouchInputSource.touchSupported; + TouchInputModule component = GetComponent<TouchInputModule>(); + if (component != null) + { + component.enabled = false; + } + ReInput.InitializedEvent += OnRewiredInitialized; + InitializeRewired(); + } + + public override void UpdateModule() + { + CheckEditorRecompile(); + if (!recompiling && ReInput.isReady && !m_HasFocus) + { + ShouldIgnoreEventsOnNoFocus(); + } + } + + public override bool IsModuleSupported() + { + return true; + } + + public override bool ShouldActivateModule() + { + if (!base.ShouldActivateModule()) + { + return false; + } + if (recompiling) + { + return false; + } + if (!ReInput.isReady) + { + return false; + } + bool flag = m_ForceModuleActive; + for (int i = 0; i < playerIds.Length; i++) + { + Player player = ReInput.players.GetPlayer(playerIds[i]); + if (player != null && (!usePlayingPlayersOnly || player.isPlaying)) + { + flag |= GetButtonDown(player, submitActionId); + flag |= GetButtonDown(player, cancelActionId); + if (moveOneElementPerAxisPress) + { + flag |= GetButtonDown(player, horizontalActionId) || GetNegativeButtonDown(player, horizontalActionId); + flag |= GetButtonDown(player, verticalActionId) || GetNegativeButtonDown(player, verticalActionId); + } + else + { + flag |= !Mathf.Approximately(GetAxis(player, horizontalActionId), 0f); + flag |= !Mathf.Approximately(GetAxis(player, verticalActionId), 0f); + } + } + } + if (isMouseSupported) + { + flag |= DidAnyMouseMove(); + flag |= GetMouseButtonDownOnAnyMouse(0); + } + if (isTouchAllowed) + { + for (int j = 0; j < base.defaultTouchInputSource.touchCount; j++) + { + Touch touch = base.defaultTouchInputSource.GetTouch(j); + flag |= touch.phase == TouchPhase.Began || touch.phase == TouchPhase.Moved || touch.phase == TouchPhase.Stationary; + } + } + return flag; + } + + public override void ActivateModule() + { + if (m_HasFocus || !ShouldIgnoreEventsOnNoFocus()) + { + base.ActivateModule(); + GameObject gameObject = base.eventSystem.currentSelectedGameObject; + if (gameObject == null) + { + gameObject = base.eventSystem.firstSelectedGameObject; + } + base.eventSystem.SetSelectedGameObject(gameObject, GetBaseEventData()); + } + } + + public override void DeactivateModule() + { + base.DeactivateModule(); + ClearSelection(); + } + + public override void Process() + { + if (!ReInput.isReady || (!m_HasFocus && ShouldIgnoreEventsOnNoFocus()) || !base.enabled || !base.gameObject.activeInHierarchy) + { + return; + } + bool flag = SendUpdateEventToSelectedObject(); + if (base.eventSystem.sendNavigationEvents) + { + if (!flag) + { + flag |= SendMoveEventToSelectedObject(); + } + if (!flag) + { + SendSubmitEventToSelectedObject(); + } + } + if (!ProcessTouchEvents() && isMouseSupported) + { + ProcessMouseEvents(); + } + } + + private bool ProcessTouchEvents() + { + if (!isTouchAllowed) + { + return false; + } + for (int i = 0; i < base.defaultTouchInputSource.touchCount; i++) + { + Touch touch = base.defaultTouchInputSource.GetTouch(i); + if (touch.type != TouchType.Indirect) + { + bool pressed; + bool released; + PlayerPointerEventData touchPointerEventData = GetTouchPointerEventData(0, 0, touch, out pressed, out released); + ProcessTouchPress(touchPointerEventData, pressed, released); + if (!released) + { + ProcessMove(touchPointerEventData); + ProcessDrag(touchPointerEventData); + } + else + { + RemovePointerData(touchPointerEventData); + } + } + } + return base.defaultTouchInputSource.touchCount > 0; + } + + private void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released) + { + GameObject gameObject = pointerEvent.pointerCurrentRaycast.gameObject; + if (pressed) + { + pointerEvent.eligibleForClick = true; + pointerEvent.delta = Vector2.zero; + pointerEvent.dragging = false; + pointerEvent.useDragThreshold = true; + pointerEvent.pressPosition = pointerEvent.position; + pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast; + HandleMouseTouchDeselectionOnSelectionChanged(gameObject, pointerEvent); + if (pointerEvent.pointerEnter != gameObject) + { + HandlePointerExitAndEnter(pointerEvent, gameObject); + pointerEvent.pointerEnter = gameObject; + } + GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.pointerDownHandler); + if (gameObject2 == null) + { + gameObject2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject); + } + double unscaledTime = ReInput.time.unscaledTime; + if (gameObject2 == pointerEvent.lastPress) + { + if (unscaledTime - (double)pointerEvent.clickTime < 0.30000001192092896) + { + int clickCount = pointerEvent.clickCount + 1; + pointerEvent.clickCount = clickCount; + } + else + { + pointerEvent.clickCount = 1; + } + pointerEvent.clickTime = (float)unscaledTime; + } + else + { + pointerEvent.clickCount = 1; + } + pointerEvent.pointerPress = gameObject2; + pointerEvent.rawPointerPress = gameObject; + pointerEvent.clickTime = (float)unscaledTime; + pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject); + if (pointerEvent.pointerDrag != null) + { + ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag); + } + } + if (released) + { + ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler); + GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject); + if (pointerEvent.pointerPress == eventHandler && pointerEvent.eligibleForClick) + { + ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler); + } + else if (pointerEvent.pointerDrag != null && pointerEvent.dragging) + { + ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.dropHandler); + } + pointerEvent.eligibleForClick = false; + pointerEvent.pointerPress = null; + pointerEvent.rawPointerPress = null; + if (pointerEvent.pointerDrag != null && pointerEvent.dragging) + { + ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); + } + pointerEvent.dragging = false; + pointerEvent.pointerDrag = null; + if (pointerEvent.pointerDrag != null) + { + ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler); + } + pointerEvent.pointerDrag = null; + ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler); + pointerEvent.pointerEnter = null; + } + } + + private bool SendSubmitEventToSelectedObject() + { + if (base.eventSystem.currentSelectedGameObject == null) + { + return false; + } + if (recompiling) + { + return false; + } + BaseEventData baseEventData = GetBaseEventData(); + for (int i = 0; i < playerIds.Length; i++) + { + Player player = ReInput.players.GetPlayer(playerIds[i]); + if (player != null && (!usePlayingPlayersOnly || player.isPlaying)) + { + if (GetButtonDown(player, submitActionId)) + { + ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.submitHandler); + break; + } + if (GetButtonDown(player, cancelActionId)) + { + ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.cancelHandler); + break; + } + } + } + return baseEventData.used; + } + + private Vector2 GetRawMoveVector() + { + if (recompiling) + { + return Vector2.zero; + } + Vector2 zero = Vector2.zero; + for (int i = 0; i < playerIds.Length; i++) + { + Player player = ReInput.players.GetPlayer(playerIds[i]); + if (player == null || (usePlayingPlayersOnly && !player.isPlaying)) + { + continue; + } + float num = GetAxis(player, horizontalActionId); + float num2 = GetAxis(player, verticalActionId); + if (Mathf.Approximately(num, 0f)) + { + num = 0f; + } + if (Mathf.Approximately(num2, 0f)) + { + num2 = 0f; + } + if (moveOneElementPerAxisPress) + { + if (GetButtonDown(player, horizontalActionId) && num > 0f) + { + zero.x += 1f; + } + if (GetNegativeButtonDown(player, horizontalActionId) && num < 0f) + { + zero.x -= 1f; + } + if (GetButtonDown(player, verticalActionId) && num2 > 0f) + { + zero.y += 1f; + } + if (GetNegativeButtonDown(player, verticalActionId) && num2 < 0f) + { + zero.y -= 1f; + } + } + else + { + if (GetButton(player, horizontalActionId) && num > 0f) + { + zero.x += 1f; + } + if (GetNegativeButton(player, horizontalActionId) && num < 0f) + { + zero.x -= 1f; + } + if (GetButton(player, verticalActionId) && num2 > 0f) + { + zero.y += 1f; + } + if (GetNegativeButton(player, verticalActionId) && num2 < 0f) + { + zero.y -= 1f; + } + } + } + return zero; + } + + private bool SendMoveEventToSelectedObject() + { + if (recompiling) + { + return false; + } + double unscaledTime = ReInput.time.unscaledTime; + Vector2 rawMoveVector = GetRawMoveVector(); + if (Mathf.Approximately(rawMoveVector.x, 0f) && Mathf.Approximately(rawMoveVector.y, 0f)) + { + m_ConsecutiveMoveCount = 0; + return false; + } + bool flag = Vector2.Dot(rawMoveVector, m_LastMoveVector) > 0f; + CheckButtonOrKeyMovement(out var downHorizontal, out var downVertical); + AxisEventData axisEventData = null; + bool flag2 = downHorizontal || downVertical; + if (flag2) + { + axisEventData = GetAxisEventData(rawMoveVector.x, rawMoveVector.y, 0f); + MoveDirection moveDir = axisEventData.moveDir; + flag2 = ((moveDir == MoveDirection.Up || moveDir == MoveDirection.Down) && downVertical) || ((moveDir == MoveDirection.Left || moveDir == MoveDirection.Right) && downHorizontal); + } + if (!flag2) + { + flag2 = ((!(m_RepeatDelay > 0f)) ? (unscaledTime > m_PrevActionTime + (double)(1f / m_InputActionsPerSecond)) : ((!flag || m_ConsecutiveMoveCount != 1) ? (unscaledTime > m_PrevActionTime + (double)(1f / m_InputActionsPerSecond)) : (unscaledTime > m_PrevActionTime + (double)m_RepeatDelay))); + } + if (!flag2) + { + return false; + } + if (axisEventData == null) + { + axisEventData = GetAxisEventData(rawMoveVector.x, rawMoveVector.y, 0f); + } + if (axisEventData.moveDir != MoveDirection.None) + { + ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler); + if (!flag) + { + m_ConsecutiveMoveCount = 0; + } + if (m_ConsecutiveMoveCount == 0 || !(downHorizontal || downVertical)) + { + m_ConsecutiveMoveCount++; + } + m_PrevActionTime = unscaledTime; + m_LastMoveVector = rawMoveVector; + } + else + { + m_ConsecutiveMoveCount = 0; + } + return axisEventData.used; + } + + private void CheckButtonOrKeyMovement(out bool downHorizontal, out bool downVertical) + { + downHorizontal = false; + downVertical = false; + for (int i = 0; i < playerIds.Length; i++) + { + Player player = ReInput.players.GetPlayer(playerIds[i]); + if (player != null && (!usePlayingPlayersOnly || player.isPlaying)) + { + downHorizontal |= GetButtonDown(player, horizontalActionId) || GetNegativeButtonDown(player, horizontalActionId); + downVertical |= GetButtonDown(player, verticalActionId) || GetNegativeButtonDown(player, verticalActionId); + } + } + } + + private void ProcessMouseEvents() + { + for (int i = 0; i < playerIds.Length; i++) + { + Player player = ReInput.players.GetPlayer(playerIds[i]); + if (player != null && (!usePlayingPlayersOnly || player.isPlaying)) + { + int mouseInputSourceCount = GetMouseInputSourceCount(playerIds[i]); + for (int j = 0; j < mouseInputSourceCount; j++) + { + ProcessMouseEvent(playerIds[i], j); + } + } + } + } + + private void ProcessMouseEvent(int playerId, int pointerIndex) + { + MouseState mousePointerEventData = GetMousePointerEventData(playerId, pointerIndex); + if (mousePointerEventData == null) + { + return; + } + MouseButtonEventData eventData = mousePointerEventData.GetButtonState(0).eventData; + ProcessMousePress(eventData); + ProcessMove(eventData.buttonData); + ProcessDrag(eventData.buttonData); + ProcessMousePress(mousePointerEventData.GetButtonState(1).eventData); + ProcessDrag(mousePointerEventData.GetButtonState(1).eventData.buttonData); + ProcessMousePress(mousePointerEventData.GetButtonState(2).eventData); + ProcessDrag(mousePointerEventData.GetButtonState(2).eventData.buttonData); + IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, pointerIndex); + if (mouseInputSource != null) + { + for (int i = 3; i < mouseInputSource.buttonCount; i++) + { + ProcessMousePress(mousePointerEventData.GetButtonState(i).eventData); + ProcessDrag(mousePointerEventData.GetButtonState(i).eventData.buttonData); + } + if (!Mathf.Approximately(eventData.buttonData.scrollDelta.sqrMagnitude, 0f)) + { + ExecuteEvents.ExecuteHierarchy(ExecuteEvents.GetEventHandler<IScrollHandler>(eventData.buttonData.pointerCurrentRaycast.gameObject), eventData.buttonData, ExecuteEvents.scrollHandler); + } + } + } + + private bool SendUpdateEventToSelectedObject() + { + if (base.eventSystem.currentSelectedGameObject == null) + { + return false; + } + BaseEventData baseEventData = GetBaseEventData(); + ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.updateSelectedHandler); + return baseEventData.used; + } + + private void ProcessMousePress(MouseButtonEventData data) + { + PlayerPointerEventData buttonData = data.buttonData; + if (GetMouseInputSource(buttonData.playerId, buttonData.inputSourceIndex) == null) + { + return; + } + GameObject gameObject = buttonData.pointerCurrentRaycast.gameObject; + if (data.PressedThisFrame()) + { + buttonData.eligibleForClick = true; + buttonData.delta = Vector2.zero; + buttonData.dragging = false; + buttonData.useDragThreshold = true; + buttonData.pressPosition = buttonData.position; + buttonData.pointerPressRaycast = buttonData.pointerCurrentRaycast; + HandleMouseTouchDeselectionOnSelectionChanged(gameObject, buttonData); + GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy(gameObject, buttonData, ExecuteEvents.pointerDownHandler); + if (gameObject2 == null) + { + gameObject2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject); + } + double unscaledTime = ReInput.time.unscaledTime; + if (gameObject2 == buttonData.lastPress) + { + if (unscaledTime - (double)buttonData.clickTime < 0.30000001192092896) + { + int clickCount = buttonData.clickCount + 1; + buttonData.clickCount = clickCount; + } + else + { + buttonData.clickCount = 1; + } + buttonData.clickTime = (float)unscaledTime; + } + else + { + buttonData.clickCount = 1; + } + buttonData.pointerPress = gameObject2; + buttonData.rawPointerPress = gameObject; + buttonData.clickTime = (float)unscaledTime; + buttonData.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject); + if (buttonData.pointerDrag != null) + { + ExecuteEvents.Execute(buttonData.pointerDrag, buttonData, ExecuteEvents.initializePotentialDrag); + } + } + if (data.ReleasedThisFrame()) + { + ExecuteEvents.Execute(buttonData.pointerPress, buttonData, ExecuteEvents.pointerUpHandler); + GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject); + if (buttonData.pointerPress == eventHandler && buttonData.eligibleForClick) + { + ExecuteEvents.Execute(buttonData.pointerPress, buttonData, ExecuteEvents.pointerClickHandler); + } + else if (buttonData.pointerDrag != null && buttonData.dragging) + { + ExecuteEvents.ExecuteHierarchy(gameObject, buttonData, ExecuteEvents.dropHandler); + } + buttonData.eligibleForClick = false; + buttonData.pointerPress = null; + buttonData.rawPointerPress = null; + if (buttonData.pointerDrag != null && buttonData.dragging) + { + ExecuteEvents.Execute(buttonData.pointerDrag, buttonData, ExecuteEvents.endDragHandler); + } + buttonData.dragging = false; + buttonData.pointerDrag = null; + if (gameObject != buttonData.pointerEnter) + { + HandlePointerExitAndEnter(buttonData, null); + HandlePointerExitAndEnter(buttonData, gameObject); + } + } + } + + private void HandleMouseTouchDeselectionOnSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent) + { + if (m_deselectIfBackgroundClicked && m_deselectBeforeSelecting) + { + DeselectIfSelectionChanged(currentOverGo, pointerEvent); + return; + } + GameObject eventHandler = ExecuteEvents.GetEventHandler<ISelectHandler>(currentOverGo); + if (m_deselectIfBackgroundClicked) + { + if (eventHandler != base.eventSystem.currentSelectedGameObject && eventHandler != null) + { + base.eventSystem.SetSelectedGameObject(null, pointerEvent); + } + } + else if (m_deselectBeforeSelecting && eventHandler != null && eventHandler != base.eventSystem.currentSelectedGameObject) + { + base.eventSystem.SetSelectedGameObject(null, pointerEvent); + } + } + + private void OnApplicationFocus(bool hasFocus) + { + m_HasFocus = hasFocus; + } + + private bool ShouldIgnoreEventsOnNoFocus() + { + if (!ReInput.isReady) + { + return true; + } + return ReInput.configuration.ignoreInputWhenAppNotInFocus; + } + + protected override void OnDestroy() + { + base.OnDestroy(); + ReInput.InitializedEvent -= OnRewiredInitialized; + ReInput.ShutDownEvent -= OnRewiredShutDown; + ReInput.EditorRecompileEvent -= OnEditorRecompile; + } + + protected override bool IsDefaultPlayer(int playerId) + { + if (playerIds == null) + { + return false; + } + if (!ReInput.isReady) + { + return false; + } + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < playerIds.Length; j++) + { + Player player = ReInput.players.GetPlayer(playerIds[j]); + if (player != null && (i >= 1 || !usePlayingPlayersOnly || player.isPlaying) && (i >= 2 || player.controllers.hasMouse)) + { + return playerIds[j] == playerId; + } + } + } + return false; + } + + private void InitializeRewired() + { + if (!ReInput.isReady) + { + Debug.LogError("Rewired is not initialized! Are you missing a Rewired Input Manager in your scene?"); + return; + } + ReInput.ShutDownEvent -= OnRewiredShutDown; + ReInput.ShutDownEvent += OnRewiredShutDown; + ReInput.EditorRecompileEvent -= OnEditorRecompile; + ReInput.EditorRecompileEvent += OnEditorRecompile; + SetupRewiredVars(); + } + + private void SetupRewiredVars() + { + if (!ReInput.isReady) + { + return; + } + SetUpRewiredActions(); + if (useAllRewiredGamePlayers) + { + IList<Player> list = (useRewiredSystemPlayer ? ReInput.players.AllPlayers : ReInput.players.Players); + playerIds = new int[list.Count]; + for (int i = 0; i < list.Count; i++) + { + playerIds[i] = list[i].id; + } + } + else + { + bool flag = false; + List<int> list2 = new List<int>(rewiredPlayerIds.Length + 1); + for (int j = 0; j < rewiredPlayerIds.Length; j++) + { + Player player = ReInput.players.GetPlayer(rewiredPlayerIds[j]); + if (player != null && !list2.Contains(player.id)) + { + list2.Add(player.id); + if (player.id == 9999999) + { + flag = true; + } + } + } + if (useRewiredSystemPlayer && !flag) + { + list2.Insert(0, ReInput.players.GetSystemPlayer().id); + } + playerIds = list2.ToArray(); + } + SetUpRewiredPlayerMice(); + } + + private void SetUpRewiredPlayerMice() + { + if (!ReInput.isReady) + { + return; + } + ClearMouseInputSources(); + for (int i = 0; i < playerMice.Count; i++) + { + Rewired.Components.PlayerMouse playerMouse = playerMice[i]; + if (!UnityTools.IsNullOrDestroyed(playerMouse)) + { + AddMouseInputSource(playerMouse); + } + } + } + + private void SetUpRewiredActions() + { + if (!ReInput.isReady) + { + return; + } + if (!setActionsById) + { + horizontalActionId = ReInput.mapping.GetActionId(m_HorizontalAxis); + verticalActionId = ReInput.mapping.GetActionId(m_VerticalAxis); + submitActionId = ReInput.mapping.GetActionId(m_SubmitButton); + cancelActionId = ReInput.mapping.GetActionId(m_CancelButton); + return; + } + InputAction action = ReInput.mapping.GetAction(horizontalActionId); + m_HorizontalAxis = ((action != null) ? action.name : string.Empty); + if (action == null) + { + horizontalActionId = -1; + } + action = ReInput.mapping.GetAction(verticalActionId); + m_VerticalAxis = ((action != null) ? action.name : string.Empty); + if (action == null) + { + verticalActionId = -1; + } + action = ReInput.mapping.GetAction(submitActionId); + m_SubmitButton = ((action != null) ? action.name : string.Empty); + if (action == null) + { + submitActionId = -1; + } + action = ReInput.mapping.GetAction(cancelActionId); + m_CancelButton = ((action != null) ? action.name : string.Empty); + if (action == null) + { + cancelActionId = -1; + } + } + + private bool GetButton(Player player, int actionId) + { + if (actionId < 0) + { + return false; + } + return player.GetButton(actionId); + } + + private bool GetButtonDown(Player player, int actionId) + { + if (actionId < 0) + { + return false; + } + return player.GetButtonDown(actionId); + } + + private bool GetNegativeButton(Player player, int actionId) + { + if (actionId < 0) + { + return false; + } + return player.GetNegativeButton(actionId); + } + + private bool GetNegativeButtonDown(Player player, int actionId) + { + if (actionId < 0) + { + return false; + } + return player.GetNegativeButtonDown(actionId); + } + + private float GetAxis(Player player, int actionId) + { + if (actionId < 0) + { + return 0f; + } + return player.GetAxis(actionId); + } + + private void CheckEditorRecompile() + { + if (recompiling && ReInput.isReady) + { + recompiling = false; + InitializeRewired(); + } + } + + private void OnEditorRecompile() + { + recompiling = true; + ClearRewiredVars(); + } + + private void ClearRewiredVars() + { + Array.Clear(playerIds, 0, playerIds.Length); + ClearMouseInputSources(); + } + + private bool DidAnyMouseMove() + { + for (int i = 0; i < playerIds.Length; i++) + { + int playerId = playerIds[i]; + Player player = ReInput.players.GetPlayer(playerId); + if (player == null || (usePlayingPlayersOnly && !player.isPlaying)) + { + continue; + } + int mouseInputSourceCount = GetMouseInputSourceCount(playerId); + for (int j = 0; j < mouseInputSourceCount; j++) + { + IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, j); + if (mouseInputSource != null && mouseInputSource.screenPositionDelta.sqrMagnitude > 0f) + { + return true; + } + } + } + return false; + } + + private bool GetMouseButtonDownOnAnyMouse(int buttonIndex) + { + for (int i = 0; i < playerIds.Length; i++) + { + int playerId = playerIds[i]; + Player player = ReInput.players.GetPlayer(playerId); + if (player == null || (usePlayingPlayersOnly && !player.isPlaying)) + { + continue; + } + int mouseInputSourceCount = GetMouseInputSourceCount(playerId); + for (int j = 0; j < mouseInputSourceCount; j++) + { + IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, j); + if (mouseInputSource != null && mouseInputSource.GetButtonDown(buttonIndex)) + { + return true; + } + } + } + return false; + } + + private void OnRewiredInitialized() + { + InitializeRewired(); + } + + private void OnRewiredShutDown() + { + ClearRewiredVars(); + } +} |