ContinuousInteraction

Custom Unity Input System interaction that fires Performed every frame while the control is actuated. Unlike the default interaction which performs once per press, this enables per-frame input reading — ideal for continuous actions like camera movement, aiming, or analog stick input.

Definition

Namespace: Paragon.Core.InputSystem Assembly: Paragon.dll

[InitializeOnLoad]
[RuntimeInitializeOnLoad]
public class ContinuousInteraction : IInputInteraction

Implements: IInputInteraction (UnityEngine.InputSystem)

Remarks

ContinuousInteraction solves a common problem with Unity's Input System: by default, input actions only fire Performed once when the interaction completes (e.g., button press). For continuous input (mouse movement, joystick axes, held buttons), game code needs to read values every frame.

How It Works

1. Process() is called by the Input System when the action's control changes. If the control is actuated and not yet in Performed/Started phase, it calls OnPerformBegin() to start the continuous loop.

2. OnPerformBegin() subscribes to InputSystem.onAfterUpdate, which fires every frame after input processing. This is the key mechanism — the Update() method runs each frame.

3. Update() calls context.PerformedAndStayPerformed() every frame, which keeps the action in Performed phase and fires the performed callback to subscribers. This continues until the control is released.

4. When the control is released, Cancel() calls context.Performed() (final perform) then context.Canceled(), and OnPerformEnd() unsubscribes from all events.

Safety Subscriptions

The interaction also subscribes to device/layout change events and (in the Editor) play mode state changes. These all trigger Reset(), which ensures the interaction cleans up if the input system state changes unexpectedly — for example, when a device is disconnected or the user exits play mode.

Quick Lookup

Goal	How
Apply to an action	Set the interaction to ContinuousInteraction in the Input Action Asset
Read value every frame	Subscribe to action.performed — it fires every frame while held
Registration	Automatic via [InitializeOnLoad] and [RuntimeInitializeOnLoad]

Methods

Process

Called by the Input System when the bound control changes state. Routes to either Cancel() (control released) or OnPerformBegin() (control actuated).

public void Process(ref InputInteractionContext context)

Parameter	Type	Description
context	ref InputInteractionContext	The interaction context from the Input System

Behavior:

• If control is not actuated: calls Cancel() to end the interaction

• If control is actuated and phase is not Performed/Started: calls OnPerformBegin() to start the per-frame loop

Reset

Called by the Input System when the interaction needs to be reset. Unsubscribes from all frame events via OnPerformEnd().

public void Reset()

Update (private)

Called every frame via InputSystem.onAfterUpdate. Checks if the interaction should continue and calls PerformedAndStayPerformed() to fire the performed callback.

private void Update()

Behavior:

• If phase is Canceled, Disabled, action map is disabled, or control is not actuated: calls Cancel()

• If phase is Performed, Started, or Waiting: calls context.PerformedAndStayPerformed()

Cancel (private)

Ends the continuous interaction. Calls OnPerformEnd(), then fires a final Performed() followed by Canceled() if the phase was active.

private void Cancel()

OnPerformBegin (private)

Subscribes to per-frame and safety events to start the continuous loop.

private void OnPerformBegin()

Subscribes to:

• InputSystem.onAfterUpdate — per-frame Update() calls

• InputSystem.onLayoutChange — layout change safety reset

• InputSystem.onDeviceChange — device change safety reset

• EditorApplication.playModeStateChanged — editor play mode safety reset (editor only)

OnPerformEnd (private)

Unsubscribes from all events registered by OnPerformBegin().

private void OnPerformEnd()

Common Pitfalls

Performed fires every frame Unlike default interactions, performed fires continuously — not just once. Subscribers that expect a single trigger per press (e.g., toggling a boolean) will fire repeatedly. Use started for one-shot press detection instead.

Must be registered before use The interaction registers itself via a static constructor with InputSystem.RegisterInteraction<ContinuousInteraction>(). If accessed before the static constructor runs (unlikely due to [InitializeOnLoad]), the interaction will not appear in the Input Action Asset editor.

Device disconnection resets the interaction If a device is disconnected or the input layout changes, Reset() is called via the safety subscriptions. This may cause unexpected cancellation of ongoing continuous actions.

Examples

Using in an Input Action Asset

In the Unity Input Action Asset editor:

1. Select an action (e.g., "Look", "Move")

2. Add an interaction → select ContinuousInteraction

3. The performed callback will now fire every frame while the control is actuated

Reading Continuous Input

// In a MonoBehaviour
private void OnEnable()
{
    lookAction.performed += OnLook;
}

private void OnLook(InputAction.CallbackContext context)
{
    // Fires every frame while mouse/stick is active
    Vector2 delta = context.ReadValue<Vector2>();
    // Apply to camera rotation
}

See Also

• Interactions Overview — subfolder overview

• InputSystem Overview — parent system