public void Process(ref InputInteractionContext context) { if (context.timerHasExpired) { if (context.continuous) { context.PerformedAndStayPerformed(); } else { context.PerformedAndGoBackToWaiting(); } return; } switch (context.phase) { case InputActionPhase.Waiting: if (context.ControlIsActuated(pressPointOrDefault)) { m_TimePressed = context.time; context.Started(); context.SetTimeout(durationOrDefault); } break; case InputActionPhase.Started: // If we've reached our hold time threshold, perform the hold. // We do this regardless of what state the control changed to. if (context.time - m_TimePressed >= durationOrDefault) { context.PerformedAndStayPerformed(); } else if (!context.ControlIsActuated()) { // Control is no longer actuated and we haven't performed a hold yet, // so cancel. context.Canceled(); } break; case InputActionPhase.Performed: if (context.ControlIsActuated(pressPointOrDefault)) { if (context.continuous) { context.PerformedAndStayPerformed(); } } else { context.Canceled(); } break; } }
public void Process(ref InputInteractionContext context) { if (context.timerHasExpired) { context.Performed(); return; } var phase = context.phase; switch (phase) { case InputActionPhase.Disabled: break; case InputActionPhase.Waiting: if (context.ControlIsActuated()) { context.Started(); context.SetTimeout(float.PositiveInfinity); } break; case InputActionPhase.Started: context.PerformedAndStayPerformed(); break; case InputActionPhase.Performed: if (context.ControlIsActuated()) { context.PerformedAndStayPerformed(); } else { ButtonControl buttonControl = context.action.controls[0] as ButtonControl; Pointer pointer = context.action.controls[0] as Pointer; if (buttonControl != null && !buttonControl.isPressed) { context.Canceled(); } if (pointer != null && !pointer.IsPressed()) { context.Canceled(); } } break; case InputActionPhase.Canceled: break; default: throw new ArgumentOutOfRangeException(nameof(phase), phase, null); } }
public void Process(ref InputInteractionContext context) { var isActuated = context.ControlIsActuated(pressPointOrDefault); switch (behavior) { case PressBehavior.PressOnly: if (m_WaitingForRelease) { if (!isActuated) { m_WaitingForRelease = false; context.Canceled(); } } else if (isActuated) { context.PerformedAndStayPerformed(); m_WaitingForRelease = true; } break; case PressBehavior.ReleaseOnly: if (m_WaitingForRelease && !isActuated) { m_WaitingForRelease = false; context.Performed(); context.Canceled(); } else if (isActuated) { context.Started(); m_WaitingForRelease = true; } break; case PressBehavior.PressAndRelease: if (m_WaitingForRelease) { if (!isActuated) { context.Performed(); context.Canceled(); } m_WaitingForRelease = isActuated; } else if (isActuated) { context.PerformedAndStayPerformed(); m_WaitingForRelease = true; } break; } }
public void Process(ref InputInteractionContext context) { var isActuated = context.ControlIsActuated(pressPointOrDefault); switch (context.phase) { case InputActionPhase.Waiting: if (isActuated) { context.Started(); context.PerformedAndStayPerformed(); m_lastPerformTime = context.time; context.SetTimeout(delay); } break; case InputActionPhase.Performed: if (!isActuated) { context.Canceled(); } else { var trigger = false; if (!m_delayPassed) { trigger = context.time - m_lastPerformTime >= delay; if (trigger) { m_delayPassed = true; } } else { trigger = context.time - m_lastPerformTime >= rate; } if (trigger) { context.PerformedAndStayPerformed(); m_lastPerformTime = context.time; context.SetTimeout(rate); } } break; } }
#pragma warning restore CS0649 public void Process(ref InputInteractionContext context) { if (context.ControlIsActuated()) { if (stayPerformed) { context.PerformedAndStayPerformed(); } else { context.Performed(); } } }
/// <inheritdoc /> public void Process(ref InputInteractionContext context) { var isActuated = context.ControlIsActuated(pressPointOrDefault); if (!isActuated) { switch (m_State) { case State.Centered: return; case State.StartedInvalidDirection: case State.StartedValidDirection: m_State = State.Centered; context.Canceled(); return; default: Assert.IsTrue(false, $"Unhandled {nameof(State)}={m_State}"); return; } } var isValidDirection = IsValidDirection(ref context); if (m_State == State.Centered) { m_State = isValidDirection ? State.StartedValidDirection : State.StartedInvalidDirection; if (isValidDirection) { context.PerformedAndStayPerformed(); } m_WasValidDirection = isValidDirection; return; } switch (sweepBehavior) { case SweepBehavior.Locked: break; case SweepBehavior.AllowReentry: if (m_WasValidDirection && !isValidDirection && m_State == State.StartedValidDirection) { context.Canceled(); } else if (!m_WasValidDirection && isValidDirection && m_State == State.StartedValidDirection) { context.PerformedAndStayPerformed(); } break; case SweepBehavior.DisallowReentry: if (m_WasValidDirection && !isValidDirection && m_State == State.StartedValidDirection) { context.Canceled(); } break; case SweepBehavior.HistoryIndependent: if (m_WasValidDirection && !isValidDirection) { context.Canceled(); } else if (!m_WasValidDirection && isValidDirection) { context.PerformedAndStayPerformed(); } break; default: Assert.IsTrue(false, $"Unhandled {nameof(SweepBehavior)}={sweepBehavior}"); break; } m_WasValidDirection = isValidDirection; }
public void Process(ref InputInteractionContext context) { var actuation = context.ComputeMagnitude(); switch (behavior) { case PressBehavior.PressOnly: if (m_WaitingForRelease) { if (actuation <= releasePointOrDefault) { m_WaitingForRelease = false; context.Canceled(); } } else if (actuation >= pressPointOrDefault) { m_WaitingForRelease = true; // Stay performed until release. context.PerformedAndStayPerformed(); } else if (actuation > 0 && !context.isStarted) { context.Started(); } break; case PressBehavior.ReleaseOnly: if (m_WaitingForRelease) { if (actuation <= releasePointOrDefault) { m_WaitingForRelease = false; context.Performed(); context.Canceled(); } } else if (actuation >= pressPointOrDefault) { m_WaitingForRelease = true; if (!context.isStarted) { context.Started(); } } else { var started = context.isStarted; if (actuation > 0 && !started) { context.Started(); } else if (Mathf.Approximately(0, actuation) && started) { context.Canceled(); } } break; case PressBehavior.PressAndRelease: if (m_WaitingForRelease) { if (actuation <= releasePointOrDefault) { m_WaitingForRelease = false; context.Performed(); if (Mathf.Approximately(0, actuation)) { context.Canceled(); } } } else if (actuation >= pressPointOrDefault) { m_WaitingForRelease = true; context.PerformedAndStayPerformed(); } else { var started = context.isStarted; if (actuation > 0 && !started) { context.Started(); } else if (Mathf.Approximately(0, actuation) && started) { context.Canceled(); } } break; } }
public void Process(ref InputInteractionContext context) { var isActuated = context.ControlIsActuated(pressPointOrDefault); switch (behavior) { case PressBehavior.PressOnly: if (m_WaitingForRelease) { if (isActuated) { if (context.continuous) { context.PerformedAndStayPerformed(); } } else { m_WaitingForRelease = false; // We need to reset the action to waiting state in order to stop it from triggering // continuously. However, we do not want to cancel here as that will trigger the action. // So go back directly to waiting here. context.Waiting(); } } else if (isActuated) { if (context.continuous) { context.PerformedAndStayPerformed(); } else { context.PerformedAndGoBackToWaiting(); } m_WaitingForRelease = true; } break; case PressBehavior.ReleaseOnly: if (m_WaitingForRelease && !isActuated) { m_WaitingForRelease = false; context.PerformedAndGoBackToWaiting(); // No support for continuous mode. } else if (isActuated) { context.Started(); m_WaitingForRelease = true; } break; case PressBehavior.PressAndRelease: if (m_WaitingForRelease) { if (!isActuated) { context.PerformedAndGoBackToWaiting(); } // No support for continuous mode. m_WaitingForRelease = isActuated; } else if (isActuated) { context.PerformedAndGoBackToWaiting(); // No support for continuous mode. m_WaitingForRelease = true; } break; } }