🎮 Lesson 3.4: Gamepad, Keyboard & Rebinding (Mini-Project)

Multiple Bindings per Action

Back in the Input Actions editor, an action can hold as many bindings as you like. To make Jump work on a controller too, select Jump, click + ▸ Add Binding, and set the new binding's Path to the gamepad's south button (buttonSouth [Gamepad] — the A/Cross button). Now Jump has two bindings:

• Space [Keyboard]
• Button South [Gamepad]

You wrote zero code for this. Whichever device the player uses, the same Jump action fires and your existing OnJump handler runs. Do the same for Move by adding a Left Stick [Gamepad] binding alongside the WASD composite (if you didn't in Lesson 3.2).

Control Schemes

A Control Scheme is a named set of device requirements — for example "Keyboard&Mouse" or "Gamepad". Schemes let the system decide which bindings belong to which device group, which matters for device switching and for local multiplayer (so Player 1's keyboard and Player 2's gamepad don't collide).

You manage schemes from the dropdown in the top-left of the Input Actions editor (it reads "All Control Schemes" by default). Choose Add Control Scheme…, name it, and add device requirements. Here's the editor showing two schemes and Jump's binding path being set to the gamepad button:

Showing the Current Binding

A remap menu needs to show the player what a control is currently bound to — "Jump: Space". The Input System turns a binding into a friendly label for you with GetBindingDisplayString():

// jumpAction is an InputAction (e.g. from PlayerInput or a reference)
string label = jumpAction.GetBindingDisplayString();   // "Space" or "A" on a pad

If an action has several bindings, pass the binding index to target a specific one, e.g. GetBindingDisplayString(0) for the keyboard binding. The string is human-readable and localises device names (the gamepad south button reads "A" on Xbox layouts, "Cross" on PlayStation).

The Rebinding Flow

Interactive rebinding means: pause the action, wait for the player to press something, capture that control, and write it into the binding. The Input System hands you an operation object that runs this whole dance. Here's the shape of it:

Figure 2: The interactive rebinding lifecycle — disable, listen, capture, clean up, refresh the label.

Interactive Rebinding in Code

Here is a focused, reusable rebinder. Give it the action and a UI label; call StartRebind() from a button:

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;                 // or TMPro for TextMeshPro
using TMPro;

public class JumpRebinder : MonoBehaviour
{
    [SerializeField] InputActionReference jumpAction;  // drag the Jump action
    [SerializeField] TMP_Text bindingLabel;            // "Jump: Space"
    [SerializeField] TMP_Text promptLabel;             // "Press any key…"

    InputActionRebindingExtensions.RebindingOperation rebindOp;

    void Start() => RefreshLabel();

    // Wire this to your Rebind button's OnClick
    public void StartRebind()
    {
        InputAction action = jumpAction.action;
        action.Disable();                              // required before rebinding

        promptLabel.gameObject.SetActive(true);
        promptLabel.text = "Press any key…";

        rebindOp = action.PerformInteractiveRebinding()
            .WithControlsExcluding("<Mouse>/position") // ignore mouse move noise
            .OnMatchWaitForAnother(0.1f)               // debounce
            .OnComplete(op => RebindComplete())
            .OnCancel(op => RebindComplete())
            .Start();
    }

    void RebindComplete()
    {
        rebindOp.Dispose();                            // free the operation
        rebindOp = null;
        jumpAction.action.Enable();                    // re-enable gameplay input
        promptLabel.gameObject.SetActive(false);
        RefreshLabel();
    }

    void RefreshLabel()
    {
        bindingLabel.text = "Jump: " +
            jumpAction.action.GetBindingDisplayString();
    }
}

Read it against Figure 2: Disable(), then PerformInteractiveRebinding() starts listening, OnComplete fires when the player presses a control, and RebindComplete disposes, re-enables, and refreshes the label. The .WithControlsExcluding and .OnMatchWaitForAnother calls are small quality-of-life touches so a stray mouse wiggle doesn't get captured.

Mini-Project: A Remap Menu

Let's assemble the deliverable: a tiny settings panel with a live label and a Rebind button that remaps Jump to whatever the player presses next.

Extend It

Summary

🚀 What's Next?

Module 3 is complete: you retired the legacy Input class, defined actions and maps, read them in code, and gave players full control over their bindings. Next we shift to what wraps around all of it — the interface. In Lesson 4.1: Canvas Render Modes & Scaling we start Module 4 by making UI that looks right on every screen size.