InputComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "InputCoreTypes.h"
#include "Components/ActorComponent.h"
#include "Framework/Commands/InputChord.h"
#include "InputComponent.generated.h"
 
class UPlayerInput;
 
template<class DelegateType, class DynamicDelegateType>
struct TInputUnifiedDelegate
{
    TInputUnifiedDelegate() {};
    TInputUnifiedDelegate(DelegateType D) : FuncDelegate(MakeShared<DelegateType>(MoveTemp(D))) {};
    TInputUnifiedDelegate(DynamicDelegateType D) : FuncDynDelegate(MakeShared<DynamicDelegateType>(MoveTemp(D))) {};
 
    inline bool IsBound() const
    {
        return ((FuncDelegate.IsValid() && FuncDelegate->IsBound()) || (FuncDynDelegate.IsValid() && FuncDynDelegate->IsBound()));
    }
 
    inline bool IsBoundToObject(void const* Object) const
    {
        if (FuncDelegate.IsValid())
        {
            if (FuncDelegate->IsBound())
            {
                return FuncDelegate->IsBoundToObject(Object);
            }
        }
        else if (FuncDynDelegate.IsValid())
        {
            if (FuncDynDelegate->IsBound())
            {
                return FuncDynDelegate->IsBoundToObject(Object);
            }
        }
 
        return false;
    }
 
    template< class UserClass >
    inline void BindDelegate(UserClass* Object, typename DelegateType::template TMethodPtr< UserClass > Func)
    {
        FuncDynDelegate.Reset();;
        FuncDelegate = MakeShared<DelegateType>(DelegateType::CreateUObject(Object, Func));
    }
 
    inline void BindDelegate(UObject* Object, const FName FuncName)
    {
        FuncDelegate.Reset();
        FuncDynDelegate = MakeShared<DynamicDelegateType>();
        FuncDynDelegate->BindUFunction(Object, FuncName);
    }
 
    DelegateType& GetDelegateForManualSet()
    {
        FuncDynDelegate.Reset();
        FuncDelegate = MakeShared<DelegateType>();
        return *FuncDelegate;
    }
 
    inline void Unbind()
    {
        FuncDelegate.Reset();
        FuncDynDelegate.Reset();
    }
 
    inline const DelegateType& GetDelegate() const
    {
        return (FuncDelegate.IsValid() ? *FuncDelegate : UnboundDelegate);
    }
 
    inline const DynamicDelegateType& GetDynamicDelegate() const
    {
        return (FuncDynDelegate.IsValid() ? *FuncDynDelegate : UnboundDynamicDelegate);
    }
 
protected:
    TSharedPtr<DelegateType> FuncDelegate;
    TSharedPtr<DynamicDelegateType> FuncDynDelegate;
 
    static const DelegateType UnboundDelegate;
    static const DynamicDelegateType UnboundDynamicDelegate;
};
 
template<class DelegateType, class DynamicDelegateType>
const DelegateType TInputUnifiedDelegate<DelegateType, DynamicDelegateType>::UnboundDelegate;
 
template<class DelegateType, class DynamicDelegateType>
const DynamicDelegateType TInputUnifiedDelegate<DelegateType, DynamicDelegateType>::UnboundDynamicDelegate;
 
 
struct FInputBinding
{
    uint8 bConsumeInput:1;
 
    uint8 bExecuteWhenPaused:1;
 
    FInputBinding()
        : bConsumeInput(true)
        , bExecuteWhenPaused(false)
    {}
};
 
DECLARE_DELEGATE( FInputActionHandlerSignature );
DECLARE_DELEGATE_OneParam( FInputActionHandlerWithKeySignature, FKey );
DECLARE_DYNAMIC_DELEGATE_OneParam( FInputActionHandlerDynamicSignature, FKey, Key );
 
struct FInputActionUnifiedDelegate
{
    FInputActionUnifiedDelegate() : BoundDelegateType(EBoundDelegate::Unbound) {};
    FInputActionUnifiedDelegate(FInputActionHandlerSignature D) : FuncDelegate(MakeShared<FInputActionHandlerSignature>(MoveTemp(D))), BoundDelegateType(EBoundDelegate::Delegate) {};
    FInputActionUnifiedDelegate(FInputActionHandlerWithKeySignature D) : FuncDelegateWithKey(MakeShared<FInputActionHandlerWithKeySignature>(MoveTemp(D))), BoundDelegateType(EBoundDelegate::DelegateWithKey) {};
    FInputActionUnifiedDelegate(FInputActionHandlerDynamicSignature D) : FuncDynDelegate(MakeShared<FInputActionHandlerDynamicSignature>(MoveTemp(D))), BoundDelegateType(EBoundDelegate::DynamicDelegate) {};
 
    inline bool IsBound() const
    {
        switch (BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            return FuncDelegate->IsBound();
 
        case EBoundDelegate::DelegateWithKey:
            return FuncDelegateWithKey->IsBound();
 
        case EBoundDelegate::DynamicDelegate:
            return FuncDynDelegate->IsBound();
        }
 
        return false;
    }
 
    inline bool IsBoundToObject(FDelegateUserObjectConst Object) const
    {
        switch (BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            return (FuncDelegate->IsBound() && FuncDelegate->IsBoundToObject(Object));
 
        case EBoundDelegate::DelegateWithKey:
            return (FuncDelegateWithKey->IsBound() && FuncDelegateWithKey->IsBoundToObject(Object));
 
        case EBoundDelegate::DynamicDelegate:
            return (FuncDynDelegate->IsBound() && FuncDynDelegate->IsBoundToObject(Object));
        }
 
        return false;
    }
 
    inline const UObject* GetUObject() const
    {
        switch (BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            return FuncDelegate->GetUObject();
 
        case EBoundDelegate::DelegateWithKey:
            return FuncDelegateWithKey->GetUObject();
 
        case EBoundDelegate::DynamicDelegate:
            return FuncDynDelegate->GetUObject();
        }
 
        return nullptr;
    }
 
    inline const void* GetObject() const
    {
        switch (BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            return FuncDelegate->GetObjectForTimerManager();
 
        case EBoundDelegate::DelegateWithKey:
            return FuncDelegateWithKey->GetObjectForTimerManager();
 
        case EBoundDelegate::DynamicDelegate:
            return FuncDynDelegate->GetUObject();
        }
 
        return nullptr;
    }
 
    template< class UserClass >
    inline void BindDelegate(UserClass* Object, typename FInputActionHandlerSignature::template TMethodPtr< UserClass > Func)
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::Delegate;
        FuncDelegate = MakeShared<FInputActionHandlerSignature>(FInputActionHandlerSignature::CreateUObject(Object, Func));
    }
 
    template< class UserClass >
    inline void BindDelegate(UserClass* Object, typename FInputActionHandlerWithKeySignature::template TMethodPtr< UserClass > Func)
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::DelegateWithKey;
        FuncDelegateWithKey = MakeShared<FInputActionHandlerWithKeySignature>(FInputActionHandlerWithKeySignature::CreateUObject(Object, Func));
    }
 
    template< class DelegateType, class UserClass, typename... VarTypes >
    inline void BindDelegate(UserClass* Object, typename DelegateType::template TMethodPtr< UserClass > Func, VarTypes... Vars)
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::Delegate;
        FuncDelegate = MakeShared<FInputActionHandlerSignature>(FInputActionHandlerSignature::CreateUObject(Object, Func, Vars...));
    }
 
    inline void BindDelegate(UObject* Object, const FName FuncName)
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::DynamicDelegate;
        FuncDynDelegate = MakeShared<FInputActionHandlerDynamicSignature>();
        FuncDynDelegate->BindUFunction(Object, FuncName);
    }
 
    FInputActionHandlerSignature& GetDelegateForManualSet()
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::Delegate;
        FuncDelegate = MakeShared<FInputActionHandlerSignature>();
        return *FuncDelegate;
    }
 
    FInputActionHandlerWithKeySignature& GetDelegateWithKeyForManualSet()
    {
        Unbind();
        BoundDelegateType = EBoundDelegate::DelegateWithKey;
        FuncDelegateWithKey = MakeShared<FInputActionHandlerWithKeySignature>();
        return *FuncDelegateWithKey;
    }
 
    inline void Unbind()
    {
        switch(BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            FuncDelegate->Unbind();
            break;
 
        case EBoundDelegate::DelegateWithKey:
            FuncDelegateWithKey->Unbind();
            break;
 
        case EBoundDelegate::DynamicDelegate:
            FuncDynDelegate->Unbind();
            break;
        }
        BoundDelegateType = EBoundDelegate::Unbound;
    }
 
    inline void Execute(const FKey Key) const
    {
        switch(BoundDelegateType)
        {
        case EBoundDelegate::Delegate:
            if (FuncDelegate->IsBound())
            {
                FuncDelegate->Execute();
            }
            break;
 
        case EBoundDelegate::DelegateWithKey:
            if (FuncDelegateWithKey->IsBound())
            {
                FuncDelegateWithKey->Execute(Key);
            }
            break;
 
        case EBoundDelegate::DynamicDelegate:
            if (FuncDynDelegate->IsBound())
            {
                FuncDynDelegate->Execute(Key);
            }
            break;
        }
    }
private:
    TSharedPtr<FInputActionHandlerSignature> FuncDelegate;
    TSharedPtr<FInputActionHandlerWithKeySignature> FuncDelegateWithKey;
    TSharedPtr<FInputActionHandlerDynamicSignature> FuncDynDelegate;
 
    enum class EBoundDelegate : uint8
    {
        Unbound,
        Delegate,
        DelegateWithKey,
        DynamicDelegate
    };
 
    EBoundDelegate BoundDelegateType;
};
 
struct FInputActionBinding : public FInputBinding
{
private:
    uint8 bPaired:1;
 
public:
    TEnumAsByte<EInputEvent> KeyEvent;
 
private:
    FName ActionName;
 
    int32 Handle;
 
public:
    FInputActionUnifiedDelegate ActionDelegate;
 
    FInputActionBinding()
        : FInputBinding()
        , bPaired(false)
        , KeyEvent(EInputEvent::IE_Pressed)
        , ActionName(NAME_None)
        , Handle(INDEX_NONE)
    { }
 
    FInputActionBinding(const FName InActionName, const  EInputEvent InKeyEvent)
        : FInputBinding()
        , bPaired(false)
        , KeyEvent(InKeyEvent)
        , ActionName(InActionName)
        , Handle(INDEX_NONE)
    { }
 
    FName GetActionName() const { return ActionName; }
    bool IsPaired() const { return bPaired; }
    int32 GetHandle() const { return Handle; }
 
    bool operator==(const FInputActionBinding& Rhs)
    {
        return (IsValid() && GetHandle() == Rhs.GetHandle());
    }
 
    bool IsValid() { return (Handle != INDEX_NONE); }
 
    void GenerateNewHandle();
 
    friend class UInputComponent;
};
 
struct FInputKeyBinding : public FInputBinding
{
    TEnumAsByte<EInputEvent> KeyEvent;
 
    FInputChord Chord;
 
    FInputActionUnifiedDelegate KeyDelegate;
 
    FInputKeyBinding()
        : FInputBinding()
        , KeyEvent(EInputEvent::IE_Pressed)
    { }
 
    FInputKeyBinding(const FInputChord InChord, const EInputEvent InKeyEvent)
        : FInputBinding()
        , KeyEvent(InKeyEvent)
        , Chord(InChord)
    { }
};
 
 
DECLARE_DELEGATE_TwoParams( FInputTouchHandlerSignature, ETouchIndex::Type, FVector );
DECLARE_DYNAMIC_DELEGATE_TwoParams( FInputTouchHandlerDynamicSignature, ETouchIndex::Type, FingerIndex, FVector, Location );
 
struct FInputTouchUnifiedDelegate : public TInputUnifiedDelegate<FInputTouchHandlerSignature, FInputTouchHandlerDynamicSignature>
{
    inline void Execute(const ETouchIndex::Type FingerIndex, const FVector Location) const
    {
        if (FuncDelegate.IsValid())
        {
            if (FuncDelegate->IsBound())
            {
                FuncDelegate->Execute(FingerIndex, Location);
            }
        }
        else if (FuncDynDelegate.IsValid())
        {
            if (FuncDynDelegate->IsBound())
            {
                FuncDynDelegate->Execute(FingerIndex, Location);
            }
        }
    }
};
 
struct FInputTouchBinding : public FInputBinding
{
    TEnumAsByte<EInputEvent> KeyEvent;
 
    FInputTouchUnifiedDelegate TouchDelegate;
 
    FInputTouchBinding()
        : FInputBinding()
        , KeyEvent(EInputEvent::IE_Pressed)
    { }
 
    FInputTouchBinding(const enum EInputEvent InKeyEvent)
        : FInputBinding()
        , KeyEvent(InKeyEvent)
    { }
};
 
 
DECLARE_DELEGATE_OneParam( FInputAxisHandlerSignature, float );
DECLARE_DYNAMIC_DELEGATE_OneParam( FInputAxisHandlerDynamicSignature, float, AxisValue );
 
struct FInputAxisUnifiedDelegate : public TInputUnifiedDelegate<FInputAxisHandlerSignature, FInputAxisHandlerDynamicSignature>
{
    inline void Execute(const float AxisValue) const
    {
        if (FuncDelegate.IsValid())
        {
            if (FuncDelegate->IsBound())
            {
                FuncDelegate->Execute(AxisValue);
            }
        }
        else if (FuncDynDelegate.IsValid())
        {
            if (FuncDynDelegate->IsBound())
            {
                FuncDynDelegate->Execute(AxisValue);
            }
        }
    }
};
 
 
struct FInputAxisBinding : public FInputBinding
{
    FName AxisName;
 
    FInputAxisUnifiedDelegate AxisDelegate;
 
    float AxisValue;
 
    FInputAxisBinding()
        : FInputBinding()
        , AxisName(NAME_None)
        , AxisValue(0.f)
    { }
 
    FInputAxisBinding(const FName InAxisName)
        : FInputBinding()
        , AxisName(InAxisName)
        , AxisValue(0.f)
    { }
};
 
 
struct FInputAxisKeyBinding : public FInputBinding
{
    float AxisValue;
 
    FKey AxisKey;
 
    FInputAxisUnifiedDelegate AxisDelegate;
 
    FInputAxisKeyBinding()
        : FInputBinding()
        , AxisValue(0.f)
    { }
 
    FInputAxisKeyBinding(const FKey InAxisKey)
        : FInputBinding()
        , AxisValue(0.f)
        , AxisKey(InAxisKey)
    {
        ensure(AxisKey.IsAxis1D());
    }
};
 
 
DECLARE_DELEGATE_OneParam(FInputVectorAxisHandlerSignature, FVector);
DECLARE_DYNAMIC_DELEGATE_OneParam(FInputVectorAxisHandlerDynamicSignature, FVector, AxisValue);
 
struct FInputVectorAxisUnifiedDelegate : public TInputUnifiedDelegate<FInputVectorAxisHandlerSignature, FInputVectorAxisHandlerDynamicSignature>
{
    inline void Execute(const FVector AxisValue) const
    {
        if (FuncDelegate.IsValid())
        {
            if (FuncDelegate->IsBound())
            {
                FuncDelegate->Execute(AxisValue);
            }
        }
        else if (FuncDynDelegate.IsValid())
        {
            if (FuncDynDelegate->IsBound())
            {
                FuncDynDelegate->Execute(AxisValue);
            }
        }
    }
};
 
struct FInputVectorAxisBinding : public FInputBinding
{
    FVector AxisValue;
 
    FKey AxisKey;
 
    FInputVectorAxisUnifiedDelegate AxisDelegate;
 
    FInputVectorAxisBinding()
        : FInputBinding()
    { }
 
    FInputVectorAxisBinding(const FKey InAxisKey)
        : FInputBinding()
        , AxisKey(InAxisKey)
    {
        ensure(AxisKey.IsAxis2D() || AxisKey.IsAxis3D());
    }
};
 
 
DECLARE_DELEGATE_OneParam( FInputGestureHandlerSignature, float );
DECLARE_DYNAMIC_DELEGATE_OneParam( FInputGestureHandlerDynamicSignature, float, Value );
 
struct FInputGestureUnifiedDelegate : public TInputUnifiedDelegate<FInputGestureHandlerSignature, FInputGestureHandlerDynamicSignature>
{
    inline void Execute(const float Value) const
    {
        if (FuncDelegate.IsValid())
        {
            if (FuncDelegate->IsBound())
            {
                FuncDelegate->Execute(Value);
            }
        }
        else if (FuncDynDelegate.IsValid())
        {
            if (FuncDynDelegate->IsBound())
            {
                FuncDynDelegate->Execute(Value);
            }
        }
    }
};
 
 
struct FInputGestureBinding : public FInputBinding
{
    float GestureValue;
 
    FKey GestureKey;
 
    FInputGestureUnifiedDelegate GestureDelegate;
 
    FInputGestureBinding()
        : FInputBinding()
        , GestureValue(0.f)
    { }
 
    FInputGestureBinding(const FKey InGestureKey)
        : FInputBinding()
        , GestureValue(0.f)
        , GestureKey(InGestureKey)
    { }
};
 
 
 
UENUM()
namespace EControllerAnalogStick
{
    enum Type : int
    {
        CAS_LeftStick,
        CAS_RightStick,
        CAS_MAX
    };
}
 
USTRUCT()
struct FCachedKeyToActionInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TWeakObjectPtr<UPlayerInput> PlayerInput;
 
    uint32 KeyMapBuiltForIndex;
 
    TMap<FKey, TArray<TSharedPtr<FInputActionBinding>>> KeyToActionMap;
 
    TArray<TSharedPtr<FInputActionBinding>> AnyKeyToActionMap;
 
    FCachedKeyToActionInfo()
        : PlayerInput(nullptr)
        , KeyMapBuiltForIndex(0)
    {
    }
};
 
UCLASS(NotBlueprintable, transient, config=Input, hidecategories=(Activation, "Components|Activation"), MinimalAPI)
class UInputComponent
    : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
    
    TArray<FInputKeyBinding> KeyBindings;
 
    TArray<FInputTouchBinding> TouchBindings;
 
    TArray<FInputAxisBinding> AxisBindings;
 
    TArray<FInputAxisKeyBinding> AxisKeyBindings;
 
    TArray<FInputVectorAxisBinding> VectorAxisBindings;
 
    TArray<FInputGestureBinding> GestureBindings;
 
private:
    TArray<TSharedPtr<FInputActionBinding>> ActionBindings;
 
    UPROPERTY(Transient, DuplicateTransient)
    TArray<FCachedKeyToActionInfo> CachedKeyToActionInfo;
 
    UFUNCTION()
    ENGINE_API void OnInputOwnerEndPlayed(AActor* InOwner, EEndPlayReason::Type EndPlayReason);
 
public:
    int32 Priority;
 
    uint8 bBlockInput:1;
 
    ENGINE_API virtual void ClearBindingsForObject(UObject* InOwner);
    
    ENGINE_API void ConditionalBuildKeyMap(UPlayerInput* PlayerInput);
 
    ENGINE_API float GetAxisValue( const FName AxisName ) const;
 
    ENGINE_API float GetAxisKeyValue( const FKey AxisKey ) const;
 
    ENGINE_API FVector GetVectorAxisValue( const FKey AxisKey ) const;
 
    ENGINE_API virtual bool HasBindings() const;
 
 
    ENGINE_API FInputActionBinding& AddActionBinding( FInputActionBinding Binding );
 
    ENGINE_API virtual void ClearActionBindings();
 
    FInputActionBinding& GetActionBinding(const int32 BindingIndex) const { return *ActionBindings[BindingIndex].Get(); }
 
    int32 GetNumActionBindings() const { return ActionBindings.Num(); }
 
    ENGINE_API void RemoveActionBinding( const int32 BindingIndex );
    ENGINE_API void RemoveActionBinding(FName ActionName, EInputEvent KeyEvent);
 
    ENGINE_API void RemoveActionBindingForHandle(const int32 Handle);
 
    ENGINE_API void RemoveActionBinding(const FInputActionBinding &BindingToRemove, const int32 BindingIndex);
 
    ENGINE_API void ClearBindingValues();
 
    template<class UserClass>
    FInputActionBinding& BindAction( const FName ActionName, const EInputEvent KeyEvent, UserClass* Object, typename FInputActionHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputActionBinding AB( ActionName, KeyEvent );
        AB.ActionDelegate.BindDelegate(Object, Func);
        return AddActionBinding(MoveTemp(AB));
    }
 
    template<class UserClass>
    FInputActionBinding& BindAction( const FName ActionName, const EInputEvent KeyEvent, UserClass* Object, typename FInputActionHandlerWithKeySignature::TMethodPtr< UserClass > Func )
    {
        FInputActionBinding AB( ActionName, KeyEvent );
        AB.ActionDelegate.BindDelegate(Object, Func);
        return AddActionBinding(MoveTemp(AB));
    }
 
    template< class DelegateType, class UserClass, typename... VarTypes >
    FInputActionBinding& BindAction( const FName ActionName, const EInputEvent KeyEvent, UserClass* Object, typename DelegateType::template TMethodPtr< UserClass > Func, VarTypes... Vars )
    {
        FInputActionBinding AB( ActionName, KeyEvent );
        AB.ActionDelegate.BindDelegate<DelegateType>(Object, Func, Vars...);
        return AddActionBinding(MoveTemp(AB));
    }
 
    template<class UserClass>
    FInputAxisBinding& BindAxis( const FName AxisName, UserClass* Object, typename FInputAxisHandlerSignature::TMethodPtr< UserClass > Func )
    {
        LogDeprecatedBindingWarning(AxisName);
        
        FInputAxisBinding AB( AxisName );
        AB.AxisDelegate.BindDelegate(Object, Func);
        AxisBindings.Emplace(MoveTemp(AB));
        return AxisBindings.Last();
    }
 
    ENGINE_API void RemoveAxisBinding(const FName AxisName);
 
    ENGINE_API void ClearAxisBindings();
 
    FInputAxisBinding& BindAxis( const FName AxisName )
    {
        LogDeprecatedBindingWarning(AxisName);
        
        FInputAxisBinding AB( AxisName );
        AxisBindings.Emplace(MoveTemp(AB));
        return AxisBindings.Last();
    }
 
    template<class UserClass>
    FInputAxisKeyBinding& BindAxisKey( const FKey AxisKey, UserClass* Object, typename FInputAxisHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputAxisKeyBinding AB(AxisKey);
        AB.AxisDelegate.BindDelegate(Object, Func);
        AxisKeyBindings.Emplace(MoveTemp(AB));
        return AxisKeyBindings.Last();
    }
 
    FInputAxisKeyBinding& BindAxisKey( const FKey AxisKey )
    {
        FInputAxisKeyBinding AB(AxisKey);
        AxisKeyBindings.Emplace(MoveTemp(AB));
        return AxisKeyBindings.Last();
    }
 
    ENGINE_API void RemoveAxisKeyBinding( const FKey AxisKey);
 
    template<class UserClass>
    FInputVectorAxisBinding& BindVectorAxis( const FKey AxisKey, UserClass* Object, typename FInputVectorAxisHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputVectorAxisBinding AB(AxisKey);
        AB.AxisDelegate.BindDelegate(Object, Func);
        VectorAxisBindings.Emplace(MoveTemp(AB));
        return VectorAxisBindings.Last();
    }
 
    FInputVectorAxisBinding& BindVectorAxis( const FKey AxisKey )
    {
        FInputVectorAxisBinding AB(AxisKey);
        VectorAxisBindings.Emplace(MoveTemp(AB));
        return VectorAxisBindings.Last();
    }
 
    template<class UserClass>
    FInputKeyBinding& BindKey( const FInputChord Chord, const EInputEvent KeyEvent, UserClass* Object, typename FInputActionHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputKeyBinding KB(Chord, KeyEvent);
        KB.KeyDelegate.BindDelegate(Object, Func);
        KeyBindings.Emplace(MoveTemp(KB));
        return KeyBindings.Last();
    }
 
    template<class UserClass>
    FInputKeyBinding& BindKey( const FKey Key, const EInputEvent KeyEvent, UserClass* Object, typename FInputActionHandlerSignature::TMethodPtr< UserClass > Func )
    {
        return BindKey(FInputChord(Key, false, false, false, false), KeyEvent, Object, Func);
    }
 
    template <class UserClass>
    FInputKeyBinding& BindKey(const FKey Key, const EInputEvent KeyEvent, UserClass* Object, typename FInputActionHandlerWithKeySignature::TMethodPtr<UserClass> Func)
    {
        FInputKeyBinding KB(FInputChord(Key, false, false, false, false), KeyEvent);
        KB.KeyDelegate.BindDelegate(Object, Func);
        KeyBindings.Emplace(MoveTemp(KB));
        return KeyBindings.Last();
    }
 
    template<class UserClass>
    FInputTouchBinding& BindTouch( const EInputEvent KeyEvent, UserClass* Object, typename FInputTouchHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputTouchBinding TB(KeyEvent);
        TB.TouchDelegate.BindDelegate(Object, Func);
        TouchBindings.Emplace(MoveTemp(TB));
        return TouchBindings.Last();
    }
 
    template<class UserClass>
    FInputGestureBinding& BindGesture( const FKey GestureKey, UserClass* Object, typename FInputGestureHandlerSignature::TMethodPtr< UserClass > Func )
    {
        FInputGestureBinding GB(GestureKey);
        GB.GestureDelegate.BindDelegate(Object, Func);
        GestureBindings.Emplace(MoveTemp(GB));
        return GestureBindings.Last();
    }
 
private:
    
    ENGINE_API static void LogDeprecatedBindingWarning(const FName BindingName);
    
    ENGINE_API void GetActionsBoundToKey(UPlayerInput* PlayerInput, FKey Key, TArray<TSharedPtr<FInputActionBinding>>& Actions) const;
 
    friend struct FGetActionsBoundToKey;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.IsInputKeyDown instead."))
    ENGINE_API bool IsControllerKeyDown(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.WasInputKeyJustPressed instead."))
    ENGINE_API bool WasControllerKeyJustPressed(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.WasInputKeyJustReleased instead."))
    ENGINE_API bool WasControllerKeyJustReleased(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputAnalogKeyState instead."))
    ENGINE_API float GetControllerAnalogKeyState(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputVectorKeyState instead."))
    ENGINE_API FVector GetControllerVectorKeyState(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputTouchState instead."))
    ENGINE_API void GetTouchState(int32 FingerIndex, float& LocationX, float& LocationY, bool& bIsCurrentlyPressed) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputKeyTimeDown instead."))
    ENGINE_API float GetControllerKeyTimeDown(FKey Key) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputMouseDelta instead."))
    ENGINE_API void GetControllerMouseDelta(float& DeltaX, float& DeltaY) const;
 
    UFUNCTION(BlueprintCallable, meta=(DeprecatedFunction, DeprecationMessage="Use PlayerController.GetInputAnalogStickState instead."))
    ENGINE_API void GetControllerAnalogStickState(EControllerAnalogStick::Type WhichStick, float& StickX, float& StickY) const;
 
    friend class UEnhancedInputComponent;   // TEMP: Support for ongoing input rework
};
 
struct FGetActionsBoundToKey
{
private:
    static void Get(UInputComponent* InputComponent, UPlayerInput* PlayerInput, FKey Key, TArray<TSharedPtr<FInputActionBinding>>& Actions)
    {
        InputComponent->GetActionsBoundToKey(PlayerInput, Key, Actions);
    }
 
    friend UPlayerInput;
};