🎮 Enhanced Input System

Why Enhanced Input?

Before UE5, Unreal used a simpler input system where you defined "Action Mappings" and "Axis Mappings" directly in Project Settings. While functional, this approach had limitations. The Enhanced Input System addresses these issues with a more powerful, flexible architecture.

Problems with the Legacy System

The old input system had several pain points:

Hardcoded Bindings: Key bindings were defined in project settings, making it difficult to change them at runtime or let players customize controls.

Limited Input Types: Actions were either digital (pressed/released) or axis (continuous values), with limited flexibility for complex input patterns.

Device Agnostic Challenges: Supporting multiple input devices (keyboard + gamepad + touch) required manual work and often duplicated logic.

No Input Processing: You couldn't easily modify input values (like dead zones, sensitivity curves) without custom code.

Enhanced Input Advantages

The Enhanced Input System solves these problems:

Data-Driven Design: Input Actions and Mapping Contexts are assets you create in the Content Browser. They can be modified, swapped, and extended without changing code.

Flexible Value Types: Actions can output booleans, floats, 2D vectors, or 3D vectors—whatever makes sense for the action.

Modifiers and Triggers: Built-in systems to process input values (dead zones, sensitivity, swizzle axes) and control when actions fire (press, release, hold, tap).

Context Switching: Different Mapping Contexts for different gameplay states (on foot, in vehicle, in menu). Switch contexts instantly.

Runtime Remapping: Players can remap controls without restarting. The system handles saving and loading preferences.

Figure: Enhanced Input provides a more flexible, data-driven approach to handling player input.

The Enhanced Input Architecture

Enhanced Input separates input handling into distinct components:

Input Actions: Define what can happen. "Jump," "Move," "Fire," "Interact." Each action specifies its value type (digital, axis, 2D, 3D).

Input Mapping Contexts: Define how actions are triggered. Map specific keys/buttons to actions. Different contexts for different situations.

Modifiers: Process input values before they reach your game. Dead zones, sensitivity curves, axis inversion, value clamping.

Triggers: Define when actions fire. On press, on release, while held, on tap, on hold for duration.

flowchart LR
    A["🎮 Physical Input
(Key/Button)"] --> B["Input Mapping
Context"]
    B --> C["Input Action"]
    C --> D["Modifiers
(Dead Zone, etc.)"]
    D --> E["Triggers
(Press/Hold/etc.)"]
    E --> F["Blueprint Event
(Your Code)"]
    
    style A fill:#e3f2fd,color:#333
    style B fill:#fff3e0,color:#333
    style C fill:#667eea,color:#fff
    style D fill:#9C27B0,color:#fff
    style E fill:#FF9800,color:#fff
    style F fill:#4CAF50,color:#fff
                

Figure: Input flows from physical device through Mapping Context, Action, Modifiers, and Triggers to your Blueprint.

Input Actions

Input Actions are data assets that define what the player can do. They don't specify which key triggers them—that's the Mapping Context's job. Actions define the type of input and what value it produces.

Creating an Input Action

To create an Input Action:

1. In Content Browser, right-click
2. Select Input → Input Action
3. Name it descriptively with "IA_" prefix (e.g., IA_Jump, IA_Move)
4. Double-click to open and configure

Input Action Settings

The most important setting is Value Type:

Digital (Bool): True or false. Perfect for buttons: jump, fire, interact, pause. Outputs true when pressed, false when released.

Axis1D (Float): A single floating-point value, typically -1 to 1. Good for throttle, zoom, single-axis movement. Can represent analog trigger pressure.

Axis2D (Vector2D): Two floating-point values (X, Y). Ideal for movement (forward/back + left/right) or camera look (yaw + pitch). Joysticks naturally output 2D.

Axis3D (Vector): Three floating-point values (X, Y, Z). Used for VR motion controllers or other 3D input devices. Less common in traditional games.

Figure: Choose the Value Type that matches what your action needs to output.

Common Input Actions

Here are typical Input Actions for a third-person game:

Other Action Settings

Beyond Value Type, Input Actions have additional settings:

Consume Input: When true (default), this action consumes the input so lower-priority actions can't use it. Disable to allow multiple actions to share the same key.

Triggers: Can define default triggers directly on the action (though usually done in Mapping Context).

Modifiers: Can define default modifiers directly on the action (though usually done in Mapping Context).

For most cases, you'll just set the Value Type and leave other settings at defaults.

Input Mapping Contexts

Input Mapping Contexts connect physical inputs (keys, buttons, sticks) to Input Actions. They define which keys trigger which actions, and can include modifiers and triggers for each mapping. You can have multiple contexts and switch between them based on gameplay state.

Creating a Mapping Context

1. In Content Browser, right-click
2. Select Input → Input Mapping Context
3. Name it with "IMC_" prefix (e.g., IMC_Default, IMC_Vehicle)
4. Double-click to open and configure

Adding Mappings

Inside the Mapping Context editor:

1. Click + Add next to "Mappings"
2. Select an Input Action from the dropdown
3. Expand the action to see its mappings
4. Click + to add a key/button mapping
5. Select the key or button from the dropdown
6. Add Modifiers and Triggers as needed

Figure: A Mapping Context maps Input Actions to specific keys with optional modifiers.

Multiple Key Bindings

Each action can have multiple key bindings. This lets you support different input devices in one context:

• IA_Move: W/A/S/D keys AND left gamepad stick
• IA_Jump: Space key AND gamepad A button
• IA_Fire: Left mouse AND right trigger

When any bound input is activated, the action fires. This makes your game automatically support multiple input devices without extra code.

WASD to Axis2D Mapping

Mapping four discrete keys (W, A, S, D) to a 2D axis requires modifiers to combine them properly:

W Key: Produces +Y (forward). Modifier: Swizzle Input Axis Values (set to YXZ to put the value in Y)

S Key: Produces -Y (backward). Modifiers: Swizzle + Negate

A Key: Produces -X (left). Modifier: Negate

D Key: Produces +X (right). No modifier needed

The system combines these into a single Vector2D value representing the movement direction.

Figure: Four discrete keys combine into a single 2D vector for movement direction.

Context Switching

You can create different Mapping Contexts for different gameplay states:

• IMC_OnFoot — Walking character controls
• IMC_Vehicle — Driving controls (accelerate, brake, steer)
• IMC_Menu — Menu navigation (confirm, cancel, navigate)
• IMC_Swimming — Swimming controls (different movement feel)

In Blueprints, you add/remove mapping contexts from the player's Enhanced Input Local Player Subsystem. When you remove one context and add another, the control scheme changes instantly.

Modifiers and Triggers

Modifiers transform input values before they reach your game. Triggers control when an action fires. Together, they provide powerful control over input behavior without writing custom code.

Input Modifiers

Modifiers process the raw input value and output a modified value. They're applied in order, so the output of one becomes the input of the next.

Common Modifiers

Dead Zone: Ignores small stick movements near the center. Essential for analog sticks that may not rest perfectly at zero. Set inner and outer dead zone thresholds.

Negate: Multiplies the value by -1. Used to invert axes (e.g., S key produces negative Y instead of positive).

Swizzle Input Axis Values: Rearranges axis components. Used when a single key needs to affect a specific axis of a 2D/3D value. Options: YXZ, ZXY, XZY, etc.

Scalar: Multiplies the input by a constant. Useful for sensitivity adjustments. A scalar of 2.0 doubles the input value.

Smooth: Applies smoothing over time to reduce jitter. Good for mouse input that feels too twitchy.

Response Curve - Exponential: Applies an exponential curve to the input. Makes small movements more precise while preserving full range for large movements.

Figure: Common modifiers transform input values. They can be chained together in sequence.

Input Triggers

Triggers define the conditions under which an action fires. By default, actions fire continuously while input is active. Triggers let you specify more precise behavior.

Common Triggers

Down: Fires continuously while the input is active (default behavior). Good for movement, aiming.

Pressed: Fires once when input first becomes active. The classic "on press" event. Good for jump, interact, single actions.

Released: Fires once when input becomes inactive. Good for "charge and release" mechanics.

Hold: Fires after input has been held for a specified duration. Good for "hold to interact" or "hold to charge."

Hold and Release: Fires when released, but only if held for minimum duration. Combines hold requirement with release timing.

Tap: Fires if input is pressed and released quickly (under threshold). Good for quick-time events or distinguishing tap from hold.

Pulse: Fires repeatedly at specified intervals while input is held. Good for auto-fire weapons.

Figure: Different triggers control when and how actions fire based on input timing.

Combining Modifiers and Triggers

Each key mapping in a Mapping Context can have its own set of modifiers and triggers. This gives you precise control:

Example: Sprint Toggle

• Action: IA_Sprint (Digital)
• Key: Left Shift
• Trigger: Pressed — fires once to toggle sprint on
• Another mapping with Released trigger could toggle it off

Example: Gamepad Look with Dead Zone and Sensitivity

• Action: IA_Look (Axis2D)
• Key: Gamepad Right Stick
• Modifier 1: Dead Zone (inner: 0.2, outer: 1.0)
• Modifier 2: Scalar (value: 2.5 for sensitivity)
• Trigger: Down (continuous while held)

Per-Action vs. Per-Mapping Configuration

You can add modifiers and triggers in two places:

On the Input Action asset: These become defaults for all mappings that use this action. Good for behavior that should always apply.

On individual mappings in the Mapping Context: These override or extend the action's defaults. Good for device-specific adjustments (e.g., dead zone only for gamepad, not keyboard).

Per-mapping configuration is more common because different devices need different processing.

Binding Input to Blueprints

Once you've created Input Actions and Mapping Contexts, you need to connect them to your Blueprint logic. This involves two steps: adding the Mapping Context to the player, and responding to Input Action events.

Adding the Mapping Context

Before Input Actions will work, you must add your Mapping Context to the player's Enhanced Input system. This is typically done in the Player Controller or Pawn's BeginPlay event.

In a Character/Pawn Blueprint:

1. Open the Event Graph
2. Add an Event BeginPlay node
3. Drag from it and search for Get Controller
4. Cast the result to PlayerController
5. From the cast output, search for Get Enhanced Input Local Player Subsystem
6. From the subsystem, call Add Mapping Context
7. Set the Mapping Context to your IMC asset
8. Set Priority (0 is fine for default context)

Figure: Blueprint flow to add a Mapping Context when the game starts.

Responding to Input Actions

With the Mapping Context added, you can now respond to Input Action events in your Blueprint:

1. In the Event Graph, right-click
2. Search for the action name (e.g., "IA_Jump")
3. Select Enhanced Action Events → IA_Jump
4. Choose the event type: Triggered, Started, Ongoing, Canceled, or Completed

Event Types Explained

Started: Fires when the action first triggers (input begins).

Triggered: The main event—fires according to the trigger rules. Most commonly used.

Ongoing: Fires every frame while action is active. Useful for continuous updates.

Canceled: Fires if the action is interrupted before completing (e.g., released before hold duration met).

Completed: Fires when the action successfully completes its trigger condition.

For simple cases, Triggered is usually what you want.

Figure: The Enhanced Input Action event provides the action value and elapsed time.

Using Action Values

The Action Value output pin provides the processed input value. Its type depends on the Input Action's Value Type:

For Digital (Bool): The value is true when triggered. You typically just care that the event fired.

For Axis1D (Float): The value ranges from -1 to 1. Use directly for things like throttle.

For Axis2D (Vector2D): Break the vector to get X and Y components. Use for movement direction.

Example: Movement from Axis2D

1. Get the Action Value from IA_Move Triggered event
2. The value type is Input Action Value—right-click and "Get Action Value As..." → "Get Action Value 2D"
3. This gives you a Vector2D
4. Use X for right/left movement, Y for forward/back
5. Feed into Add Movement Input with appropriate direction vectors

Switching Mapping Contexts

To change control schemes (e.g., entering a vehicle), remove one context and add another:

1. Get the Enhanced Input Local Player Subsystem (same as before)
2. Call Remove Mapping Context with the old context
3. Call Add Mapping Context with the new context

This instantly swaps the controls. The old bindings stop working; the new bindings take over.

sequenceDiagram
    participant P as Player
    participant BP as Blueprint
    participant EIS as Enhanced Input Subsystem
    
    Note over BP,EIS: Initial State: IMC_OnFoot active
    P->>BP: Press "Enter Vehicle" 
    BP->>EIS: Remove Mapping Context (IMC_OnFoot)
    BP->>EIS: Add Mapping Context (IMC_Vehicle)
    Note over BP,EIS: Now: IMC_Vehicle active
    
    P->>BP: Press "Exit Vehicle"
    BP->>EIS: Remove Mapping Context (IMC_Vehicle)
    BP->>EIS: Add Mapping Context (IMC_OnFoot)
    Note over BP,EIS: Back to: IMC_OnFoot
                

Figure: Switching Mapping Contexts changes the active control scheme instantly.

Hands-On: Set Up WASD Movement

Let's put everything together by creating a complete movement system from scratch. We'll create Input Actions, configure a Mapping Context with keyboard and gamepad support, and wire it up in a Character Blueprint.

Step 1: Create a New Project or Use Existing

You can either:

• Create a new Third Person project (already has Enhanced Input set up—examine it)
• Create a new Blank project to build from scratch (we'll do this)

For learning, let's start with a Blank project:

1. Create a new Blank project with Blueprint, Starter Content
2. Let it load completely

Step 2: Create Input Actions

First, create the Input Actions we need:

Create IA_Move:

1. In Content Browser, right-click → Input → Input Action
2. Name it IA_Move
3. Double-click to open
4. Set Value Type to Axis2D (Vector2D)
5. Save and close

Create IA_Look:

1. Right-click → Input → Input Action
2. Name it IA_Look
3. Set Value Type to Axis2D (Vector2D)
4. Save and close

Create IA_Jump:

1. Right-click → Input → Input Action
2. Name it IA_Jump
3. Set Value Type to Digital (bool) (default)
4. Save and close

Step 3: Create Input Mapping Context

1. Right-click → Input → Input Mapping Context
2. Name it IMC_Default
3. Double-click to open

Now add mappings for each action:

Map IA_Move (WASD + Gamepad)

1. Click + next to "Mappings"
2. Select IA_Move
3. Expand IA_Move to see its mappings

Add W key (forward):

1. Click + to add a mapping
2. Click the key dropdown, select W
3. Click + next to Modifiers
4. Add Swizzle Input Axis Values — set Order to YXZ
5. This puts the input into the Y axis (forward/back)

Add S key (backward):

1. Click + to add another mapping
2. Select S
3. Add Modifier: Swizzle Input Axis Values → YXZ
4. Add Modifier: Negate (makes it negative Y)

Add A key (left):

1. Add mapping for A
2. Add Modifier: Negate (negative X = left)

Add D key (right):

1. Add mapping for D
2. No modifiers needed (positive X = right)

Add Gamepad Left Stick:

1. Add mapping, select Gamepad Left Thumbstick 2D-Axis
2. Add Modifier: Dead Zone
3. Set Lower Threshold to 0.2

Figure: Complete IA_Move mapping with WASD keys and gamepad stick.

Map IA_Look (Mouse + Gamepad)

1. Click + next to Mappings, select IA_Look
2. Add mapping: Mouse XY 2D-Axis — no modifiers needed
3. Add mapping: Gamepad Right Thumbstick 2D-Axis
4. Add Modifier to gamepad: Dead Zone (Lower: 0.2)
5. Optional: Add Scalar modifier for sensitivity (e.g., 2.0)

Map IA_Jump (Space + Gamepad)

1. Click +, select IA_Jump
2. Add mapping: Space Bar
3. Add mapping: Gamepad Face Button Bottom (A on Xbox, X on PlayStation)

Save the Mapping Context.

Step 4: Create a Character Blueprint

1. Right-click in Content Browser → Blueprint Class
2. Select Character as parent
3. Name it BP_PlayerCharacter
4. Double-click to open

Add a visual representation:

1. In Components panel, select the Mesh component
2. In Details, set Skeletal Mesh to a mannequin or any available mesh
3. Or add a Static Mesh component (sphere/capsule) for visibility

Add a camera:

1. Click Add Component → Spring Arm
2. Attach it to the Capsule (drag onto Capsule in hierarchy)
3. Set Target Arm Length to 300
4. Enable Use Pawn Control Rotation
5. Add a Camera component as child of Spring Arm

Step 5: Add Input Setup to Character

Open the Event Graph and create the input setup:

Add Mapping Context on BeginPlay:

1. Add Event BeginPlay
2. Add Get Controller node
3. Add Cast To PlayerController
4. From the cast result, add Get Enhanced Input Local Player Subsystem
5. From the subsystem, add Add Mapping Context
6. Set Mapping Context to IMC_Default
7. Set Priority to 0
8. Connect the execution wires

Step 6: Handle Movement Input

Add movement handling:

1. Right-click → search "IA_Move" → select EnhancedInputAction IA_Move
2. Choose the Triggered event
3. From the Action Value pin, drag and select Get Action Value 2D
4. This gives you X (right/left) and Y (forward/back) values

Calculate movement direction:

1. Add Get Control Rotation node
2. Add Break Rotator to get Yaw
3. Add Make Rotator with only Yaw (Pitch and Roll = 0)
4. Add Get Forward Vector from this rotator (for forward/back)
5. Add Get Right Vector from this rotator (for left/right)

Apply movement:

1. Multiply Forward Vector by Input Y value
2. Multiply Right Vector by Input X value
3. Add the two vectors together
4. Feed result into Add Movement Input

Figure: Movement flow—input direction combined with camera rotation to move character.

Step 7: Handle Look Input

1. Add EnhancedInputAction IA_Look (Triggered)
2. Get Action Value 2D from Action Value
3. Add Add Controller Yaw Input — connect Input X
4. Add Add Controller Pitch Input — connect Input Y (may need to negate for natural feel)

Step 8: Handle Jump Input

1. Add EnhancedInputAction IA_Jump (Triggered)
2. Add Jump node (built into Character class)
3. Connect execution wire from IA_Jump to Jump

Step 9: Set Up Game Mode

1. Create a new Blueprint: Blueprint Class → Game Mode Base
2. Name it BP_GameMode
3. Open it and in Details panel, set Default Pawn Class to BP_PlayerCharacter
4. Go to Edit → Project Settings → Maps & Modes
5. Set Default GameMode to BP_GameMode

Step 10: Add a Player Start and Test

1. In your level, add a Player Start actor
2. Add a floor (Place Actors → Basic → Cube, scale to 10×10×0.1)
3. Position Player Start above the floor
4. Press Play

Test the controls:

• WASD should move the character
• Mouse should rotate the camera
• Space should make the character jump
• If you have a gamepad, test those inputs too

Troubleshooting Common Issues

Summary

In this lesson, you've mastered the Enhanced Input System—Unreal Engine 5's modern, data-driven approach to handling player input. This system provides the flexibility and power needed for professional game development while remaining accessible for beginners.

Key Concepts

Enhanced Input Architecture: Separates input handling into distinct components: Input Actions (what can happen), Input Mapping Contexts (how it's triggered), Modifiers (value processing), and Triggers (when it fires). This separation enables flexibility and reusability.

Input Actions: Data assets that define player capabilities like Move, Jump, Fire. Each action has a Value Type (Digital, Axis1D, Axis2D, Axis3D) that determines what kind of data it outputs.

Input Mapping Contexts: Connect physical inputs (keys, buttons, sticks) to Input Actions. Support multiple bindings per action for multi-device support. Can be swapped at runtime for different control schemes.

Modifiers: Transform input values before they reach your game. Dead Zone eliminates stick drift. Negate inverts values. Swizzle rearranges axes. Scalar adjusts sensitivity. Applied in sequence.

Triggers: Control when actions fire. Pressed for one-shot events. Down for continuous input. Hold for delayed activation. Tap for quick press detection. Pulse for auto-repeat.

Blueprint Integration: Add Mapping Context via the Enhanced Input Local Player Subsystem. Respond to Enhanced Input Action events. Use Action Value for the processed input data.

Best Practices

• Name consistently: Use IA_ prefix for Input Actions, IMC_ for Mapping Contexts
• Choose correct Value Type: Digital for buttons, Axis2D for movement/look, Axis1D for single-axis controls
• Apply Dead Zone to analog inputs: Always add Dead Zone to gamepad sticks
• Order modifiers correctly: Dead Zone → Scalar → Curve (process, then scale, then shape)
• Support multiple devices: Add keyboard AND gamepad mappings to the same action
• Use context switching: Create separate Mapping Contexts for different gameplay states
• Test with actual devices: Keyboard feel differs from gamepad—test both

Figure: Enhanced Input transforms raw hardware signals into game-ready events.

What's Next?

Now that you can receive and process player input, the next lesson focuses on Character Movement—diving deeper into the Character Movement Component to customize walking, running, jumping, and other movement behaviors. You'll learn how to tune movement parameters for different gameplay feels.

Knowledge Check