/// <inheritdoc />
public void Process(ref InputInteractionContext context)
{
switch (context.phase)
{
case InputActionPhase.Waiting:
case InputActionPhase.Canceled:
if (context.ControlIsActuated(PressPointOrDefault) &&
Time.time >= ignoreInputUntilTime - 0.1f)
{
context.Started();
if (fireImmediately)
{
context.PerformedAndStayStarted();
}
ignoreInputUntilTime = Time.time + InitialPauseOrDefault;
// Check input again when the time elapsed or input changed.
context.SetTimeout(InitialPauseOrDefault);
}
break;
case InputActionPhase.Started:
if (!context.ControlIsActuated())
{
Cancel(ref context);
}
else if (Time.time >= ignoreInputUntilTime - 0.1f)
{
// Perform action but stay in the started phase, because we want to fire again after durationOrDefault
context.PerformedAndStayStarted();
ignoreInputUntilTime = Time.time + RepeatedPauseOrDefault;
// Check input again when the time elapsed or input changed.
context.SetTimeout(RepeatedPauseOrDefault);
}
break;
case InputActionPhase.Performed:
if (!context.ControlIsActuated(PressPointOrDefault))
{
Cancel(ref context);
}
break;
default:
if (!context.ControlIsActuated(PressPointOrDefault))
{
Cancel(ref context);
}
break;
}
}
////TODO: make sure 2d doesn't move too far
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
context.Canceled();
return;
}
if (context.isWaiting && context.ControlIsActuated(pressPointOrDefault))
{
m_TapStartTime = context.time;
// Set timeout slightly after duration so that if tap comes in exactly at the expiration
// time, it still counts as a valid tap.
context.Started();
context.SetTimeout(durationOrDefault + 0.00001f);
return;
}
if (context.isStarted && !context.ControlIsActuated(releasePointOrDefault))
{
if (context.time - m_TapStartTime <= durationOrDefault)
{
context.Performed();
}
else
{
////REVIEW: does it matter to cancel right after expiration of 'duration' or is it enough to cancel on button up like here?
context.Canceled();
}
}
}
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
context.Performed();
return;
}
if (context.isWaiting && !context.controlHasDefaultValue)
{
m_TimePressed = context.time;
context.Started();
context.SetTimeout(durationOrDefault);
return;
}
////TODO: need to ignore releases on controls that aren't m_PressedControl
if (context.isStarted && context.controlHasDefaultValue)
{
if (context.time - m_TimePressed >= durationOrDefault)
{
context.Performed();
}
else
{
context.Cancelled();
}
}
}
////TODO: make sure 2d doesn't move too far
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
context.Cancelled();
return;
}
if (context.isWaiting && !context.controlHasDefaultValue)
{
m_TapStartTime = context.time;
context.SetTimeout(durationOrDefault);
context.Started();
return;
}
if (context.isStarted && context.controlHasDefaultValue)
{
if (context.time - m_TapStartTime <= durationOrDefault)
{
context.Performed();
}
else
{
////REVIEW: does it matter to cancel right after expiration of 'duration' or is it enough to cancel on button up like here?
context.Cancelled();
}
}
}
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;
}
}
/// <inheritdoc />
public void Process(ref InputInteractionContext context)
{
switch (context.phase)
{
case InputActionPhase.Waiting:
case InputActionPhase.Canceled:
if (context.ControlIsActuated(PressPointOrDefault))
{
context.Started();
if (fireImmediately)
{
context.PerformedAndStayStarted();
}
context.SetTimeout(InitialPauseOrDefault);
}
break;
case InputActionPhase.Started:
if (!context.ControlIsActuated())
{
context.Canceled();
}
else
{
// Perform action but stay in the started phase, because we want to fire again after durationOrDefault
context.PerformedAndStayStarted();
// Fire again after durationOrDefault
context.SetTimeout(RepeatedPauseOrDefault);
}
break;
case InputActionPhase.Performed:
if (!context.ControlIsActuated(PressPointOrDefault))
{
context.Canceled();
}
break;
default:
if (!context.ControlIsActuated(PressPointOrDefault))
{
context.Canceled();
}
break;
}
}
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)
{
Vector2 stickPos = context.ReadValue <Vector2>();
if (context.timerHasExpired)
{
context.Canceled();
}
if (stickPos.magnitude < deadZone)
{
hasStarted = false;
context.Canceled();
}
switch (context.phase)
{
case InputActionPhase.Waiting:
if (stickPos.magnitude > deadZone && !hasStarted)
{
context.Started();
timeStartedMoving = context.time;
hasStarted = true;
}
break;
case InputActionPhase.Started:
if ((context.time - timeStartedMoving) > duration || stickPos.magnitude <= deadZone)
{
context.Canceled();
}
if (stickPos.magnitude >= smashZone)
{
context.Performed();
context.SetTimeout(0.1f);
}
break;
}
}
public void Process(ref InputInteractionContext context)
{
switch (context.phase)
{
case InputActionPhase.Waiting:
if (context.ControlIsActuated(pressPointOrDefault))
{
if (m_TimePressed <= 0)
{
m_TimePressed = context.time;
context.SetTimeout(durationOrDefault);
}
else if (context.time - m_TimePressed >= durationOrDefault)
{
context.Started();
}
}
else
{
Reset();
}
break;
case InputActionPhase.Started:
if (!context.ControlIsActuated())
{
context.Performed();
Reset();
}
break;
case InputActionPhase.Performed:
context.Canceled();
break;
}
}
/// <inheritdoc />
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
// We use timers multiple times but no matter what, if they expire it means
// that we didn't get input in time.
context.Canceled();
return;
}
switch (m_CurrentTapPhase)
{
case TapPhase.None:
if (context.ControlIsActuated(pressPointOrDefault))
{
m_CurrentTapPhase = TapPhase.WaitingForNextRelease;
m_CurrentTapStartTime = context.time;
context.Started();
context.SetTimeout(tapTimeOrDefault);
}
break;
case TapPhase.WaitingForNextRelease:
if (!context.ControlIsActuated(pressPointOrDefault))
{
if (context.time - m_CurrentTapStartTime <= tapTimeOrDefault)
{
++m_CurrentTapCount;
if (m_CurrentTapCount >= tapCount)
{
context.Performed();
}
else
{
m_CurrentTapPhase = TapPhase.WaitingForNextPress;
m_LastTapReleaseTime = context.time;
context.SetTimeout(tapDelayOrDefault);
}
}
else
{
context.Canceled();
}
}
break;
case TapPhase.WaitingForNextPress:
if (context.ControlIsActuated(pressPointOrDefault))
{
if (context.time - m_LastTapReleaseTime <= tapDelayOrDefault)
{
m_CurrentTapPhase = TapPhase.WaitingForNextRelease;
m_CurrentTapStartTime = context.time;
context.SetTimeout(tapTimeOrDefault);
}
else
{
context.Canceled();
}
}
break;
}
}
/// <inheritdoc />
public void Process(ref InputInteractionContext context)
{
if (context.timerHasExpired)
{
// We use timers multiple times but no matter what, if they expire it means
// that we didn't get input in time.
context.Canceled();
return;
}
switch (m_CurrentTapPhase)
{
case TapPhase.None:
if (context.ControlIsActuated(pressPointOrDefault))
{
m_CurrentTapPhase = TapPhase.WaitingForNextRelease;
m_CurrentTapStartTime = context.time;
context.Started();
var maxTapTime = tapTimeOrDefault;
var maxDelayInBetween = tapDelayOrDefault;
context.SetTimeout(maxTapTime);
// We'll be using multiple timeouts so set a total completion time that
// effects the result of InputAction.GetTimeoutCompletionPercentage()
// such that it accounts for the total time we allocate for the interaction
// rather than only the time of one single timeout.
context.SetTotalTimeoutCompletionTime(maxTapTime * tapCount + (tapCount - 1) * maxDelayInBetween);
}
break;
case TapPhase.WaitingForNextRelease:
if (!context.ControlIsActuated(releasePointOrDefault))
{
if (context.time - m_CurrentTapStartTime <= tapTimeOrDefault)
{
++m_CurrentTapCount;
if (m_CurrentTapCount >= tapCount)
{
context.Performed();
}
else
{
m_CurrentTapPhase = TapPhase.WaitingForNextPress;
m_LastTapReleaseTime = context.time;
context.SetTimeout(tapDelayOrDefault);
}
}
else
{
context.Canceled();
}
}
break;
case TapPhase.WaitingForNextPress:
if (context.ControlIsActuated(pressPointOrDefault))
{
if (context.time - m_LastTapReleaseTime <= tapDelayOrDefault)
{
m_CurrentTapPhase = TapPhase.WaitingForNextRelease;
m_CurrentTapStartTime = context.time;
context.SetTimeout(tapTimeOrDefault);
}
else
{
context.Canceled();
}
}
break;
}
}