IntVector.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/Crc.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 "Misc/LargeWorldCoordinatesSerializer.h"
 
namespace UE::Math
{
 
template <typename InIntType>
struct TIntVector3
{
    using IntType = InIntType;
    static_assert(std::is_integral_v<IntType>, "Only an integer types are supported.");
 
    union
    {
        struct
        {
            IntType X;
 
            IntType Y;
 
            IntType Z;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        IntType XYZ[3];
    };
 
    static const TIntVector3 ZeroValue;
 
    static const TIntVector3 NoneValue;
 
    [[nodiscard]] TIntVector3() = default;
 
    [[nodiscard]] TIntVector3(IntType InX, IntType InY, IntType InZ)
        : X(InX)
        , Y(InY)
        , Z(InZ)
    {
    }
 
    [[nodiscard]] explicit TIntVector3(IntType InValue)
        : X(InValue)
        , Y(InValue)
        , Z(InValue)
    {
    }
 
    [[nodiscard]] explicit TIntVector3(TIntVector4<IntType> Other)
        : X(Other.X)
        , Y(Other.Y)
        , Z(Other.Z)
    {
    }
 
    template <typename FloatType>
    [[nodiscard]] explicit TIntVector3(TVector<FloatType> InVector);
 
    [[nodiscard]] explicit TIntVector3(EForceInit)
        : X(0)
        , Y(0)
        , Z(0)
    {
    }
 
    template <typename OtherIntType>
    [[nodiscard]] explicit TIntVector3(TIntVector3<OtherIntType> Other)
        : X(IntCastChecked<IntType>(Other.X))
        , Y(IntCastChecked<IntType>(Other.Y))
        , Z(IntCastChecked<IntType>(Other.Z))
    {
    }
 
    // Workaround for clang deprecation warnings for deprecated XYZ member in implicitly-defined special member functions
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    TIntVector3(TIntVector3&&) = default;
    TIntVector3(const TIntVector3&) = default;
    TIntVector3& operator=(TIntVector3&&) = default;
    TIntVector3& operator=(const TIntVector3&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    [[nodiscard]] const IntType& operator()(int32 ComponentIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZ[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] IntType& operator()(int32 ComponentIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZ[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] const IntType& operator[](int32 ComponentIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZ[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] IntType& operator[](int32 ComponentIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZ[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    [[nodiscard]] bool operator==(const TIntVector3& Other) const
    {
        return X == Other.X && Y == Other.Y && Z == Other.Z;
    }
 
    [[nodiscard]] bool operator!=(const TIntVector3& Other) const
    {
        return X != Other.X || Y != Other.Y || Z != Other.Z;
    }
 
    TIntVector3& operator*=(const TIntVector3& Other)
    {
        X *= Other.X;
        Y *= Other.Y;
        Z *= Other.Z;
 
        return *this;
    }
 
    TIntVector3& operator*=(IntType Scale)
    {
        X *= Scale;
        Y *= Scale;
        Z *= Scale;
 
        return *this;
    }
 
    TIntVector3& operator/=(IntType Divisor)
    {
        X /= Divisor;
        Y /= Divisor;
        Z /= Divisor;
 
        return *this;
    }
 
    TIntVector3& operator%=(IntType Divisor)
    {
        X %= Divisor;
        Y %= Divisor;
        Z %= Divisor;
 
        return *this;
    }
 
    TIntVector3& operator+=(const TIntVector3& Other)
    {
        X += Other.X;
        Y += Other.Y;
        Z += Other.Z;
 
        return *this;
    }
 
    TIntVector3& operator-=(const TIntVector3& Other)
    {
        X -= Other.X;
        Y -= Other.Y;
        Z -= Other.Z;
 
        return *this;
    }
 
    [[nodiscard]] TIntVector3 operator*(const TIntVector3& Other) const
    {
        return TIntVector3(*this) *= Other;
    }
 
    [[nodiscard]] TIntVector3 operator*(IntType Scale) const
    {
        return TIntVector3(*this) *= Scale;
    }
 
    [[nodiscard]] TIntVector3 operator/(IntType Divisor) const
    {
        return TIntVector3(*this) /= Divisor;
    }
 
    [[nodiscard]] TIntVector3 operator%(IntType Divisor) const
    {
        return TIntVector3(*this) %= Divisor;
    }
 
    [[nodiscard]] TIntVector3 operator+(const TIntVector3& Other) const
    {
        return TIntVector3(*this) += Other;
    }
 
    [[nodiscard]] TIntVector3 operator-(const TIntVector3& Other) const
    {
        return TIntVector3(*this) -= Other;
    }
 
    [[nodiscard]] TIntVector3 operator>>(IntType Shift) const
    {
        return TIntVector3(X >> Shift, Y >> Shift, Z >> Shift);
    }
 
    [[nodiscard]] TIntVector3 operator<<(IntType Shift) const
    {
        return TIntVector3(X << Shift, Y << Shift, Z << Shift);
    }
 
    [[nodiscard]] TIntVector3 operator&(IntType Value) const
    {
        return TIntVector3(X & Value, Y & Value, Z & Value);
    }
 
    [[nodiscard]] TIntVector3 operator|(IntType Value) const
    {
        return TIntVector3(X | Value, Y | Value, Z | Value);
    }
 
    [[nodiscard]] TIntVector3 operator^(IntType Value) const
    {
        return TIntVector3(X ^ Value, Y ^ Value, Z ^ Value);
    }
 
    [[nodiscard]] bool IsZero() const
    {
        return *this == ZeroValue;
    }
 
    [[nodiscard]] IntType GetMax() const
    {
        return FMath::Max(FMath::Max(X, Y), Z);
    }
 
    [[nodiscard]] IntType GetAbsMax() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Max(FMath::Max(FMath::Abs(X), FMath::Abs(Y)), FMath::Abs(Z));
        }
        else
        {
            return GetMax();
        }
    }
 
    [[nodiscard]] IntType GetMin() const
    {
        return FMath::Min(FMath::Min(X, Y), Z);
    }
 
    [[nodiscard]] IntType GetAbsMin() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Min(FMath::Min(FMath::Abs(X), FMath::Abs(Y)), FMath::Abs(Z));
        }
        else
        {
            return GetMin();
        }
    }
 
    [[nodiscard]] TIntVector3 ComponentMax(const TIntVector3& Other) const
    {
        return TIntVector3(
            FMath::Max(X, Other.X),
            FMath::Max(Y, Other.Y),
            FMath::Max(Z, Other.Z));
    }
 
    [[nodiscard]] TIntVector3 ComponentMin(const TIntVector3& Other) const
    {
        return TIntVector3(
            FMath::Min(X, Other.X),
            FMath::Min(Y, Other.Y),
            FMath::Min(Z, Other.Z));
    }
 
    [[nodiscard]] IntType Size() const
    {
        int64 LocalX64 = (int64)X;
        int64 LocalY64 = (int64)Y;
        int64 LocalZ64 = (int64)Z;
        return IntType(FMath::Sqrt(double(LocalX64 * LocalX64 + LocalY64 * LocalY64 + LocalZ64 * LocalZ64)));
    }
 
    template <typename CharType>
    void AppendString(TStringBuilderBase<CharType>& Out) const
    {
        Out << "X=" << X << " Y=" << Y << " Z=" << Z;
    }
 
    template <typename CharType>
    friend TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const TIntVector3& Vector)
    {
        Vector.AppendString(Builder);
        return Builder;
    }
 
    void AppendString(FString& Out) const
    {
        TStringBuilder<128> Builder;
        Builder << *this;
        Out.Append(Builder);
    }
 
    [[nodiscard]] FString ToString() const
    {
        FString Out;
        AppendString(Out);
        return Out;
    }
 
    bool InitFromString(const FString& InSourceString)
    {
        X = Y = Z = 0;
 
        // The initialization is only successful if the X, Y and Z values can all be parsed from the string
        const bool bSuccessful = FParse::Value(*InSourceString, TEXT("X="), X) && FParse::Value(*InSourceString, TEXT("Y="), Y) && FParse::Value(*InSourceString, TEXT("Z="), Z);
 
        return bSuccessful;
    }
 
    [[nodiscard]] static TIntVector3 DivideAndRoundUp(TIntVector3 Lhs, IntType Divisor)
    {
        return TIntVector3(FMath::DivideAndRoundUp(Lhs.X, Divisor), FMath::DivideAndRoundUp(Lhs.Y, Divisor), FMath::DivideAndRoundUp(Lhs.Z, Divisor));
    }
 
    [[nodiscard]] static TIntVector3 DivideAndRoundUp(TIntVector3 Lhs, TIntVector3 Divisor)
    {
        return TIntVector3(FMath::DivideAndRoundUp(Lhs.X, Divisor.X), FMath::DivideAndRoundUp(Lhs.Y, Divisor.Y), FMath::DivideAndRoundUp(Lhs.Z, Divisor.Z));
    }
 
    [[nodiscard]] static int32 Num()
    {
        return 3;
    }
 
    friend FArchive& operator<<(FArchive& Ar, TIntVector3& Vector)
    {
        return Ar << Vector.X << Vector.Y << Vector.Z;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, TIntVector3& Vector)
    {
        FStructuredArchive::FRecord Record = Slot.EnterRecord();
        Record << SA_VALUE(TEXT("X"), Vector.X);
        Record << SA_VALUE(TEXT("Y"), Vector.Y);
        Record << SA_VALUE(TEXT("Z"), Vector.Z);
    }
 
    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, IntVector, Int32Vector, Int64Vector);
        }
        else if constexpr (std::is_same_v<IntType, int64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, IntVector, Int64Vector, Int32Vector);
        }
        else if constexpr (std::is_same_v<IntType, uint32>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector, Uint32Vector, Uint64Vector);
        }
        else if constexpr (std::is_same_v<IntType, uint64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector, Uint64Vector, Uint32Vector);
        }
        else
        {
            static_assert(sizeof(IntType) == 0, "Unimplemented");
            return false;
        }
    }
};
 
template <typename IntType>
const TIntVector3<IntType> TIntVector3<IntType>::ZeroValue(0, 0, 0);
 
template <typename IntType>
const TIntVector3<IntType> TIntVector3<IntType>::NoneValue(INDEX_NONE, INDEX_NONE, INDEX_NONE);
 
 
template <typename InIntType>
struct TIntVector2
{
    using IntType = InIntType;
    static_assert(std::is_integral_v<IntType>, "Only an integer types are supported.");
 
    union
    {
        struct
        {
            IntType X;
 
            IntType Y;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        IntType XY[2];
    };
 
    static const TIntVector2 ZeroValue;
 
    static const TIntVector2 NoneValue;
 
    TIntVector2() = default;
 
    TIntVector2(IntType InX, IntType InY)
        : X(InX)
        , Y(InY)
    {
    }
 
    explicit TIntVector2(IntType InValue)
        : X(InValue)
        , Y(InValue)
    {
    }
 
    TIntVector2(EForceInit)
        : X(0)
        , Y(0)
    {
    }
 
    TIntVector2(TIntPoint<IntType> Other)
        : X(Other.X)
        , Y(Other.Y)
    {
    }
 
    explicit TIntVector2(TIntVector3<IntType> Other)
        : X(Other.X)
        , Y(Other.Y)
    {
    }
 
    template <typename OtherIntType>
    explicit TIntVector2(TIntVector2<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
    TIntVector2(TIntVector2&&) = default;
    TIntVector2(const TIntVector2&) = default;
    TIntVector2& operator=(TIntVector2&&) = default;
    TIntVector2& operator=(const TIntVector2&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    const IntType& operator[](int32 ComponentIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XY[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    IntType& operator[](int32 ComponentIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XY[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    bool operator==(const TIntVector2& Other) const
    {
        return X==Other.X && Y==Other.Y;
    }
 
    bool operator!=(const TIntVector2& Other) const
    {
        return X!=Other.X || Y!=Other.Y;
    }
 
    TIntVector2& operator*=(const TIntVector2& Other)
    {
        X *= Other.X;
        Y *= Other.Y;
 
        return *this;
    }
 
    TIntVector2& operator*=(IntType Scale)
    {
        X *= Scale;
        Y *= Scale;
 
        return *this;
    }
 
    TIntVector2& operator/=(IntType Divisor)
    {
        X /= Divisor;
        Y /= Divisor;
 
        return *this;
    }
 
    TIntVector2& operator%=(IntType Divisor)
    {
        X %= Divisor;
        Y %= Divisor;
 
        return *this;
    }
 
    TIntVector2& operator+=(const TIntVector2& Other)
    {
        X += Other.X;
        Y += Other.Y;
 
        return *this;
    }
 
    TIntVector2& operator-=(const TIntVector2& Other)
    {
        X -= Other.X;
        Y -= Other.Y;
 
        return *this;
    }
 
    TIntVector2 operator*(const TIntVector2& Other) const
    {
        return TIntVector2(*this) *= Other;
    }
 
    TIntVector2 operator*(IntType Scale) const
    {
        return TIntVector2(*this) *= Scale;
    }
 
    TIntVector2 operator/(IntType Divisor) const
    {
        return TIntVector2(*this) /= Divisor;
    }
 
    TIntVector2 operator%(IntType Divisor) const
    {
        return TIntVector2(*this) %= Divisor;
    }
 
    TIntVector2 operator+(const TIntVector2& Other) const
    {
        return TIntVector2(*this) += Other;
    }
 
    TIntVector2 operator-(const TIntVector2& Other) const
    {
        return TIntVector2(*this) -= Other;
    }
 
    TIntVector2 operator>>(IntType Shift) const
    {
        return TIntVector2(X >> Shift, Y >> Shift);
    }
 
    TIntVector2 operator<<(IntType Shift) const
    {
        return TIntVector2(X << Shift, Y << Shift);
    }
 
    TIntVector2 operator&(IntType Value) const
    {
        return TIntVector2(X & Value, Y & Value);
    }
 
    TIntVector2 operator|(IntType Value) const
    {
        return TIntVector2(X | Value, Y | Value);
    }
 
    TIntVector2 operator^(IntType Value) const
    {
        return TIntVector2(X ^ Value, Y ^ Value);
    }
 
    bool IsZero() const
    {
        return *this == ZeroValue;
    }
 
    IntType GetMax() const
    {
        return FMath::Max(X, Y);
    }
 
    IntType GetAbsMax() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Max(FMath::Abs(X), FMath::Abs(Y));
        }
        else
        {
            return GetMax();
        }
    }
 
    IntType GetMin() const
    {
        return FMath::Min(X, Y);
    }
 
    IntType GetAbsMin() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Min(FMath::Abs(X), FMath::Abs(Y));
        }
        else
        {
            return GetMin();
        }
    }
 
    TIntVector2 ComponentMax(const TIntVector2& Other) const
    {
        return TIntVector2(
            FMath::Max(X, Other.X),
            FMath::Max(Y, Other.Y));
    }
 
    TIntVector2 ComponentMin(const TIntVector2& Other) const
    {
        return TIntVector2(
            FMath::Min(X, Other.X),
            FMath::Min(Y, Other.Y));
    }
 
    template <typename CharType>
    void AppendString(TStringBuilderBase<CharType>& Out) const
    {
        Out << "X=" << X << " Y=" << Y;
    }
 
    template <typename CharType>
    friend TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const TIntVector2& Vector)
    {
        Vector.AppendString(Builder);
        return Builder;
    }
 
    void AppendString(FString& Out) const
    {
        TStringBuilder<128> Builder;
        Builder << *this;
        Out.Append(Builder);
    }
 
    FString ToString() const
    {
        FString Out;
        AppendString(Out);
        return Out;
    }
 
    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;
    }
 
    static TIntVector2 DivideAndRoundUp(TIntVector2 Lhs, IntType Divisor)
    {
        return TIntVector2(FMath::DivideAndRoundUp(Lhs.X, Divisor), FMath::DivideAndRoundUp(Lhs.Y, Divisor));
    }
 
    static TIntVector2 DivideAndRoundUp(TIntVector2 Lhs, TIntVector2 Divisor)
    {
        return TIntVector2(FMath::DivideAndRoundUp(Lhs.X, Divisor.X), FMath::DivideAndRoundUp(Lhs.Y, Divisor.Y));
    }
 
    static int32 Num()
    {
        return 2;
    }
 
    friend FArchive& operator<<(FArchive& Ar, TIntVector2& Vector)
    {
        return Ar << Vector.X << Vector.Y;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, TIntVector2& Vector)
    {
        FStructuredArchive::FRecord Record = Slot.EnterRecord();
        Record << SA_VALUE(TEXT("X"), Vector.X);
        Record << SA_VALUE(TEXT("Y"), Vector.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, IntVector2, Int32Vector2, Int64Vector2);
        }
        else if constexpr (std::is_same_v<IntType, int64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, IntVector2, Int64Vector2, Int32Vector2);
        }
        else if constexpr (std::is_same_v<IntType, uint32>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector2, Uint32Vector2, Uint64Vector2);
        }
        else if constexpr (std::is_same_v<IntType, uint64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector2, Uint64Vector2, Uint32Vector2);
        }
        else
        {
            static_assert(sizeof(IntType) == 0, "Unimplemented");
            return false;
        }
    }
};
 
template <typename IntType>
const TIntVector2<IntType> TIntVector2<IntType>::ZeroValue(0, 0);
 
template <typename IntType>
const TIntVector2<IntType> TIntVector2<IntType>::NoneValue(INDEX_NONE, INDEX_NONE);
 
 
template <typename InIntType>
struct TIntVector4
{
    using IntType = InIntType;
    static_assert(std::is_integral_v<IntType>, "Only an integer types are supported.");
 
    union
    {
        struct
        {
            IntType X;
 
            IntType Y;
 
            IntType Z;
            
            IntType W;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        IntType XYZW[4];
    };
 
    static const TIntVector4 ZeroValue;
 
    static const TIntVector4 NoneValue;
 
    TIntVector4() = default;
 
    TIntVector4(IntType InX, IntType InY, IntType InZ, IntType InW)
        : X(InX)
        , Y(InY)
        , Z(InZ)
        , W(InW)
    {
    }
 
    explicit TIntVector4(IntType InValue)
        : X(InValue)
        , Y(InValue)
        , Z(InValue)
        , W(InValue)
    {
    }
 
    explicit TIntVector4(const TIntVector3<IntType>& InValue, IntType InW = 0)
        : X(InValue.X)
        , Y(InValue.Y)
        , Z(InValue.Z)
        , W(InW)
    {
    }
 
    TIntVector4(EForceInit)
        : X(0)
        , Y(0)
        , Z(0)
        , W(0)
    {
    }
 
    template <typename OtherIntType>
    explicit TIntVector4(TIntVector4<OtherIntType> Other)
        : X(IntCastChecked<IntType>(Other.X))
        , Y(IntCastChecked<IntType>(Other.Y))
        , Z(IntCastChecked<IntType>(Other.Z))
        , W(IntCastChecked<IntType>(Other.W))
    {
    }
 
    // Workaround for clang deprecation warnings for deprecated XYZW member in implicitly-defined special member functions
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    TIntVector4(TIntVector4&&) = default;
    TIntVector4(const TIntVector4&) = default;
    TIntVector4& operator=(TIntVector4&&) = default;
    TIntVector4& operator=(const TIntVector4&) = default;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    const IntType& operator()(int32 ComponentIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZW[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    IntType& operator()(int32 ComponentIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZW[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    const IntType& operator[](int32 ComponentIndex) const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZW[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    IntType& operator[](int32 ComponentIndex)
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return XYZW[ComponentIndex];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    bool operator==(const TIntVector4& Other) const
    {
        return X == Other.X && Y == Other.Y && Z == Other.Z && W == Other.W;
    }
 
    bool operator!=(const TIntVector4& Other) const
    {
        return X != Other.X || Y != Other.Y || Z != Other.Z || W != Other.W;
    }
 
    TIntVector4& operator*=(const TIntVector4& Other)
    {
        X *= Other.X;
        Y *= Other.Y;
        Z *= Other.Z;
        W *= Other.W;
 
        return *this;
    }
 
    TIntVector4& operator*=(IntType Scale)
    {
        X *= Scale;
        Y *= Scale;
        Z *= Scale;
        W *= Scale;
 
        return *this;
    }
 
    TIntVector4& operator/=(IntType Divisor)
    {
        X /= Divisor;
        Y /= Divisor;
        Z /= Divisor;
        W /= Divisor;
 
        return *this;
    }
 
    TIntVector4& operator%=(IntType Divisor)
    {
        X %= Divisor;
        Y %= Divisor;
        Z %= Divisor;
        W %= Divisor;
 
        return *this;
    }
 
    TIntVector4& operator+=(const TIntVector4& Other)
    {
        X += Other.X;
        Y += Other.Y;
        Z += Other.Z;
        W += Other.W;
 
        return *this;
    }
 
    TIntVector4& operator-=(const TIntVector4& Other)
    {
        X -= Other.X;
        Y -= Other.Y;
        Z -= Other.Z;
        W -= Other.W;
 
        return *this;
    }
 
    TIntVector4 operator*(const TIntVector4& Other) const
    {
        return TIntVector4(*this) *= Other;
    }
 
    TIntVector4 operator*(IntType Scale) const
    {
        return TIntVector4(*this) *= Scale;
    }
 
    TIntVector4 operator/(IntType Divisor) const
    {
        return TIntVector4(*this) /= Divisor;
    }
 
    TIntVector4 operator%(IntType Divisor) const
    {
        return TIntVector4(*this) %= Divisor;
    }
 
    TIntVector4 operator+(const TIntVector4& Other) const
    {
        return TIntVector4(*this) += Other;
    }
 
    TIntVector4 operator-(const TIntVector4& Other) const
    {
        return TIntVector4(*this) -= Other;
    }
 
    TIntVector4 operator>>(IntType Shift) const
    {
        return TIntVector4(X >> Shift, Y >> Shift, Z >> Shift, W >> Shift);
    }
 
    TIntVector4 operator<<(IntType Shift) const
    {
        return TIntVector4(X << Shift, Y << Shift, Z << Shift, W << Shift);
    }
 
    TIntVector4 operator&(IntType Value) const
    {
        return TIntVector4(X & Value, Y & Value, Z & Value, W & Value);
    }
 
    TIntVector4 operator|(IntType Value) const
    {
        return TIntVector4(X | Value, Y | Value, Z | Value, W | Value);
    }
 
    TIntVector4 operator^(IntType Value) const
    {
        return TIntVector4(X ^ Value, Y ^ Value, Z ^ Value, W ^ Value);
    }
 
    bool IsZero() const
    {
        return *this == ZeroValue;
    }
 
    IntType GetMax() const
    {
        return FMath::Max(FMath::Max(FMath::Max(X, Y), Z), W);
    }
 
    IntType GetAbsMax() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Max(FMath::Max(FMath::Max(FMath::Abs(X), FMath::Abs(Y)), FMath::Abs(Z)), FMath::Abs(W));
        }
        else
        {
            return GetMax();
        }
    }
 
    IntType GetMin() const
    {
        return FMath::Min(FMath::Min(FMath::Min(X, Y), Z), W);
    }
 
    IntType GetAbsMin() const
    {
        if constexpr (std::is_signed_v<IntType>)
        {
            return FMath::Min(FMath::Min(FMath::Min(FMath::Abs(X), FMath::Abs(Y)), FMath::Abs(Z)), FMath::Abs(W));
        }
        else
        {
            return GetMin();
        }
    }
 
    TIntVector4 ComponentMax(const TIntVector4& Other) const
    {
        return TIntVector4(
            FMath::Max(X, Other.X),
            FMath::Max(Y, Other.Y),
            FMath::Max(Z, Other.Z),
            FMath::Max(W, Other.W));
    }
 
    TIntVector4 ComponentMin(const TIntVector4& Other) const
    {
        return TIntVector4(
            FMath::Min(X, Other.X),
            FMath::Min(Y, Other.Y),
            FMath::Min(Z, Other.Z),
            FMath::Min(W, Other.W));
    }
 
    template <typename CharType>
    void AppendString(TStringBuilderBase<CharType>& Out) const
    {
        Out << "X=" << X << " Y=" << Y << " Z=" << Z << " W=" << W;
    }
 
    template <typename CharType>
    friend TStringBuilderBase<CharType>& operator<<(TStringBuilderBase<CharType>& Builder, const TIntVector4& Vector)
    {
        Vector.AppendString(Builder);
        return Builder;
    }
 
    void AppendString(FString& Out) const
    {
        TStringBuilder<128> Builder;
        Builder << *this;
        Out.Append(Builder);
    }
 
    FString ToString() const
    {
        FString Out;
        AppendString(Out);
        return Out;
    }
 
    bool InitFromString(const FString& InSourceString)
    {
        X = Y = Z = W = 0;
 
        // The initialization is only successful if the X, Y, Z and W values can all be parsed from the string
        const bool bSuccessful = FParse::Value(*InSourceString, TEXT("X="), X) && FParse::Value(*InSourceString, TEXT("Y="), Y) && FParse::Value(*InSourceString, TEXT("Z="), Z) && FParse::Value(*InSourceString, TEXT("W="), W);
 
        return bSuccessful;
    }
 
    static TIntVector4 DivideAndRoundUp(TIntVector4 Lhs, IntType Divisor)
    {
        return TIntVector4(
            FMath::DivideAndRoundUp(Lhs.X, Divisor),
            FMath::DivideAndRoundUp(Lhs.Y, Divisor),
            FMath::DivideAndRoundUp(Lhs.Z, Divisor),
            FMath::DivideAndRoundUp(Lhs.W, Divisor));
    }
 
    static TIntVector4 DivideAndRoundUp(TIntVector4 Lhs, TIntVector4 Divisor)
    {
        return TIntVector4(
            FMath::DivideAndRoundUp(Lhs.X, Divisor.X),
            FMath::DivideAndRoundUp(Lhs.Y, Divisor.Y),
            FMath::DivideAndRoundUp(Lhs.Z, Divisor.Z),
            FMath::DivideAndRoundUp(Lhs.W, Divisor.W));
    }
 
    static int32 Num()
    {
        return 4;
    }
 
    friend FArchive& operator<<(FArchive& Ar, TIntVector4& Vector)
    {
        return Ar << Vector.X << Vector.Y << Vector.Z << Vector.W;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, TIntVector4& Vector)
    {
        FStructuredArchive::FRecord Record = Slot.EnterRecord();
        Record << SA_VALUE(TEXT("X"), Vector.X);
        Record << SA_VALUE(TEXT("Y"), Vector.Y);
        Record << SA_VALUE(TEXT("Z"), Vector.Z);
        Record << SA_VALUE(TEXT("W"), Vector.W);
    }
 
    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, IntVector4, Int32Vector4, Int64Vector4);
        }
        else if constexpr (std::is_same_v<IntType, int64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, IntVector4, Int64Vector4, Int32Vector4);
        }
        else if constexpr (std::is_same_v<IntType, uint32>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector4, Uint32Vector4, Uint64Vector4);
        }
        else if constexpr (std::is_same_v<IntType, uint64>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, UintVector4, Uint64Vector4, Uint32Vector4);
        }
        else
        {
            static_assert(sizeof(IntType) == 0, "Unimplemented");
            return false;
        }
    }
};
 
template <typename IntType>
const TIntVector4<IntType> TIntVector4<IntType>::ZeroValue(0, 0, 0, 0);
 
template <typename IntType>
const TIntVector4<IntType> TIntVector4<IntType>::NoneValue(INDEX_NONE, INDEX_NONE, INDEX_NONE, INDEX_NONE);
 
template<typename T>
uint32 GetTypeHash(const TIntVector2<T>& Vector)
{
    // Note: this assumes there's no padding in Vector that could contain uncompared data.
    return FCrc::MemCrc32(&Vector, sizeof(Vector));
}
 
template<typename T>
uint32 GetTypeHash(const TIntVector3<T>& Vector)
{
    // Note: this assumes there's no padding in Vector that could contain uncompared data.
    return FCrc::MemCrc_DEPRECATED(&Vector, sizeof(Vector));
}
 
template<typename T>
uint32 GetTypeHash(const TIntVector4<T>& Vector)
{
    // Note: this assumes there's no padding in Vector that could contain uncompared data.
    return FCrc::MemCrc32(&Vector, sizeof(Vector));
}
 
} 
 
template <> struct TIsPODType<FInt32Vector2>  { enum { Value = true }; };
template <> struct TIsPODType<FUint32Vector2> { enum { Value = true }; };
template <> struct TIsPODType<FInt32Vector3>  { enum { Value = true }; };
template <> struct TIsPODType<FUint32Vector3> { enum { Value = true }; };
template <> struct TIsPODType<FInt32Vector4>  { enum { Value = true }; };
template <> struct TIsPODType<FUint32Vector4> { enum { Value = true }; };
 
template <> struct TIsUECoreVariant<FInt32Vector2>  { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint32Vector2> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FInt32Vector3>  { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint32Vector3> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FInt32Vector4>  { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint32Vector4> { enum { Value = true }; };
 
template <> struct TIsPODType<FInt64Vector2> { enum { Value = true }; };
template <> struct TIsPODType<FUint64Vector2> { enum { Value = true }; };
template <> struct TIsPODType<FInt64Vector3> { enum { Value = true }; };
template <> struct TIsPODType<FUint64Vector3> { enum { Value = true }; };
template <> struct TIsPODType<FInt64Vector4> { enum { Value = true }; };
template <> struct TIsPODType<FUint64Vector4> { enum { Value = true }; };
 
template <> struct TIsUECoreVariant<FInt64Vector2> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint64Vector2> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FInt64Vector3> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint64Vector3> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FInt64Vector4> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FUint64Vector4> { enum { Value = true }; };