InputState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "InputCoreTypes.h"
#include "Math/NumericLimits.h"
#include "Math/Ray.h"
#include "Math/UnrealMath.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "UObject/ObjectMacros.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "InputState.generated.h"
 
class UObject;
 
 
UENUM()
enum class EInputDevices
{
    None = 0,
    Keyboard = 1,
    Mouse = 2,
    Gamepad = 4,
 
    OculusTouch = 8,
    HTCViveWands = 16,
    AnySpatialDevice = OculusTouch | HTCViveWands,
 
    TabletFingers = 1024
};
ENUM_CLASS_FLAGS(EInputDevices);
 
 
 
/*
 * FInputRayHit is returned by various hit-test interface functions.
 * Generally this is intended to be returned as the result of a hit-test with a FInputDeviceRay 
 */
USTRUCT(BlueprintType)
struct FInputRayHit
{
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    bool bHit;
 
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    double HitDepth;
 
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    FVector HitNormal;
 
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    bool bHasHitNormal;
 
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    int32 HitIdentifier;
 
    void* HitOwner;
 
    UPROPERTY(BlueprintReadWrite, Category = InputRayHit)
    TWeakObjectPtr<UObject> HitObject;
 
    void SetHitObject(UObject* InHitObject)
    {
        HitObject = InHitObject;
        HitOwner = InHitObject;
    }
 
    FInputRayHit()
    {
        bHit = false;
        HitDepth = (double)TNumericLimits<float>::Max();
        HitNormal = FVector(0, 0, 1);
        bHasHitNormal = false;
        HitIdentifier = 0;
        HitOwner = nullptr;
        HitObject = nullptr;
    }
 
    explicit FInputRayHit(double HitDepthIn)
    {
        bHit = true;
        HitDepth = HitDepthIn;
        HitNormal = FVector(0, 0, 1);
        bHasHitNormal = false;
        HitIdentifier = 0;
        HitOwner = nullptr;
        HitObject = nullptr;
    }
 
    explicit FInputRayHit(double HitDepthIn, const FVector& HitNormalIn)
    {
        bHit = true;
        HitDepth = HitDepthIn;
        HitNormal = HitNormalIn;
        bHasHitNormal = true;
        HitIdentifier = 0;
        HitOwner = nullptr;
        HitObject = nullptr;
    }
 
};
 
 
 
 
 
USTRUCT(BlueprintType)
struct FDeviceButtonState
{
    GENERATED_BODY()
    
    
    UPROPERTY(transient, BlueprintReadWrite, Category = DeviceButtonState)
    FKey Button;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = DeviceButtonState)
    bool bPressed;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = DeviceButtonState)
    bool bDown;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = DeviceButtonState)
    bool bReleased;
 
    UPROPERTY(Transient, BlueprintReadWrite, Category = DeviceButtonState)
    bool bDoubleClicked;
 
    FDeviceButtonState()
    {
        Button = FKey();
        bPressed = bDown = bReleased = bDoubleClicked = false;
    }
 
    FDeviceButtonState(const FKey& ButtonIn)
    {
        Button = ButtonIn;
        bPressed = bDown = bReleased = bDoubleClicked = false;
    }
 
    void SetStates(bool bPressedIn, bool bDownIn, bool bReleasedIn, bool bDoubleClickedIn = false)
    {
        bPressed = bPressedIn;
        bDown = bDownIn;
        bReleased = bReleasedIn;
        bDoubleClicked = bDoubleClickedIn;
    }
};
 
 
 
USTRUCT(BlueprintType)
struct FKeyboardInputDeviceState
{
    GENERATED_BODY()
    
    
    UPROPERTY(transient, BlueprintReadWrite, Category = KeyboardInputDeviceState)
    FDeviceButtonState ActiveKey;
};
 
 
 
USTRUCT(BlueprintType)
struct FMouseInputDeviceState
{
    GENERATED_BODY()
    
    
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FDeviceButtonState Left;
        
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FDeviceButtonState Middle;
        
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FDeviceButtonState Right;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    float WheelDelta;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FVector2D Position2D;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FVector2D Delta2D;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FRay WorldRay;
 
    FMouseInputDeviceState()
    {
        Left = FDeviceButtonState(EKeys::LeftMouseButton);
        Middle = FDeviceButtonState(EKeys::MiddleMouseButton);
        Right = FDeviceButtonState(EKeys::RightMouseButton);
        WheelDelta = false;
        Position2D = FVector2D::ZeroVector;
        Delta2D = FVector2D::ZeroVector;
        WorldRay = FRay();
    }
};
 
 
 
USTRUCT(BlueprintType)
struct FInputDeviceState
{
    GENERATED_BODY()
 
    
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    EInputDevices InputDevice;
 
    //
    // keyboard modifiers
    //
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    bool bShiftKeyDown;
    
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    bool bAltKeyDown;
    
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    bool bCtrlKeyDown;
    
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    bool bCmdKeyDown;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FKeyboardInputDeviceState Keyboard;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = MouseInputDeviceState)
    FMouseInputDeviceState Mouse;
 
    FInputDeviceState() 
    {
        InputDevice = EInputDevices::None;
        bShiftKeyDown = bAltKeyDown = bCtrlKeyDown = bCmdKeyDown = false;
        Keyboard = FKeyboardInputDeviceState();
        Mouse = FMouseInputDeviceState();
    }
 
    void SetModifierKeyStates(bool bShiftDown, bool bAltDown, bool bCtrlDown, bool bCmdDown) 
    {
        bShiftKeyDown = bShiftDown;
        bAltKeyDown = bAltDown;
        bCtrlKeyDown = bCtrlDown;
        bCmdKeyDown = bCmdDown;
    }
 
    bool IsFromDevice(EInputDevices DeviceType) const
    {
        return ((InputDevice & DeviceType) != EInputDevices::None);
    }
 
 
 
 
    //
    // utility functions to pass as lambdas
    // 
 
    static bool IsShiftKeyDown(const FInputDeviceState& InputState)
    {
        return InputState.bShiftKeyDown;
    }
 
    static bool IsCtrlKeyDown(const FInputDeviceState& InputState)
    {
        return InputState.bCtrlKeyDown;
    }
 
    static bool IsAltKeyDown(const FInputDeviceState& InputState)
    {
        return InputState.bAltKeyDown;
    }
 
    static bool IsCmdKeyDown(const FInputDeviceState& InputState)
    {
        return InputState.bCmdKeyDown;
    }
};
 
 
 
 
USTRUCT(BlueprintType)
struct FInputDeviceRay
{
    GENERATED_BODY()
 
    
    UPROPERTY(transient, BlueprintReadWrite, Category = InputDeviceRay)
    FRay WorldRay;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = InputDeviceRay)
    bool bHas2D = false;
 
    UPROPERTY(transient, BlueprintReadWrite, Category = InputDeviceRay)
    FVector2D ScreenPosition;
 
    // this is required for a USTRUCT
    FInputDeviceRay()
    {
        WorldRay = FRay();
        bHas2D = false;
        ScreenPosition = FVector2D(0, 0);
    }
 
    explicit FInputDeviceRay(const FRay& WorldRayIn)
    {
        WorldRay = WorldRayIn;
        bHas2D = false;
        ScreenPosition = FVector2D(0, 0);
    }
 
    FInputDeviceRay(const FRay& WorldRayIn, const FVector2D& ScreenPositionIn)
    {
        WorldRay = WorldRayIn;
        bHas2D = true;
        ScreenPosition = ScreenPositionIn;
    }
 
    FInputDeviceRay(const FInputDeviceState& Input)
    {
        if (Input.IsFromDevice(EInputDevices::Mouse))
        {
            WorldRay = Input.Mouse.WorldRay;
            bHas2D = true;
            ScreenPosition = Input.Mouse.Position2D;
        }
        else
        {
            ensure(false);
            WorldRay = FRay(FVector::ZeroVector, FVector(0, 0, 1), true);
            ScreenPosition = FVector2D(0, 0);
            bHas2D = false;
        }
    }
};