IntRect.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/MathFwd.h" // IWYU pragma: export
#include "Math/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Math/IntPoint.h"
#include "Math/Vector2D.h"
 
namespace UE::Math
{
 
template <typename InIntType>
struct TIntRect
{
    using IntType = InIntType;
    using IntPointType = TIntPoint<IntType>;
    static_assert(std::is_integral_v<IntType>, "Only an integer types are supported.");
 
    union
    {
        struct
        {
            IntPointType Min;
 
            IntPointType Max;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        IntPointType MinMax[2];
    };
 
    [[nodiscard]] TIntRect()
        : Min(ForceInit)
        , Max(ForceInit)
    {}
 
    [[nodiscard]] TIntRect(IntType X0, IntType Y0, IntType X1, IntType Y1)
        : Min(X0, Y0)
        , Max(X1, Y1)
    {
    }
 
    [[nodiscard]] TIntRect(IntPointType InMin, IntPointType InMax)
        : Min(InMin)
        , Max(InMax)
    {
    }
 
    [[nodiscard]] TIntRect(const TIntRect& Other)
    {
        *this = Other;
    }
 
    TIntRect& operator=(const TIntRect& Other)
    {
        Min = Other.Min;
        Max = Other.Max;
        return *this;
    }
 
    template <typename OtherIntType>
    [[nodiscard]] explicit TIntRect(TIntRect<OtherIntType> Other)
        : Min(IntPointType(Other.Min))
        , Max(IntPointType(Other.Max))
    {
    }
 
    [[nodiscard]] const TIntRect& operator()(int32 PointIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return MinMax[PointIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] TIntRect& operator()(int32 PointIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return MinMax[PointIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] bool operator==(const TIntRect& Other) const
    {
        return Min == Other.Min && Max == Other.Max;
    }
 
    [[nodiscard]] bool operator!=(const TIntRect& Other) const
    {
        return Min != Other.Min || Max != Other.Max;
    }
 
    TIntRect& operator*=(IntType Scale)
    {
        Min *= Scale;
        Max *= Scale;
 
        return *this;
    }
 
    TIntRect& operator+=(const IntPointType& Point)
    {
        Min += Point;
        Max += Point;
 
        return *this;
    }
 
    TIntRect& operator-=(const IntPointType& Point)
    {
        Min -= Point;
        Max -= Point;
 
        return *this;
    }
 
    [[nodiscard]] TIntRect operator*(IntType Scale) const
    {
        return TIntRect(Min * Scale, Max * Scale);
    }
 
    [[nodiscard]] TIntRect operator/(IntType Div) const
    {
        return TIntRect(Min / Div, Max / Div);
    }
 
    [[nodiscard]] TIntRect operator+(const IntPointType& Point) const
    {
        return TIntRect(Min + Point, Max + Point);
    }
 
    [[nodiscard]] TIntRect operator/(const IntPointType& Point) const
    {
        return TIntRect(Min / Point, Max / Point);
    }
 
    [[nodiscard]] TIntRect operator-(const IntPointType& Point) const
    {
        return TIntRect(Min - Point, Max - Point);
    }
 
    [[nodiscard]] TIntRect operator+(const TIntRect& Other) const
    {
        return TIntRect(Min + Other.Min, Max + Other.Max);
    }
 
    [[nodiscard]] TIntRect operator-(const TIntRect& Other) const
    {
        return TIntRect(Min - Other.Min, Max - Other.Max);
    }
 
    [[nodiscard]] IntType Area() const
    {
        return (Max.X - Min.X) * (Max.Y - Min.Y);
    }
 
    [[nodiscard]] TIntRect Bottom(IntType InHeight) const
    {
        return TIntRect(Min.X, FMath::Max(Min.Y, Max.Y - InHeight), Max.X, Max.Y);
    }
 
    void Clip(const TIntRect& R)
    {
        Min.X = FMath::Max<IntType>(Min.X, R.Min.X);
        Min.Y = FMath::Max<IntType>(Min.Y, R.Min.Y);
        Max.X = FMath::Min<IntType>(Max.X, R.Max.X);
        Max.Y = FMath::Min<IntType>(Max.Y, R.Max.Y);
 
        // return zero area if not overlapping
        Max.X = FMath::Max<IntType>(Min.X, Max.X);
        Max.Y = FMath::Max<IntType>(Min.Y, Max.Y);
    }
 
    void Union(const TIntRect& R)
    {
        Min.X = FMath::Min<IntType>(Min.X, R.Min.X);
        Min.Y = FMath::Min<IntType>(Min.Y, R.Min.Y);
        Max.X = FMath::Max<IntType>(Max.X, R.Max.X);
        Max.Y = FMath::Max<IntType>(Max.Y, R.Max.Y);
    }
 
    [[nodiscard]] bool Intersect(const TIntRect& Other) const
    {
        return Other.Min.X < Max.X && Other.Max.X > Min.X && Other.Min.Y < Max.Y && Other.Max.Y > Min.Y;
    }
 
    [[nodiscard]] bool Contains(IntPointType P) const
    {
        return P.X >= Min.X && P.X < Max.X&& P.Y >= Min.Y && P.Y < Max.Y;
    }
 
    [[nodiscard]] bool Contains(const FIntRect& Other) const
    {
        return Other.Min.X >= Min.X && Other.Max.X <= Max.X &&
               Other.Min.Y >= Min.Y && Other.Max.Y <= Max.Y;
    }
 
    void GetCenterAndExtents(IntPointType& OutCenter, IntPointType& OutExtent) const
    {
        OutExtent.X = (Max.X - Min.X) / 2;
        OutExtent.Y = (Max.Y - Min.Y) / 2;
 
        OutCenter.X = Min.X + OutExtent.X;
        OutCenter.Y = Min.Y + OutExtent.Y;
    }
 
    [[nodiscard]] IntType Height() const
    {
        return (Max.Y - Min.Y);
    }
 
 
    void InflateRect(IntType Amount)
    {
        Min.X -= Amount;
        Min.Y -= Amount;
        Max.X += Amount;
        Max.Y += Amount;
    }
    void Include(IntPointType Point)
    {
        Min.X = FMath::Min(Min.X, Point.X);
        Min.Y = FMath::Min(Min.Y, Point.Y);
        Max.X = FMath::Max(Max.X, Point.X);
        Max.Y = FMath::Max(Max.Y, Point.Y);
    }
 
    [[nodiscard]] TIntRect Inner(IntPointType Shrink) const
    {
        return TIntRect(Min + Shrink, Max - Shrink);
    }
    [[nodiscard]] TIntRect Right(IntType InWidth) const
    {
        return TIntRect(FMath::Max(Min.X, Max.X - InWidth), Min.Y, Max.X, Max.Y);
    }
 
    [[nodiscard]] TIntRect Scale(double Fraction) const
    {
        using Vec2D = UE::Math::TVector2<double>;
        const Vec2D Min2D = Vec2D((double)Min.X, (double)Min.Y) * Fraction;
        const Vec2D Max2D = Vec2D((double)Max.X, (double)Max.Y) * Fraction;
 
        return TIntRect(
            IntCastChecked<IntType>(FMath::FloorToInt64(Min2D.X)),
            IntCastChecked<IntType>(FMath::FloorToInt64(Min2D.Y)),
            IntCastChecked<IntType>(FMath::CeilToInt64(Max2D.X)),
            IntCastChecked<IntType>(FMath::CeilToInt64(Max2D.Y))
        );
    }
 
    [[nodiscard]] IntPointType Size() const
    {
        return IntPointType(Max.X - Min.X, Max.Y - Min.Y);
    }
 
    [[nodiscard]] FString ToString() const
    {
        return FString::Printf(TEXT("Min=(%s) Max=(%s)"), *Min.ToString(), *Max.ToString());
    }
 
    [[nodiscard]] IntType Width() const
    {
        return Max.X - Min.X;
    }
 
    [[nodiscard]] bool IsEmpty() const
    {
        return Width() == 0 && Height() == 0;
    }
 
    [[nodiscard]] static TIntRect DivideAndRoundUp(TIntRect lhs, IntType Div)
    {
        return DivideAndRoundUp(lhs, IntPointType(Div, Div));
    }
 
    [[nodiscard]] static TIntRect DivideAndRoundUp(TIntRect lhs, IntPointType Div)
    {
        return TIntRect(lhs.Min / Div, IntPointType::DivideAndRoundUp(lhs.Max, Div));
    }
 
    [[nodiscard]] static constexpr int32 Num()
    {
        return 2;
    }
 
public:
 
    friend FArchive& operator<<( FArchive& Ar, TIntRect& Rect )
    {
        return Ar << Rect.Min.X << Rect.Min.Y << Rect.Max.X << Rect.Max.Y;
    }
};
 
template <typename IntType>
uint32 GetTypeHash(const TIntRect<IntType>& InRect)
{
    return HashCombine(GetTypeHash(InRect.Min), GetTypeHash(InRect.Max));
}
 
} 
 
template <> struct TIsPODType<FInt32Rect> { enum { Value = true }; };
template <> struct TIsPODType<FUint32Rect> { enum { Value = true }; };
 
template <> struct TIsUECoreVariant<FInt32Rect>  { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint32Rect> { enum { Value = true }; };
 
template <> struct TIsPODType<FInt64Rect> { enum { Value = true }; };
template <> struct TIsPODType<FUint64Rect> { enum { Value = true }; };
 
template <> struct TIsUECoreVariant<FInt64Rect> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint64Rect> { enum { Value = true }; };