SLayoutComponent.h

Go to the documentation of this file.

// Copyright 2024 Lost in Game Studio. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/Layout/SConstraintCanvas.h"
 
class STouchInterface;
enum class EInteractionType : uint8;
class STouchInterfaceRuntime;
class SConstraintCanvas;
class SOverlay;
class SRetainerWidget;
 
struct FDecorator
{
    TSharedPtr<SWidget> DecoratorWidget;
    TEnumAsByte<EHorizontalAlignment> HorizontalAlignment;
    TEnumAsByte<EVerticalAlignment> VerticalAlignment;
    int32 ZOrder;
    bool bShowOnPress;
    bool bShowOnRelease;
 
    FDecorator(TSharedPtr<SWidget> InDecorator, const int32 DesiredZOrder, const bool bVisibleOnPress, const bool bVisibleOnRelease)
    : DecoratorWidget(InDecorator)
    , HorizontalAlignment(HAlign_Fill)
    , VerticalAlignment(VAlign_Fill)
    , ZOrder(DesiredZOrder)
    , bShowOnPress(bVisibleOnPress)
    , bShowOnRelease(bVisibleOnRelease)
    {
        
    }
 
    FDecorator(TSharedPtr<SWidget> InDecorator, TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment, TEnumAsByte<EVerticalAlignment> InVerticalAlignment, const int32 DesiredZOrder, const bool bVisibleOnPress, const bool bVisibleOnRelease)
    : DecoratorWidget(InDecorator)
    , HorizontalAlignment(InHorizontalAlignment)
    , VerticalAlignment(InVerticalAlignment)
    , ZOrder(DesiredZOrder)
    , bShowOnPress(bVisibleOnPress)
    , bShowOnRelease(bVisibleOnRelease)
    {
        
    }
};
 
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnTouchDelegate, const FGeometry&, const FGeometry&, const FPointerEvent&)
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnTickDelegate, const FGeometry&, double, float)

class TOUCHINTERFACE_API SLayoutComponent : public SCompoundWidget
{
public:
    SLATE_BEGIN_ARGS(SLayoutComponent)
        : _WidgetSlot(nullptr)
        , _LayoutWidget(nullptr)
        , _Parent(nullptr)
        , _bSupportChildren(false)
        , _InputPriority(0)
        , _RecenterOffset(ForceInitToZero)
        , _bConsumeInput(false)
        , _bRecenterOnTouch(false)
        , _TopLeftPosition(ForceInitToZero)
        , _InteractionSize(100.0f)
        , _bRecenterHitBox(false)
        , _bIsEditor(false)
        {
        }
        
        SLATE_ARGUMENT(SConstraintCanvas::FSlot*, WidgetSlot)
        SLATE_ARGUMENT(TSharedPtr<STouchInterface>, LayoutWidget)
        SLATE_ARGUMENT(TSharedPtr<SLayoutComponent>, Parent)
        SLATE_ARGUMENT(TArray<FDecorator>, Decorators)
        SLATE_ARGUMENT(bool, bSupportChildren)
        SLATE_ARGUMENT(int32, InputPriority)
        SLATE_ARGUMENT(FVector2D, RecenterOffset)
        SLATE_ARGUMENT(EInteractionType, InteractionShape)
        SLATE_ARGUMENT(bool, bConsumeInput)
        SLATE_ARGUMENT(bool, bRecenterOnTouch)
        SLATE_ARGUMENT(FVector4f, AnchorOffset)
        SLATE_ARGUMENT(FVector2D, TopLeftPosition)
        SLATE_ARGUMENT(FVector2D, Size)
        SLATE_ARGUMENT(float, InteractionSize)
        SLATE_ARGUMENT(bool, bRecenterHitBox)
        SLATE_ARGUMENT(FName, ComponentName)
        SLATE_ARGUMENT(bool, bIsEditor)
        
    SLATE_END_ARGS()
 
    SLayoutComponent();
    
    virtual ~SLayoutComponent();
    
    //Constructs this widget with InArgs
    void Construct(const FArguments& InArgs);
 
    void Destruct();
 
    EActiveTimerReturnType PostGeometryInitialization(double InCurrentTime, float InDeltaTime);
    
    //Constructs UUserWidget (Widget Decorator)
    void ConstructWidget() const;
    
    //Get position of widget in layout space
    FVector2D GetTopLeftPosition() const { return LayoutTopLeftPosition; }
 
    FVector2D GetSize() const { return Size; }
 
    TSharedPtr<STouchInterfaceRuntime> GetRuntimeTouchInterfaceWidget() const;
 
    int32 GetInputPriority() const { return InputPriority; }
 
 
    void SetDecorators(TArray<FDecorator> NewDecorators);
    void AddDecorator(TSharedPtr<SWidget> Decorator);
    void InsertDecorator(TSharedPtr<SWidget> Decorator, int32 Index);
    void RemoveDecorator(TSharedPtr<SWidget> DecoratorToRemove);
 
    void ShowDecorator(TSharedPtr<SWidget> DecoratorWidget);
    void HideDecorator(TSharedPtr<SWidget> DecoratorWidget);
 
    //TODO: Switch decorator position. Decorator at index 4 moves to index 2
 
    
    //Returns true if consume input
    virtual bool ProcessPressEvent(const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
    virtual void ProcessMoveEvent(const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
    virtual void ProcessReleaseEvent(const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
 
    //Begin SWidget
    virtual FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const override { return Size; }
    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;
    //End SWidget
    
    //TODO: Remove double click
 
    virtual void PaintDebug(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle) const;
 
    
    //Called by STouchInterfaceLayout when geometry change
    virtual void UpdateScaleFactor(const FGeometry& LayoutGeometry, const float& ScaleFactor);
 
    //Mainly called by parent (when parent layout top left position change)
    //virtual void UpdateLayoutTopLeftLocation(FVector2D ParentTopLeftLocation);
 
    virtual FVector2D Recenter(const FVector2D AbsoluteLocation);
    
    virtual void ResetPosition();
 
    //TODO: Smooth refresh for position like geometry or orientation change
 
    //TODO: Use FRuntimeVectorCurve
    void Animate();
 
    // Remove all UUserWidget from container and rebuild
    void FullRebuildWidgetDecorator();
 
    virtual void SetAnchor(const FAnchors NewAnchors);
    
    virtual void SetSize(const FVector2D NewSize);
 
    virtual void SetAnchorOffset(const FVector4f Offset);
 
    virtual void SetAlignment(const FVector2D NewAlignment);
    
    virtual void SetInteractionType(const EInteractionType NewType);
    
    virtual void SetInteractionSize(const float Value) { InteractionSize = Value; }
    
    virtual void SetInputPriority(const int32 Value) { InputPriority = Value; }
    

    virtual void SetPositionFromTopLeft(const FVector2D NewPosition);
 
    void SetDrawDebugEnabled(const bool bEnable) { bDrawDebug = bEnable; }
 
    void SetDebugType(const int32 InDebugType) { DebugType = InDebugType; }
 
    virtual bool IsUnderLocation(const FVector2D AbsoluteLocation);
    
    virtual bool CanInteract() const;
 
    virtual bool IsPressed() const { return bIsPressed; }
 
    virtual void BlockInput(const bool bBlock) { bBlockInput = bBlock; }
 
    
    FVector2D ScreenSpaceToLayoutSpace(const FVector2D Location);
    FVector2D LocalSpaceToNormalized(const FVector2D Location) const;
 
    SConstraintCanvas::FSlot* CreateSlot(const FAnchors Anchor, const FVector2D Alignment);
    void AddChild(TSharedPtr<SLayoutComponent> Component);
    void AddChild(TSharedPtr<SLayoutComponent> Component, const FAnchors Anchor, const FVector2D Alignment);
    void RemoveChild(TSharedPtr<SLayoutComponent> Component);
 
#if WITH_EDITOR
    virtual void PaintOutline(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle) const;
    
    virtual void Select() { bDrawSelectOutline = true; }
    virtual void Unselect() { bDrawSelectOutline = false; }
 
    virtual void Hover() { bDrawHoverOutline = true; }
    virtual void UnHover() { bDrawHoverOutline = false; }
#endif
 
protected:
    void SetSlotPosition(const FVector2D& SlotPosition) const;
    void SetSlotSize(const FVector2D SlotSize) const;
 
private:
    FVector2D ComponentLocationToTopLeftLocation(const FVector2D InComponentLocation) const;
 
    FVector2D TopLeftLocationToComponentLocation(const FVector2D TopLeftLocation) const;
 
public:
    FOnTouchDelegate OnPress;
    FOnTouchDelegate OnMove;
    FOnTouchDelegate OnRelease;
    FOnTickDelegate OnTick;
    
protected:
    FVector2D ComponentLocation;
    
    //Position of component in layout space
    FVector2D LayoutTopLeftPosition;
 
    //Offset from pivot to center of geometry
    FVector2D PivotOffset;
 
    //Offset from origin to recenter location
    FVector2D RecenterOffset;
 
    FVector2D Size;
    
    FVector2D ScaledSize;
 
    int32 InputPriority;
 
private:
    TSharedPtr<SConstraintCanvas> CanvasWidget;
 
    TSharedPtr<SRetainerWidget> RetainerWidget;
    
    TSharedPtr<SOverlay> OverlayWidget;
 
    TSharedPtr<SLayoutComponent> Parent;
 
    TArray<TSharedPtr<SLayoutComponent>> Children;
 
    TArray<FDecorator> Decorators;
    
    TSharedPtr<STouchInterface> LayoutWidget;
    
    SConstraintCanvas::FSlot* WidgetSlot;
    
    TArray<int32> AffectedFingerIndex;
 
    uint8 bForceRefresh:1;
 
    int32 DebugType;
 
    //FBox2D Box2DRepresentation;
 
    //TODO: Implement Slate Attribute (See SColorBlock for example)
    //TSlateAttribute<UInputDecorator*> Decorator;
    //TSlateAttribute<FVector2D> RecenterOffset;
    
    EInteractionType InteractionShape;
    
    bool bConsumeInput;
    bool bRecenterOnTouch;
    bool bRecenterHitBox;
    bool bDrawDebug;
    bool bBlockInput;
    bool bIsPressed;
    bool bIsEditorWidget;
    
    FVector4f AnchorOffset;
 
    FVector2D TopLeftPosition;
    
    float InteractionSize;
    
    FName ComponentName;
 
#if WITH_EDITORONLY_DATA
    uint8 bDrawSelectOutline:1;
    uint8 bDrawHoverOutline:1;
#endif
};