SVirtualControl.h

Go to the documentation of this file.

// Copyright 2023 Lost in Game Studio. All Rights Reserved.
 
#pragma once
 
#include "Widgets/SLeafWidget.h"
#include "SDeprecatedTouchInterface.h"
#include "UObject/StrongObjectPtr.h"
 
class UTouchInterfaceSettings;
class UEnhancedInputLocalPlayerSubsystem;
 
DEFINE_LOG_CATEGORY_STATIC(LogVirtualControl, Log, All);
 
//TODO: For parenting feature, use SCompoundWidget, add canvas or other and then use ArrangeChildren
 
// Base class for virtual input
class TOUCHINTERFACE_API SVirtualControl : public SLeafWidget
{
    //TODO: Needed for Slate Attribute optimization (invalidation)
    //SLATE_DECLARE_WIDGET(SVirtualControl, SLeafWidget)
    
public:
    SLATE_BEGIN_ARGS(SVirtualControl)
        : _TouchInterface(nullptr)
        , _VirtualInput(nullptr)
        , _Slot(nullptr)
        , _AutoPositioning(false)
        , _ParentOffset(ForceInitToZero)
        {}
        SLATE_ARGUMENT(TSharedPtr<SDeprecatedTouchInterface>, TouchInterface)
        SLATE_ARGUMENT(FVirtualControl, VirtualControl)
        SLATE_ARGUMENT(UVirtualInput*, VirtualInput)
        SLATE_ARGUMENT(SConstraintCanvas::FSlot*, Slot)
        SLATE_ARGUMENT(bool, AutoPositioning)
        SLATE_ARGUMENT(FVector2D, ParentOffset)
        SLATE_ARGUMENT(ULocalPlayer*, LocalPlayer)
 
        SLATE_ATTRIBUTE(float, Opacity)
        SLATE_ATTRIBUTE(float, ScaleFactor)
        SLATE_ATTRIBUTE(bool, DrawDebug)
    SLATE_END_ARGS()
    
    SVirtualControl();

    void Construct(const FArguments& InArgs);

    virtual ~SVirtualControl() override;
    
    virtual bool OnPress(const FGeometry& MyGeometry, const FPointerEvent& Event);
    virtual void OnMove(const FGeometry& MyGeometry, const FPointerEvent& Event);
    virtual void OnRelease(const FGeometry& MyGeometry, const FPointerEvent& Event);
    virtual void OnTick(const FGeometry& MyGeometry, const float InScaleFactor, const double InCurrentTime, const float InDeltaTime, const bool InForceUpdate, const bool OrientToLandscape);
 
    //Begin SWidget Implementation
    virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
    //virtual void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime) override;
    virtual FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const override;
    virtual bool SupportsKeyboardFocus() const override { return false; }
    //End SWidget Implementation
 
    //virtual int32 PaintAdditionalLayer(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle);
    
    void SetCanvasSlot(SConstraintCanvas::FSlot* NewSlot) { CanvasSlot = NewSlot; }

    virtual void RefreshPosition() { bRefreshPosition = true; }
 
    virtual void DrawLayer(const FVisualLayer& InLayer, const FVector2D InSize, const FVector2D InBrushSize, float Angle, const FVector2D InOffset, const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle) const;
 
    virtual bool IsInside(const FVector2D FingerPosition);
 
    EControlType GetControlType() const { return VirtualControl.Type; }
 
    FName GetControlName() const { return VirtualControl.ControlName; }
 
    FVirtualControl GetData() const { return VirtualControl; }
 
    FVirtualControl& GetDataRef() { return VirtualControl; }
 
    TArray<UVirtualInputEvent*> GetVirtualInputEventInstances() { return VirtualInputEvents; }

    void AddNewLayer(const FVisualLayer& VisualLayer);

    //void AddNewLayer(const FVisualLayer& VisualLayer, int32 LayerGroup);
    void InsertNewLayer(const FVisualLayer& VisualLayer, const int32 Index);
    void RemoveLayer(const FName LayerName);
    void RemoveLayerByIndex(const int32 LayerIndex);
 
    UMaterialInstanceDynamic* GetLayerDynamicMaterialInstance(const FName LayerName, UObject* InOuter);

    bool ApplyModification();
 
    bool ContainPointerIndex(int32 PointerIndex);
    
    //int32 GetPointerIndex() const { return CapturePointerIndex; }
 
    UEnhancedInputLocalPlayerSubsystem* GetEnhancedInputSubsystem();
 
    void HandleOnOrientationChanged(const bool bOrientToLandscape);
 
    void Reset();
 
    void ResetChild(const FVector2D ParentPosition);
 
    virtual void FlushPressedKey();
 
    bool AddChild(TSharedPtr<SVirtualControl> Other);
 
    // Called before destroy
    void PreDestroy();
 
    bool RemoveChild(TSharedPtr<SVirtualControl> ChildToRemove);
 
    bool IsParent() const { return ChildControls.Num() > 0; }
 
    bool IsChild() const { return VirtualControl.bIsChild; }
 
    const TArray<TSharedPtr<SVirtualControl>>& GetLinkedVirtualControls() { return ChildControls; }
 
    // Inject input with enhanced input subsystem. The injected input will be processed next tick
    void InjectInput(const UInputAction* Action, FInputActionValue RawValue);
    
    // Stop injection for given action
    void StopInjectingInput(const UInputAction* Action);
 
    void SetEnableInput(const bool Enabled) { bBlockInput = !Enabled; }
 
    ULocalPlayer* GetLocalPlayer() const { return LocalPlayer; }
    
protected:
    const UTouchInterfaceSettings* GetSettings();

    void AlignBoxIntoScreen(FVector2D& Position, const FVector2D& Size, const FVector2D& ScreenSize);

    void ResolveRelativePosition(FVector2D& Position, const FVector2D RelativeTo);

    virtual void CalculateCorrectedValues(const FVector2D& Center, const FVector2D Offset, const FGeometry& AllottedGeometry, const float InScaleFactor);

    virtual void Recenter(const FVector2D DesiredPosition);

    virtual void RefreshChild(const FGeometry& MyGeometry, const FVector2D ParentCenter, const float InScaleFactor);
    
    virtual void RecenterChild(const FVector2D ParentPosition);

    void SetLocalPosition(const FVector2D NewPosition, const bool IsNormalized);
 
    bool MultitouchDetected() const { return bMultitouchDetected; }
    
 
    TSharedPtr<SDeprecatedTouchInterface> ParentWidget;
    
    TArray<int32> CapturePointerIndex;
    
    FVirtualControl VirtualControl;
 
    UVirtualInput* VirtualInput;
 
    SConstraintCanvas::FSlot* CanvasSlot;
 
    TAttribute<float> TouchInterfaceOpacity;
    TAttribute<float> ScaleFactor;
    TAttribute<bool> DrawDebug;
    
    uint8 bIsPressed:1;
    uint8 bBlockInput:1;
 
    uint8 bRefreshPosition:1;
 
    uint8 bAutoPositioning:1;
    uint8 bUseLandscapePosition:1;
 
    uint8 bSupportMultitouch:1;
 
    FVector2D AbsoluteCenter;
    FVector2D CorrectedCenter;
    FVector2D CorrectedVisualSize;
    FVector2D CorrectedInteractionSize;
    FVector2D ParentOffset;
    FVector2D CorrectedOffset;
    
    float CorrectedInteractionRadiusSize;
 
    float CircleHitMaxLength;
 
    float CurrentScaleFactor;
    
    float PreviousScaleFactor;

    double CurrentTime;

    float DeltaTime;
    
    float ElapsedTime;
 
    float LastElapsedTime;
 
    float DebugOpacity;
 
private:
    // Set offset in canvas
    void SetOffset(const FVector2D NewPosition, const FVector2D NewVisualSize) const;
 
    void ComputeEffectiveKernelSize(float Strength, int32& OutKernelSize, int32& OutDownsampleAmount) const;
    
    const UTouchInterfaceSettings* Settings;
    
    UEnhancedInputLocalPlayerSubsystem* InputSubsystem;
 
    float TimeToReset;
    
    uint8 bMustBeReset:1;
 
    uint8 bMultitouchDetected:1;
 
    TArray<TSharedPtr<SVirtualControl>> ChildControls;
 
    TMap<const UInputAction*, FInputActionValue> InjectedInputs;
 
    TArray<UVirtualInputEvent*> VirtualInputEvents;
 
    ULocalPlayer* LocalPlayer;
};