Skip to content

Enable Input / Disable Input / Set Ignore Move and Look Input

At a glance

Lives in: Blueprint API / Input - Targets: Enable Input and Disable Input target an Actor; ignore move/look targets a Controller - Returns: no value - Fails by: the actor not receiving input, input still being ignored, or the wrong local controller owning the input path - Official docs: Enable Input, Disable Input, Set Ignore Move Input, and Set Ignore Look Input

The one-minute version

  • Enable Input pushes a specific actor onto a PlayerController's input stack. It is for actors that need to listen to player input directly.
  • Disable Input removes that actor from the stack. If the PlayerController pin is None, it stops input from all controllers for that actor.
  • Set Ignore Move Input and Set Ignore Look Input tell a controller to ignore movement or look input requests.
  • Ignore move/look calls stack. If you call ignore true twice, you need two matching false calls or a reset to fully unlock it.
  • These nodes are local-player/input-routing tools. They do not replicate input, remove Enhanced Input mapping contexts, pause the game, or disable collision/movement components.
  • Most player input still belongs on the PlayerController or possessed pawn, not on every door, pickup, or widget in the level.

What they actually do

There are two different mechanisms here:

flowchart LR
    PC[PlayerController] --> Stack[Input stack]
    Stack --> Actor[Enabled Actor input events]
    PC --> MoveGate[Ignore move/look counters]
    MoveGate --> Pawn[Possessed pawn receives usable movement/look]

Enable Input gives an actor an input component and registers it with the PlayerController so the actor can receive input events. Disable Input undoes that registration for the actor/controller pair.

The ignore nodes are controller gates:

pseudocode of the engine behavior - not engine source

function EnableInput(Actor, PlayerController):
    if PlayerController is None:
        return
    Actor creates/uses an InputComponent
    PlayerController pushes Actor.InputComponent onto its input stack

function DisableInput(Actor, PlayerController):
    if PlayerController is None:
        remove Actor.InputComponent from all PlayerControllers
    else:
        remove Actor.InputComponent from that PlayerController

function SetIgnoreMoveInput(true):
    MoveIgnoreCounter += 1

function SetIgnoreMoveInput(false):
    MoveIgnoreCounter = max(0, MoveIgnoreCounter - 1)

function IsMoveInputIgnored():
    return MoveIgnoreCounter > 0

Look input follows the same counter shape.

When they fail (and what failure does)

Common causes:

  1. The PlayerController pin is wrong or None. An actor cannot listen to input from a controller it was not registered with.
  2. You enabled input on a remote machine. Player input is local. Server and remote-client copies of an actor do not all own the same keyboard/gamepad.
  3. Another input component consumes the action first. Input stack order and consume settings matter.
  4. Enhanced Input mappings are not active. Enable Input does not add an Input Mapping Context to the local player.
  5. Move/look ignore was stacked. One unlock call may not undo several lock calls.
  6. You disabled the actor input but the possessed pawn still handles input. Actor input and pawn/controller input are different paths.
  7. Movement is blocked elsewhere. Ignoring move input is not the same as disabling collision, Character Movement, AI movement, or physics.

Failure is usually quiet. The node does not return a success Boolean or explain which input component consumed the action. Print the controller name, local control state, active mapping contexts, and ignore state when debugging.

The pattern everyone actually uses

For a one-off interactable actor, prefer an interface call from the player's input path:

PlayerController / pawn Interact input
-> line trace
-> Interface Message: Interact on hit actor

Use Enable Input only when the actor itself truly owns a temporary direct input mode, such as a possessed turret, inspection object, or local puzzle actor:

Player enters turret
-> Enable Input(Target = Turret, Player Controller = local PC)
-> add turret mapping context if using Enhanced Input
-> Set Ignore Move Input(true) on player controller

Player exits turret
-> Set Ignore Move Input(false)
-> remove turret mapping context
-> Disable Input(Target = Turret, Player Controller = local PC)

For death or stun, gate input from the controller and movement owner:

Character dies
-> Controller Set Ignore Move Input(true)
-> Controller Set Ignore Look Input(true) if camera should lock
-> CharacterMovement Disable Movement if the body must stop
-> remove or change mapping contexts if the mode changed

The C++ twin, for the curious (our own example code):

void AInspectObject::BeginInspect(APlayerController* Controller)
{
    EnableInput(Controller);

    if (IsValid(Controller))
    {
        Controller->SetIgnoreMoveInput(true);
    }
}

void AInspectObject::EndInspect(APlayerController* Controller)
{
    DisableInput(Controller);

    if (IsValid(Controller))
    {
        Controller->SetIgnoreMoveInput(false);
    }
}

Enhanced Input is a separate layer

With Enhanced Input, the input stack and mapping contexts both matter:

  • Mapping contexts decide which physical buttons/axes produce Input Actions.
  • Input bindings decide which object receives those action events.
  • Enable Input can let an actor bind/receive events, but it does not add the mapping context that makes the action exist.
  • Removing a mapping context can stop actions without disabling the actor.

For most first projects, keep gameplay actions on the possessed pawn or PlayerController, and add/remove mapping contexts at mode changes.

Lookalikes - which one do I want?

Node / setting Changes Use when
Enable Input Registers actor input with a PlayerController A specific actor should listen directly to local input temporarily.
Disable Input Removes actor input registration That actor should stop listening directly.
Set Ignore Move Input Controller ignores movement input; stacked Death, stun, menus, or modes should block movement requests.
Set Ignore Look Input Controller ignores look input; stacked Camera aim should lock or UI/mode owns the pointer.
Reset Ignore Move/Look Input Clears the stacked ignore counter Cleanup must guarantee the controller is unlocked.
Set Input Mode Game/UI Routes focus between gameplay and UI Menus need cursor/focus behavior.
Add/Remove Mapping Context Changes Enhanced Input action mappings A gameplay mode needs a different action map.
Disable Movement Stops Character Movement modes The character body should not move even if input arrives.

Rule of thumb: Enable Input gives an actor a chance to hear local input; ignore move/look tells the controller to discard a category of input; mapping contexts decide which actions exist.

Going deeper