Vector2D.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 "Misc/AssertionMacros.h"
#include "Misc/Crc.h"
#include "Math/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Misc/Parse.h"
#include "Misc/LargeWorldCoordinatesSerializer.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Misc/NetworkVersion.h"
#endif
#include "Misc/EngineNetworkCustomVersion.h"
#include "Math/IntPoint.h"
#include "Logging/LogMacros.h"
 
#include <type_traits>
 
#ifdef _MSC_VER
#pragma warning (push)
// Ensure template functions don't generate shadowing warnings against global variables at the point of instantiation.
#pragma warning (disable : 4459)
#endif
 
 
namespace UE
{
namespace Math
{
template<typename T>    
struct TVector2 
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    
    union
    {
        struct
        {
            T X;
 
            T Y;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        T XY[2];
    };
 
    static constexpr int32 NumComponents = 2;
 
    CORE_API static const TVector2<T> ZeroVector;
 
    CORE_API static const TVector2<T> UnitVector;
 
    CORE_API static const TVector2<T> Unit45Deg;
 
    static inline TVector2<T> Zero() { return TVector2<T>::ZeroVector; }
    static inline TVector2<T> One() { return TVector2<T>::UnitVector; }
    static inline TVector2<T> UnitX() { return TVector2<T>(1, 0); }
    static inline TVector2<T> UnitY() { return TVector2<T>(0, 1); }
 
public:
 
    [[nodiscard]] TVector2() = default;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T>(T InX, T InY);
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT TVector2<T>(T InF);
 
    template <typename IntType>
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T>(TIntPoint<IntType> InPos);
 
    template <typename IntType>
    [[nodiscard]] explicit  TVector2<T>(TIntVector2<IntType> V);
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT TVector2<T>(EForceInit);
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT TVector2<T>(ENoInit) { }
 
    [[nodiscard]] explicit inline TVector2<T>(const TVector<T>& V);
 
    [[nodiscard]] explicit inline TVector2<T>(const TVector4<T>& V);
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator+(const TVector2<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator-(const TVector2<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator*(T Scale) const;
 
    [[nodiscard]] TVector2<T> operator/(T Scale) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator+(T A) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator-(T A) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator*(const TVector2<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator/(const TVector2<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT T operator|(const TVector2<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT T operator^(const TVector2<T>& V) const;
 
public:
 
    [[nodiscard]] bool operator==(const TVector2<T>& V) const;
 
    [[nodiscard]] bool operator!=(const TVector2<T>& V) const;
 
    [[nodiscard]] bool ComponentwiseAllLessThan(const TVector2<T>& Other) const;
 
    [[nodiscard]] bool ComponentwiseAllGreaterThan(const TVector2<T>& Other) const;
 
    [[nodiscard]] bool ComponentwiseAllLessOrEqual(const TVector2<T>& Other) const;
 
    [[nodiscard]] bool ComponentwiseAllGreaterOrEqual(const TVector2<T>& Other) const;
 
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> operator-() const;
 
    inline TVector2<T> operator+=(const TVector2<T>& V);
 
    inline TVector2<T> operator-=(const TVector2<T>& V);
 
    inline TVector2<T> operator*=(T Scale);
 
    TVector2<T> operator/=(T V);
 
    TVector2<T> operator*=(const TVector2<T>& V);
 
    TVector2<T> operator/=(const TVector2<T>& V);
 
    [[nodiscard]] T& operator[](int32 Index);
 
    [[nodiscard]] T operator[](int32 Index) const;
 
    [[nodiscard]] T& Component(int32 Index);
 
    [[nodiscard]] T Component(int32 Index) const;
 
    [[nodiscard]] bool IsValidIndex(int32 Index) const;
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT static T DotProduct(const TVector2<T>& A, const TVector2<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static T DistSquared(const TVector2<T>& V1, const TVector2<T>& V2);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static T Distance(const TVector2<T>& V1, const TVector2<T>& V2);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static T CrossProduct(const TVector2<T>& A, const TVector2<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static TVector2<T> Max(const TVector2<T>& A, const TVector2<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static TVector2<T> Min(const TVector2<T>& A, const TVector2<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT static TVector2<T> Clamp(const TVector2<T>& V, const TVector2<T>& MinValue, const TVector2<T>& MaxValue);
 
    [[nodiscard]] bool Equals(const TVector2<T>& V, T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    void Set(T InX, T InY);
 
    [[nodiscard]] T GetMax() const;
 
    [[nodiscard]] T GetAbsMax() const;
 
    [[nodiscard]] T GetMin() const;
 
    [[nodiscard]] TVector2<T> ComponentMin(const TVector2<T>& Other) const;
 
    [[nodiscard]] TVector2<T> ComponentMax(const TVector2<T>& Other) const;
 
    [[nodiscard]] T Size() const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT T Length() const
    {
        return Size();
    }
 
    [[nodiscard]] T SizeSquared() const;
    
    [[nodiscard]] UE_FORCEINLINE_HINT T SquaredLength() const
    {
        return SizeSquared();
    }
 
    [[nodiscard]] T Dot(const TVector2<T>& V2) const;
 
    [[nodiscard]] TVector2<T> GetRotated(T AngleDeg) const;
 
    [[nodiscard]] TVector2<T> GetSafeNormal(T Tolerance=UE_SMALL_NUMBER) const;
 
    bool Normalize(T Tolerance=UE_SMALL_NUMBER);
 
    [[nodiscard]] bool IsNearlyZero(T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    void ToDirectionAndLength(TVector2<T>& OutDir, T& OutLength) const;
    template<typename FArg UE_REQUIRES(!std::is_same_v<T, FArg>)>
    void ToDirectionAndLength(TVector2<T>& OutDir, FArg& OutLength) const
    {
        FReal TempOut;
        ToDirectionAndLength(OutDir, TempOut);
        OutLength = static_cast<FArg>(TempOut);
    }
 
    [[nodiscard]] bool IsZero() const;
 
    [[nodiscard]] FIntPoint IntPoint() const;
 
    [[nodiscard]] TVector2<T> RoundToVector() const;
 
    [[nodiscard]] TVector2<T> ClampAxes(T MinAxisVal, T MaxAxisVal) const;
 
    [[nodiscard]] TVector2<T> GetClampedToSize(T Min, T Max) const;
 
    [[nodiscard]] TVector2<T> GetClampedToMaxSize(T MaxSize) const;
 
    [[nodiscard]] inline TVector2<T> GetSignVector() const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector2<T> GetAbs() const;
 
    [[nodiscard]] FString ToString() const;
 
    bool InitFromString(const FString& InSourceString);
 
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    bool Serialize(FStructuredArchive::FSlot Slot)
    {
        Slot << *this;
        return true;
    }
 
    bool SerializeFromMismatchedTag(FName StructTag, FArchive& Ar)
    {
        if constexpr (std::is_same_v<T, float>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, Vector2D, Vector2f, Vector2d);
        }
        else
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, Vector2D, Vector2d, Vector2f);
        }
    }
 
#if ENABLE_NAN_DIAGNOSTIC
    inline void DiagnosticCheckNaN()
    {
        if (ContainsNaN())
        {
            logOrEnsureNanError(TEXT("FVector2 contains NaN: %s"), *ToString());
            *this = TVector2<T>::ZeroVector;
        }
    }
#else
    UE_FORCEINLINE_HINT void DiagnosticCheckNaN() {}
#endif
 
    [[nodiscard]] inline bool ContainsNaN() const
    {
        return (!FMath::IsFinite(X) || 
                !FMath::IsFinite(Y));
    }
 
    bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
    {
        Ar.UsingCustomVersion(FEngineNetworkCustomVersion::Guid);
 
        if (Ar.EngineNetVer() >= FEngineNetworkCustomVersion::SerializeDoubleVectorsAsDoubles && Ar.EngineNetVer() != FEngineNetworkCustomVersion::Ver21AndViewPitchOnly_DONOTUSE)
        {
            Ar << X << Y;
        }
        else
        {
            checkf(Ar.IsLoading(), TEXT("float -> double conversion applied outside of load!"));
            // Always serialize as float
            float SX, SY;
            Ar << SX << SY;
            X = SX;
            Y = SY;
        }
        return true;
    }
 
    [[nodiscard]] inline TVector<T> SphericalToUnitCartesian() const;
    
    
    
    // Conversion from other type.
    template<typename FArg UE_REQUIRES(!std::is_same_v<T, FArg>)>
    explicit TVector2(const TVector2<FArg>& From)
        : TVector2<T>((T)From.X, (T)From.Y)
    {
    }
};
 
template<typename T>
UE_FORCEINLINE_HINT uint32 GetTypeHash(const TVector2<T>& Vector)
{
    // Note: this assumes there's no padding in TVector2<T> that could contain uncompared data.
    return FCrc::MemCrc_DEPRECATED(&Vector,sizeof(Vector));
}
 
/* TVector2<T> inline functions
*****************************************************************************/
 
inline FArchive& operator<<(FArchive& Ar, TVector2<float>& V)
{
    // @warning BulkSerialize: TVector2<T> is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    return Ar << V.X << V.Y;
}
 
inline void operator<<(FStructuredArchive::FSlot Slot, TVector2<float>& V)
{
    // @warning BulkSerialize: TVector2<T> is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    FStructuredArchive::FStream Stream = Slot.EnterStream();
    Stream.EnterElement() << V.X;
    Stream.EnterElement() << V.Y;
}
 
inline FArchive& operator<<(FArchive& Ar, TVector2<double>& V)
{
    // @warning BulkSerialize: TVector2<T> is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    if (Ar.UEVer() >= EUnrealEngineObjectUE5Version::LARGE_WORLD_COORDINATES)
    {
        Ar << V.X << V.Y;
    }
    else
    {
        checkf(Ar.IsLoading(), TEXT("float -> double conversion applied outside of load!"));
        // Stored as floats, so serialize float and copy.
        float X, Y;
        Ar << X << Y;
        V = TVector2<double>(X, Y);
    }
    return Ar;
}
 
inline void operator<<(FStructuredArchive::FSlot Slot, TVector2<double>& V)
{
    // @warning BulkSerialize: TVector2<T> is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    FStructuredArchive::FStream Stream = Slot.EnterStream();
    if (Slot.GetUnderlyingArchive().UEVer() >= EUnrealEngineObjectUE5Version::LARGE_WORLD_COORDINATES)
    {
        Stream.EnterElement() << V.X;
        Stream.EnterElement() << V.Y;
    }
    else
    {
        checkf(Slot.GetUnderlyingArchive().IsLoading(), TEXT("float -> double conversion applied outside of load!"));
        // Stored as floats, so serialize float and copy.
        float X, Y;
        Stream.EnterElement() << X;
        Stream.EnterElement() << Y;
        V = TVector2<double>(X, Y);
    }
}
 
#if !defined(_MSC_VER) || defined(__clang__)  // MSVC can't forward declare explicit specializations
template<> CORE_API const FVector2f FVector2f::ZeroVector;
template<> CORE_API const FVector2f FVector2f::UnitVector;
template<> CORE_API const FVector2f FVector2f::Unit45Deg;
template<> CORE_API const FVector2d FVector2d::ZeroVector;
template<> CORE_API const FVector2d FVector2d::UnitVector;
template<> CORE_API const FVector2d FVector2d::Unit45Deg;
#endif
 
template<typename T, typename T2 UE_REQUIRES(std::is_arithmetic_v<T2>)>
UE_FORCEINLINE_HINT TVector2<T> operator*(T2 Scale, const TVector2<T>& V)
{
    return V.operator*(Scale);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T>::TVector2(T InX,T InY)
    :   X(InX), Y(InY)
{ }
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T>::TVector2(T InF)
    :   X(InF), Y(InF)
{ }
 
template<typename T>
template<typename IntType>
inline TVector2<T>::TVector2(TIntPoint<IntType> InPos)
{
    X = (T)InPos.X;
    Y = (T)InPos.Y;
}
 
template<typename T>
template<typename IntType>
inline TVector2<T>::TVector2(TIntVector2<IntType> V)
{
    X = (T)V.X;
    Y = (T)V.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T>::TVector2(EForceInit)
    : X(0), Y(0)
{
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator+(const TVector2<T>& V) const
{
    return TVector2<T>(X + V.X, Y + V.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator-(const TVector2<T>& V) const
{
    return TVector2<T>(X - V.X, Y - V.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator*(T Scale) const
{
    return TVector2<T>(X * Scale, Y * Scale);
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator/(T Scale) const
{
    const T RScale = 1.f/Scale;
    return TVector2<T>(X * RScale, Y * RScale);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator+(T A) const
{
    return TVector2<T>(X + A, Y + A);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator-(T A) const
{
    return TVector2<T>(X - A, Y - A);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator*(const TVector2<T>& V) const
{
    return TVector2<T>(X * V.X, Y * V.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator/(const TVector2<T>& V) const
{
    return TVector2<T>(X / V.X, Y / V.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::operator|(const TVector2<T>& V) const
{
    return X*V.X + Y*V.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::operator^(const TVector2<T>& V) const
{
    return X*V.Y - Y*V.X;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::DotProduct(const TVector2<T>& A, const TVector2<T>& B)
{
    return A | B;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::DistSquared(const TVector2<T> &V1, const TVector2<T> &V2)
{
    return FMath::Square(V2.X-V1.X) + FMath::Square(V2.Y-V1.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::Distance(const TVector2<T>& V1, const TVector2<T>& V2)
{
    return FMath::Sqrt(TVector2<T>::DistSquared(V1, V2));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::CrossProduct(const TVector2<T>& A, const TVector2<T>& B)
{
    return A ^ B;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::Max(const TVector2<T>& A, const TVector2<T>& B)
{
    return TVector2<T>(FMath::Max(A.X, B.X), FMath::Max(A.Y, B.Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::Min(const TVector2<T>& A, const TVector2<T>& B)
{
    return TVector2<T>(FMath::Min(A.X, B.X), FMath::Min(A.Y, B.Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::Clamp(const TVector2<T>& V, const TVector2<T>& MinValue, const TVector2<T>& MaxValue)
{
    return TVector2<T>(FMath::Clamp(V.X, MinValue.X, MaxValue.X), FMath::Clamp(V.Y, MinValue.Y, MaxValue.Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::operator==(const TVector2<T>& V) const
{
    return X==V.X && Y==V.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::operator!=(const TVector2<T>& V) const
{
    return X!=V.X || Y!=V.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::ComponentwiseAllLessThan(const TVector2<T>& Other) const
{
    return X < Other.X && Y < Other.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::ComponentwiseAllGreaterThan(const TVector2<T>& Other) const
{
    return X > Other.X && Y > Other.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::ComponentwiseAllLessOrEqual(const TVector2<T>& Other) const
{
    return X <= Other.X && Y <= Other.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::ComponentwiseAllGreaterOrEqual(const TVector2<T>& Other) const
{
    return X >= Other.X && Y >= Other.Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::Equals(const TVector2<T>& V, T Tolerance) const
{
    return FMath::Abs(X-V.X) <= Tolerance && FMath::Abs(Y-V.Y) <= Tolerance;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::operator-() const
{
    return TVector2<T>(-X, -Y);
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator+=(const TVector2<T>& V)
{
    X += V.X; Y += V.Y;
    return *this;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator-=(const TVector2<T>& V)
{
    X -= V.X; Y -= V.Y;
    return *this;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator*=(T Scale)
{
    X *= Scale; Y *= Scale;
    return *this;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator/=(T V)
{
    const T RV = 1.f/V;
    X *= RV; Y *= RV;
    return *this;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator*=(const TVector2<T>& V)
{
    X *= V.X; Y *= V.Y;
    return *this;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::operator/=(const TVector2<T>& V)
{
    X /= V.X; Y /= V.Y;
    return *this;
}
 
template<typename T>
UE_FORCEINLINE_HINT T& TVector2<T>::operator[](int32 Index)
{
    return Component(Index);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::operator[](int32 Index) const
{
    return Component(Index);
}
 
template<typename T>
inline void TVector2<T>::Set(T InX, T InY)
{
    X = InX;
    Y = InY;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::GetMax() const
{
    return FMath::Max(X,Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::GetAbsMax() const
{
    return FMath::Max(FMath::Abs(X),FMath::Abs(Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::GetMin() const
{
    return FMath::Min(X,Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::ComponentMin(const TVector2<T>& Other) const
{
    return TVector2<T>(FMath::Min(X, Other.X), FMath::Min(Y, Other.Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::ComponentMax(const TVector2<T>& Other) const
{
    return TVector2<T>(FMath::Max(X, Other.X), FMath::Max(Y, Other.Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::Size() const
{
    return FMath::Sqrt(X*X + Y*Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::SizeSquared() const
{
    return X*X + Y*Y;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector2<T>::Dot(const TVector2<T>& V2) const
{ 
    return X * V2.X + Y * V2.Y;
} 
 
template<typename T>
inline TVector2<T> TVector2<T>::GetRotated(const T AngleDeg) const
{
    // Based on FVector::RotateAngleAxis with Axis(0,0,1)
 
    T S, C;
    FMath::SinCos(&S, &C, FMath::DegreesToRadians(AngleDeg));
 
    return TVector2<T>(
        C * X - S * Y,
        S * X + C * Y);
}
 
template<typename T>
inline TVector2<T> TVector2<T>::GetSafeNormal(T Tolerance) const
{   
    const T SquareSum = X*X + Y*Y;
    if(SquareSum > Tolerance)
    {
        const T Scale = FMath::InvSqrt(SquareSum);
        return TVector2<T>(X*Scale, Y*Scale);
    }
    return TVector2<T>(0.f, 0.f);
}
 
template<typename T>
inline bool TVector2<T>::Normalize(T Tolerance)
{
    const T SquareSum = X*X + Y*Y;
    if(SquareSum > Tolerance)
    {
        const T Scale = FMath::InvSqrt(SquareSum);
        X *= Scale;
        Y *= Scale;
        return true;
    }
    X = 0.0f;
    Y = 0.0f;
    return false;
}
 
template<typename T>
inline void TVector2<T>::ToDirectionAndLength(TVector2<T> &OutDir, T &OutLength) const
{
    OutLength = Size();
    if (OutLength > UE_SMALL_NUMBER)
    {
        T OneOverLength = static_cast<T>(1.0f) / OutLength;
        OutDir = TVector2<T>(static_cast<T>(X*OneOverLength), static_cast<T>(Y*OneOverLength));
    }
    else
    {
        OutDir = TVector2<T>::ZeroVector;
    }
}
 
template<typename T>
inline bool TVector2<T>::IsNearlyZero(T Tolerance) const
{
    return  FMath::Abs(X)<=Tolerance
        &&  FMath::Abs(Y)<=Tolerance;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector2<T>::IsZero() const
{
    return X==0.f && Y==0.f;
}
 
template<typename T>
inline T& TVector2<T>::Component(int32 Index)
{
    check(IsValidIndex(Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    return XY[Index];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
template<typename T>
inline T TVector2<T>::Component(int32 Index) const
{
    check(IsValidIndex(Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    return XY[Index];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
template<typename T>
bool TVector2<T>::IsValidIndex(int32 Index) const
{
    return (Index >= 0) && (Index < NumComponents);
}
 
template<typename T>
inline FIntPoint TVector2<T>::IntPoint() const
{
    if constexpr (std::is_same_v<T, float>)
    {
        return FIntPoint( FMath::RoundToInt32(X), FMath::RoundToInt32(Y) );
    }
    else
    {
        // FIntPoint constructor from FInt64Point checks that the int64 fits in int32.
        return FIntPoint( FInt64Point(FMath::RoundToInt64(X), FMath::RoundToInt64(Y)) );
    }
}
 
template<typename T>
inline TVector2<T> TVector2<T>::RoundToVector() const
{
    if constexpr (std::is_same_v<T, float>)
    {
        return TVector2<T>(FMath::RoundToFloat(X), FMath::RoundToFloat(Y));
    }
    else
    {
        return TVector2<T>(FMath::RoundToDouble(X), FMath::RoundToDouble(Y));
    }
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::ClampAxes(T MinAxisVal, T MaxAxisVal) const
{
    return TVector2<T>(FMath::Clamp(X, MinAxisVal, MaxAxisVal), FMath::Clamp(Y, MinAxisVal, MaxAxisVal));
}
 
template<typename T>
inline TVector2<T> TVector2<T>::GetClampedToSize(T Min, T Max) const
{
    T VecSize = Size();
    const TVector2<T> VecDir = (VecSize > UE_SMALL_NUMBER) ? (*this / VecSize) : ZeroVector;
 
    VecSize = FMath::Clamp(VecSize, Min, Max);
 
    return VecSize * VecDir;
}
 
template<typename T>
inline TVector2<T> TVector2<T>::GetClampedToMaxSize(T MaxSize) const
{
    if (MaxSize < UE_KINDA_SMALL_NUMBER)
    {
        return ZeroVector;
    }
 
    const T VSq = SizeSquared();
    if (VSq > FMath::Square(MaxSize))
    {
        const T Scale = MaxSize * FMath::InvSqrt(VSq);
        return TVector2<T>(X * Scale, Y * Scale);
    }
    else
    {
        return *this;
    }
}
 
template<typename T>
inline TVector2<T> TVector2<T>::GetSignVector() const
{
    return TVector2<T>
        (
        FMath::FloatSelect(X, (T)1, (T)-1),
        FMath::FloatSelect(Y, (T)1, (T)-1)
        );
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector2<T> TVector2<T>::GetAbs() const
{
    return TVector2<T>(FMath::Abs(X), FMath::Abs(Y));
}
 
template<typename T>
UE_FORCEINLINE_HINT FString TVector2<T>::ToString() const
{
    return FString::Printf(TEXT("X=%3.3f Y=%3.3f"), X, Y);
}
 
template<typename T>
inline bool TVector2<T>::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;
}
 
} // namespace UE::Math
} // UE
 
UE_DECLARE_LWC_TYPE(Vector2,, FVector2D);
 
template <> struct TIsPODType<FVector2f> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FVector2f> { enum { Value = true }; };
template<> struct TCanBulkSerialize<FVector2f> { enum { Value = true }; };
template <> struct TIsPODType<FVector2d> { enum { Value = true }; };
template <> struct TIsUECoreVariant<FVector2d> { enum { Value = true }; };
template<> struct TCanBulkSerialize<FVector2d> { enum { Value = true }; };
 
 
#ifdef _MSC_VER
#pragma warning (pop)
#endif