PlayerInput.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//~=============================================================================
// PlayerInput
// Object within PlayerController that manages player input.
// Only spawned on client.
//~=============================================================================
 
#pragma once
 
#include "CoreMinimal.h"
#include "Framework/Commands/InputChord.h"
#include "GestureRecognizer.h"
#include "InputCoreTypes.h"
#include "InputKeyEventArgs.h"
#include "KeyState.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
 
#include "PlayerInput.generated.h"
 
class FDebugDisplayInfo;
class UInputComponent;
class ULocalPlayer;
struct FDelegateDispatchDetails;
struct FInputActionBinding;
struct FInputAxisBinding;
struct FInputKeyBinding;
 
 
USTRUCT()
struct FKeyBind
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(config, EditAnywhere, Category = "Input")
    FKey Key;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    FString Command;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 Control:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 Shift:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 Alt:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 Cmd:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 bIgnoreCtrl:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 bIgnoreShift:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 bIgnoreAlt:1;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    uint8 bIgnoreCmd:1;
 
    UPROPERTY(transient)
    uint8 bDisabled : 1;
 
    FKeyBind()
        : Control(false)
        , Shift(false)
        , Alt(false)
        , Cmd(false)
        , bIgnoreCtrl(false)
        , bIgnoreShift(false)
        , bIgnoreAlt(false)
        , bIgnoreCmd(false)
        , bDisabled(false)
    {
    }
};
 
USTRUCT()
struct FInputAxisProperties
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category="Input")
    float DeadZone;
 
    UPROPERTY(EditAnywhere, Category="Input")
    float Sensitivity;
 
    UPROPERTY(EditAnywhere, Category="Input")
    float Exponent;
 
    UPROPERTY(EditAnywhere, Category="Input")
    uint8 bInvert:1;
 
    FInputAxisProperties()
        : DeadZone(0.2f)
        , Sensitivity(1.f)
        , Exponent(1.f)
        , bInvert(false)
    {}
    
};
 
USTRUCT()
struct FInputAxisConfigEntry
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(VisibleAnywhere, Category="Input")
    FName AxisKeyName;
 
    UPROPERTY(EditAnywhere, Category="Input")
    struct FInputAxisProperties AxisProperties;
};
 
USTRUCT( BlueprintType )
struct FInputActionKeyMapping
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FName ActionName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    uint8 bShift:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    uint8 bCtrl:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    uint8 bAlt:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    uint8 bCmd:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FKey Key;
 
    bool operator==(const FInputActionKeyMapping& Other) const
    {
        return (   ActionName == Other.ActionName
                && Key == Other.Key
                && bShift == Other.bShift
                && bCtrl == Other.bCtrl
                && bAlt == Other.bAlt
                && bCmd == Other.bCmd);
    }
 
    bool operator<(const FInputActionKeyMapping& Other) const
    {
        bool bResult = false;
        if (ActionName.LexicalLess(Other.ActionName))
        {
            bResult = true;
        }
        else if (ActionName == Other.ActionName)
        {
            bResult = (Key < Other.Key);
        }
        return bResult;
    }
 
    FInputActionKeyMapping(const FName InActionName = NAME_None, const FKey InKey = EKeys::Invalid, const bool bInShift = false, const bool bInCtrl = false, const bool bInAlt = false, const bool bInCmd = false)
        : ActionName(InActionName)
        , bShift(bInShift)
        , bCtrl(bInCtrl)
        , bAlt(bInAlt)
        , bCmd(bInCmd)
        , Key(InKey)
    {}
};
 
USTRUCT( BlueprintType )
struct FInputAxisKeyMapping
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FName AxisName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    float Scale;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Input")
    FKey Key;
 
    bool operator==(const FInputAxisKeyMapping& Other) const
    {
        return (   AxisName == Other.AxisName
                && Key == Other.Key
                && Scale == Other.Scale);
    }
 
    bool operator<(const FInputAxisKeyMapping& Other) const
    {
        bool bResult = false;
        if (AxisName.LexicalLess(Other.AxisName))
        {
            bResult = true;
        }
        else if (AxisName == Other.AxisName)
        {
            if (Key < Other.Key)
            {
                bResult = true;
            }
            else if (Key == Other.Key)
            {
                bResult = (Scale < Other.Scale);
 
            }
        }
        return bResult;
    }
 
    FInputAxisKeyMapping(const FName InAxisName = NAME_None, const FKey InKey = EKeys::Invalid, const float InScale = 1.f)
        : AxisName(InAxisName)
        , Scale(InScale)
        , Key(InKey)
    {}
};
 
 
USTRUCT(BlueprintType)
struct UE_DEPRECATED(5.7, "Speech mappings are deprecated. These were only used by a now deprecated platform.") FInputActionSpeechMapping
{
    GENERATED_USTRUCT_BODY()
 
    static FName GetKeyCategory()
    {
        return FName(TEXT("Speech"));
    }
    FName GetActionName() const
    {
        return ActionName;
    }
    FName GetSpeechKeyword() const
    {
        return SpeechKeyword;
    }
    FName GetKeyName() const
    {
        return FName(*FString::Printf(TEXT("%s_%s"), *GetKeyCategory().ToString(), *SpeechKeyword.ToString()));
    }
private:
    UPROPERTY(EditAnywhere, Category="Input")
    FName ActionName;
 
    UPROPERTY(EditAnywhere, Category="Input")
    FName SpeechKeyword;
public:
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    bool operator==(const FInputActionSpeechMapping& Other) const
    {
        return (   ActionName == Other.ActionName
                && SpeechKeyword == Other.SpeechKeyword);
    }
 
    bool operator<(const FInputActionSpeechMapping& Other) const
    {
        bool bResult = false;
        if (ActionName.LexicalLess(Other.ActionName))
        {
            bResult = true;
        }
        else if (ActionName == Other.ActionName)
        {
            bResult = (SpeechKeyword.LexicalLess(Other.SpeechKeyword));
        }
        return bResult;
    }
 
    FInputActionSpeechMapping(const FName InActionName = NAME_None, const FName InSpeechKeyword = NAME_None)
        : ActionName(InActionName)
        , SpeechKeyword(InSpeechKeyword)
    {}
    
    ~FInputActionSpeechMapping() = default;
    FInputActionSpeechMapping(const FInputActionSpeechMapping&) = default;
    FInputActionSpeechMapping(FInputActionSpeechMapping&&) = default;
    FInputActionSpeechMapping& operator=(const FInputActionSpeechMapping&) = default;
    FInputActionSpeechMapping& operator=(FInputActionSpeechMapping&&) = default;
    
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
};
 
struct UE_DEPRECATED(5.6, "Use FInputKeyEventArgs instead") FInputKeyParams
{
    FInputKeyParams() = default;
    
    FInputKeyParams(FKey InKey, enum EInputEvent InEvent, FVector InDelta, bool bGamepadOverride = false, FInputDeviceId InInputDevice = INPUTDEVICEID_NONE)
        : Key(InKey)
        , InputDevice(InInputDevice)
        , Event(InEvent)
        , Delta(InDelta)
        , bIsGamepadOverride(bGamepadOverride)
    {};
 
    FInputKeyParams(FKey InKey, enum EInputEvent InEvent, double InDelta, bool bGamepadOverride = false, FInputDeviceId InInputDevice = INPUTDEVICEID_NONE)
        : Key(InKey)
        , InputDevice(InInputDevice)
        , Event(InEvent)
        , Delta(FVector(InDelta, 0.0, 0.0))
        , bIsGamepadOverride(bGamepadOverride)
    {};
    
    FInputKeyParams(FKey InKey, double InDelta, float InDeltaTime, int32 InNumSamples, bool bGamepadOverride = false, FInputDeviceId InInputDevice = INPUTDEVICEID_NONE)
        : Key(InKey)
        , InputDevice(InInputDevice)
        , NumSamples(InNumSamples)
        , DeltaTime(InDeltaTime)
        , Delta(FVector(InDelta, 0.0, 0.0))
        , bIsGamepadOverride(bGamepadOverride)
    {};
 
    FInputKeyParams(FKey InKey, FVector InDelta, float InDeltaTime, int32 InNumSamples, bool bGamepadOverride = false, FInputDeviceId InInputDevice = INPUTDEVICEID_NONE)
        : Key(InKey)
        , InputDevice(InInputDevice)
        , NumSamples(InNumSamples)
        , DeltaTime(InDeltaTime)
        , Delta(InDelta)
        , bIsGamepadOverride(bGamepadOverride)
    {};
 
    FKey Key = EKeys::Invalid;
 
    FInputDeviceId InputDevice = INPUTDEVICEID_NONE;
 
    enum EInputEvent Event = EInputEvent::IE_Pressed;
 
    int32 NumSamples = 0;
 
    float DeltaTime = 1 / 60.f;
    
    FVector Delta = FVector::ZeroVector;
 
    bool bIsGamepadOverride = false;
 
    bool IsGamepad() const { return Key.IsGamepadKey() || bIsGamepadOverride; }
 
    double Get1DAxisDelta() const { return Delta.X; }
 
    FVector2D Get2DAxisDelta() const { return FVector2D((float)Delta.X, (float)Delta.Y); }
 
    FVector Get3DAxisDelta() const { return Delta; }
};
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogPlayerInput, Log, All);
 
UCLASS(config=Input, transient, MinimalAPI)
class UPlayerInput : public UObject
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API UPlayerInput();
 
    // NOTE: These touch vectors are calculated and set directly, they do not go through the .ini Bindings
    // Touch locations, from 0..1 (0,0 is top left, 1,1 is bottom right), the Z component is > 0 if the touch is currently held down
    // @todo: We have 10 touches to match the number of Touch* entries in EKeys (not easy to make this an enum or define or anything)
    FVector Touches[EKeys::NUM_TOUCH_KEYS];
 
    TMap<uint32, FVector> TouchEventLocations;
 
    // Mouse smoothing sample data
    float ZeroTime[2];    
    float SmoothedMouse[2];    
    int32 MouseSamples;    
    float MouseSamplingTotal;    
private:
    TEnumAsByte<EInputEvent> CurrentEvent;
 
public:
    UPROPERTY(config, EditAnywhere, Category = "Input")
    TArray<struct FKeyBind> DebugExecBindings;
 
    TArray<struct FInputAxisConfigEntry> AxisConfig;
 
    TArray<struct FInputActionKeyMapping> ActionMappings;
 
    TArray<struct FInputAxisKeyMapping> AxisMappings;
 
    UPROPERTY(config, EditAnywhere, Category = "Input")
    TArray<FName> InvertedAxis;
 
    ENGINE_API bool GetAxisProperties(const FKey AxisKey, FInputAxisProperties& AxisProperties);
 
    ENGINE_API void SetAxisProperties(const FKey AxisKey, const FInputAxisProperties& AxisProperties);
 
    ENGINE_API void SetMouseSensitivity(const float SensitivityX, const float SensitivityY);
 
    UFUNCTION(exec)
    void SetMouseSensitivity(const float Sensitivity) { SetMouseSensitivity(Sensitivity, Sensitivity); }
 
    UFUNCTION(exec)
    ENGINE_API void SetBind(FName BindName, const FString& Command);
 
    ENGINE_API float GetMouseSensitivityX();
 
    ENGINE_API float GetMouseSensitivityY();
 
    ENGINE_API bool GetInvertAxisKey(const FKey AxisKey);
 
    ENGINE_API bool GetInvertAxis(const FName AxisName);
 
    UFUNCTION(exec)
    ENGINE_API void InvertAxisKey(const FKey AxisKey);
 
    UFUNCTION(exec)
    ENGINE_API void InvertAxis(const FName AxisName);
 
    UFUNCTION(exec)
    ENGINE_API void ClearSmoothing();
 
    ENGINE_API void AddActionMapping(const FInputActionKeyMapping& KeyMapping);
 
    ENGINE_API void RemoveActionMapping(const FInputActionKeyMapping& KeyMapping);
 
    ENGINE_API void AddAxisMapping(const FInputAxisKeyMapping& KeyMapping);
 
    ENGINE_API void RemoveAxisMapping(const FInputAxisKeyMapping& KeyMapping);
 
    static ENGINE_API void AddEngineDefinedActionMapping(const FInputActionKeyMapping& ActionMapping);
 
    static ENGINE_API void AddEngineDefinedAxisMapping(const FInputAxisKeyMapping& AxisMapping);
 
    ENGINE_API void ForceRebuildingKeyMaps(const bool bRestoreDefaults = false);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Input")
    ENGINE_API APlayerController* GetOuterAPlayerController() const;
 
    ENGINE_API ULocalPlayer* GetOwningLocalPlayer() const;
    
private:
 
    struct FActionKeyDetails
    {
        TArray<FInputActionKeyMapping> Actions;
 
        FInputChord CapturingChord;
    };
 
    struct FAxisKeyDetails
    {
        TArray<FInputAxisKeyMapping> KeyMappings;
 
        uint8 bInverted:1;
 
        FAxisKeyDetails()
            : bInverted(false)
        {
        }
    };
 
    TMap<FKey,FInputAxisProperties> AxisProperties;
 
    mutable TMap<FName,FActionKeyDetails> ActionKeyMap;
 
    mutable TMap<FName,FAxisKeyDetails> AxisKeyMap;
 
    TMap<FKey,FKeyState> KeyStateMap;
 
    mutable uint32 KeyMapBuildIndex;
 
    mutable uint8 bKeyMapsBuilt:1;
 
public:
    
    //~ Begin UObject Interface
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual UWorld* GetWorld() const override;
    //~ End UObject Interface
 
    ENGINE_API virtual void FlushPressedKeys();
 
    ENGINE_API void FlushPressedActionBindingKeys(FName ActionName);
 
    UE_DEPRECATED(5.6, "Use the version which takes a FInputKeyEventArgs instead.")
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    ENGINE_API virtual bool InputKey(const FInputKeyParams& Params) final;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API virtual bool InputKey(const FInputKeyEventArgs& Params);
 
    UE_DEPRECATED(5.6, "Use the version which takes a FInputDeviceId and Timestamp instead.")
    ENGINE_API bool InputTouch(uint32 Handle, ETouchType::Type Type, const FVector2D& TouchLocation, float Force, FDateTime DeviceTimestamp, uint32 TouchpadIndex);
    
    ENGINE_API bool InputTouch(
        const FInputDeviceId DeviceId,
        uint32 Handle,
        ETouchType::Type Type,
        const FVector2D& TouchLocation,
        float Force,
        uint32 TouchpadIndex,
        const uint64 Timestamp);
 
    UE_DEPRECATED(5.6, "Use the version which takes in a FInputDeviceId and a timestamp instead.")
    ENGINE_API bool InputMotion(const FVector& Tilt, const FVector& RotationRate, const FVector& Gravity, const FVector& Acceleration);
 
    ENGINE_API bool InputMotion(
        const FInputDeviceId DeviceId,
        const FVector& Tilt,
        const FVector& RotationRate,
        const FVector& Gravity,
        const FVector& Acceleration,
        const uint64 Timestamp);
 
    UE_DEPRECATED(5.6, "Use the version which takes a device id and timestamp instead.")
    ENGINE_API bool InputGesture(const FKey Gesture, const EInputEvent Event, const float Value);
 
    ENGINE_API bool InputGesture(
        const FInputDeviceId DeviceId,
        const FKey Gesture,
        const EInputEvent Event,
        const float Value,
        const uint64 Timestamp);
 
    ENGINE_API void UpdatePinchStartDistance();
 
    ENGINE_API void Tick(float DeltaTime);
 
    ENGINE_API virtual void ProcessInputStack(const TArray<UInputComponent*>& InputComponentStack, const float DeltaTime, const bool bGamePaused);
 
protected:
    
    ENGINE_API virtual void EvaluateKeyMapState(const float DeltaTime, const bool bGamePaused, OUT TArray<TPair<FKey, FKeyState*>>& KeysWithEvents);
 
    ENGINE_API virtual void EvaluateInputDelegates(const TArray<UInputComponent*>& InputComponentStack, const float DeltaTime, const bool bGamePaused, const TArray<TPair<FKey, FKeyState*>>& KeysWithEvents);
 
    virtual void PrepareInputDelegatesForEvaluation(const TArray<UInputComponent*>& InputComponentStack, const float DeltaTime, const bool bGamePaused, const TArray<TPair<FKey, FKeyState*>>& KeysWithEvents) {}
 
    ENGINE_API virtual bool EvaluateInputComponentDelegates(UInputComponent* const IC, const TArray<TPair<FKey, FKeyState*>>& KeysWithEvents, const float DeltaTime, const bool bGamePaused);
    
    ENGINE_API virtual void EvaluateBlockedInputComponent(UInputComponent* InputComponent);
    
public:
 
    ENGINE_API void DiscardPlayerInput();
 
    ENGINE_API virtual float SmoothMouse(float aMouse, uint8& SampleCount, int32 Index);
 
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
 
    FKeyState* GetKeyState(FKey InKey) { return KeyStateMap.Find(InKey); }
    const FKeyState* GetKeyState(FKey InKey) const { return KeyStateMap.Find(InKey); }
 
    ENGINE_API bool IsPressed( FKey InKey ) const;
    
    ENGINE_API bool WasJustPressed( FKey InKey ) const;
 
    ENGINE_API bool WasJustReleased( FKey InKey ) const;
 
    ENGINE_API float GetTimeDown( FKey InKey ) const;
 
    ENGINE_API float GetKeyValue( FKey InKey ) const;
 
    ENGINE_API float GetRawKeyValue( FKey InKey ) const;
 
    ENGINE_API FVector GetProcessedVectorKeyValue(FKey InKey) const;
 
    ENGINE_API FVector GetRawVectorKeyValue(FKey InKey) const;
 
    ENGINE_API bool IsAltPressed() const;
 
    ENGINE_API bool IsCtrlPressed() const;
 
    ENGINE_API bool IsShiftPressed() const;
 
    ENGINE_API bool IsCmdPressed() const;
 
    uint32 GetKeyMapBuildIndex() const { return KeyMapBuildIndex; }
 
#if !UE_BUILD_SHIPPING
    ENGINE_API bool Exec(UWorld* UInWorld, const TCHAR* Cmd,FOutputDevice& Ar);
 
    ENGINE_API FString GetBind(FKey Key);
 
    ENGINE_API FKeyBind GetExecBind(FString const& ExecCommand);
 
    ENGINE_API bool ExecInputCommands( UWorld* InWorld, const TCHAR* Cmd, class FOutputDevice& Ar);
#endif
 
    ENGINE_API virtual const TArray<FInputActionKeyMapping>& GetKeysForAction(const FName ActionName) const;
 
    ENGINE_API virtual const TArray<FInputAxisKeyMapping>& GetKeysForAxis(const FName AxisName) const;
 
    static const TArray<FInputActionKeyMapping>& GetEngineDefinedActionMappings() { return EngineDefinedActionMappings; }
    static const TArray<FInputAxisKeyMapping>& GetEngineDefinedAxisMappings() { return EngineDefinedAxisMappings; }
 
protected:
    TMap<FKey, FKeyState>& GetKeyStateMap()
    { return KeyStateMap; }
 
    ENGINE_API virtual FVector MassageVectorAxisInput(FKey Key, FVector RawValue);
 
    ENGINE_API virtual float MassageAxisInput(FKey Key, float RawValue);
 
private:
 
    ENGINE_API void ProcessNonAxesKeys(FKey Inkey, FKeyState* KeyState);
    
    // finished processing input for this frame, clean up for next update
    ENGINE_API void FinishProcessingPlayerInput();
 
    ENGINE_API bool KeyEventOccurred(FKey Key, EInputEvent Event, TArray<uint32>& EventIndices, const FKeyState* KeyState = nullptr) const;
 
    /* Collects the chords and the delegates they invoke for an action binding
     * @param ActionBinding - the action to determine whether it occurred
     * @param bGamePaused - whether the game is currently paused
     * @param FoundChords - the list of chord/delegate pairs to add to
     * @param KeysToConsume - array to collect the keys associated with this binding that should be consumed
     */
    ENGINE_API void GetChordsForAction(const FInputActionBinding& ActionBinding, const bool bGamePaused, TArray<struct FDelegateDispatchDetails>& FoundChords, TArray<FKey>& KeysToConsume);
 
    /* Helper function for GetChordsForAction to examine each keymapping that belongs to the ActionBinding
     * @param KeyMapping - the key mapping to determine whether it occured
     * @param ActionBinding - the action to determine whether it occurred
     * @param bGamePaused - whether the game is currently paused
     * @param FoundChords - the list of chord/delegate pairs to add to
     * @param KeysToConsume - array to collect the keys associated with this binding that should be consumed
     */
    ENGINE_API void GetChordsForKeyMapping(const FInputActionKeyMapping& KeyMapping, const FInputActionBinding& ActionBinding, const bool bGamePaused, TArray<FDelegateDispatchDetails>& FoundChords, TArray<FKey>& KeysToConsume, const FKeyState* KeyState = nullptr);
 
    /* Collects the chords and the delegates they invoke for a key binding
     * @param KeyBinding - the key to determine whether it occurred
     * @param bGamePaused - whether the game is currently paused
     * @param FoundChords - the list of chord/delegate pairs to add to
     * @param KeysToConsume - array to collect the keys associated with this binding that should be consumed
     */
    ENGINE_API void GetChordForKey(const FInputKeyBinding& KeyBinding, const bool bGamePaused, TArray<struct FDelegateDispatchDetails>& FoundChords, TArray<FKey>& KeysToConsume, const FKeyState* KeyState = nullptr);
 
    /* Returns the summed values of all the components of this axis this frame
     * @param AxisBinding - the action to determine if it ocurred
     * @param KeysToConsume - array to collect the keys associated with this binding that should be consumed
     * @param bHadAnyNonConsumedKeys - If false, then all keys related to the axis binding have been consumed and there were none that could be used to determine the value
     *
     * @return The value of the axis based on the all the key mappings to it added together
     */
    ENGINE_API float DetermineAxisValue(const FInputAxisBinding& AxisBinding, const bool bGamePaused, TArray<FKey>& KeysToConsume, OUT bool& bHadAnyNonConsumedKeys) const;
 
    inline void ConditionalBuildKeyMappings() const
    {
        if (!bKeyMapsBuilt)
        {
            ConditionalBuildKeyMappings_Internal();
        }
    }
 
    ENGINE_API virtual void ConditionalBuildKeyMappings_Internal() const;
 
    ENGINE_API void ConsumeKey(FKey Key);
 
    ENGINE_API bool IsKeyConsumed(FKey Key, const FKeyState* KeyState = nullptr) const;
 
protected:
 
    ENGINE_API void ConditionalInitAxisProperties();
 
    ENGINE_API virtual bool IsKeyHandledByAction(FKey Key) const;
 
    ENGINE_API void GetActionsBoundToKey(UInputComponent* InputComponent, FKey Key, TArray<TSharedPtr<FInputActionBinding>>& Actions);
 
private:
 
    // @todo: Move this up to Slate?
    FGestureRecognizer GestureRecognizer;
    friend FGestureRecognizer;
 
    static ENGINE_API const TArray<FInputActionKeyMapping> NoKeyMappings;
 
    static ENGINE_API const TArray<FInputAxisKeyMapping> NoAxisMappings;
 
    static ENGINE_API TArray<FInputActionKeyMapping> EngineDefinedActionMappings;
 
    static ENGINE_API TArray<FInputAxisKeyMapping> EngineDefinedAxisMappings;
 
    // Temporary array used as part of input processing
    TArray<uint32> EventIndices;
 
    uint32 EventCount;
 
    float LastTimeDilation;
 
    friend class UEnhancedPlayerInput;  // TEMP: Support for ongoing input rework
};