InputBehavior.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "InputState.h"
#include "Math/NumericLimits.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "InputBehavior.generated.h"
 
UENUM()
enum class EInputCaptureSide
{
    None = 0,
    Left = 1,
    Right = 2,
    Both = 3,
    Any = 99
};
 
struct FInputCaptureData
{
    EInputCaptureSide WhichSide;
    void* CustomData;
 
    FInputCaptureData()
    {
        WhichSide = EInputCaptureSide::None;
        CustomData = nullptr;
    }
};
 
UENUM()
enum class EInputCaptureRequestType
{
    Begin = 1,
    Ignore = 2
};
 
// predeclaration
class UInputBehavior;
 
struct FInputCaptureRequest
{
    UInputBehavior* Source;
    EInputCaptureRequestType Type;
    EInputCaptureSide Side;
 
    double HitDepth;
 
    void* Owner;
 
    FInputCaptureRequest(
        EInputCaptureRequestType type,
        UInputBehavior* behavior,
        EInputCaptureSide whichSide,
        double hitDepth = TNumericLimits<double>::Max()
    )
    {
        this->Type = type;
        this->Source = behavior;
        this->Side = whichSide;
        this->Owner = nullptr;
        this->HitDepth = hitDepth;
    }
 
    static FInputCaptureRequest Begin(
        UInputBehavior* behavior, EInputCaptureSide whichSide, double hitDepth = TNumericLimits<double>::Max()
    )
    {
        return FInputCaptureRequest(EInputCaptureRequestType::Begin, behavior, whichSide, hitDepth);
    }
 
    static FInputCaptureRequest Ignore()
    {
        return FInputCaptureRequest(
            EInputCaptureRequestType::Ignore, nullptr, EInputCaptureSide::Any, TNumericLimits<double>::Max()
        );
    }
 
    friend bool operator<(const FInputCaptureRequest& l, const FInputCaptureRequest& r);
};
 
UENUM()
enum class EInputCaptureState
{
    Begin = 1, // start capturing (which should always be the case if BeginCapture is called)
    Continue = 2, // Behavior wants to continue capturing
    End = 3, // Behavior wants to end capturing
    Ignore = 4 // Behavior ignored this event
};
 
struct FInputCaptureUpdate
{
    EInputCaptureState State;
    UInputBehavior* Source;
    FInputCaptureData Data;
 
    static FInputCaptureUpdate Begin(UInputBehavior* SourceBehavior, EInputCaptureSide WhichSide, void* CustomData = nullptr)
    {
        return FInputCaptureUpdate(EInputCaptureState::Begin, SourceBehavior, WhichSide, CustomData);
    }
 
    static FInputCaptureUpdate Continue()
    {
        return FInputCaptureUpdate(EInputCaptureState::Continue, nullptr, EInputCaptureSide::Any);
    }
    static FInputCaptureUpdate End()
    {
        return FInputCaptureUpdate(EInputCaptureState::End, nullptr, EInputCaptureSide::Any);
    }
    static FInputCaptureUpdate Ignore()
    {
        return FInputCaptureUpdate(EInputCaptureState::Ignore, nullptr, EInputCaptureSide::Any);
    }
 
    FInputCaptureUpdate(
        EInputCaptureState StateIn, UInputBehavior* SourceBehaviorIn, EInputCaptureSide WhichSideIn, void* CustomData = nullptr
    )
    {
        State = StateIn;
        Source = SourceBehaviorIn;
        Data.WhichSide = WhichSideIn;
        Data.CustomData = CustomData;
    }
};
 
struct FInputCapturePriority
{
    static constexpr int DEFAULT_GIZMO_PRIORITY = 50;
    static constexpr int DEFAULT_TOOL_PRIORITY = 100;
 
    int Priority;
 
    FInputCapturePriority(int priority = DEFAULT_TOOL_PRIORITY)
    {
        Priority = priority;
    }
 
    FInputCapturePriority MakeLower(int DeltaAmount = 1) const
    {
        return FInputCapturePriority(Priority + DeltaAmount);
    }
 
    FInputCapturePriority MakeHigher(int DeltaAmount = 1) const
    {
        return FInputCapturePriority(Priority - DeltaAmount);
    }
 
    friend bool operator<(const FInputCapturePriority& l, const FInputCapturePriority& r)
    {
        return l.Priority < r.Priority;
    }
    friend bool operator==(const FInputCapturePriority& l, const FInputCapturePriority& r)
    {
        return l.Priority == r.Priority;
    }
};
 
UCLASS(Transient, MinimalAPI)
class UInputBehavior : public UObject
{
    GENERATED_BODY()
 
public:
    INTERACTIVETOOLSFRAMEWORK_API UInputBehavior();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCapturePriority GetPriority();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void SetDefaultPriority(const FInputCapturePriority& Priority);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual EInputDevices GetSupportedDevices();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureRequest WantsCapture(const FInputDeviceState& InputState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureUpdate BeginCapture(
        const FInputDeviceState& InputState, EInputCaptureSide eSide
    );
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureUpdate UpdateCapture(
        const FInputDeviceState& InputState, const FInputCaptureData& CaptureData
    );
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ForceEndCapture(const FInputCaptureData& CaptureData);
 
    //
    // hover support (optional)
    //
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool WantsHoverEvents();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureRequest WantsHoverCapture(const FInputDeviceState& InputState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureUpdate BeginHoverCapture(
        const FInputDeviceState& InputState, EInputCaptureSide eSide
    );
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FInputCaptureUpdate UpdateHoverCapture(const FInputDeviceState& InputState);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void EndHoverCapture();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool WantsForceEndCapture();
 
    UE_EXPERIMENTAL(5.7, "Capture stealing is experimental behavior. Its implementation may change in the future.")
    INTERACTIVETOOLSFRAMEWORK_API virtual bool AllowsCaptureStealing();
 
    UE_EXPERIMENTAL(5.7, "Capture stealing is experimental behavior. Its implementation may change in the future.")
    INTERACTIVETOOLSFRAMEWORK_API void SetAllowsCaptureStealing(TAttribute<bool> InAllowsCaptureStealing);
 
protected:
    FInputCapturePriority DefaultPriority;
 
    UE_EXPERIMENTAL(5.7, "Capture stealing is experimental behavior. Its implementation may change in the future.")
    TAttribute<bool> CaptureStealing;
};