/ue-input-system

Enhanced Input: Trigger and Modifier Reference

Companion reference for the ue-input-system skill. Covers the built-in UInputTrigger and UInputModifier classes with their exact properties and defaults, the mapping-context and subsystem APIs, input-mode filtering, and the UEnhancedInputUserSettings rebinding path. Everything lives in the EnhancedInput plugin module.

Source headers: InputAction.h, InputActionValue.h, InputTriggers.h, InputModifiers.h, InputMappingContext.h, EnhancedActionKeyMapping.h, EnhancedInputSubsystemInterface.h, EnhancedInputSubsystems.h, EnhancedInputDeveloperSettings.h, EnhancedInputPlatformSettings.h, PlayerMappableKeySettings.h, EnhancedInputLibrary.h, UserSettings/EnhancedInputUserSettings.h.

UInputAction Properties

class UInputAction : public UDataAsset

EInputActionAccumulationBehavior

FInputActionInstance (Runtime)

Available inside FInputActionInstance callbacks:

ETriggerEvent

Bitmask enum. Represents state transitions observed in a single tick.

Completed will not fire if any trigger on the same action reports Ongoing that frame.

Trigger Classes

ETriggerState (Internal)

Triggers return one of three states:

ETriggerType (Multi-Trigger Evaluation)

UInputTriggerDown

DisplayName: "Down"
Class: UInputTriggerDown : public UInputTrigger
TriggerType: Explicit
SupportedEvents: Instant

Behavior: Fires Triggered every frame input magnitude exceeds ActuationThreshold. This is the implicit default when an action has no triggers assigned.

Properties:

Use for: Continuous actions where you want firing as long as a key is held (before adding a proper trigger).

UInputTriggerPressed

DisplayName: "Pressed"
Class: UInputTriggerPressed : public UInputTrigger
TriggerType: Explicit
SupportedEvents: Instant

Behavior: Fires Triggered exactly once on the first frame input exceeds ActuationThreshold. Holding the input does not fire again. Re-press is required for another trigger.

Properties:

Use for: Discrete press-once actions: jump initiation, weapon fire on semi-auto, menu confirm.

UInputTriggerReleased

DisplayName: "Released"
Class: UInputTriggerReleased : public UInputTrigger
TriggerType: Explicit
SupportedEvents: Instant

Behavior: Returns Ongoing while input exceeds ActuationThreshold. Fires Triggered once when input drops back below the threshold after having been actuated.

Properties:

Use for: Release-on-let-go: throwing after wind-up on a dedicated action, "lift to release" grenades.

UInputTriggerHold

DisplayName: "Hold"
Class: UInputTriggerHold : public UInputTriggerTimedBase
TriggerType: Explicit
SupportedEvents: Ongoing (Started, Ongoing, Triggered, Canceled)

Behavior: Returns Ongoing while input is held. After HoldTimeThreshold seconds, fires Triggered. If bIsOneShot=false, continues firing Triggered every frame. If input is released before the threshold, fires Canceled.

Properties:

Use for: Hold-to-interact prompts, charged attacks where you need the Ongoing callback to show a progress bar. Combine with GetElapsedTime() in the Ongoing handler.

Example — charge bar:

void AMyCharacter::UpdateChargeBar(const FInputActionInstance& Instance)
{
    // Instance.GetElapsedTime() grows while key is held
    const float Progress = FMath::Clamp(
        Instance.GetElapsedTime() / HoldTrigger->HoldTimeThreshold, 0.f, 1.f);
    ChargeBarWidget->SetPercent(Progress);
}

UInputTriggerHoldAndRelease

DisplayName: "Hold And Release"
Class: UInputTriggerHoldAndRelease : public UInputTriggerTimedBase
TriggerType: Explicit
SupportedEvents: Ongoing

Behavior: Returns Ongoing while input is held. Fires Triggered only when input is released after having been held for at least HoldTimeThreshold seconds. If released before the threshold, does not trigger.

Properties:

Use for: "Pull back and release" bows, charged throws where the shot fires on release. Different from UInputTriggerHold in that the payload fires on release, not during hold.

UInputTriggerTap

DisplayName: "Tap"
Class: UInputTriggerTap : public UInputTriggerTimedBase
TriggerType: Explicit
SupportedEvents: Instant

Behavior: Fires Triggered if input is actuated then released within TapReleaseTimeThreshold seconds. Returns Ongoing while held within the window. If held past the threshold without release, the trigger does not fire.

Properties:

Use for: Quick-dash on tap (vs hold for a sustained dash). Combine with a separate UInputTriggerHold on a second binding of the same key to distinguish tap vs hold.

UInputTriggerRepeatedTap

DisplayName: "Repeated Tap"
Class: UInputTriggerRepeatedTap : public UInputTriggerTimedBase
TriggerType: Explicit
SupportedEvents: Ongoing (inherited from UInputTriggerTimedBase)

Behavior: Fires Triggered when the input is tapped NumberOfTapsWhichTriggerRepeat times in succession, with each individual tap completing within TapReleaseTimeThreshold and each gap between taps within RepeatDelay seconds.

Properties:

Use for: Double-tap dodge roll (NumberOfTapsWhichTriggerRepeat=2), triple-tap finisher.

UInputTriggerPulse

DisplayName: "Pulse"
Class: UInputTriggerPulse : public UInputTriggerTimedBase
TriggerType: Explicit
SupportedEvents: Ongoing

Behavior: While input is held, fires Triggered at regular Interval second intervals. If bTriggerOnStart=true, also fires immediately on the first actuation frame. Stops after TriggerLimit fires if TriggerLimit > 0.

Properties:

Use for: Automatic weapon fire rate, repeated ability pulses while holding a key, tick-based resource drain.

UInputTriggerChordAction

DisplayName: "Chorded Action"
Class: UInputTriggerChordAction : public UInputTrigger
TriggerType: Implicit
SupportedEvents: Instant
NotInputConfigurable: true (not exposed in per-mapping settings)

Behavior: This action only fires when ChordAction is simultaneously in Triggered state. When mappings rebuild, the subsystem injects a UInputTriggerChordBlocker into every lower-priority mapping that shares the chorded mapping's key, so that key's solo actions are blocked while the chord is active (EnhancedInputSubsystemInterface.cpp:587-609).

Properties:

Setup pattern — Shift+E for special interact:

1. Create IA_Sprint (Bool) bound to Shift in the IMC
2. Create IA_SpecialInteract (Bool) bound to E, and IA_Interact (Bool) also bound to E in a later (lower-priority) mapping
3. On IA_SpecialInteract, add a UInputTriggerChordAction with ChordAction = IA_Sprint
4. Result: E fires IA_Interact; Shift+E fires IA_SpecialInteract; E while Shift is held does NOT fire IA_Interact

Modifier Classes

UInputModifierDeadZone

DisplayName: "Dead Zone"
Class: UInputModifierDeadZone : public UInputModifier

Behavior: Input values with magnitude below LowerThreshold are zeroed out. Values are remapped from [LowerThreshold, UpperThreshold] to [0, 1]. Values above UpperThreshold are clamped to 1.

Properties:

EDeadZoneType:

Use for: All gamepad analog stick mappings. Add per-stick-mapping in the IMC, not on the action asset.

UInputModifierScalar

DisplayName: "Scalar"
Class: UInputModifierScalar : public UInputModifier

Behavior: Multiplies each axis component of the input by the corresponding component of Scalar. Has no effect on Boolean value types.

Properties:

Use for: Mouse sensitivity scaling (Scalar=(0.4, 0.4, 1.0)), axis inversion without using Negate (set component to -1.0), adjusting controller stick sensitivity.

UInputModifierScaleByDeltaTime

DisplayName: "Scale By Delta Time"
Class: UInputModifierScaleByDeltaTime : public UInputModifier

Behavior: Multiplies the input value by the current frame's DeltaTime. No configurable properties.

Use for: Making input frame-rate independent when feeding raw values into physics or math that expects a per-second rate. Not typically needed for movement (AddMovementInput already accounts for DeltaTime internally).

UInputModifierNegate

DisplayName: "Negate"
Class: UInputModifierNegate : public UInputModifier

Behavior: Inverts selected axes by multiplying by -1.

Properties:

Use for: Y-axis inversion for "inverted look" options, negating the S and A keys in WASD-to-2D composition.

Common setup — invert Y only: Set bX=false, bY=true, bZ=false.

UInputModifierSwizzleAxis

DisplayName: "Swizzle Input Axis Values"
Class: UInputModifierSwizzleAxis : public UInputModifier

Behavior: Reorders the X, Y, Z components of the input value according to Order.

Properties:

EInputAxisSwizzle:

Use for: The canonical WASD-to-Axis2D mapping. W produces a 1D value of 1.0 on X. Adding SwizzleAxis(YXZ) converts it to Y=1.0, which is forward in the Axis2D Move action.

UInputModifierSmooth

DisplayName: "Smooth"
Class: UInputModifierSmooth : public UInputModifier

Behavior: Averages the input value over recent samples to reduce per-frame jitter. Uses a rolling average with TotalSampleTime as the accumulation window (SMOOTH_TOTAL_SAMPLE_TIME_DEFAULT = 0.0083f). Resets when input returns to zero.

No configurable properties: TotalSampleTime is a protected member with no UPROPERTY, so it is not editable on the asset and not reachable from Blueprint.

Use for: Smoothing raw mouse delta input for look controls. Add alongside Scalar on mouse look mappings.

UInputModifierSmoothDelta

DisplayName: "Smooth Delta"
Class: UInputModifierSmoothDelta : public UInputModifier

Behavior: Produces a smoothed normalized delta between the current and previous frame's input value, using one of many configurable interpolation methods.

Properties:

ENormalizeInputSmoothingType options: Lerp, Interp_To, Interp_Constant_To, Interp_Circular_In/Out/In_Out, Interp_Ease_In/Out/In_Out, Interp_Expo_In/Out/In_Out, Interp_Sin_In/Out/In_Out (None also exists, UMETA(Hidden), InputModifiers.h:83)

Use for: Smooth acceleration/deceleration on stick or mouse input where you want to author the feel curve precisely.

UInputModifierResponseCurveExponential

DisplayName: "Response Curve - Exponential"
Class: UInputModifierResponseCurveExponential : public UInputModifier

Behavior: Applies sign(x) * |x|^CurveExponent per axis, creating a non-linear response. Values below 1 create a "softer" near-center feel; values above 1 create a "harder" aggressive feel.

Properties:

Use for: Analog stick look sensitivity curves — a squared or cubed response gives fine control near center with fast movement at the edges.

UInputModifierResponseCurveUser

DisplayName: "Response Curve - User Defined"
Class: UInputModifierResponseCurveUser : public UInputModifier

Behavior: Applies separate UCurveFloat assets per axis, evaluating each curve with the current axis value as input. Gives full artist control over the response shape.

Properties:

Use for: Precise feel tuning with a visible curve asset. Preferred over ResponseCurveExponential when the exact shape matters and needs iteration in the Curve Editor.

UInputModifierFOVScaling

DisplayName: "FOV Scaling"
Class: UInputModifierFOVScaling : public UInputModifier

Behavior: Scales the mouse look input value by the current camera FOV, maintaining a consistent angular displacement per mouse unit regardless of zoom level.

Properties:

Use for: Mouse look on any character with a zoom/aim-down-sights mechanic. Without this, zoomed-in aim feels faster than unzoomed aim in terms of screen pixels.

UInputModifierToWorldSpace

DisplayName: "To World Space"
Class: UInputModifierToWorldSpace : public UInputModifier

Behavior: Converts a 2D axis input into world space. The up/down axis maps to world forward (X), and left/right maps to world right (Y). Allows the value to be passed directly to AddMovementInput or similar world-space functions without manual conversion.

No configurable properties.

Use for: Simplifying movement handler code when you want to receive a world-space direction directly from the callback rather than rotating by the actor's facing.

Modifier Execution Order

Modifiers are applied in this sequence:

1. Per-mapping modifiers (defined on each FEnhancedActionKeyMapping in the IMC)
2. Action-level modifiers (defined on the UInputAction asset Modifiers array)

Within each group, modifiers execute in array order. The output of modifier N is the input to modifier N+1.

Typical keyboard+mouse stack for a look action (per mapping, in order):

Scalar (0.4, 0.4, 1.0)  ->  Smooth  ->  FOV Scaling

Typical gamepad stick move action (per mapping, in order):

Y stick axis mapping: Dead Zone (Radial, 0.2, 1.0)  ->  Swizzle Input Axis Values (YXZ)
X stick axis mapping: Dead Zone (Radial, 0.2, 1.0)

No action-level modifiers are needed in either case.

Custom Trigger Interface

Override in a UInputTrigger subclass:

UInputTrigger::IsActuated(const FInputActionValue&) helper: Returns true if Value.GetMagnitudeSq() >= ActuationThreshold * ActuationThreshold.

UInputTriggerTimedBase base class provides:

• HeldDuration — accumulated time while actuated
• CalculateHeldDuration(PlayerInput, DeltaTime) — increments with optional time dilation
• Automatically transitions to Ongoing on first actuation

Custom Modifier Interface

Override in a UInputModifier subclass:

The returned FInputActionValue will be cast back to the action's ValueType before further processing, so you can return any type internally.

Worked example:

// MyClampMagnitudeModifier.h
#pragma once

#include "InputModifiers.h"
#include "MyClampMagnitudeModifier.generated.h"

UCLASS(EditInlineNew, meta = (DisplayName = "Clamp Magnitude"))
class MYGAME_API UMyClampMagnitudeModifier : public UInputModifier
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Settings")
	float MaxMagnitude = 1.0f;

protected:
	virtual FInputActionValue ModifyRaw_Implementation(
		const UEnhancedPlayerInput* PlayerInput, FInputActionValue CurrentValue, float DeltaTime) override
	{
		FVector Direction = CurrentValue.Get<FVector>();
		if (Direction.SizeSquared() > MaxMagnitude * MaxMagnitude)
		{
			Direction = Direction.GetSafeNormal() * MaxMagnitude;
		}
		return FInputActionValue(CurrentValue.GetValueType(), Direction);
	}
};

UInputMappingContext Properties

class UInputMappingContext : public UDataAsset

After mutating an IMC, call UEnhancedInputLibrary::RequestRebuildControlMappingsUsingContext(Context, bForceImmediately).

FEnhancedActionKeyMapping

UPlayerMappableKeySettings

UPlayerMappableKeySettings::GetKnownMappingNames() returns every registered mapping name and is the GetOptions source for UPROPERTY(meta=(GetOptions="EnhancedInput.PlayerMappableKeySettings.GetKnownMappingNames")).

EMappingContextRegistrationTrackingMode

UEnhancedInputLocalPlayerSubsystem API

// Add a context (BeginPlay or on mode change)
Subsystem->AddMappingContext(IMC, Priority, Options);

// Remove a context (on mode change, unpossess)
Subsystem->RemoveMappingContext(IMC, Options);

// Remove all contexts
Subsystem->ClearAllMappings();

// Check if a context is currently active
Subsystem->HasMappingContext(IMC);

// Query current value of an action without a binding
Subsystem->GetPlayerInput()->GetActionValue(InputAction);

FModifyContextOptions — every field already holds the default below, so pass the struct only to change one:

Other members of IEnhancedInputSubsystemInterface, shared by the local-player and world subsystems:

Input Mode Filtering

Enable bEnableInputModeFiltering on UEnhancedInputDeveloperSettings first. The subsystem keeps a FGameplayTagContainer of the current mode; contexts whose query fails stay registered but stop producing input, so priorities and registration counts are untouched.

EMappingContextInputModeFilterOptions

UEnhancedInputDeveloperSettings::DefaultInputMode is the tag container every new UEnhancedPlayerInput starts with.

UEnhancedInputUserSettings

Header: UserSettings/EnhancedInputUserSettings.h. A USaveGame created per subsystem when bEnableUserSettings is set; the class comes from UserSettingsClass and the save slot from InputSettingsSaveSlotName. This is the supported runtime key-rebinding path.

Profile identifiers are FString. MapPlayerKey and its siblings report problems through the FGameplayTagContainer& FailureReason out-parameter rather than a return value: an empty container means success.

FMapPlayerKeyArgs

UEnhancedPlayerMappableKeyProfile

FKeyMappingRow holds a TSet<FPlayerKeyMapping> Mappings and answers HasAnyMappings().

FPlayerKeyMapping

UEnhancedInputWorldSubsystem

A UWorldSubsystem implementing IEnhancedInputSubsystemInterface, DisplayName "Enhanced Input World Subsystem (Experimental)". Use it to bind input on actors that will never have an owning APlayerController. Enable it with bEnableWorldSubsystem in UEnhancedInputDeveloperSettings; DefaultWorldInputClass chooses its UEnhancedPlayerInput class.

The actor needs an InputComponent. AActor::EnableInput only creates one when given a PlayerController (Actor.cpp:4895-4900), so with no controller create it yourself: NewObject<UEnhancedInputComponent>(this), RegisterComponent(), assign it to InputComponent, then add it (as in the SKILL.md example). AddMappingContext and the rest of the interface behave exactly as on the local-player subsystem, but there is no UEnhancedInputUserSettings here.

EnhancedInputPlatformSettings

Header: EnhancedInputPlatformSettings.h. Build.cs: add DeveloperSettings when you call Get() — it is inline and calls UPlatformSettingsManager (DeveloperSettings/Public/Engine/PlatformSettingsManager.h), so the link fails without it.

UEnhancedInputPlatformSettings* PlatformSettings = UEnhancedInputPlatformSettings::Get();

UEnhancedInputPlatformData is an abstract, Blueprintable UObject. Subclass it per platform and fill MappingContextRedirects to swap one UInputMappingContext for another; GetContextRedirect(InContext) returns the replacement, or InContext itself when there is none.

UEnhancedInputLibrary

A UBlueprintFunctionLibrary in EnhancedInputLibrary.h.

FInputActionValue