LayoutComponent.h

Go to the documentation of this file.

 // Copyright 2024 Lost in Game Studio. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "Widgets/Layout/SConstraintCanvas.h"
#include "LayoutComponent.generated.h"
 
 class UComponentDecoratorGroup;
class ULayoutGroupComponent;
class UTouchInterfaceLayout;
class UComponentLogic;
class UProgressBarLayer;
class URadialProgressBarLayer;
class UTextLayer;
class UBlurLayer;
class UFlipbookLayer;
class UWidgetLayer;
class UComponentDecorator;
class STouchInterface;
class SLayoutComponent;
class UTextureRenderTarget2D;
class ULocalPlayer;
 
#if WITH_EDITOR
DECLARE_MULTICAST_DELEGATE(FOnObjectChanged)
#endif
 
UENUM(BlueprintType)
enum class EInteractionType : uint8
{
    Square,

    Circle,

    Alpha
};
 
USTRUCT(BlueprintType)
struct FHitBox
{
    GENERATED_BODY()
 
    UPROPERTY(Category="Hit Box", EditAnywhere, BlueprintReadWrite)
    EInteractionType Shape;
 
    UPROPERTY(Category="Hit Box", EditAnywhere, BlueprintReadWrite)
    FVector2D Position;
 
    UPROPERTY(Category="Hit Box", EditAnywhere, BlueprintReadWrite)
    FVector2D Size;
 
    FHitBox()
    : Shape(EInteractionType::Square)
    , Position(ForceInitToZero)
    , Size(ForceInitToZero)
    {
        
    }
};
 
UENUM(BlueprintType)
enum class EAnchorPosition : uint8
{
    TopLeft,
    TopMiddle,
    TopRight,
    CenterLeft,
    Center,
    CenterRight,
    BottomLeft,
    BottomMiddle,
    BottomRight,
    HalfLeft,
    HalfRight,
    Fill,
    //Custom
};
 
//TODO: Add in options settings the class used for layout component (should derive from layout component)

UCLASS(BlueprintType)
class TOUCHINTERFACE_API ULayoutComponent : public UObject
{
    GENERATED_BODY()
 
public:
    ULayoutComponent();
 
    virtual void BeginDestroy() override;
    
    //TODO: Make Create Widget Instance function like in Component Decorator class
    virtual TSharedRef<SLayoutComponent> TakeWidget(SConstraintCanvas::FSlot* WidgetSlot, TSharedPtr<STouchInterface> LayoutWidget, ULocalPlayer* LocalPlayer, TSharedPtr<SLayoutComponent> InParent = nullptr);
    
    UTextureRenderTarget2D* GetCollapsedLayer();
    
    //FName GenerateUniqueName();
 
    FVector2D GetComponentOffset() const { return LayoutModifierOffset; }
 
    void SetComponentOffset(const FVector2D InCenterOffset) { LayoutModifierOffset = InCenterOffset; }
 
    virtual void UpdateScaleFactor(const FGeometry& LayoutGeometry, const float& ScaleFactor);
 
    void SetPortraitMode(const bool bEnable);
 
    bool IsInPortraitMode() const { return bPortraitMode; }
 
    bool AllowPositionModification() const { return bAllowLocationModification; }
 
    bool AllowSizeModification() const { return bAllowSizeModification; }
 
    virtual TSharedPtr<SLayoutComponent> GetWidgetInstance() const { return ComponentWidget; }
 
    TSharedPtr<STouchInterface> GetTouchInterfaceWidget() const { return TouchInterfaceWidget; }
    
    void SetAnchor(const FAnchors NewAnchor);
    
    void SetTopLeftLocation(const FVector2D Value);
    
    void SetSize(const FVector2D Value);
    
    FVector2D GetParentSize() const;
 
#if WITH_EDITOR
    virtual void OnBeginEditByEditor();
 
    virtual void OnDesignerSizeChanged(const FIntPoint NewSize);
 
    virtual void OnCleanedByEditor();
    
    virtual void OnEndEditByEditor();
 
    //TODO: Remove this function and add bool bIsEditor in TakeWidget function
    virtual TSharedRef<SLayoutComponent> TakeEditorWidget(SConstraintCanvas::FSlot* WidgetSlot, TSharedPtr<STouchInterface> LayoutWidget, TSharedPtr<SLayoutComponent> InParent = nullptr);
    
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    virtual void NotifyOnPropertyChanged();
 
    FBox2D GetBox2D(FVector2D GeometrySize) const;
 
    void RebuildDecorator();
#endif
    
public:
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    FAnchors GetAnchor() const { return Anchors; }
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    FVector2D GetAlignment() const { return Alignment; }
    
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    FVector4f GetAnchorOffset() const { return AnchorOffset; }

    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetComponentLocation() const;

    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetComponentTopLeftLocation();
 
    //TODO: Get component center location
    
    //TODO: Get component aligned location. Alignment offset

    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetComponentLocalLocation() const;

    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetLayoutTopLeftLocation() const;

    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetLayoutTopLeftCenterLocation() const;
    
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    virtual FVector2D GetLayoutTopLeftLocationAtAlignment(FVector2D AtAlignment);
    
 
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable, BlueprintPure)
    float GetComponentAngle() const { return Angle; }
    
 
    UFUNCTION(Category="Layout Component|Size", BlueprintCallable, BlueprintPure)
    FVector2D GetComponentSize() const;
 
    // Return max offset for this component position in layout modifier
    UFUNCTION(Category="Layout Component|Modifier", BlueprintCallable, BlueprintPure)
    virtual FVector4f GetComponentMaxOffset() const { return MaxCenterOffset; }
 
    // Return min (X) and max (Y) size scale for this component in layout modifier
    UFUNCTION(Category="Layout Component|Modifier", BlueprintCallable, BlueprintPure)
    FVector2D GetComponentSizeScale() const { return MaxSizeScale; }
 
    
    //SETTERS
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void SetComponentAnchorPreset(const EAnchorPosition Anchor);
 
    //UFUNCTION(Category="Layout", BlueprintCallable)
    //virtual void SetComponentCustomAnchors(const FAnchors InAnchors);
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void SetComponentAlignment(const FVector2D NewAlignment);
    
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void SetAnchorOffset(const FVector4f NewAnchorOffset);
    
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable)
    virtual void SetComponentLocation(const FVector2D NewLocation);
 
    // Set component location in local space (component space if there is a parent, layout space otherwise).
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable)
    virtual void SetComponentLocalLocation(const FVector2D NewLocation);
 
    // Set component offset for portrait mode in layout space.
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable)
    virtual void SetComponentPortraitOffset(const FVector2D NewOffset);
 
    //TODO: Add component offset, local offset
 
    // Set component angle in degree.
    UFUNCTION(Category="Layout Component|Position", BlueprintCallable)
    virtual void SetComponentAngle(const float Value);
    
    
    UFUNCTION(Category="Layout Component|Size", BlueprintCallable)
    virtual void SetComponentSize(const FVector2D NewSize);
 
    //TODO: SetComponentLocationAndSize
    
    //TODO: Remove this function, it's useless
    UFUNCTION(Category="Layout Component|Modifier", BlueprintCallable)
    virtual void SetComponentSizeScale(const FVector2D NewSizeScale);
    
 
    //UTILITIES
    
    UFUNCTION(Category="Layout Component", BlueprintCallable, BlueprintPure)
    virtual bool IsUnderLocation(const FVector2D AbsoluteLocation);
 
    UFUNCTION(Category="Layout Component", BlueprintCallable, BlueprintPure)
    virtual bool CanInteract() const;
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual bool IsPressed() const;
 
    UFUNCTION(Category="Layout Component|Visibility", BlueprintCallable)
    virtual void SetComponentVisibility(const bool bVisible);
 
    UFUNCTION(Category="Layout Component|Visibility", BlueprintCallable)
    virtual bool IsVisible();
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void Recenter(const FVector2D LayoutPosition = FVector2D::ZeroVector);
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void ResetPosition();
 
    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual const FGeometry& GetComponentGeometry();
    
    // Return true if this component is inside group
    UFUNCTION(Category="Layout Component", BlueprintCallable, BlueprintPure)
    virtual bool IsChild() const;
    
    UFUNCTION(Category="Layout Component", BlueprintCallable, BlueprintPure)
    ULayoutComponent* GetParent() const;
 
    UFUNCTION(Category="Layout Component", BlueprintCallable, BlueprintPure)
    UTouchInterfaceLayout* GetTouchInterfaceLayout() const;

    UFUNCTION(Category="Layout Component", BlueprintCallable)
    virtual void RebuildDecorators() const;
 
 
    //ADD-FIND-REMOVE DECORATOR
 
    // Add new decorator. Return instance of created decorator.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    UComponentDecorator* AddDecoratorByClass(TSubclassOf<UComponentDecorator> DecoratorClass, const FName Name);
 
    // Add new decorator.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void AddDecorator(UComponentDecorator* Decorator);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    UComponentDecorator* InsertDecoratorByClassAt(TSubclassOf<UComponentDecorator> DecoratorClass, FName Name, int32 Index);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void InsertDecoratorAt(UComponentDecorator* Decorator, int32 Index);
 
    // Remove decorator by name.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void RemoveDecoratorByName(const FName Name);
 
    // Remove decorator by index.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void RemoveDecoratorAt(const int32 Index);
 
    // Get index of decorator by name.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    int32 GetDecoratorIndex(const FName Name);
 
    // Returns the first instance of decorator type.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable,  meta=(DeterminesOutputType = "Class"))
    UComponentDecorator* GetDecoratorByClass(TSubclassOf<UComponentDecorator> Class);
 
    // Returns decorator instance by name.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UComponentDecorator* GetDecoratorByName(const FName Name, bool bRecursive);
 
    // Returns decorator instance by index.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UComponentDecorator* GetDecoratorByIndex(const int32 Index);
 
    // Returns all decorator of type.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable,  meta=(DeterminesOutputType = "Class"))
    TArray<UComponentDecorator*> GetAllDecoratorsOfClass(TSubclassOf<UComponentDecorator> Class);
 
    // Returns all decorators.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    TArray<UComponentDecorator*> GetAllDecorators(bool bRecursive);
    
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    TArray<FName> GetAllDecoratorNames(bool bRecursive);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UProgressBarLayer* GetDecoratorAsProgressBar(const FName LayerName);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UTextLayer* GetDecoratorAsText(const FName LayerName);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UBlurLayer* GetDecoratorAsBlur(const FName LayerName);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UFlipbookLayer* GetDecoratorAsFlipbook(const FName LayerName);
    
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UComponentDecoratorGroup* GetDecoratorAsGroup(const FName LayerName);

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    UWidgetLayer* GetDecoratorAsWidget(const FName LayerName);
    
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    bool ContainDecoratorName(const FName Name, bool bRecursive = false);
 
    // Returns true if contain decorator instance.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    bool ContainDecorator(UObject* LayerObject);
 
    // Returns true if contain decorator of class.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable, BlueprintPure)
    bool ContainDecoratorClass(TSubclassOf<UComponentDecorator> Class);
 
    // Get opacity value of decorator (global, each decorator can have different opacity).
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    float GetOpacity() const { return Opacity; }
 
    // Set opacity value of decorator.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void SetOpacity(const float Value) { Opacity = Value; }

    bool HitPixel(const FVector2D NormalizedPosition, const float AlphaTolerance = 0);
    
    //MODIFYING DECORATOR

    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void BeginEditDecorator(const FName LayerName);
 
    // Apply decorator modifications on next tick.
    UFUNCTION(Category="Layout Component|Appearance", BlueprintCallable)
    void EndEditDecorator();
 
    //TODO: GetDynamicMat
 
    bool ConsumeInput() const { return bConsumeInput; }
    bool CanRecenter() const { return bRecenterOnTouch; }
    
    FVector2D GetOffsetFromCenter() const { return OffsetFromCenter; }
 
    EInteractionType GetInteractionShape() const { return InteractionShape; }
 
    //Get the interaction size of component.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable, BlueprintPure)
    float GetInteractionSize() const { return InteractionSize; }
 
    //Get the priority of this component.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    int32 GetInputPriority() const { return Priority; }
 
    //Return true if this component consume input.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    bool IsConsumeInput() const { return bConsumeInput; }
 
    //TODO: Return ULayoutComponent instead of UGroupInputComponent
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable, BlueprintPure)
    ULayoutGroupComponent* GetGroup();
 
 
    //Set the interaction size of this component.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    void SetInteractionSize(const float Value);
 
    //Set the input priority of this component.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    void SetInputPriority(const int32 NewPriority);

    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    void SetConsumeInput(const bool Value) { bConsumeInput = Value; }
 
    //Enable input. This component will now receive input.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    void EnableInput();
 
    //Disable input (no interaction).
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    void DisableInput();
 
    //Return true if input is enabled.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable, BlueprintPure)
    bool IsInputEnabled();
 
    //Set the new logic class used by this component.
    UFUNCTION(Category="Layout Component|Input", BlueprintCallable)
    UComponentLogic* SetLogic(const TSubclassOf<UComponentLogic> NewLogicClass);
 
    
//PROPERTIES
public:
 
#if WITH_EDITOR
    FOnObjectChanged OnObjectChanged;
 
    friend class STouchInterfaceLayoutEditor;
    friend class FTouchInterfaceLayoutEditor;
    friend class SWidgetHandle;
    friend class SAnchorHandle;
    friend class FTouchInterfaceDesignerEditorMenuExtender;
#endif
 
    //TODO: In near future, remove anchor preset and make custom detail panel with small widget (like umg but always displayed) for quick preset
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess="true"))
    EAnchorPosition AnchorPreset;
    
    //Anchors of component
    //UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess="true"), meta=(EditCondition="AnchorPreset==EAnchorPosition::Custom"))
    //FAnchors Anchors;
    
    //TODO: Remove Location and use only AnchorOffset with custom detail panel (Rename anchor offset labels)
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(EditCondition="AnchorPreset!=EAnchorPosition::HalfLeft && AnchorPreset!=EAnchorPosition::HalfRight && AnchorPreset!=EAnchorPosition::Fill", EditConditionHides))
    FVector2D Location;
    
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(EditCondition="AnchorPreset==EAnchorPosition::HalfLeft || AnchorPreset==EAnchorPosition::HalfRight || AnchorPreset==EAnchorPosition::Fill", EditConditionHides))
    FVector4f AnchorOffset;

    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(EditCondition="AnchorPreset!=EAnchorPosition::HalfLeft && AnchorPreset!=EAnchorPosition::HalfRight && AnchorPreset!=EAnchorPosition::Fill", EditConditionHides))
    FVector2D Size;
    
    // Pivot location inside component geometry.
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(AllowPrivateAccess="true"), meta=(EditCondition="AnchorPreset!=EAnchorPosition::HalfLeft && AnchorPreset!=EAnchorPosition::HalfRight && AnchorPreset!=EAnchorPosition::Fill", EditConditionHides))
    FVector2D Alignment;
    
    UPROPERTY()
    FVector2D DesignLocation;
    
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly)
    FVector2D PortraitOffset;
    
    // Angle of component.
    UPROPERTY(Category="Layout", EditAnywhere, BlueprintReadOnly, meta=(ClampMin=-180.0f, ClampMax=180.0f))
    float Angle;
    

    UPROPERTY()
    FVector2D DesignSize;
 
    // Array of decorator that compose the layout component.
    //UPROPERTY()
    //TArray<UComponentDecorator*> Decorators;
    
    UPROPERTY()
    TArray<TObjectPtr<UComponentDecorator>> Decorators;
    
    
    // Global Opacity of decorator.
    UPROPERTY(Category="Appearance", EditAnywhere, BlueprintReadOnly, meta=(ClampMin=0.0f, ClampMax=1.0f))
    float Opacity;
 
    // If false, this component appear hidden at startup.
    UPROPERTY(Category="Appearance", EditAnywhere, BlueprintReadOnly)
    uint8 bIsVisible:1;
    

    UPROPERTY(Category="Optimization", EditAnywhere, BlueprintReadOnly)
    uint8 bOptimizeRendering:1;
    
    
    // Enable or disable component location modification in the layout modifier widget.
    UPROPERTY(Category="Modifier", EditAnywhere, BlueprintReadOnly)
    bool bAllowLocationModification;

    UPROPERTY(Category="Modifier", EditAnywhere, BlueprintReadOnly)
    FVector4f MaxCenterOffset;
 
    UPROPERTY(Category="Modifier", EditAnywhere, BlueprintReadOnly)
    uint8 bAllowSizeModification:1;

    UPROPERTY(Category="Modifier", EditAnywhere, BlueprintReadOnly)
    FVector2D MaxSizeScale;
 

    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly)
    uint8 bRecenterOnTouch:1;
    
    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadWrite)
    EInteractionType InteractionShape;

    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly, meta=(ClampMin=0, ForceUnits="%"))
    float InteractionSize;
 
    /* If enabled, hit box is moved when component is re-centered.
     * Base hit box keep its position and a child hit box is created with center at current touch position.
     * Its center position cannot exceed the max size of base hit box. */
    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly, meta=(EditCondition="bRecenterOnTouch"))
    bool bRecenterHitBox;
 
    //TODO: Offset for interaction shape?

    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly)
    uint8 bConsumeInput:1;

    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly, meta=(EditCondition="bConsumeInput==true"))
    int32 Priority;
 
    // Enable if you want to receive tick event in logic. Disable if not needed (save performance).
    //UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly)
    //uint8 bShouldTick:1;
 
    UPROPERTY(Category="Input", EditAnywhere, BlueprintReadOnly, Instanced)
    TObjectPtr<UComponentLogic> Logic;
 
    //TODO: Make animation system for layout component
    //UPROPERTY(Category="Layer", EditAnywhere, BlueprintReadOnly, Instanced)
    //TArray<TObjectPtr<class ULCDecorator_Animation>> Animations;
    
 
protected:
    UPROPERTY()
    FVector2D LayoutModifierOffset;
    
    UPROPERTY()
    float CurrentSizeScale;
 
    //TODO: Use this instead of function in child class
    TSharedPtr<SLayoutComponent> ComponentWidget;
    
    TSharedPtr<STouchInterface> TouchInterfaceWidget;
 
    //Logic that is duplicated at runtime for edit
    UPROPERTY()
    TObjectPtr<UComponentLogic> LogicCompInstance;
 
    //UPROPERTY()
    //TObjectPtr<ULayoutComponent> Parent;
 
    //TODO: Can we use UObject for parent and then determine, when needed, if UObject is LayoutComponent or TouchInterfaceLayout?
    //TODO: TouchInterfaceLayout should reference touch interface widget for better interaction
    //UPROPERTY()
    //TObjectPtr<UObject> Parent;
    
    FVector2D OffsetFromCenter;
    
    //TODO: Remove this, compute top left location only when needed (mainly in editor)
    UPROPERTY()
    FVector2D TopLeftLocation;
 
private:
    UPROPERTY()
    TWeakObjectPtr<UComponentDecorator> DecoratorEdited;
    
    UPROPERTY()
    FVector2D ComponentSize;
 
    UPROPERTY()
    FAnchors Anchors;
    
    float CachedScaleFactor;
 
    uint8 bPortraitMode:1;
 
    uint8 bBlockInput:1;
 
#if WITH_EDITOR
    FVector2D DesignerSize;
#endif
 
    //TODO: Layout Location (location in touch interface geometry space), Local Location (location in layout component space or anchor space), Relative Location (relative location in touch interface geometry, 
};