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;
}
}
