SlateRect.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Layout/Margin.h"
#include "Types/SlateVector2.h"
 
class FSlateRect
{
public:
 
    float Left;
    float Top;
    float Right;
    float Bottom;
 
    explicit FSlateRect( float InLeft = -1, float InTop = -1, float InRight = -1, float InBottom = -1 )
        : Left(InLeft)
        , Top(InTop)
        , Right(InRight)
        , Bottom(InBottom)
    { }
 
    FSlateRect( const UE::Slate::FDeprecateVector2DParameter& InStartPos, const UE::Slate::FDeprecateVector2DParameter& InEndPos )
        : Left(InStartPos.X)
        , Top(InStartPos.Y)
        , Right(InEndPos.X)
        , Bottom(InEndPos.Y)
    { }
 
    static FSlateRect FromPointAndExtent(const UE::Slate::FDeprecateVector2DParameter& TopLeft, const UE::Slate::FDeprecateVector2DParameter& Size)
    {
        return FSlateRect(TopLeft, TopLeft + Size);
    }
    
public:
 
    inline bool IsValid() const
    {
        return !(Left == -1 && Right == -1 && Bottom == -1 && Top == -1) && Right >= Left && Bottom >= Top;
    }
 
    inline bool IsEmpty() const
    {
        return GetArea() <= UE_SMALL_NUMBER;
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetSize() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetSize2f());
    }
    inline FVector2f GetSize2f() const
    {
        return FVector2f(Right - Left, Bottom - Top);
    }
 
    inline float GetArea() const
    {
        return (Right - Left) * (Bottom - Top);
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetCenter() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetCenter2f());
    }
    inline FVector2f GetCenter2f() const
    {
        return FVector2f(Left, Top) + GetSize2f() * 0.5f;
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetTopLeft() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetTopLeft2f());
    }
    inline FVector2f GetTopLeft2f() const
    {
        return FVector2f(Left, Top);
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetTopRight() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetTopRight2f());
    }
    inline FVector2f GetTopRight2f() const
    {
        return FVector2f(Right, Top);
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetBottomRight() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetBottomRight2f());
    }
    inline FVector2f GetBottomRight2f() const
    {
        return FVector2f(Right, Bottom);
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetBottomLeft() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetBottomLeft2f());
    }
    inline FVector2f GetBottomLeft2f() const
    {
        return FVector2f(Left, Bottom);
    }
 
    inline FSlateRect InsetBy(const struct FMargin& InsetAmount) const
    {
        return FSlateRect(Left + InsetAmount.Left, Top + InsetAmount.Top, Right - InsetAmount.Right, Bottom - InsetAmount.Bottom);
    }
 
    inline FSlateRect ExtendBy(const FMargin& ExtendAmount) const
    {
        return FSlateRect(Left - ExtendAmount.Left, Top - ExtendAmount.Top, Right + ExtendAmount.Right, Bottom + ExtendAmount.Bottom);
    }
 
    inline FSlateRect OffsetBy( const UE::Slate::FDeprecateVector2DParameter& OffsetAmount ) const
    {
        return FSlateRect(GetTopLeft2f() + OffsetAmount, GetBottomRight2f() + OffsetAmount);
    }
 
    inline FSlateRect ScaleBy(float ScaleBy) const
    {
        const FVector2f Delta = GetSize() * 0.5f * ScaleBy;
        return ExtendBy(FMargin(Delta));
    }
 
    inline FSlateRect Expand( const FSlateRect& Other ) const
    {
        return FSlateRect( FMath::Min( Left, Other.Left ), FMath::Min( Top, Other.Top ), FMath::Max( Right, Other.Right ), FMath::Max( Bottom, Other.Bottom ) );
    }
 
    inline FSlateRect Round() const
    {
        return FSlateRect(
            FMath::RoundToFloat(Left),
            FMath::RoundToFloat(Top),
            FMath::RoundToFloat(Right),
            FMath::RoundToFloat(Bottom));
    }
 
    inline FSlateRect IntersectionWith(const FSlateRect& Other) const
    {
        bool bOverlapping;
        return IntersectionWith(Other, bOverlapping);
    }
 
    FSlateRect IntersectionWith(const FSlateRect& Other, bool& OutOverlapping) const
    {
        FSlateRect Intersected( FMath::Max( this->Left, Other.Left ), FMath::Max(this->Top, Other.Top), FMath::Min( this->Right, Other.Right ), FMath::Min( this->Bottom, Other.Bottom ) );
        if ( (Intersected.Bottom < Intersected.Top) || (Intersected.Right < Intersected.Left) )
        {
            OutOverlapping = false;
            // The intersection has 0 area and should not be rendered at all.
            return FSlateRect(0,0,0,0);
        }
        else
        {
            OutOverlapping = true;
            return Intersected;
        }
    }
 
    inline bool ContainsPoint( const UE::Slate::FDeprecateVector2DParameter& Point ) const
    {
        return Point.X >= Left && Point.X <= Right && Point.Y >= Top && Point.Y <= Bottom;
    }
 
    bool operator==( const FSlateRect& Other ) const
    {
        return
            Left == Other.Left &&
            Top == Other.Top &&
            Right == Other.Right &&
            Bottom == Other.Bottom;
    }
 
    bool operator!=( const FSlateRect& Other ) const
    {
        return Left != Other.Left || Top != Other.Top || Right != Other.Right || Bottom != Other.Bottom;
    }
 
    friend FSlateRect operator+( const FSlateRect& A, const FSlateRect& B )
    {
        return FSlateRect( A.Left + B.Left, A.Top + B.Top, A.Right + B.Right, A.Bottom + B.Bottom );
    }
 
    friend FSlateRect operator-( const FSlateRect& A, const FSlateRect& B )
    {
        return FSlateRect( A.Left - B.Left, A.Top - B.Top, A.Right - B.Right, A.Bottom - B.Bottom );
    }
 
    friend FSlateRect operator*( float Scalar, const FSlateRect& Rect )
    {
        return FSlateRect( Rect.Left * Scalar, Rect.Top * Scalar, Rect.Right * Scalar, Rect.Bottom * Scalar );
    }
 
    static bool DoRectanglesIntersect( const FSlateRect& A, const FSlateRect& B )
    {
        //  Segments A and B do not intersect when:
        //
        //       (left)   A     (right)
        //         o-------------o
        //  o---o        OR         o---o
        //    B                       B
        //
        //
        // We assume the A and B are well-formed rectangles.
        // i.e. (Top,Left) is above and to the left of (Bottom,Right)
        const bool bDoNotOverlap =
            B.Right < A.Left || A.Right < B.Left ||
            B.Bottom < A.Top || A.Bottom < B.Top;
 
        return ! bDoNotOverlap;
    }
 
    inline static bool IsRectangleContained( const FSlateRect& A, const FSlateRect& B )
    {
        return (A.Left <= B.Left) && (A.Right >= B.Right) && (A.Top <= B.Top) && (A.Bottom >= B.Bottom);
    }
 
    SLATECORE_API FString ToString() const;
 
    SLATECORE_API bool InitFromString(const FString& InSourceString);
 
    
    friend inline uint32 GetTypeHash(const FSlateRect& Key)
    {
        uint32 Hash = 0;
        Hash = HashCombine(Hash, GetTypeHash(Key.Left));
        Hash = HashCombine(Hash, GetTypeHash(Key.Right));
        Hash = HashCombine(Hash, GetTypeHash(Key.Top));
        Hash = HashCombine(Hash, GetTypeHash(Key.Bottom));
        return Hash;
    }
};
 
template <typename TransformType>
FSlateRect TransformRect(const TransformType& Transform, const FSlateRect& Rect)
{
    FVector2f TopLeftTransformed = TransformPoint(Transform, FVector2f(Rect.Left, Rect.Top));
    FVector2f BottomRightTransformed = TransformPoint(Transform, FVector2f(Rect.Right, Rect.Bottom));
 
    if (TopLeftTransformed.X > BottomRightTransformed.X)
    {
        Swap(TopLeftTransformed.X, BottomRightTransformed.X);
    }
    if (TopLeftTransformed.Y > BottomRightTransformed.Y)
    {
        Swap(TopLeftTransformed.Y, BottomRightTransformed.Y);
    }
    return FSlateRect(TopLeftTransformed, BottomRightTransformed);
}
 
template<> struct TIsPODType<FSlateRect> { enum { Value = true }; };