Ue Input System

Runtime Key Rebinding

UEnhancedInputUserSettings (UserSettings/EnhancedInputUserSettings.h) is the sanctioned rebinding path. It is a USaveGame, created per subsystem when bEnableUserSettings is on, and saved to the slot named by InputSettingsSaveSlotName.

#include "EnhancedInputSubsystems.h"
#include "UserSettings/EnhancedInputUserSettings.h"

void UMyRebindWidget::RebindKey(FName MappingName, const FKey& NewKey)
{
	UEnhancedInputLocalPlayerSubsystem* Subsystem =
		ULocalPlayer::GetSubsystemFromController<UEnhancedInputLocalPlayerSubsystem>(GetOwningPlayer());
	UEnhancedInputUserSettings* Settings = Subsystem ? Subsystem->GetUserSettings() : nullptr;
	if (!Settings)
	{
		return;
	}

	FMapPlayerKeyArgs Args;
	Args.MappingName = MappingName;
	Args.Slot = EPlayerMappableKeySlot::First;
	Args.NewKey = NewKey;

	FGameplayTagContainer FailureReason;
	Settings->MapPlayerKey(Args, FailureReason);
	if (FailureReason.IsEmpty())
	{
		Settings->SaveSettings();
	}
}

Register any IMC the settings UI must list — even one never added to the subsystem — with RegisterInputMappingContext(IMC); adding a context with bNotifyUserSettings = true does it for you. Read mappings back with FindMappingsInRow(MappingName) and FindCurrentMappingForSlot(MappingName, Slot), reset with ResetAllPlayerKeysInRow or ResetKeyProfileIdToDefault, and persist with SaveSettings() / AsyncSaveSettings(). Profile identifiers are FString, not FGameplayTag — ProfileIdString, GetProfileIdString(), GetActiveKeyProfileId(), GetKeyProfileWithId(), SetActiveKeyProfile().

An action or mapping is only rebindable if it carries a UPlayerMappableKeySettings (Name, DisplayName, DisplayCategory, Metadata, SupportedKeyProfileIds) — either on the UInputAction or on the FEnhancedActionKeyMapping with SettingBehavior = OverrideSettings. Full API and struct tables: references/input-action-reference.md.

Input Without a PlayerController

UEnhancedInputWorldSubsystem (Experimental in 5.8) lets actors that will never be possessed receive input delegates. Enable it with bEnableWorldSubsystem in UEnhancedInputDeveloperSettings.

#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "Engine/World.h"

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

	// AddActorInputComponent reads AActor::InputComponent, created only for possessed actors.
	if (!InputComponent)
	{
		InputComponent = NewObject<UEnhancedInputComponent>(this, TEXT("DoorInputComponent"));
		InputComponent->RegisterComponent();
	}

	UEnhancedInputComponent* EIC = CastChecked<UEnhancedInputComponent>(InputComponent);
	EIC->BindAction(OpenAction, ETriggerEvent::Started, this, &AMyDoor::Open);

	if (UEnhancedInputWorldSubsystem* WorldInput =
			GetWorld()->GetSubsystem<UEnhancedInputWorldSubsystem>())
	{
		WorldInput->AddActorInputComponent(this);
		WorldInput->AddMappingContext(DoorContext, 0);
	}
}

Pair every AddActorInputComponent with RemoveActorInputComponent on EndPlay. The subsystem implements the same IEnhancedInputSubsystemInterface as the local-player one, so AddMappingContext, InjectInputForAction and friends behave identically — but it has no user settings and no local player.

Per-Platform Input Data

UEnhancedInputPlatformSettings (UPlatformSettings, UEnhancedInputPlatformSettings::Get()) holds an InputData array of UEnhancedInputPlatformData subclasses. Each one defines MappingContextRedirects, a TMap swapping one UInputMappingContext for another on that platform; GetContextRedirect(Context) returns the replacement or the original. Use it to substitute a touch or console context without branching in gameplay code. Calling Get() needs DeveloperSettings in Build.cs (it inlines a UPlatformSettingsManager call).

Custom Triggers

Subclass UInputTrigger and override UpdateState_Implementation, returning ETriggerState::None, Ongoing or Triggered.

// MyDoubleClickTrigger.h
#pragma once

#include "EnhancedPlayerInput.h"
#include "Engine/World.h"
#include "InputTriggers.h"
#include "MyDoubleClickTrigger.generated.h"

UCLASS(EditInlineNew, meta = (DisplayName = "Double Click"))
class MYGAME_API UMyDoubleClickTrigger : public UInputTrigger
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Trigger Settings")
	float DoubleClickThreshold = 0.3f;

protected:
	virtual ETriggerType GetTriggerType_Implementation() const override { return ETriggerType::Explicit; }

	virtual ETriggerState UpdateState_Implementation(
		const UEnhancedPlayerInput* PlayerInput, FInputActionValue ModifiedValue, float DeltaTime) override
	{
		const bool bActuated = IsActuated(ModifiedValue);
		const float Now = PlayerInput->GetWorld()->GetTimeSeconds();

		ETriggerState Result = ETriggerState::None;
		if (bActuated && !bWasActuated)
		{
			if ((Now - LastPressTime) <= DoubleClickThreshold)
			{
				LastPressTime = 0.f;
				Result = ETriggerState::Triggered;
			}
			else
			{
				LastPressTime = Now;
			}
		}

		bWasActuated = bActuated;
		return Result;
	}

private:
	float LastPressTime = 0.f;
	bool bWasActuated = false;
};

IsActuated(Value) is Value.GetMagnitudeSq() >= ActuationThreshold * ActuationThreshold. For time-based triggers derive from UInputTriggerTimedBase, which transitions to Ongoing on actuation and gives you HeldDuration plus CalculateHeldDuration(PlayerInput, DeltaTime) and bAffectedByTimeDilation. Override IsBlocking(const ETriggerState State) const for blockers and GetDebugState() const for the debug HUD. If your trigger keeps state across mapping rebuilds, override ReceiveTriggerReinstanced_Implementation(const UInputTrigger* OldTrigger) and call Super.

Custom Modifiers

Subclass UInputModifier and override:

virtual FInputActionValue ModifyRaw_Implementation(
	const UEnhancedPlayerInput* PlayerInput, FInputActionValue CurrentValue, float DeltaTime) override;

The returned value is converted back to the action's ValueType before further processing, so you may return any shape internally — FInputActionValue(CurrentValue.GetValueType(), Vector) preserves it. Override GetVisualizationColor_Implementation(FInputActionValue SampleValue, FInputActionValue FinalValue) const to control the debug overlay colour. Worked example: references/input-action-reference.md.

UI Input Mode

Without CommonUI, switch modes on the PlayerController with SetInputMode(FInputModeUIOnly()), SetInputMode(FInputModeGameAndUI()) or SetInputMode(FInputModeGameOnly()).

CommonUI routes input through UCommonActivatableWidget stacks and removes most manual SetInputMode calls. Enhanced Input and Common Input are unified: turn on UCommonInputSettings::bEnableEnhancedInputSupport (Project Settings → Game → Common Input; requires a restart) and CommonUI's click and back actions become UInputAction assets — UCommonUIInputData::EnhancedInputClickAction and EnhancedInputBackAction — instead of data-table rows. Widget stacks, activatable widgets and input configs belong to ue-ui-umg-slate.

Debugging

ShowDebug EnhancedInput prints the applied mapping contexts, each action's value and trigger state, and each trigger's GetDebugState(). ShowDebug WorldSubsystemInput does the same for UEnhancedInputWorldSubsystem; ShowDebug InputSettings dumps the developer settings; LogWorldSubsystemInput at VeryVerbose logs every key the world subsystem processes.

Deprecated — do not use

Common Mistakes

Adding the mapping context in SetupPlayerInputComponent: that call can run before the controller and local player are resolved. Add contexts in BeginPlay, OnPossess/PossessedBy, or a PlayerControllerChanged handler.

Setting bIgnoreAllPressedKeysUntilRelease = true "to be safe": it is already the default on FModifyContextOptions. Only touch it to set false.

Binding Triggered for a button press: Triggered fires every active frame. Use Started for press-once and Completed for release.

Expecting Completed alongside Ongoing: Completed is suppressed on any tick where a trigger reports Ongoing. Split into two actions with their own triggers.

No dead zone on sticks: analog sticks rest at non-zero. Add Dead Zone (Radial) to every stick mapping.

Missing swizzle for WASD: a keyboard key produces a 1D value on X. Without Swizzle Input Axis Values (YXZ) on W and S, forward/back never reaches the Y component of an Axis2D action.

Calling MapKey/UnmapKey for player rebinding: those mutate the IMC asset and are editor/config helpers. Use UEnhancedInputUserSettings::MapPlayerKey instead, and pass bNotifyUserSettings = true when adding contexts you want listed in a rebinding UI.

Replicating trigger events: input is client-local. Replicate the result — movement input, ability activation — never the ETriggerEvent.

Legacy binding on a UEnhancedInputComponent: BindAxis and the FName BindAction overloads are = delete and fail to compile. Migrate them rather than defining ENHANCED_INPUT_ALLOW_LEGACY_BINDING=1.

Related Skills

• ue-gameplay-framework — APlayerController, possession, SetupPlayerInputComponent lifecycle
• ue-ui-umg-slate — CommonUI activatable-widget stacks, input configs, cursor and focus
• ue-character-movement — consuming FInputActionValue through AddMovementInput
• ue-gameplay-abilities — activating abilities from input, UAbilitySystemComponent input IDs
• ue-actor-component-architecture — UActorComponent/UInputComponent ownership, EnableInput, component-owned input
• Also relevant: ue-cpp-foundations, ue-game-features, ue-gameplay-cameras, ue-mover