Vector.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 "Math/MathFwd.h" // IWYU pragma: export
#include "Math/NumericLimits.h"
#include "Misc/Crc.h"
#include "Math/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Misc/Parse.h"
#include "Misc/LargeWorldCoordinatesSerializer.h"
#include "Misc/NetworkVersion.h"
#include "Math/Color.h"
#include "Math/IntPoint.h"
#include "Logging/LogMacros.h"
#include "Math/Vector2D.h"
#include "Misc/ByteSwap.h"
#include "Internationalization/Text.h"
#include "Internationalization/Internationalization.h"
#include "Math/IntVector.h"
#include "Math/Axis.h"
#include "Serialization/MemoryLayout.h"
#include "UObject/ObjectVersion.h"
#include <type_traits>
 
#if PLATFORM_ENABLE_VECTORINTRINSICS
#include "Math/VectorRegister.h"
#endif
 
#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
 
// Move out of global namespace to avoid collisions with Chaos::TVector within the physics code.
namespace UE
{
namespace Math
{
 
struct TVectorConstInit {};
 
template<typename T>
struct TVector
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
 
    union
    {
        struct
        {
            T X;
 
            T Y;
 
            T Z;
        };
 
        UE_DEPRECATED(all, "For internal use only")
        T XYZ[3];
    };
 
    static constexpr int32 NumComponents = 3;
 
    CORE_API static const TVector<T> ZeroVector;
    
    CORE_API static const TVector<T> OneVector;
    
    CORE_API static const TVector<T> UpVector;
    
    CORE_API static const TVector<T> DownVector;
    
    CORE_API static const TVector<T> ForwardVector;
    
    CORE_API static const TVector<T> BackwardVector;
    
    CORE_API static const TVector<T> RightVector;
    
    CORE_API static const TVector<T> LeftVector;
    
    CORE_API static const TVector<T> XAxisVector;
    
    CORE_API static const TVector<T> YAxisVector;
    
    CORE_API static const TVector<T> ZAxisVector;
 
    [[nodiscard]] static inline TVector<T> Zero() { return ZeroVector; }
 
    [[nodiscard]] static inline TVector<T> One() { return OneVector; }
 
    [[nodiscard]] static inline TVector<T> UnitX() { return XAxisVector; }
 
    [[nodiscard]] static inline TVector<T> UnitY() { return YAxisVector; }
 
    [[nodiscard]] static inline TVector<T> UnitZ() { return ZAxisVector; }
 
public:
 
#if ENABLE_NAN_DIAGNOSTIC
    inline void DiagnosticCheckNaN() const
    {
        if (ContainsNaN())
        {
            logOrEnsureNanError(TEXT("FVector contains NaN: %s"), *ToString());
            *const_cast<TVector<T>*>(static_cast<const TVector<T>*>(this)) = ZeroVector;
        }
    }
 
    inline void DiagnosticCheckNaN(const TCHAR* Message) const
    {
        if (ContainsNaN())
        {
            logOrEnsureNanError(TEXT("%s: FVector contains NaN: %s"), Message, *ToString());
            *const_cast<TVector<T>*>(static_cast<const TVector<T>*>(this)) = ZeroVector;
        }
    }
#else
    UE_FORCEINLINE_HINT void DiagnosticCheckNaN() const {}
    UE_FORCEINLINE_HINT void DiagnosticCheckNaN(const TCHAR* Message) const {}
#endif
 
    [[nodiscard]] TVector() = default;
 
    [[nodiscard]] explicit inline TVector(T InF);
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr TVector(T InF, TVectorConstInit);
 
    [[nodiscard]] inline TVector(T InX, T InY, T InZ);
 
    [[nodiscard]] explicit inline TVector(const TVector2<T> V, T InZ);
 
    [[nodiscard]] inline TVector(const UE::Math::TVector4<T>& V);
 
    [[nodiscard]] explicit TVector(const FLinearColor& InColor);
 
    template <typename IntType>
    [[nodiscard]] explicit TVector(TIntVector3<IntType> InVector);
 
    template <typename IntType>
    [[nodiscard]] explicit TVector(TIntPoint<IntType> A);
 
    [[nodiscard]] explicit inline TVector(EForceInit);
 
    [[nodiscard]] inline TVector<T> operator^(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> Cross(const TVector<T>& V2) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT static TVector<T> CrossProduct(const TVector<T>& A, const TVector<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT T operator|(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT T Dot(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT static T DotProduct(const TVector<T>& A, const TVector<T>& B);
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator+(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator-(const TVector<T>& V) const;
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator-(FArg Bias) const
    {
        return TVector<T>(X - (T)Bias, Y - (T)Bias, Z - (T)Bias);
    }
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator+(FArg Bias) const
    {
        return TVector<T>(X + (T)Bias, Y + (T)Bias, Z + (T)Bias);
    }
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator*(FArg Scale) const
    {
        return TVector<T>(X * (T)Scale, Y * (T)Scale, Z * (T)Scale);
    }
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    [[nodiscard]] TVector<T> operator/(FArg Scale) const
    {
        const T RScale = T(1) / Scale;
        return TVector<T>(X * RScale, Y * RScale, Z * RScale);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator*(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator/(const TVector<T>& V) const;
 
    // Binary comparison operators.
 
   [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TVector<T>& V) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool Equals(const TVector<T>& V, T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool AllComponentsEqual(T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> operator-() const;
 
    inline TVector<T> operator+=(const TVector<T>& V);
 
    inline TVector<T> operator-=(const TVector<T>& V);
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    inline TVector<T> operator*=(FArg Scale)
    {
        X *= Scale; Y *= Scale; Z *= Scale;
        DiagnosticCheckNaN();
        return *this;
    }
 
    template<typename FArg UE_REQUIRES(std::is_arithmetic_v<FArg>)>
    TVector<T> operator/=(FArg Scale)
    {
        const T RV = (T)1 / Scale;
        X *= RV; Y *= RV; Z *= RV;
        DiagnosticCheckNaN();
        return *this;
    }
 
    TVector<T> operator*=(const TVector<T>& V);
 
    TVector<T> operator/=(const TVector<T>& V);
 
    [[nodiscard]] T& operator[](int32 Index);
 
    [[nodiscard]] T operator[](int32 Index)const;
 
    [[nodiscard]] T& Component(int32 Index);
 
    [[nodiscard]] T Component(int32 Index) const;
 
    bool IsValidIndex(int32 Index) const;
 
    [[nodiscard]] T GetComponentForAxis(EAxis::Type Axis) const;
 
    void SetComponentForAxis(EAxis::Type Axis, T Component);
 
public:
 
    // Simple functions.
 
    void Set(T InX, T InY, T InZ);
 
    [[nodiscard]] T GetMax() const;
 
    [[nodiscard]] T GetAbsMax() const;
 
    [[nodiscard]] T GetMin() const;
 
    [[nodiscard]] T GetAbsMin() const;
 
    [[nodiscard]] TVector<T> ComponentMin(const TVector<T>& Other) const;
 
    [[nodiscard]] TVector<T> ComponentMax(const TVector<T>& Other) const;
 
    [[nodiscard]] TVector<T> GetAbs() const;
 
    [[nodiscard]] T Size() const;
 
    [[nodiscard]] T Length() const;
 
    [[nodiscard]] T SizeSquared() const;
 
    [[nodiscard]] T SquaredLength() const;
 
    [[nodiscard]] T Size2D() const ;
 
    [[nodiscard]] T SizeSquared2D() const ;
 
    [[nodiscard]] bool IsNearlyZero(T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    [[nodiscard]] bool IsZero() const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsUnit(T LengthSquaredTolerance = UE_KINDA_SMALL_NUMBER) const;
 
    [[nodiscard]] bool IsNormalized() const;
 
    bool Normalize(T Tolerance=UE_SMALL_NUMBER);
 
    [[nodiscard]] inline TVector<T> GetUnsafeNormal() const;
 
    [[nodiscard]] TVector<T> GetSafeNormal(T Tolerance=UE_SMALL_NUMBER, const TVector<T>& ResultIfZero = ZeroVector) const;
 
    [[nodiscard]] TVector<T> GetSafeNormal2D(T Tolerance=UE_SMALL_NUMBER, const TVector<T>& ResultIfZero = ZeroVector) const;
 
    void ToDirectionAndLength(TVector<T>& OutDir, double& OutLength) const;
    void ToDirectionAndLength(TVector<T>& OutDir, float& OutLength) const;
 
    [[nodiscard]] inline TVector<T> GetSignVector() const;
 
    [[nodiscard]] TVector<T> Projection() const;
 
    [[nodiscard]] inline TVector<T> GetUnsafeNormal2D() const;
 
    [[nodiscard]] TVector<T> GridSnap(const T& GridSz) const;
 
    [[nodiscard]] TVector<T> BoundToCube(T Radius) const;
 
    [[nodiscard]] TVector<T> BoundToBox(const TVector<T>& Min, const TVector<T>& Max) const;
 
    [[nodiscard]] TVector<T> GetClampedToSize(T Min, T Max) const;
 
    [[nodiscard]] TVector<T> GetClampedToSize2D(T Min, T Max) const;
 
    [[nodiscard]] TVector<T> GetClampedToMaxSize(T MaxSize) const;
 
    [[nodiscard]] TVector<T> GetClampedToMaxSize2D(T MaxSize) const;
 
    void AddBounded(const TVector<T>& V, T Radius=MAX_int16);
 
    [[nodiscard]] TVector<T> Reciprocal() const;
 
    [[nodiscard]] bool IsUniform(T Tolerance=UE_KINDA_SMALL_NUMBER) const;
 
    [[nodiscard]] TVector<T> MirrorByVector(const TVector<T>& MirrorNormal) const;
 
    [[nodiscard]] TVector<T> MirrorByPlane(const TPlane<T>& Plane) const;
 
    [[nodiscard]] TVector<T> RotateAngleAxis(const T AngleDeg, const TVector<T>& Axis) const;
    
    [[nodiscard]] TVector<T> RotateAngleAxisRad(const T AngleRad, const TVector<T>& Axis) const;
 
    [[nodiscard]] inline T CosineAngle2D(TVector<T> B) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> ProjectOnTo(const TVector<T>& A) const ;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TVector<T> ProjectOnToNormal(const TVector<T>& Normal) const;
 
    [[nodiscard]] CORE_API TRotator<T> ToOrientationRotator() const;
 
    [[nodiscard]] CORE_API TQuat<T> ToOrientationQuat() const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT UE::Math::TRotator<T> Rotation() const
    {
        return ToOrientationRotator();
    }
 
    void FindBestAxisVectors(TVector<T>& Axis1, TVector<T>& Axis2) const;
 
    void UnwindEuler();
 
    bool ContainsNaN() const;
 
    [[nodiscard]] FString ToString() const;
 
   [[nodiscard]]  FText ToText() const;
 
    [[nodiscard]] FString ToCompactString() const;
 
    [[nodiscard]] FText ToCompactText() const;
 
    bool InitFromString(const FString& InSourceString);
 
    bool InitFromCompactString(const FString& InSourceString);
 
    [[nodiscard]] TVector2<T> UnitCartesianToSpherical() const;
 
    [[nodiscard]] T HeadingAngle() const;
 
    [[nodiscard]] static CORE_API TVector<T> SlerpVectorToDirection(const TVector<T>& V, const TVector<T>& Direction, T Alpha);
 
    [[nodiscard]] static CORE_API TVector<T> SlerpNormals(const TVector<T>& NormalA, const TVector<T>& NormalB, T Alpha);
 
    static void CreateOrthonormalBasis(TVector<T>& XAxis,TVector<T>& YAxis,TVector<T>& ZAxis);
 
    [[nodiscard]] static bool PointsAreSame(const TVector<T> &P, const TVector<T> &Q);
    
    [[nodiscard]] static bool PointsAreNear(const TVector<T> &Point1, const TVector<T> &Point2, T Dist);
 
    [[nodiscard]] static T PointPlaneDist(const TVector<T> &Point, const TVector<T> &PlaneBase, const TVector<T> &PlaneNormal);
 
    [[nodiscard]] static TVector<T> PointPlaneProject(const TVector<T>& Point, const TPlane<T>& Plane);
 
    [[nodiscard]] static TVector<T> PointPlaneProject(const TVector<T>& Point, const TVector<T>& A, const TVector<T>& B, const TVector<T>& C);
 
    [[nodiscard]] static TVector<T> PointPlaneProject(const TVector<T>& Point, const TVector<T>& PlaneBase, const TVector<T>& PlaneNormal);
 
    [[nodiscard]] static TVector<T> VectorPlaneProject(const TVector<T>& V, const TVector<T>& PlaneNormal);
 
    [[nodiscard]] static UE_FORCEINLINE_HINT T Dist(const TVector<T> &V1, const TVector<T> &V2);
    [[nodiscard]] static UE_FORCEINLINE_HINT T Distance(const TVector<T> &V1, const TVector<T> &V2)
    {
        return Dist(V1, V2);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT T DistXY(const TVector<T> &V1, const TVector<T> &V2);
    [[nodiscard]] static UE_FORCEINLINE_HINT T Dist2D(const TVector<T> &V1, const TVector<T> &V2)
    {
        return DistXY(V1, V2);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT T DistSquared(const TVector<T> &V1, const TVector<T> &V2);
 
    [[nodiscard]] static UE_FORCEINLINE_HINT T DistSquaredXY(const TVector<T> &V1, const TVector<T> &V2);
    [[nodiscard]] static UE_FORCEINLINE_HINT T DistSquared2D(const TVector<T> &V1, const TVector<T> &V2)
    {
        return DistSquaredXY(V1, V2);
    }
    
    [[nodiscard]] static UE_FORCEINLINE_HINT T BoxPushOut(const TVector<T>& Normal, const TVector<T>& Size);
 
    [[nodiscard]] static inline TVector<T> Min( const TVector<T>& A, const TVector<T>& B );
    [[nodiscard]] static inline TVector<T> Max( const TVector<T>& A, const TVector<T>& B );
 
    [[nodiscard]] static inline TVector<T> Min3( const TVector<T>& A, const TVector<T>& B, const TVector<T>& C );
    [[nodiscard]] static inline TVector<T> Max3( const TVector<T>& A, const TVector<T>& B, const TVector<T>& C );
 
    [[nodiscard]] static bool Parallel(const TVector<T>& Normal1, const TVector<T>& Normal2, T ParallelCosineThreshold = UE_THRESH_NORMALS_ARE_PARALLEL);
 
    [[nodiscard]] static bool Coincident(const TVector<T>& Normal1, const TVector<T>& Normal2, T ParallelCosineThreshold = UE_THRESH_NORMALS_ARE_PARALLEL);
 
    [[nodiscard]] static bool Orthogonal(const TVector<T>& Normal1, const TVector<T>& Normal2, T OrthogonalCosineThreshold = UE_THRESH_NORMALS_ARE_ORTHOGONAL);
 
    [[nodiscard]] static bool Coplanar(const TVector<T>& Base1, const TVector<T>& Normal1, const TVector<T>& Base2, const TVector<T>& Normal2, T ParallelCosineThreshold = UE_THRESH_NORMALS_ARE_PARALLEL);
 
    [[nodiscard]] static T Triple(const TVector<T>& X, const TVector<T>& Y, const TVector<T>& Z);
 
    static T EvaluateBezier(const TVector<T>* ControlPoints, int32 NumPoints, TArray<TVector<T>>& OutPoints);
 
    [[nodiscard]] static TVector<T> RadiansToDegrees(const TVector<T>& RadVector);
 
    [[nodiscard]] static TVector<T> DegreesToRadians(const TVector<T>& DegVector);
 
    static void GenerateClusterCenters(TArray<TVector<T>>& Clusters, const TArray<TVector<T>>& Points, int32 NumIterations, int32 NumConnectionsToBeValid);
    
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
    
    bool Serialize(FStructuredArchive::FSlot Slot)
    {
        Slot << *this;
        return true;
    }
 
    bool SerializeFromMismatchedTag(FName StructTag, FStructuredArchive::FSlot Slot)
    {
        if constexpr (std::is_same_v<T, float>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Slot, Vector, Vector3f, Vector3d);
        }
        else
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Slot, Vector, Vector3d, Vector3f);
        }
    }
    
    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 << Z;
        }
        else
        {
            checkf(Ar.IsLoading(), TEXT("float -> double conversion applied outside of load!"));
            // Always serialize as float
            float SX, SY, SZ;
            Ar << SX << SY << SZ;
            X = SX;
            Y = SY;
            Z = SZ;
        }
        return true;
    }
 
    // Conversion from other type.
    template<typename FArg UE_REQUIRES(!std::is_same_v<T, FArg>)>
    explicit TVector(const TVector<FArg>& From) : TVector<T>((T)From.X, (T)From.Y, (T)From.Z) {}
};
 
inline FArchive& operator<<(FArchive& Ar, TVector<float>& V)
{
    // @warning BulkSerialize: FVector3f is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    Ar << V.X << V.Y << V.Z;
 
    V.DiagnosticCheckNaN();
 
    return Ar;
}
 
inline FArchive& operator<<(FArchive& Ar, TVector<double>& V)
{
    // @warning BulkSerialize: FVector3d is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    if (Ar.UEVer() >= EUnrealEngineObjectUE5Version::LARGE_WORLD_COORDINATES)
    {
        Ar << V.X;
        Ar << V.Y;
        Ar << V.Z;
    }
    else
    {
        checkf(Ar.IsLoading(), TEXT("float -> double conversion applied outside of load!"));
        // Stored as floats, so serialize float and copy.
        float X, Y, Z;
 
        Ar << X;
        Ar << Y;
        Ar << Z;
 
        V = TVector<double>(X, Y, Z);
    };
 
    V.DiagnosticCheckNaN();
 
    return Ar;
}
 
inline void operator<<(FStructuredArchive::FSlot Slot, TVector<float>& V)
{
    // @warning BulkSerialize: FVector3f is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    FStructuredArchive::FRecord Record = Slot.EnterRecord();
    Record << SA_VALUE(TEXT("X"), V.X);
    Record << SA_VALUE(TEXT("Y"), V.Y);
    Record << SA_VALUE(TEXT("Z"), V.Z);
    V.DiagnosticCheckNaN();
}
 
inline void operator<<(FStructuredArchive::FSlot Slot, TVector<double>& V)
{
    // @warning BulkSerialize: FVector3d is serialized as memory dump
    // See TArray::BulkSerialize for detailed description of implied limitations.
    FStructuredArchive::FRecord Record = Slot.EnterRecord();
 
    if (Slot.GetUnderlyingArchive().UEVer() >= EUnrealEngineObjectUE5Version::LARGE_WORLD_COORDINATES)
    {
        Record << SA_VALUE(TEXT("X"), V.X);
        Record << SA_VALUE(TEXT("Y"), V.Y);
        Record << SA_VALUE(TEXT("Z"), V.Z);
    }
    else
    {
        checkf(Slot.GetUnderlyingArchive().IsLoading(), TEXT("float -> double conversion applied outside of load!"));
        // Stored as floats, so serialize float and copy.
        float X, Y, Z;
        Record << SA_VALUE(TEXT("X"), X);
        Record << SA_VALUE(TEXT("Y"), Y);
        Record << SA_VALUE(TEXT("Z"), Z);
        V = TVector<double>(X, Y, Z);
    }
    V.DiagnosticCheckNaN();
}
 
/* FVector inline functions
 *****************************************************************************/
 
template<typename T>
inline TVector<T>::TVector(const TVector2<T> V, T InZ)
    : X(V.X), Y(V.Y), Z(InZ)
{
    DiagnosticCheckNaN();
}
 
 
 
template<typename T>
inline TVector<T> TVector<T>::RotateAngleAxis(const T AngleDeg, const TVector<T>& Axis) const
{
    return RotateAngleAxisRad(FMath::DegreesToRadians(AngleDeg), Axis);
}
 
template<typename T>
inline TVector<T> TVector<T>::RotateAngleAxisRad(const T AngleRad, const TVector<T>& Axis) const
{
    T S, C;
    FMath::SinCos(&S, &C, AngleRad);
 
    const T XX  = Axis.X * Axis.X;
    const T YY  = Axis.Y * Axis.Y;
    const T ZZ  = Axis.Z * Axis.Z;
 
    const T XY  = Axis.X * Axis.Y;
    const T YZ  = Axis.Y * Axis.Z;
    const T ZX  = Axis.Z * Axis.X;
 
    const T XS  = Axis.X * S;
    const T YS  = Axis.Y * S;
    const T ZS  = Axis.Z * S;
 
    const T OMC = 1.f - C;
 
    return TVector<T>(
        (OMC * XX + C) * X + (OMC * XY - ZS) * Y + (OMC * ZX + YS) * Z,
        (OMC * XY + ZS) * X + (OMC * YY + C) * Y + (OMC * YZ - XS) * Z,
        (OMC * ZX - YS) * X + (OMC * YZ + XS) * Y + (OMC * ZZ + C) * Z
        );
}
 
template<typename T>
inline bool TVector<T>::PointsAreSame(const TVector<T>& P, const TVector<T>& Q)
{
    T Temp;
    Temp=P.X-Q.X;
    if((Temp > -UE_THRESH_POINTS_ARE_SAME) && (Temp < UE_THRESH_POINTS_ARE_SAME))
    {
        Temp=P.Y-Q.Y;
        if((Temp > -UE_THRESH_POINTS_ARE_SAME) && (Temp < UE_THRESH_POINTS_ARE_SAME))
        {
            Temp=P.Z-Q.Z;
            if((Temp > -UE_THRESH_POINTS_ARE_SAME) && (Temp < UE_THRESH_POINTS_ARE_SAME))
            {
                return true;
            }
        }
    }
    return false;
}
 
template<typename T>
inline bool TVector<T>::PointsAreNear(const TVector<T>& Point1, const TVector<T>& Point2, T Dist)
{
    T Temp;
    Temp=(Point1.X - Point2.X); if (FMath::Abs(Temp)>=Dist) return false;
    Temp=(Point1.Y - Point2.Y); if (FMath::Abs(Temp)>=Dist) return false;
    Temp=(Point1.Z - Point2.Z); if (FMath::Abs(Temp)>=Dist) return false;
    return true;
}
 
template<typename T>
inline T TVector<T>::PointPlaneDist
(
    const TVector<T> &Point,
    const TVector<T> &PlaneBase,
    const TVector<T> &PlaneNormal
)
{
    return (Point - PlaneBase) | PlaneNormal;
}
 
 
template<typename T>
inline TVector<T> TVector<T>::PointPlaneProject(const TVector<T>& Point, const TVector<T>& PlaneBase, const TVector<T>& PlaneNorm)
{
    //Find the distance of X from the plane
    //Add the distance back along the normal from the point
    return Point - TVector<T>::PointPlaneDist(Point,PlaneBase,PlaneNorm) * PlaneNorm;
}
 
template<typename T>
inline TVector<T> TVector<T>::VectorPlaneProject(const TVector<T>& V, const TVector<T>& PlaneNormal)
{
    return V - V.ProjectOnToNormal(PlaneNormal);
}
 
template<typename T>
inline bool TVector<T>::Parallel(const TVector<T>& Normal1, const TVector<T>& Normal2, T ParallelCosineThreshold)
{
    const T NormalDot = Normal1 | Normal2;
    return FMath::Abs(NormalDot) >= ParallelCosineThreshold;
}
 
template<typename T>
inline bool TVector<T>::Coincident(const TVector<T>& Normal1, const TVector<T>& Normal2, T ParallelCosineThreshold)
{
    const T NormalDot = Normal1 | Normal2;
    return NormalDot >= ParallelCosineThreshold;
}
 
template<typename T>
inline bool TVector<T>::Orthogonal(const TVector<T>& Normal1, const TVector<T>& Normal2, T OrthogonalCosineThreshold)
{
    const T NormalDot = Normal1 | Normal2;
    return FMath::Abs(NormalDot) <= OrthogonalCosineThreshold;
}
 
template<typename T>
inline bool TVector<T>::Coplanar(const TVector<T>& Base1, const TVector<T>& Normal1, const TVector<T>& Base2, const TVector<T>& Normal2, T ParallelCosineThreshold)
{
    if      (!TVector<T>::Parallel(Normal1,Normal2,ParallelCosineThreshold)) return false;
    else if (FMath::Abs(TVector<T>::PointPlaneDist (Base2,Base1,Normal1)) > UE_THRESH_POINT_ON_PLANE) return false;
    else return true;
}
 
template<typename T>
inline T TVector<T>::Triple(const TVector<T>& X, const TVector<T>& Y, const TVector<T>& Z)
{
    return
    (   (X.X * (Y.Y * Z.Z - Y.Z * Z.Y))
    +   (X.Y * (Y.Z * Z.X - Y.X * Z.Z))
    +   (X.Z * (Y.X * Z.Y - Y.Y * Z.X)));
}
 
template<typename T>
inline TVector<T> TVector<T>::RadiansToDegrees(const TVector<T>& RadVector)
{
    return RadVector * (180.f / UE_PI);
}
 
template<typename T>
inline TVector<T> TVector<T>::DegreesToRadians(const TVector<T>& DegVector)
{
    return DegVector * (UE_PI / 180.f);
}
 
template<typename T>
inline TVector<T>::TVector(T InF)
    : X(InF), Y(InF), Z(InF)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
UE_FORCEINLINE_HINT constexpr TVector<T>::TVector(T InF, TVectorConstInit)
    : X(InF), Y(InF), Z(InF)
{
}
 
template<typename T>
inline TVector<T>::TVector(T InX, T InY, T InZ)
    : X(InX), Y(InY), Z(InZ)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
inline TVector<T>::TVector(const FLinearColor& InColor)
    : X(InColor.R), Y(InColor.G), Z(InColor.B)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
template <typename IntType>
inline TVector<T>::TVector(TIntVector3<IntType> InVector)
    : X((T)InVector.X), Y((T)InVector.Y), Z((T)InVector.Z)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
template <typename IntType>
inline TVector<T>::TVector(TIntPoint<IntType> A)
    : X((T)A.X), Y((T)A.Y), Z(0.f)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
inline TVector<T>::TVector(EForceInit)
    : X(0.0f), Y(0.0f), Z(0.0f)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
inline TVector<T> TVector<T>::operator^(const TVector<T>& V) const
{
    return TVector<T>
        (
        Y * V.Z - Z * V.Y,
        Z * V.X - X * V.Z,
        X * V.Y - Y * V.X
        );
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::Cross(const TVector<T>& V) const
{
    return *this ^ V;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::CrossProduct(const TVector<T>& A, const TVector<T>& B)
{
    return A ^ B;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::operator|(const TVector<T>& V) const
{
    return X*V.X + Y*V.Y + Z*V.Z;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::Dot(const TVector<T>& V) const
{
    return *this | V;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::DotProduct(const TVector<T>& A, const TVector<T>& B)
{
    return A | B;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::operator+(const TVector<T>& V) const
{
    return TVector<T>(X + V.X, Y + V.Y, Z + V.Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::operator-(const TVector<T>& V) const
{
    return TVector<T>(X - V.X, Y - V.Y, Z - V.Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::operator*(const TVector<T>& V) const
{
    return TVector<T>(X * V.X, Y * V.Y, Z * V.Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::operator/(const TVector<T>& V) const
{
    return TVector<T>(X / V.X, Y / V.Y, Z / V.Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::operator==(const TVector<T>& V) const
{
    return X==V.X && Y==V.Y && Z==V.Z;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::operator!=(const TVector<T>& V) const
{
    return X!=V.X || Y!=V.Y || Z!=V.Z;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::Equals(const TVector<T>& V, T Tolerance) const
{
    return FMath::Abs(X-V.X) <= Tolerance && FMath::Abs(Y-V.Y) <= Tolerance && FMath::Abs(Z-V.Z) <= Tolerance;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::AllComponentsEqual(T Tolerance) const
{
    return FMath::Abs(X - Y) <= Tolerance && FMath::Abs(X - Z) <= Tolerance && FMath::Abs(Y - Z) <= Tolerance;
}
 
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::operator-() const
{
    return TVector<T>(-X, -Y, -Z);
}
 
 
template<typename T>
inline TVector<T> TVector<T>::operator+=(const TVector<T>& V)
{
    X += V.X; Y += V.Y; Z += V.Z;
    DiagnosticCheckNaN();
    return *this;
}
 
template<typename T>
inline TVector<T> TVector<T>::operator-=(const TVector<T>& V)
{
    X -= V.X; Y -= V.Y; Z -= V.Z;
    DiagnosticCheckNaN();
    return *this;
}
 
template<typename T>
inline TVector<T> TVector<T>::operator*=(const TVector<T>& V)
{
    X *= V.X; Y *= V.Y; Z *= V.Z;
    DiagnosticCheckNaN();
    return *this;
}
 
template<typename T>
inline TVector<T> TVector<T>::operator/=(const TVector<T>& V)
{
    X /= V.X; Y /= V.Y; Z /= V.Z;
    DiagnosticCheckNaN();
    return *this;
}
 
template<typename T>
UE_FORCEINLINE_HINT T& TVector<T>::operator[](int32 Index)
{
    return Component(Index);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::operator[](int32 Index)const
{
    return Component(Index);
}
 
template<typename T>
inline void TVector<T>::Set(T InX, T InY, T InZ)
{
    X = InX;
    Y = InY;
    Z = InZ;
    DiagnosticCheckNaN();
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::GetMax() const
{
    return FMath::Max(FMath::Max(X,Y),Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::GetAbsMax() const
{
    return FMath::Max(FMath::Max(FMath::Abs(X),FMath::Abs(Y)),FMath::Abs(Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::GetMin() const
{
    return FMath::Min(FMath::Min(X,Y),Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::GetAbsMin() const
{
    return FMath::Min(FMath::Min(FMath::Abs(X),FMath::Abs(Y)),FMath::Abs(Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::ComponentMin(const TVector<T>& Other) const
{
    return TVector<T>(FMath::Min(X, Other.X), FMath::Min(Y, Other.Y), FMath::Min(Z, Other.Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::ComponentMax(const TVector<T>& Other) const
{
    return TVector<T>(FMath::Max(X, Other.X), FMath::Max(Y, Other.Y), FMath::Max(Z, Other.Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::GetAbs() const
{
    return TVector<T>(FMath::Abs(X), FMath::Abs(Y), FMath::Abs(Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::Size() const
{
    return FMath::Sqrt(X*X + Y*Y + Z*Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::Length() const
{
    return Size();
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::SizeSquared() const
{
    return X*X + Y*Y + Z*Z;
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::SquaredLength() const
{
    return SizeSquared();
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::Size2D() const
{
    return FMath::Sqrt(X*X + Y*Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::SizeSquared2D() const
{
    return X*X + Y*Y;
}
 
template<typename T>
inline bool TVector<T>::IsNearlyZero(T Tolerance) const
{
    return
        FMath::Abs(X)<=Tolerance
        &&  FMath::Abs(Y)<=Tolerance
        &&  FMath::Abs(Z)<=Tolerance;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::IsZero() const
{
    return X==0.f && Y==0.f && Z==0.f;
}
 
template<typename T>
inline bool TVector<T>::Normalize(T Tolerance)
{
    const T SquareSum = X*X + Y*Y + Z*Z;
    if(SquareSum > Tolerance)
    {
        const T Scale = FMath::InvSqrt(SquareSum);
        X *= Scale; Y *= Scale; Z *= Scale;
        return true;
    }
    return false;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::IsUnit(T LengthSquaredTolerance) const
{
    return FMath::Abs(1.0f - SizeSquared()) < LengthSquaredTolerance;
}
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::IsNormalized() const
{
    return (FMath::Abs(1.f - SizeSquared()) < UE_THRESH_VECTOR_NORMALIZED);
}
 
template<typename T>
inline void TVector<T>::ToDirectionAndLength(TVector<T>& OutDir, double& OutLength) const
{
    OutLength = Size();
    if (OutLength > UE_SMALL_NUMBER)
    {
        T OneOverLength = T(1.0 / OutLength);
        OutDir = TVector<T>(X * OneOverLength, Y * OneOverLength, Z * OneOverLength);
    }
    else
    {
        OutDir = ZeroVector;
    }
}
 
template<typename T>
inline void TVector<T>::ToDirectionAndLength(TVector<T>& OutDir, float& OutLength) const
{
    OutLength = (float)Size();
    if (OutLength > UE_SMALL_NUMBER)
    {
        float OneOverLength = 1.0f / OutLength;
        OutDir = TVector<T>(X * OneOverLength, Y * OneOverLength, Z * OneOverLength);
    }
    else
    {
        OutDir = ZeroVector;
    }
}
 
 
template<typename T>
inline TVector<T> TVector<T>::GetSignVector() const
{
    return TVector<T>
        (
        FMath::FloatSelect(X, (T)1, (T)-1),     // LWC_TODO: Templatize FMath functionality
        FMath::FloatSelect(Y, (T)1, (T)-1),
        FMath::FloatSelect(Z, (T)1, (T)-1)
        );
}
 
template<typename T>
inline TVector<T> TVector<T>::Projection() const
{
    const T RZ = 1.f/Z;
    return TVector<T>(X*RZ, Y*RZ, 1);
}
 
template<typename T>
inline TVector<T> TVector<T>::GetUnsafeNormal() const
{
    const T Scale = FMath::InvSqrt(X*X+Y*Y+Z*Z);
    return TVector<T>(X*Scale, Y*Scale, Z*Scale);
}
 
template<typename T>
inline TVector<T> TVector<T>::GetUnsafeNormal2D() const
{
    const T Scale = FMath::InvSqrt(X * X + Y * Y);
    return TVector<T>(X*Scale, Y*Scale, 0);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::GridSnap(const T& GridSz) const
{
    return TVector<T>(FMath::GridSnap(X, GridSz),FMath::GridSnap(Y, GridSz),FMath::GridSnap(Z, GridSz));
}
 
template<typename T>
inline TVector<T> TVector<T>::BoundToCube(T Radius) const
{
    return TVector<T>
        (
        FMath::Clamp(X,-Radius,Radius),
        FMath::Clamp(Y,-Radius,Radius),
        FMath::Clamp(Z,-Radius,Radius)
        );
}
 
template<typename T>
inline TVector<T> TVector<T>::BoundToBox(const TVector<T>& Min, const TVector<T>& Max) const
{
    return TVector<T>
    (
        FMath::Clamp(X, Min.X, Max.X),
        FMath::Clamp(Y, Min.Y, Max.Y),
        FMath::Clamp(Z, Min.Z, Max.Z)
    );
}
 
 
template<typename T>
inline TVector<T> TVector<T>::GetClampedToSize(T Min, T Max) const
{
    T VecSize = Size();
    const TVector<T> VecDir = (VecSize > UE_SMALL_NUMBER) ? (*this/VecSize) : ZeroVector;
 
    VecSize = FMath::Clamp(VecSize, Min, Max);
 
    return VecSize * VecDir;
}
 
template<typename T>
inline TVector<T> TVector<T>::GetClampedToSize2D(T Min, T Max) const
{
    T VecSize2D = Size2D();
    const TVector<T> VecDir = (VecSize2D > UE_SMALL_NUMBER) ? (*this/VecSize2D) : ZeroVector;
 
    VecSize2D = FMath::Clamp(VecSize2D, Min, Max);
 
    return TVector<T>(VecSize2D * VecDir.X, VecSize2D * VecDir.Y, Z);
}
 
template<typename T>
inline TVector<T> TVector<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 TVector<T>(X*Scale, Y*Scale, Z*Scale);
    }
    else
    {
        return *this;
    }   
}
 
template<typename T>
inline TVector<T> TVector<T>::GetClampedToMaxSize2D(T MaxSize) const
{
    if (MaxSize < UE_KINDA_SMALL_NUMBER)
    {
        return TVector<T>(0.f, 0.f, Z);
    }
 
    const T VSq2D = SizeSquared2D();
    if (VSq2D > FMath::Square(MaxSize))
    {
        const T Scale = MaxSize * FMath::InvSqrt(VSq2D);
        return TVector<T>(X*Scale, Y*Scale, Z);
    }
    else
    {
        return *this;
    }
}
 
template<typename T>
UE_FORCEINLINE_HINT void TVector<T>::AddBounded(const TVector<T>& V, T Radius)
{
    *this = (*this + V).BoundToCube(Radius);
}
 
template<typename T>
inline T& TVector<T>::Component(int32 Index)
{
    check(IsValidIndex(Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    return XYZ[Index];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
template<typename T>
inline T TVector<T>::Component(int32 Index) const
{
    check(IsValidIndex(Index));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    return XYZ[Index];
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
template<typename T>
bool TVector<T>::IsValidIndex(int32 Index) const
{
    return (Index >= 0) && (Index < NumComponents);
}
 
template<typename T>
inline T TVector<T>::GetComponentForAxis(EAxis::Type Axis) const
{
    switch (Axis)
    {
    case EAxis::X:
        return X;
    case EAxis::Y:
        return Y;
    case EAxis::Z:
        return Z;
    case EAxis::None:
    default:
        return 0.f;
    }
}
 
template<typename T>
inline void TVector<T>::SetComponentForAxis(EAxis::Type Axis, T Component)
{
    switch (Axis)
    {
    case EAxis::X:
        X = Component;
        break;
    case EAxis::Y:
        Y = Component;
        break;
    case EAxis::Z:
        Z = Component;
        break;
    case EAxis::None:
    default:
        break;
    }
}
 
template<typename T>
inline TVector<T> TVector<T>::Reciprocal() const
{
    TVector<T> RecVector;
    if (X!=0.f)
    {
        RecVector.X = 1.f/X;
    }
    else 
    {
        RecVector.X = UE_BIG_NUMBER;
    }
    if (Y!=0.f)
    {
        RecVector.Y = 1.f/Y;
    }
    else 
    {
        RecVector.Y = UE_BIG_NUMBER;
    }
    if (Z!=0.f)
    {
        RecVector.Z = 1.f/Z;
    }
    else 
    {
        RecVector.Z = UE_BIG_NUMBER;
    }
 
    return RecVector;
}
 
 
 
 
template<typename T>
UE_FORCEINLINE_HINT bool TVector<T>::IsUniform(T Tolerance) const
{
    return AllComponentsEqual(Tolerance);
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::MirrorByVector(const TVector<T>& MirrorNormal) const
{
    return *this - MirrorNormal * (2.f * (*this | MirrorNormal));
}
 
template<typename T>
inline TVector<T> TVector<T>::GetSafeNormal(T Tolerance, const TVector<T>& ResultIfZero) const
{
    const T SquareSum = X*X + Y*Y + Z*Z;
 
    // Not sure if it's safe to add tolerance in there. Might introduce too many errors
    if(SquareSum == 1.f)
    {
        return *this;
    }       
    else if(SquareSum < Tolerance)
    {
        return ResultIfZero;
    }
    const T Scale = (T)FMath::InvSqrt(SquareSum);
    return TVector<T>(X*Scale, Y*Scale, Z*Scale);
}
 
template<typename T>
inline TVector<T> TVector<T>::GetSafeNormal2D(T Tolerance, const TVector<T>& ResultIfZero) const
{
    const T SquareSum = X*X + Y*Y;
 
    // Not sure if it's safe to add tolerance in there. Might introduce too many errors
    if(SquareSum == 1.f)
    {
        if(Z == 0.f)
        {
            return *this;
        }
        else
        {
            return TVector<T>(X, Y, 0.f);
        }
    }
    else if(SquareSum < Tolerance)
    {
        return ResultIfZero;
    }
 
    const T Scale = FMath::InvSqrt(SquareSum);
    return TVector<T>(X*Scale, Y*Scale, 0.f);
}
 
template<typename T>
inline T TVector<T>::CosineAngle2D(TVector<T> B) const
{
    TVector<T> A(*this);
    A.Z = 0.0f;
    B.Z = 0.0f;
    A.Normalize();
    B.Normalize();
    return A | B;
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::ProjectOnTo(const TVector<T>& A) const
{ 
    return (A * ((*this | A) / (A | A))); 
}
 
template<typename T>
UE_FORCEINLINE_HINT TVector<T> TVector<T>::ProjectOnToNormal(const TVector<T>& Normal) const
{
    return (Normal * (*this | Normal));
}
 
 
template<typename T>
void TVector<T>::GenerateClusterCenters(TArray<TVector<T>>& Clusters, const TArray<TVector<T>>& Points, int32 NumIterations, int32 NumConnectionsToBeValid)
{
    struct FClusterMovedHereToMakeCompile
    {
        TVector<T> ClusterPosAccum;
        int32 ClusterSize;
    };
 
    // Check we have >0 points and clusters
    if (Points.Num() == 0 || Clusters.Num() == 0)
    {
        return;
    }
 
    // Temp storage for each cluster that mirrors the order of the passed in Clusters array
    TArray<FClusterMovedHereToMakeCompile> ClusterData;
    ClusterData.AddZeroed(Clusters.Num());
 
    // Then iterate
    for (int32 ItCount = 0; ItCount < NumIterations; ItCount++)
    {
        // Classify each point - find closest cluster center
        for (int32 i = 0; i < Points.Num(); i++)
        {
            const TVector<T>& Pos = Points[i];
 
            // Iterate over all clusters to find closes one
            int32 NearestClusterIndex = INDEX_NONE;
            T NearestClusterDistSqr = UE_BIG_NUMBER;
            for (int32 j = 0; j < Clusters.Num(); j++)
            {
                const T DistSqr = (Pos - Clusters[j]).SizeSquared();
                if (DistSqr < NearestClusterDistSqr)
                {
                    NearestClusterDistSqr = DistSqr;
                    NearestClusterIndex = j;
                }
            }
            // Update its info with this point
            if (NearestClusterIndex != INDEX_NONE)
            {
                ClusterData[NearestClusterIndex].ClusterPosAccum += Pos;
                ClusterData[NearestClusterIndex].ClusterSize++;
            }
        }
 
        // All points classified - update cluster center as average of membership
        for (int32 i = 0; i < Clusters.Num(); i++)
        {
            if (ClusterData[i].ClusterSize > 0)
            {
                Clusters[i] = ClusterData[i].ClusterPosAccum / (T)ClusterData[i].ClusterSize;
            }
        }
    }
 
    // so now after we have possible cluster centers we want to remove the ones that are outliers and not part of the main cluster
    for (int32 i = 0; i < ClusterData.Num(); i++)
    {
        if (ClusterData[i].ClusterSize < NumConnectionsToBeValid)
        {
            Clusters.RemoveAt(i);
        }
    }
}
 
template<typename T>
T TVector<T>::EvaluateBezier(const TVector<T>* ControlPoints, int32 NumPoints, TArray<TVector<T>>& OutPoints)
{
    check(ControlPoints);
    check(NumPoints >= 2);
 
    // var q is the change in t between successive evaluations.
    const T q = 1.f / (T)(NumPoints - 1); // q is dependent on the number of GAPS = POINTS-1
 
    // recreate the names used in the derivation
    const TVector<T>& P0 = ControlPoints[0];
    const TVector<T>& P1 = ControlPoints[1];
    const TVector<T>& P2 = ControlPoints[2];
    const TVector<T>& P3 = ControlPoints[3];
 
    // coefficients of the cubic polynomial that we're FDing -
    const TVector<T> a = P0;
    const TVector<T> b = 3 * (P1 - P0);
    const TVector<T> c = 3 * (P2 - 2 * P1 + P0);
    const TVector<T> d = P3 - 3 * P2 + 3 * P1 - P0;
 
    // initial values of the poly and the 3 diffs -
    TVector<T> S = a;                       // the poly value
    TVector<T> U = b * q + c * q * q + d * q * q * q;   // 1st order diff (quadratic)
    TVector<T> V = 2 * c * q * q + 6 * d * q * q * q;   // 2nd order diff (linear)
    TVector<T> W = 6 * d * q * q * q;               // 3rd order diff (constant)
 
    // Path length.
    T Length = 0;
 
    TVector<T> OldPos = P0;
    OutPoints.Add(P0);  // first point on the curve is always P0.
 
    for (int32 i = 1; i < NumPoints; ++i)
    {
        // calculate the next value and update the deltas
        S += U;         // update poly value
        U += V;         // update 1st order diff value
        V += W;         // update 2st order diff value
        // 3rd order diff is constant => no update needed.
 
        // Update Length.
        Length += TVector<T>::Dist(S, OldPos);
        OldPos = S;
 
        OutPoints.Add(S);
    }
 
    // Return path length as experienced in sequence (linear interpolation between points).
    return Length;
}
 
template<typename T>
void TVector<T>::CreateOrthonormalBasis(TVector<T>& XAxis, TVector<T>& YAxis, TVector<T>& ZAxis)
{
    // Project the X and Y axes onto the plane perpendicular to the Z axis.
    XAxis -= (XAxis | ZAxis) / (ZAxis | ZAxis) * ZAxis;
    YAxis -= (YAxis | ZAxis) / (ZAxis | ZAxis) * ZAxis;
 
    // If the X axis was parallel to the Z axis, choose a vector which is orthogonal to the Y and Z axes.
    if (XAxis.SizeSquared() < UE_DELTA * UE_DELTA)
    {
        XAxis = YAxis ^ ZAxis;
    }
 
    // If the Y axis was parallel to the Z axis, choose a vector which is orthogonal to the X and Z axes.
    if (YAxis.SizeSquared() < UE_DELTA * UE_DELTA)
    {
        YAxis = XAxis ^ ZAxis;
    }
 
    // Normalize the basis vectors.
    XAxis.Normalize();
    YAxis.Normalize();
    ZAxis.Normalize();
}
 
template<typename T>
void TVector<T>::UnwindEuler()
{
    X = FMath::UnwindDegrees(X);
    Y = FMath::UnwindDegrees(Y);
    Z = FMath::UnwindDegrees(Z);
}
 
template<typename T>
void TVector<T>::FindBestAxisVectors(TVector<T>& Axis1, TVector<T>& Axis2) const
{
    const T NX = FMath::Abs(X);
    const T NY = FMath::Abs(Y);
    const T NZ = FMath::Abs(Z);
 
    // Find best basis vectors.
    if (NZ > NX && NZ > NY) Axis1 = TVector<T>(1, 0, 0);
    else                    Axis1 = TVector<T>(0, 0, 1);
 
    TVector<T> Tmp = Axis1 - *this * (Axis1 | *this);
    Axis1 = Tmp.GetSafeNormal();
    Axis2 = Axis1 ^ *this;
}
 
template<typename T>
inline bool TVector<T>::ContainsNaN() const
{
    return (!FMath::IsFinite(X) || 
            !FMath::IsFinite(Y) ||
            !FMath::IsFinite(Z));
}
 
template<typename T>
UE_FORCEINLINE_HINT FString TVector<T>::ToString() const
{
    return FString::Printf(TEXT("X=%3.3f Y=%3.3f Z=%3.3f"), X, Y, Z);
}
 
template<typename T>
inline FText TVector<T>::ToText() const
{
    FFormatNamedArguments Args;
    Args.Add(TEXT("X"), X);
    Args.Add(TEXT("Y"), Y);
    Args.Add(TEXT("Z"), Z);
 
    return FText::Format(NSLOCTEXT("Core", "Vector3", "X={X} Y={Y} Z={Z}"), Args);
}
 
template<typename T>
inline FText TVector<T>::ToCompactText() const
{
    if (IsNearlyZero())
    {
        return NSLOCTEXT("Core", "Vector3_CompactZeroVector", "V(0)");
    }
 
    const bool XIsNotZero = !FMath::IsNearlyZero(X);
    const bool YIsNotZero = !FMath::IsNearlyZero(Y);
    const bool ZIsNotZero = !FMath::IsNearlyZero(Z);
 
    FNumberFormattingOptions FormatRules;
    FormatRules.MinimumFractionalDigits = 2;
    FormatRules.MinimumIntegralDigits = 0;
 
    FFormatNamedArguments Args;
    Args.Add(TEXT("X"), FText::AsNumber(X, &FormatRules));
    Args.Add(TEXT("Y"), FText::AsNumber(Y, &FormatRules));
    Args.Add(TEXT("Z"), FText::AsNumber(Z, &FormatRules));
 
    if (XIsNotZero && YIsNotZero && ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactXYZ", "V(X={X}, Y={Y}, Z={Z})"), Args);
    }
    else if (!XIsNotZero && YIsNotZero && ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactYZ", "V(Y={Y}, Z={Z})"), Args);
    }
    else if (XIsNotZero && !YIsNotZero && ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactXZ", "V(X={X}, Z={Z})"), Args);
    }
    else if (XIsNotZero && YIsNotZero && !ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactXY", "V(X={X}, Y={Y})"), Args);
    }
    else if (!XIsNotZero && !YIsNotZero && ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactZ", "V(Z={Z})"), Args);
    }
    else if (XIsNotZero && !YIsNotZero && !ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactX", "V(X={X})"), Args);
    }
    else if (!XIsNotZero && YIsNotZero && !ZIsNotZero)
    {
        return FText::Format(NSLOCTEXT("Core", "Vector3_CompactY", "V(Y={Y})"), Args);
    }
 
    return NSLOCTEXT("Core", "Vector3_CompactZeroVector", "V(0)");
}
 
template<typename T>
inline FString TVector<T>::ToCompactString() const
{
    if(IsNearlyZero())
    {
        return FString(TEXT("V(0)"));
    }
 
    FString ReturnString(TEXT("V("));
    bool bIsEmptyString = true;
    if(!FMath::IsNearlyZero(X))
    {
        ReturnString += FString::Printf(TEXT("X=%.2f"), X);
        bIsEmptyString = false;
    }
    if(!FMath::IsNearlyZero(Y))
    {
        if(!bIsEmptyString)
        {
            ReturnString += FString(TEXT(", "));
        }
        ReturnString += FString::Printf(TEXT("Y=%.2f"), Y);
        bIsEmptyString = false;
    }
    if(!FMath::IsNearlyZero(Z))
    {
        if(!bIsEmptyString)
        {
            ReturnString += FString(TEXT(", "));
        }
        ReturnString += FString::Printf(TEXT("Z=%.2f"), Z);
        bIsEmptyString = false;
    }
    ReturnString += FString(TEXT(")"));
    return ReturnString;
}
 
template<typename T>
inline bool TVector<T>::InitFromCompactString(const FString& InSourceString)
{
    X = Y = Z = 0;
 
    if (FCString::Strifind(*InSourceString, TEXT("V(0)")) != nullptr)
    {
        return true;
    }
 
    const bool bSuccessful = FParse::Value(*InSourceString, TEXT("X="), X) | FParse::Value(*InSourceString, TEXT("Y="), Y) | FParse::Value(*InSourceString, TEXT("Z="), Z); //-V792
 
    return bSuccessful;
}
 
template<typename T>
inline bool TVector<T>::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;
}
 
template<typename T>
inline TVector2<T> TVector<T>::UnitCartesianToSpherical() const
{
    checkSlow(IsUnit());
    const T Theta = FMath::Acos(Z / Size());
    const T Phi = FMath::Atan2(Y, X);
    return TVector2<T>(Theta, Phi);
}
 
template<typename T>
inline T TVector<T>::HeadingAngle() const
{
    // Project Dir into Z plane.
    TVector<T> PlaneDir = *this;
    PlaneDir.Z = 0.f;
    PlaneDir = PlaneDir.GetSafeNormal();
 
    T Angle = FMath::Acos(PlaneDir.X);
 
    if(PlaneDir.Y < 0.0f)
    {
        Angle *= -1.0f;
    }
 
    return Angle;
}
 
 
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::Dist(const TVector<T>& V1, const TVector<T>& V2)
{
    return FMath::Sqrt(TVector<T>::DistSquared(V1, V2));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::DistXY(const TVector<T>& V1, const TVector<T>& V2)
{
    return FMath::Sqrt(TVector<T>::DistSquaredXY(V1, V2));
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::DistSquared(const TVector<T>& V1, const TVector<T>& V2)
{
    return FMath::Square(V2.X-V1.X) + FMath::Square(V2.Y-V1.Y) + FMath::Square(V2.Z-V1.Z);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::DistSquaredXY(const TVector<T>& V1, const TVector<T>& V2)
{
    return FMath::Square(V2.X-V1.X) + FMath::Square(V2.Y-V1.Y);
}
 
template<typename T>
UE_FORCEINLINE_HINT T TVector<T>::BoxPushOut(const TVector<T>& Normal, const TVector<T>& Size)
{
    return FMath::Abs(Normal.X*Size.X) + FMath::Abs(Normal.Y*Size.Y) + FMath::Abs(Normal.Z*Size.Z);
}
 
template<typename T>
inline TVector<T> TVector<T>::Min(const TVector<T>& A, const TVector<T>& B)
{
    return TVector<T>(
        FMath::Min( A.X, B.X ),
        FMath::Min( A.Y, B.Y ),
        FMath::Min( A.Z, B.Z )
        ); 
}
 
template<typename T>
inline TVector<T> TVector<T>::Max(const TVector<T>& A, const TVector<T>& B)
{
    return TVector<T>(
        FMath::Max( A.X, B.X ),
        FMath::Max( A.Y, B.Y ),
        FMath::Max( A.Z, B.Z )
        ); 
}
 
template<typename T>
inline TVector<T> TVector<T>::Min3( const TVector<T>& A, const TVector<T>& B, const TVector<T>& C )
{
    return TVector<T>(
        FMath::Min3( A.X, B.X, C.X ),
        FMath::Min3( A.Y, B.Y, C.Y ),
        FMath::Min3( A.Z, B.Z, C.Z )
        ); 
}
 
template<typename T>
inline TVector<T> TVector<T>::Max3(const TVector<T>& A, const TVector<T>& B, const TVector<T>& C)
{
    return TVector<T>(
        FMath::Max3( A.X, B.X, C.X ),
        FMath::Max3( A.Y, B.Y, C.Y ),
        FMath::Max3( A.Z, B.Z, C.Z )
        ); 
}
 
#if !defined(_MSC_VER) || defined(__clang__)  // MSVC can't forward declare explicit specializations
template<> CORE_API const FVector3f FVector3f::ZeroVector;
template<> CORE_API const FVector3f FVector3f::OneVector;
template<> CORE_API const FVector3f FVector3f::UpVector;
template<> CORE_API const FVector3f FVector3f::DownVector;
template<> CORE_API const FVector3f FVector3f::ForwardVector;
template<> CORE_API const FVector3f FVector3f::BackwardVector;
template<> CORE_API const FVector3f FVector3f::RightVector;
template<> CORE_API const FVector3f FVector3f::LeftVector;
template<> CORE_API const FVector3f FVector3f::XAxisVector;
template<> CORE_API const FVector3f FVector3f::YAxisVector;
template<> CORE_API const FVector3f FVector3f::ZAxisVector;
template<> CORE_API const FVector3d FVector3d::ZeroVector;
template<> CORE_API const FVector3d FVector3d::OneVector;
template<> CORE_API const FVector3d FVector3d::UpVector;
template<> CORE_API const FVector3d FVector3d::DownVector;
template<> CORE_API const FVector3d FVector3d::ForwardVector;
template<> CORE_API const FVector3d FVector3d::BackwardVector;
template<> CORE_API const FVector3d FVector3d::RightVector;
template<> CORE_API const FVector3d FVector3d::LeftVector;
template<> CORE_API const FVector3d FVector3d::XAxisVector;
template<> CORE_API const FVector3d FVector3d::YAxisVector;
template<> CORE_API const FVector3d FVector3d::ZAxisVector;
#endif
 
template<typename T, typename T2 UE_REQUIRES(std::is_arithmetic_v<T2>)>
UE_FORCEINLINE_HINT TVector<T> operator*(T2 Scale, const TVector<T>& V)
{
    return V.operator*(Scale);
}
 
template<typename T>
UE_FORCEINLINE_HINT uint32 GetTypeHash(const TVector<T>& Vector)
{
    // Note: this assumes there's no padding in Vector that could contain uncompared data.
    return FCrc::MemCrc_DEPRECATED(&Vector, sizeof(Vector));
}
 
} // namespace UE::Math
} // namespace UE
 
template<> struct TCanBulkSerialize<FVector3f> { enum { Value = true }; };
template<> struct TIsPODType<FVector3f> { enum { Value = true }; };
template<> struct TIsUECoreVariant<FVector3f> { enum { Value = true }; };
DECLARE_INTRINSIC_TYPE_LAYOUT(FVector3f);
 
template<> struct TCanBulkSerialize<FVector3d> { enum { Value = true }; };
template<> struct TIsPODType<FVector3d> { enum { Value = true }; };
template<> struct TIsUECoreVariant<FVector3d> { enum { Value = true }; };
DECLARE_INTRINSIC_TYPE_LAYOUT(FVector3d);
 
template<typename T>
inline UE::Math::TVector<T> ClampVector(const UE::Math::TVector<T>& V, const UE::Math::TVector<T>& Min, const UE::Math::TVector<T>& Max)
{
    return UE::Math::TVector<T>(
        FMath::Clamp(V.X, Min.X, Max.X),
        FMath::Clamp(V.Y, Min.Y, Max.Y),
        FMath::Clamp(V.Z, Min.Z, Max.Z)
    );
}
 
#if PLATFORM_LITTLE_ENDIAN
#define INTEL_ORDER_VECTOR(x) (x)
#else
template<typename T>
static UE_FORCEINLINE_HINT UE::Math::TVector<T> INTEL_ORDER_VECTOR(UE::Math::TVector<T> v)
{
    return UE::Math::TVector<T>(INTEL_ORDERF(v.X), INTEL_ORDERF(v.Y), INTEL_ORDERF(v.Z));
}
#endif
 
 
template<typename T, typename U>
inline T ComputeSquaredDistanceFromBoxToPoint(const UE::Math::TVector<T>& Mins, const UE::Math::TVector<T>& Maxs, const UE::Math::TVector<U>& Point)
{
    // Accumulates the distance as we iterate axis
    T DistSquared = 0;
 
    // Check each axis for min/max and add the distance accordingly
    // NOTE: Loop manually unrolled for > 2x speed up
    if (Point.X < Mins.X)
    {
        DistSquared += FMath::Square(Point.X - Mins.X);
    }
    else if (Point.X > Maxs.X)
    {
        DistSquared += FMath::Square(Point.X - Maxs.X);
    }
 
    if (Point.Y < Mins.Y)
    {
        DistSquared += FMath::Square(Point.Y - Mins.Y);
    }
    else if (Point.Y > Maxs.Y)
    {
        DistSquared += FMath::Square(Point.Y - Maxs.Y);
    }
 
    if (Point.Z < Mins.Z)
    {
        DistSquared += FMath::Square(Point.Z - Mins.Z);
    }
    else if (Point.Z > Maxs.Z)
    {
        DistSquared += FMath::Square(Point.Z - Maxs.Z);
    }
 
    return DistSquared;
}
 
 
/* FMath inline functions
 *****************************************************************************/
 
template<typename T>
inline UE::Math::TVector<T> FMath::LinePlaneIntersection
    (
    const UE::Math::TVector<T>&Point1,
    const UE::Math::TVector<T>&Point2,
    const UE::Math::TVector<T>&PlaneOrigin,
    const UE::Math::TVector<T>&PlaneNormal
    )
{
    return
        Point1
        + (Point2 - Point1)
        *   (((PlaneOrigin - Point1)|PlaneNormal) / ((Point2 - Point1)|PlaneNormal));
}
 
template<typename T>
inline bool FMath::LineSphereIntersection(const UE::Math::TVector<T>& Start, const UE::Math::TVector<T>& Dir, T Length, const UE::Math::TVector<T>& Origin, T Radius)
{
    const UE::Math::TVector<T>  EO = Start - Origin;
    const T     v = (Dir | (Origin - Start));
    const T     disc = Radius * Radius - ((EO | EO) - v * v);
 
    if(disc >= 0)
    {
        const T Time = (v - Sqrt(disc)) / Length;
 
        if(Time >= 0 && Time <= 1)
            return 1;
        else
            return 0;
    }
    else
        return 0;
}
 
inline FVector FMath::VRand()
{
    FVector Result;
    FVector::FReal L;
 
    do
    {
        // Check random vectors in the unit sphere so result is statistically uniform.
        Result.X = FRand() * 2.f - 1.f;
        Result.Y = FRand() * 2.f - 1.f;
        Result.Z = FRand() * 2.f - 1.f;
        L = Result.SizeSquared();
    }
    while(L > 1.0f || L < UE_KINDA_SMALL_NUMBER);
 
    return Result * (1.0f / Sqrt(L));
}
 
/* TVector2<T> inline functions
 *****************************************************************************/
namespace UE {
namespace Math {
 
template<typename InIntType>
template <typename FloatType>
TIntVector3<InIntType>::TIntVector3(TVector<FloatType> InVector)
{
    if constexpr (std::is_same_v<IntType, int32>)
    {
        X = FMath::TruncToInt32(InVector.X);
        Y = FMath::TruncToInt32(InVector.Y);
        Z = FMath::TruncToInt32(InVector.Z);
    }
    else if constexpr (std::is_same_v<IntType, uint32>)
    {
        X = IntCastChecked<uint32, int64>(FMath::TruncToInt64(InVector.X));
        Y = IntCastChecked<uint32, int64>(FMath::TruncToInt64(InVector.Y));
        Z = IntCastChecked<uint32, int64>(FMath::TruncToInt64(InVector.Z));
    }
    else
    {
        static_assert(sizeof(IntType) == 0, "Unimplemented");
    }
}
 
template<typename T>
inline TVector2<T>::TVector2( const TVector<T>& V )
    : X(V.X), Y(V.Y)
{
    DiagnosticCheckNaN();
}
 
template<typename T>
inline TVector<T> TVector2<T>::SphericalToUnitCartesian() const
{
    const T SinTheta = FMath::Sin(X);
    return TVector<T>(FMath::Cos(Y) * SinTheta, FMath::Sin(Y) * SinTheta, FMath::Cos(X));
}
 
} // namespace UE::Math
    
namespace LWC
{
inline constexpr FVector::FReal DefaultFloatPrecision = 1./16.;
 
// Validated narrowing cast for world positions. FVector -> FVector3f
inline FVector3f NarrowWorldPositionChecked(const FVector& WorldPosition)
{
    FVector3f Narrowed;
    Narrowed.X = FloatCastChecked<float>(WorldPosition.X, DefaultFloatPrecision);
    Narrowed.Y = FloatCastChecked<float>(WorldPosition.Y, DefaultFloatPrecision);
    Narrowed.Z = FloatCastChecked<float>(WorldPosition.Z, DefaultFloatPrecision);
    return Narrowed;
}
 
// Validated narrowing cast for world positions. FVector -> FVector3f
inline FVector3f NarrowWorldPositionChecked(const FVector::FReal InX, const FVector::FReal InY, const FVector::FReal InZ)
{
    FVector3f Narrowed;
    Narrowed.X = FloatCastChecked<float>(InX, DefaultFloatPrecision);
    Narrowed.Y = FloatCastChecked<float>(InY, DefaultFloatPrecision);
    Narrowed.Z = FloatCastChecked<float>(InZ, DefaultFloatPrecision);
    return Narrowed;
}
 
} // namespace UE::LWC
 
} // namespace UE
 
#if PLATFORM_ENABLE_VECTORINTRINSICS
template<>
inline FVector FMath::CubicInterp(const FVector& P0, const FVector& T0, const FVector& P1, const FVector& T1, const float& A)
{
    static_assert(PLATFORM_ENABLE_VECTORINTRINSICS == 1, "Requires vector intrinsics.");
    FVector res;
 
    const float A2 = A * A;
    const float A3 = A2 * A;
 
    const float s0 = (2 * A3) - (3 * A2) + 1;
    const float s1 = A3 - (2 * A2) + A;
    const float s2 = (A3 - A2);
    const float s3 = (-2 * A3) + (3 * A2);
 
    VectorRegister v0 = VectorMultiply(VectorLoadFloat1(&s0), VectorLoadFloat3(&P0));
    v0 = VectorMultiplyAdd(VectorLoadFloat1(&s1), VectorLoadFloat3(&T0), v0);
    VectorRegister v1 = VectorMultiply(VectorLoadFloat1(&s2), VectorLoadFloat3(&T1));
    v1 = VectorMultiplyAdd(VectorLoadFloat1(&s3), VectorLoadFloat3(&P1), v1);
 
    VectorStoreFloat3(VectorAdd(v0, v1), &res);
 
    return res;
}
#endif
 
#ifdef _MSC_VER
#pragma warning (pop)
#endif