SDeprecatedTouchInterface.h

Go to the documentation of this file.

// Copyright 2022 Lost in Game Studio. All Rights Reserved.
 
#pragma once
 
#include "TouchInterface/VirtualControlSetup.h"
#include "VirtualShape/VirtualShape.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/Layout/SConstraintCanvas.h"
 
class SVirtualAnchor;
struct FTouchInterfaceConfiguration;
//class UVirtualShape;
class UShapeRecognizer;
class SVirtualShapeDrawer;
enum class EScalingMode;
 
class UTouchInterfaceSettings;
class SVirtualControl;
class UTouchInterfaceListener;
class UWorld;
class UGameInstance;
class ULocalPlayer;
class UEnhancedInputLocalPlayerSubsystem;
 
DECLARE_DELEGATE_TwoParams(FOnTouchEvent, int32, FVector2D);
DECLARE_DELEGATE_OneParam(FOnStateChangedEvent, bool);
DECLARE_DELEGATE_OneParam(FOnAutoMoveSignature, FVector2D);
 
struct FVirtualControlWidget
{
    FName Name;
    SConstraintCanvas::FSlot* Slot;
    TSharedPtr<SVirtualControl> VirtualControl;
    uint8 bIsChild:1;
 
    FVirtualControlWidget(const FName InName, SConstraintCanvas::FSlot* InSlot, TSharedPtr<SVirtualControl> VirtualControl, const bool IsChild) :
    Name(InName),
    Slot(InSlot),
    VirtualControl(VirtualControl),
    bIsChild(IsChild)
    {
        
    }
};
 
class TOUCHINTERFACE_API SDeprecatedTouchInterface : public SCompoundWidget
{
    SLATE_BEGIN_ARGS(SDeprecatedTouchInterface)
        : _LoadConfig(false)
        , _UserIndex(0)
        , _ConfigIndex(0)
        {}
 
        SLATE_ARGUMENT(bool, LoadConfig)
        SLATE_ARGUMENT(int32, UserIndex)
        SLATE_ARGUMENT(int32, ConfigIndex)
        
        SLATE_EVENT(FOnTouchEvent, OnTouchBegan)
        SLATE_EVENT(FOnTouchEvent, OnTouchMoved)
        SLATE_EVENT(FOnTouchEvent, OnTouchEnded)
        SLATE_EVENT(FOnStateChangedEvent, OnActiveStateChanged)
        SLATE_EVENT(FOnStateChangedEvent, OnVisibilityStateChanged)
    SLATE_END_ARGS()
 
    SDeprecatedTouchInterface();
        
    void Construct(const FArguments& InArgs, ULocalPlayer* InLocalPlayer, UVirtualControlSetup* InVirtualControlSetup);
 
private:
    void GenerateVirtualInputNextFrame(TArray<FVirtualControl>& InVirtualControls);

    void GenerateVirtualControls(TArray<FVirtualControl> InVirtualControls);
    
    TSharedRef<SVirtualControl> ConstructVirtualControlWidget(const FVirtualControl& InVirtualControl, SConstraintCanvas::FSlot* OwnerSlot, TSharedPtr<SVirtualControl>&);

    void GenerateChildControls(const TArray<FName> ChildrenName, TSharedPtr<SVirtualControl> Parent, TArray<FVirtualControl>& InVirtualControls);
 
    // Generate virtual anchor widgets and add associated virtual inputs
    //void GenerateVirtualAnchors(const TArray<FVirtualAnchor>& InVirtualAnchors);
 
    EActiveTimerReturnType ActivateTouchInterface(double InCurrentTime, float InDeltaTime);
 
    EActiveTimerReturnType DrawVirtualControl(double InCurrentTime, float InDeltaTime);
 
public:
    //Begin SWidget implementation
    virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
    virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
    virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
    
    virtual FReply OnTouchStarted(const FGeometry& MyGeometry, const FPointerEvent& Event) override;
    virtual FReply OnTouchMoved(const FGeometry& MyGeometry, const FPointerEvent& Event) override;
    virtual FReply OnTouchEnded(const FGeometry& MyGeometry, const FPointerEvent& Event) override;
    
    virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override;
    virtual int32 OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override;
    virtual bool SupportsKeyboardFocus() const override { return false; }
    virtual FVector2D ComputeDesiredSize(float) const override { return FVector2D(100, 100); }
    //End SWidget implementation
    
    virtual void RebuildTouchInterface(const bool bLoadConfig, const int32 InUserIndex, const int32 InConfigIndex);
 
    // Called before destruction
    virtual void PreDestruct();

    static FName GenerateUniqueLayerName(const TArray<FVisualLayer>& VisualLayers);
    static bool DoesThisNameExistInVisualLayer(const TArray<FVisualLayer> VisualLayers, const FName OtherName);

    int32 GetControllerId() const { return ControllerIdAssociated; }

    UWorld* GetWorldContext() const;
 
 
    TArray<UTouchInterfaceListener*>& GetListeners() { return TouchInputComps; }    
    
    TSharedPtr<SVirtualControl> GetVirtualControlWidget(const FName ControlName);
 
 
    //TODO: Make only getters and eventually setters. All logics are written in subsystem
 
    // INPUT
 
    bool RegisterTouchInputComponent(UTouchInterfaceListener* ManagerComp);
    bool UnregisterTouchInputComponent(UTouchInterfaceListener* ManagerComp);
 
    void UnregisterAllManagerComponents();
    
    // Whether or not input is enabled
    void BlockInput(const bool bBlock) { bBlockInput = bBlock; }
 
    // Whether or not gesture is enabled
    void BlockGesture(const bool bBlock) { bBlockRecognizers = bBlock; }
 
    // Change InputAction on virtual control
    bool ChangeInputAction(const FName ControlName, UInputAction* Action);
 
    // Enable virtual input (user interaction)
    void EnableVirtualInput(const FName InputName);
 
    // Disable virtual input (no interaction)
    void DisableVirtualInput(const FName InputName);
    
    
    // VISIBILITY
 
    // Shows or hides the touch interface widget
    void SetWidgetVisibility(const bool bInVisible, const bool bInBlockInput, const bool bInBlockGesture);
    
    // Show or hide virtual input by name
    void SetVirtualInputVisibility(const FName Name, const bool bInVisible, const bool bIncludeChildren);
 
    // Show all virtual input
    void ShowAllVirtualInputs();
 
    // Hide all virtual input
    void HideAllVirtualInputs();
 
    float GetVirtualInputOpacity(const FName ControlName);
 
    void SetVirtualInputOpacity(const FName ControlName, const float NewOpacity); 
 
 
    //DATA
    
    bool GetVirtualControlData(const FName ControlName, FVirtualControl& VirtualControl);
 
    FVirtualControl& GetVirtualControl(const FName ControlName);

    TArray<FVirtualControl> GetAllControls(const bool IncludeButton = true, const bool IncludeJoystick = false, const bool IncludeTouchRegion = false);

    void AddControl(const FVirtualControl& NewControl);

    void RemoveControl(const FName Name, const bool bRemoveChildren);

    void ResetToDefault();
 
    
    // VISUAL
    
    void SetVirtualControlVisualLayers(const FName ControlName, TArray<FVisualLayer> Layers);

    void GetVirtualControlLayer(const FName ControlName, const FName LayerName, FVisualLayer& OutLayer);

    void SetVirtualControlLayer(const FName ControlName, const FVisualLayer& Layer);
    
    FName AddNewLayer(const FName ControlName, FVisualLayer& Layer);

    FName InsertNewLayer(const FName ControlName, FVisualLayer& Layer, const int32 Index);

    void RemoveLayer(const FName ControlName, const FName LayerName);
 
    void RemoveLayerAt(const FName ControlName, const int32 Index);
    
    //Todo: Add function to allow dev to Add/Remove layer

    UMaterialInstanceDynamic* GetLayerDynamicMaterialInstance(const FName ControlName, const FName LayerName, UObject* InOuter);
 
    void SetControlSize(const FName Name, const FVector2D NewVisualSize, const FVector2D NewThumbSize, const FVector2D NewInteractionSize);
 
    bool SetControlPosition(const FName Name, const FVector2D NewPosition, const bool InLandscape);
 
    
    // UTILITIES
 
    TArray<UTouchInterfaceListener*> GetAllListener();
    
    /***/
    bool GetTypeOfControl(const FName ControlName, EControlType& Type);
 
    bool ContainName(const FName ControlName);
 
    TArray<FName> GetAllControlNames();
    
    TArray<FName> GetLayerNames(const FName ControlName);
 
    UEnhancedInputLocalPlayerSubsystem* GetEnhancedInputSubsystem() const { return EnhancedInputSubsystem; }
 
    bool IsActive() const { return State == State_Active; }
 
    bool IsVisible() const { return bVisible; }
 
    void SetScaleMultiplier(const float NewScale) { ScaleMultiplier = NewScale; }

    FVector2D LocalToNormalized(const FVector2D LocalPosition) const;

    FVector2D NormalizedToLocal(const FVector2D NormalizedPosition) const;
 
    static float GetDebugOpacity();
 
    //SAVE
    
    bool SaveConfigurationFromCurrentSetup(const uint32 InUserIndex, const uint32 InConfigIndex);
    bool LoadConfiguration(const uint32 InUserIndex, const uint32 InConfigIndex);
    
    // EVENTS
    
    FOnTouchEvent OnTouchBeganEvent;
    FOnTouchEvent OnTouchMovedEvent;
    FOnTouchEvent OnTouchEndedEvent;
 
    FOnStateChangedEvent OnActiveStateChanged;
    FOnStateChangedEvent OnVisibilityStateChanged;
 
private:
    void SetWidgetOpacity(const float DeltaTime);
 
public:
    float GetVirtualControlOpacity() const { return CurrentOpacity; }
 
    float GetCurrentScaleFactor() const { return CurrentScaleFactor; }
 
    bool GetDrawDebug() const { return bDrawDebug; }
    
    float GetScaleFactor(const FGeometry& Geometry);
 
private:
 
    // Callback for handling device orientation changes
    virtual void HandleOnOrientationChanged(const int32 Mode);
 
    int32 GetVisualLayerIndex(TArray<FVisualLayer>& VisualLayer, const FName LayerName);
 
    bool CanSendInputsToRecognizer(const bool bHitControl) const;
    
    // Callback for handling display metrics changes
    //virtual void HandleDisplayMetricsChanged(const FDisplayMetrics& NewDisplayMetric);
    
    TSharedPtr<SConstraintCanvas> VirtualControlCanvas;
    
    TArray<TSharedRef<SVirtualControl>> VirtualControlWidgets;
 
    TSharedPtr<SVirtualShapeDrawer> ShapeDrawer;
    
    TArray<UTouchInterfaceListener*> TouchInputComps;
 
    TArray<UVirtualShape> VirtualShapes;
 
    struct FFingerDebugData
    {
        uint32 FingerIndex;
        FVector2D Position;
 
        FFingerDebugData(const uint32 InFingerIndex, const FVector2D InPosition) :
        FingerIndex(InFingerIndex),
        Position(InPosition)
        {
        
        }
    };
    
    TArray<FFingerDebugData> Fingers;
 
    UVirtualControlSetup* VirtualControlSetup;
    
    UEnhancedInputLocalPlayerSubsystem* EnhancedInputSubsystem;
 
    const UTouchInterfaceSettings* Settings;
 
    class UTouchInterfaceSave* ConfigurationSaveSlot;
 
    UGameInstance* PersistantOuter;
    
    EScalingMode ScalingMode;
 
    TArray<FVirtualControlWidget> ChildWidgets;
 
    TArray<TSharedPtr<SVirtualAnchor>> VirtualAnchors;
 
    //TAttribute<UWorld*> WorldContext;
    //TAttribute<ULocalPlayer*> LocalPlayer;
 
    UWorld* WorldContext;
    ULocalPlayer* LocalPlayer;
    
    float CurrentScaleFactor;
    float ScaleMultiplier;

    uint8 bVisible:1;

    uint8 bIsActivated:1;
 
    
    uint8 bActiveEventSend:1;
    
    uint8 bBlockInput:1;
 
 
    //GESTURE RECOGNIZER
    
    uint8 bGestureRecognizerEnabled:1;
    
    uint8 bBlockRecognizers:1;
 
    // From settings : block touch event
    uint8 bBlockTouchEvent:1;
 
    uint8 bMoveEventAllowed:1;
 
    uint8 bCaptureMouse:1;
 
 
    //SHAPE RECOGNIZER
    
    // True if the widget should send input to the Shape Recognition Manager
    uint8 bShapeRecognizerEnabled:1;
    
    uint8 bBlockShapeRecognition:1;
 
    
    uint8 bDrawDebug:1;
 
    int32 NumberOfActiveControl;
    
    int32 ControllerIdAssociated;
 
    FSlateBrush DebugCircle;

    float ActiveOpacity;
    float InactiveOpacity;
    float ActiveLerpRate;
    float InactiveLerpRate;
    float TimeUntilDeactivated;
    float TimeUntilReset;
    float ActivationDelay;
    float StartupDelay;
 
    uint8 bCalculatePositionAuto:1;
 
    enum ETouchInterfaceState
    {
        State_Active,
        State_CountingDownToInactive,
        State_CountingDownToReset,
        State_Inactive,
    };

    ETouchInterfaceState State;

    uint8 bIsInLandscapeMode:1;

    float CurrentOpacity;
 
    /* Countdown until next state change */
    float Countdown;

    float PreviousScalingFactor = 0.0f;
 
    FVector2D PreviousGeometrySize;
    
    float OpacityCurveValue;
 
    uint8 bLoadFromSave:1;
    int32 UserIndex;
    int32 ConfigIndex;
};