IntPoint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Parse.h"
#include "Math/MathFwd.h" // IWYU pragma: export
#include "Math/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/TypeHash.h"
#include "Misc/LargeWorldCoordinatesSerializer.h"
 
namespace UE::Math
{
 
template <typename InIntType>
struct TIntPoint
{
    using IntType = InIntType;
    static_assert(std::is_integral_v<IntType>, "An integer type is required.");
 
    union
    {
        struct
        {
            IntType X;
 
            IntType Y;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        IntType XY[2];
    };
 
    static const TIntPoint ZeroValue;
 
    static const TIntPoint NoneValue;
 
    [[nodiscard]] TIntPoint() = default;
 
[[nodiscard]] TIntPoint(IntType InX, IntType InY)
        : X(InX)
        , Y(InY)
    {
    }
 
    [[nodiscard]] TIntPoint(IntType InXY)
        : X(InXY)
        , Y(InXY)
    {
    }
 
    [[nodiscard]] explicit TIntPoint(EForceInit)
        : X(0)
        , Y(0)
    {
    }
 
    template <typename OtherIntType>
    [[nodiscard]] explicit TIntPoint(TIntPoint<OtherIntType> Other)
        : X(IntCastChecked<IntType>(Other.X))
        , Y(IntCastChecked<IntType>(Other.Y))
    {
    }
 
    // Workaround for clang deprecation warnings for deprecated XY member in implicitly-defined special member functions
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    TIntPoint(TIntPoint&&) = default;
    TIntPoint(const TIntPoint&) = default;
    TIntPoint& operator=(TIntPoint&&) = default;
    TIntPoint& operator=(const TIntPoint&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    [[nodiscard]] const IntType& operator()(int32 PointIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XY[PointIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] IntType& operator()(int32 PointIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XY[PointIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] bool operator==(const TIntPoint& Other) const
    {
        return X == Other.X && Y == Other.Y;
    }
 
    [[nodiscard]] bool operator!=(const TIntPoint& Other) const
    {
        return (X != Other.X) || (Y != Other.Y);
    }
 
    TIntPoint& operator*=(IntType Scale)
    {
        X *= Scale;
        Y *= Scale;
 
        return *this;
    }
 
    TIntPoint& operator/=(IntType Divisor)
    {
        X /= Divisor;
        Y /= Divisor;
 
        return *this;
    }
 
    TIntPoint& operator+=(const TIntPoint& Other)
    {
        X += Other.X;
        Y += Other.Y;
 
        return *this;
    }
 
    TIntPoint& operator*=(const TIntPoint& Other)
    {
        X *= Other.X;
        Y *= Other.Y;
 
        return *this;
    }
 
    TIntPoint& operator-=(const TIntPoint& Other)
    {
        X -= Other.X;
        Y -= Other.Y;
 
        return *this;
    }
 
    TIntPoint& operator/=(const TIntPoint& Other)
    {
        X /= Other.X;
        Y /= Other.Y;
 
        return *this;
    }
 
    [[nodiscard]] TIntPoint operator*(IntType Scale) const
    {
        return TIntPoint(*this) *= Scale;
    }
 
    [[nodiscard]] TIntPoint operator/(IntType Divisor) const
    {
        return TIntPoint(*this) /= Divisor;
    }
 
    [[nodiscard]] TIntPoint operator+(const TIntPoint& Other) const
    {
        return TIntPoint(*this) += Other;
    }
 
    [[nodiscard]] TIntPoint operator-(const TIntPoint& Other) const
    {
        return TIntPoint(*this) -= Other;
    }
 
    [[nodiscard]] TIntPoint operator*(const TIntPoint& Other) const
    {
        return TIntPoint(*this) *= Other;
    }
 
    [[nodiscard]] TIntPoint operator/(const TIntPoint& Other) const
    {
        return TIntPoint(*this) /= Other;
    }
 
    [[nodiscard]] IntType& operator[](IntType Index)
    {
        check(Index >= 0 && Index < 2);
        return ((Index == 0) ? X : Y);
    }
 
    [[nodiscard]] IntType operator[](IntType Index) const
    {
        check(Index >= 0 && Index < 2);
        return ((Index == 0) ? X : Y);
    }
 
    [[nodiscard]] TIntPoint ComponentMin(const TIntPoint& Other) const
    {
        return TIntPoint(FMath::Min(X, Other.X), FMath::Min(Y, Other.Y));
    }
 
    [[nodiscard]] TIntPoint ComponentMax(const TIntPoint& Other) const
    {
        return TIntPoint(FMath::Max(X, Other.X), FMath::Max(Y, Other.Y));
    }
 
    [[nodiscard]] IntType GetMax() const
    {
        return FMath::Max(X, Y);
    }
 
    [[nodiscard]] IntType GetMin() const
    {
        return FMath::Min(X, Y);
    }
 
    [[nodiscard]] IntType Size() const
    {
        int64 LocalX64 = (int64)X;
        int64 LocalY64 = (int64)Y;
        return IntType(FMath::Sqrt(double(LocalX64 * LocalX64 + LocalY64 * LocalY64)));
    }
 
    [[nodiscard]] IntType SizeSquared() const
    {
        return X * X + Y * Y;
    }
 
    [[nodiscard]] FString ToString() const
    {
        return FString::Printf(TEXT("X=%s Y=%s"), *LexToString(X), *LexToString(Y));
    }
 
    bool InitFromString(const FString& InSourceString)
    {
        X = Y = 0;
 
        // The initialization is only successful if the X and Y values can all be parsed from the string
        const bool bSuccessful = FParse::Value(*InSourceString, TEXT("X="), X) && FParse::Value(*InSourceString, TEXT("Y="), Y);
 
        return bSuccessful;
    }
 
    [[nodiscard]] static TIntPoint DivideAndRoundUp(TIntPoint lhs, IntType Divisor)
    {
        return TIntPoint(FMath::DivideAndRoundUp(lhs.X, Divisor), FMath::DivideAndRoundUp(lhs.Y, Divisor));
    }
 
    [[nodiscard]] static TIntPoint DivideAndRoundUp(TIntPoint lhs, TIntPoint Divisor)
    {
        return TIntPoint(FMath::DivideAndRoundUp(lhs.X, Divisor.X), FMath::DivideAndRoundUp(lhs.Y, Divisor.Y));
    }
 
    [[nodiscard]] static TIntPoint DivideAndRoundDown(TIntPoint lhs, IntType Divisor)
    {
        return TIntPoint(FMath::DivideAndRoundDown(lhs.X, Divisor), FMath::DivideAndRoundDown(lhs.Y, Divisor));
    }
 
    [[nodiscard]] static TIntPoint DivideAndRoundDown(TIntPoint lhs, TIntPoint Divisor)
    {
        return TIntPoint(FMath::DivideAndRoundDown(lhs.X, Divisor.X), FMath::DivideAndRoundDown(lhs.Y, Divisor.Y));
    }
 
    [[nodiscard]] static int32 Num()
    {
        return 2;
    }
 
    friend FArchive& operator<<(FArchive& Ar, TIntPoint& Point)
    {
        return Ar << Point.X << Point.Y;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, TIntPoint& Point)
    {
        FStructuredArchive::FRecord Record = Slot.EnterRecord();
        Record << SA_VALUE(TEXT("X"), Point.X) << SA_VALUE(TEXT("Y"), Point.Y);
    }
 
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    bool SerializeFromMismatchedTag(FName StructTag, FArchive& Ar)
    {
        if constexpr (std::is_same_v<IntType, int32>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, IntPoint, Int32Point, Int64Point);
        }
        else if constexpr (std::is_same_v<IntType, int64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, IntPoint, Int64Point, Int32Point);
        }
        else if constexpr (std::is_same_v<IntType, uint32>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintPoint, Uint32Point, Uint64Point);
        }
        else if constexpr (std::is_same_v<IntType, uint64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintPoint, Uint64Point, Uint32Point);
        }
        else
        {
            static_assert(sizeof(IntType) == 0, "Unimplemented");
            return false;
        }
    }
};
 
template <typename IntType>
const TIntPoint<IntType> TIntPoint<IntType>::ZeroValue(0, 0);
 
template <typename IntType>
const TIntPoint<IntType> TIntPoint<IntType>::NoneValue(static_cast<IntType>(INDEX_NONE), static_cast<IntType>(INDEX_NONE));
 
template <typename IntType>
uint32 GetTypeHash(const TIntPoint<IntType>& InPoint)
{
    return HashCombine(::GetTypeHash(InPoint.X), ::GetTypeHash(InPoint.Y));
}
 
template <>
inline FString TIntPoint<int64>::ToString() const
{
    return FString::Printf(TEXT("X=%lld Y=%lld"), X, Y);
}
 
template <>
inline FString TIntPoint<int32>::ToString() const
{
    return FString::Printf(TEXT("X=%d Y=%d"), X, Y);
}
 
template <>
inline FString TIntPoint<int16>::ToString() const
{
    return FString::Printf(TEXT("X=%d Y=%d"), X, Y);
}
 
template <>
inline FString TIntPoint<int8>::ToString() const
{
    return FString::Printf(TEXT("X=%d Y=%d"), X, Y);
}
 
template <>
inline FString TIntPoint<uint64>::ToString() const
{
    return FString::Printf(TEXT("X=%llu Y=%llu"), X, Y);
}
 
template <>
inline FString TIntPoint<uint32>::ToString() const
{
    return FString::Printf(TEXT("X=%u Y=%u"), X, Y);
}
 
template <>
inline FString TIntPoint<uint16>::ToString() const
{
    return FString::Printf(TEXT("X=%u Y=%u"), X, Y);
}
 
template <>
inline FString TIntPoint<uint8>::ToString() const
{
    return FString::Printf(TEXT("X=%u Y=%u"), X, Y);
}
 
} 
 
template <> struct TIsPODType<FInt32Point>  { enum { Value = true }; };
template <> struct TIsPODType<FUint32Point> { enum { Value = true }; };
 
template<> struct TIsUECoreVariant<FInt32Point>  { enum { Value = true }; };
template<> struct TIsUECoreVariant<FUint32Point> { enum { Value = true }; };
 
template <> struct TIsPODType<FInt64Point> { enum { Value = true }; };
template <> struct TIsPODType<FUint64Point> { enum { Value = true }; };
 
template<> struct TIsUECoreVariant<FInt64Point> { enum { Value = true }; };
template<> struct TIsUECoreVariant<FUint64Point> { enum { Value = true }; };