InputActionMapBinding

Abstract base class for declaring input action handlers using the [InputActionCallback] attribute. Subclass this to create a binding for one action map — mark methods with the attribute, and the system auto-discovers and wires them to Unity input actions via reflection.

Definition

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

[Serializable]
public abstract class InputActionMapBinding

Remarks

InputActionMapBinding is the core class that makes the attribute-driven input system work. Each subclass represents the handler set for one InputActionMap. When Bind() is called:

1. The target InputActionMap is resolved from the InputActionScheme

2. Reflection scans the subclass for methods marked with [InputActionCallback]

3. Each method is wrapped in an InputActionCallback (with automatic type conversion)

4. Wrapped callbacks are subscribed to the appropriate InputAction phase event (started, performed, or canceled)

When Unbind() is called, all subscriptions are reversed and the callback dictionary is cleared.

Quick Lookup

Goal	How
Create a binding	Subclass InputActionMapBinding, add [InputActionCallback] methods
Bind callbacks	binding.Bind(autoEnable: true)
Unbind callbacks	binding.Unbind(autoDisable: true)
Enable the action map	binding.Enable()
Disable the action map	binding.Disable()
Check if enabled	binding.IsEnabled
Custom bind logic	Override OnBind()
Custom unbind logic	Override OnUnbind()

Properties

Name

The name of the action map this binding is associated with.

public string Name { get; }

ActionMap

The resolved InputActionMap instance. Only available after Bind() has been called.

public InputActionMap ActionMap { get; }

IsEnabled

Whether the underlying action map is currently enabled.

public bool IsEnabled { get; }

Methods

Initialize

Configures the binding with its parent scheme and action map name. Called by the bindings container during setup.

public void Initialize(InputActionScheme inputScheme, string actionMapName)

Parameter	Type	Description
inputScheme	InputActionScheme	The parent scheme component
actionMapName	string	Name of the action map in the InputActionAsset

Bind

Resolves the action map, discovers callback methods, wraps them, and subscribes to input action events.

public void Bind(bool autoEnable = false)

Parameter	Type	Description
autoEnable	bool	If true, calls Enable() on the action map after binding. Defaults to false.

Binding process:

1. Resolves InputActionMap from inputScheme.GetActionMap(actionMapName)

2. Optionally enables the action map

3. Scans for [InputActionCallback] methods via reflection

4. Wraps each method in an InputActionCallback with type conversion

5. Subscribes each callback to the matching InputAction's phase event

6. Calls OnBind() for custom post-bind logic

Unbind

Unsubscribes all callbacks and clears the binding dictionary.

public void Unbind(bool autoDisable = true)

Parameter	Type	Description
autoDisable	bool	If true, calls Disable() on the action map after unbinding. Defaults to true.

Unbinding process:

1. Calls OnUnbind() for custom pre-unbind logic

2. Unsubscribes all callbacks from their InputAction phase events

3. Clears the callback dictionary

4. Optionally disables the action map

5. Sets actionMap to null

Enable

Enables the underlying action map.

public void Enable()

Disable

Disables the underlying action map.

public void Disable()

GetCallbackMethods (static)

Returns all methods on a given type that have the [InputActionCallback] attribute.

public static IEnumerable<MethodInfo> GetCallbackMethods(Type bindingType)

Parameter	Type	Description
bindingType	Type	The binding subclass type to scan

Searches public and non-public instance methods.

Extension Points

Optional Overrides

Method	Purpose
OnBind()	Called after all callbacks are subscribed. Use for additional setup.
OnUnbind()	Called before callbacks are unsubscribed. Use for cleanup.

Implementation Requirements

When subclassing InputActionMapBinding, you MUST:

1. Mark handler methods with [InputActionCallback("ActionName")]

2. Ensure ActionName matches an action in the target InputActionMap

3. Mark the class with [Serializable] for Inspector serialization

You SHOULD:

• Use typed parameters (Vector2, float, etc.) for automatic value extraction

• Specify InputActionPhase when you need non-default phases (default is PERFORMED)

• Override OnBind() / OnUnbind() for custom setup and teardown

You SHOULD NOT:

• Manually subscribe to InputAction events — the system handles this

• Have two methods with the same (ActionName, Phase) pair — the dictionary key will conflict

• Call Bind() without first calling Initialize() — the action map name will be null

Common Pitfalls

Action name must match exactly The ActionName in [InputActionCallback("ActionName")] must match the name of an action in the bound InputActionMap. A mismatch will cause FindAction() to return null, resulting in a NullReferenceException.

Duplicate (ActionName, Phase) keys Each (ActionName, InputActionPhase) pair must be unique within a binding class. Having two methods with the same action name and phase will throw a duplicate key exception during Bind().

Bind/Unbind symmetry Always pair Bind() with Unbind(). Forgetting to unbind leaves dangling event subscriptions. The InputActionScheme.Disable() method handles this automatically.

Examples

Basic movement binding

using System;
using UnityEngine;
using Paragon.Core.InputSystem;

[Serializable]
public class PlayerMovementBinding : InputActionMapBinding
{
    private Vector2 moveInput;

    [InputActionCallback("Move")]
    private void OnMove(Vector2 input)
    {
        moveInput = input;
    }

    [InputActionCallback("Move", InputActionPhase.CANCELLED)]
    private void OnMoveStop()
    {
        moveInput = Vector2.zero;
    }

    [InputActionCallback("Jump", InputActionPhase.STARTED)]
    private void OnJump()
    {
        Debug.Log("Jump!");
    }
}

Binding with custom setup

using System;
using UnityEngine;
using UnityEngine.InputSystem;
using Paragon.Core.InputSystem;

[Serializable]
public class CameraBinding : InputActionMapBinding
{
    private Camera targetCamera;

    protected override void OnBind()
    {
        targetCamera = Camera.main;
    }

    protected override void OnUnbind()
    {
        targetCamera = null;
    }

    [InputActionCallback("Look")]
    private void OnLook(Vector2 delta)
    {
        // Use targetCamera with delta input
    }

    [InputActionCallback("Zoom")]
    private void OnZoom(float scrollValue)
    {
        // Use targetCamera for zoom
    }
}

See Also

• InputActionCallbackAttribute — attribute for declaring handlers

• InputActionCallback — delegate wrapper with type conversion

• InputActionPhase — phase enum

• InputActionScheme — root component that manages bindings