🎮 Lesson 4.1: Enhanced Input in C++

The Four Pieces

Enhanced Input separates "what the player did" from "which key did it" from "your code." Four pieces cooperate:

Module Setup

Enhanced Input lives in its own module. Add it to your .Build.cs (Lesson 2.1) or you'll get unresolved-symbol errors:

// MyProject.Build.cs
PublicDependencyModuleNames.AddRange(new string[]
{
    "Core", "CoreUObject", "Engine", "InputCore",
    "EnhancedInput"    // ← required for Enhanced Input
});

The IA and IMC assets are created in the editor (right-click → Input). In C++ you reference them via UPROPERTY pointers a designer assigns:

// In your Pawn/Character header:
class UInputAction;
class UInputMappingContext;

// Assigned in the editor to IMC_Default, IA_Move, IA_Look, IA_Jump...
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
TObjectPtr<UInputMappingContext> DefaultMappingContext;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
TObjectPtr<UInputAction> MoveAction;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
TObjectPtr<UInputAction> JumpAction;

Adding a Mapping Context

A mapping context is inactive until you add it to the player's Enhanced Input subsystem. Do this in BeginPlay (or on possession — Lesson 4.3), because it needs the world and the player controller.

#include "EnhancedInputSubsystems.h"   // UEnhancedInputLocalPlayerSubsystem

void AMyCharacter::BeginPlay()
{
    Super::BeginPlay();

    // The PlayerController driving this pawn (may be null for AI-possessed pawns):
    if (APlayerController* PC = Cast<APlayerController>(GetController()))
    {
        // Get the per-player Enhanced Input subsystem and add our context.
        if (UEnhancedInputLocalPlayerSubsystem* Subsystem =
                ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(
                    PC->GetLocalPlayer()))
        {
            Subsystem->AddMappingContext(DefaultMappingContext, /*Priority=*/0);
        }
    }
}

Binding Actions in C++

Binding happens in the overridable SetupPlayerInputComponent. The incoming component is an UEnhancedInputComponent — cast it, then BindAction.

#include "EnhancedInputComponent.h"

void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    // Enhanced Input provides a richer component; cast to reach BindAction.
    if (UEnhancedInputComponent* EIC = Cast<UEnhancedInputComponent>(PlayerInputComponent))
    {
        // BindAction(Action, TriggerEvent, Object, &Function)
        EIC->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyCharacter::Move);
        EIC->BindAction(JumpAction, ETriggerEvent::Started,   this, &AMyCharacter::StartJump);
        EIC->BindAction(JumpAction, ETriggerEvent::Completed, this, &AMyCharacter::StopJump);
    }
}

Trigger events — when the function fires

Reading Input Values

Every bound function receives a const FInputActionValue& — a typed container for the input's current value. You read it according to the action's value type (set on the IA asset).

#include "InputActionValue.h"

// A 2D move action (WASD or left stick) -> a Vector2D:
void AMyCharacter::Move(const FInputActionValue& Value)
{
    const FVector2D Axis = Value.Get<FVector2D>();   // X = right/left, Y = fwd/back

    if (Controller)
    {
        AddMovementInput(GetActorForwardVector(), Axis.Y);
        AddMovementInput(GetActorRightVector(),   Axis.X);
    }
}

// A digital (button) action -> a bool:
void AMyCharacter::StartJump(const FInputActionValue& Value)
{
    const bool bPressed = Value.Get<bool>();   // usually true on Started
    Jump();   // ACharacter's built-in jump (Lesson 4.2)
}

// A 1D axis action (trigger, throttle) -> a float:
void AMyCharacter::Throttle(const FInputActionValue& Value)
{
    const float Amount = Value.Get<float>();
}

Hands-on Exercise & Quiz

void AMyCharacter::Look(const FInputActionValue& Value)
{
    const FVector2D Axis = Value.Get<FVector2D>();
    AddControllerYawInput(Axis.X);
    AddControllerPitchInput(Axis.Y);
}

Summary

📚 Additional Resources

• Enhanced Input (Epic)
• Input Overview (Epic)

🚀 What's Next?

Input is flowing into your functions. Now let's make it move a real character: Pawns, Characters, and the Character Movement Component — turning that AddMovementInput call into walking, jumping, and falling.