TwoVectors.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/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Math/Vector.h"
 
struct FTwoVectors
{
public:
 
    FVector v1;
 
    FVector v2;
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT   FTwoVectors();
 
    [[nodiscard]] UE_FORCEINLINE_HINT   FTwoVectors( FVector In1, FVector In2 );
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT FTwoVectors( EForceInit );
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator+( const FTwoVectors& V ) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator-( const FTwoVectors& V ) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator*( float Scale ) const;
 
    [[nodiscard]] FTwoVectors operator/( float Scale ) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator*( const FTwoVectors& V ) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator/( const FTwoVectors& V ) const;
 
    // Binary comparison operators.
 
    [[nodiscard]] bool operator==( const FTwoVectors& V ) const;
 
    [[nodiscard]] bool operator!=( const FTwoVectors& V ) const;
 
    [[nodiscard]] bool Equals( const FTwoVectors& V, float Tolerance = UE_KINDA_SMALL_NUMBER ) const;
 
    // Unary operators.
 
    [[nodiscard]] UE_FORCEINLINE_HINT FTwoVectors operator-() const;
 
    // Assignment operators.
 
    UE_FORCEINLINE_HINT FTwoVectors operator+=( const FTwoVectors& V );
 
    UE_FORCEINLINE_HINT FTwoVectors operator-=( const FTwoVectors& V );
 
    UE_FORCEINLINE_HINT FTwoVectors operator*=( float Scale );
 
    FTwoVectors operator/=( float V );
 
    FTwoVectors operator*=( const FTwoVectors& V );
 
    FTwoVectors operator/=( const FTwoVectors& V );
 
    FVector::FReal& operator[]( int32 i );
 
public:
 
    [[nodiscard]] FVector::FReal GetMax() const;
 
    [[nodiscard]] FVector::FReal GetMin() const;
 
    [[nodiscard]] FString ToString() const;
 
public:
 
    friend FArchive& operator<<( FArchive& Ar, FTwoVectors& TwoVectors )
    {
        return Ar << TwoVectors.v1 << TwoVectors.v2;
    }
 
    bool Serialize( FArchive& Ar )
    {
        Ar << *this;
        return true;
    }
};
 
 
/* FTwoVectors inline functions
 *****************************************************************************/
 
UE_FORCEINLINE_HINT FTwoVectors operator*( float Scale, const FTwoVectors& V )
{
    return V.operator*( Scale );
}
 
 
inline  FTwoVectors::FTwoVectors() :
    v1(0.0f),
    v2(0.0f)
{ }
 
 
inline FTwoVectors::FTwoVectors( FVector In1, FVector In2 )
    : v1(In1)
    , v2(In2)
{ }
 
 
inline FTwoVectors::FTwoVectors( EForceInit )
    : v1(ForceInit)
    , v2(ForceInit)
{ }
 
 
inline FTwoVectors FTwoVectors::operator+( const FTwoVectors& V ) const
{
    return FTwoVectors(
        FVector(v1 + V.v1),
        FVector(v2 + V.v2)
    );
}
 
 
inline FTwoVectors FTwoVectors::operator-( const FTwoVectors& V ) const
{
    return FTwoVectors( 
        FVector(v1 - V.v1),
        FVector(v2 - V.v2)
    );
}
 
 
inline FTwoVectors FTwoVectors::operator*( float Scale ) const
{
    return FTwoVectors(
        FVector(v1 * Scale),
        FVector(v2 * Scale)
    );
}
 
 
inline FTwoVectors FTwoVectors::operator/( float Scale ) const
{
    const float RScale = 1.f / Scale;
 
    return FTwoVectors(
        FVector(v1 * RScale), 
        FVector(v2 * RScale)
    );
}
 
 
inline FTwoVectors FTwoVectors::operator*( const FTwoVectors& V ) const
{
    return FTwoVectors(
        FVector(v1 * V.v1),
        FVector(v2 * V.v2)
        );
}
 
 
inline FTwoVectors FTwoVectors::operator/( const FTwoVectors& V ) const
{
    return FTwoVectors(
        FVector(v1 / V.v1),
        FVector(v2 / V.v2)
    );
}
 
 
UE_FORCEINLINE_HINT bool FTwoVectors::operator==( const FTwoVectors& V ) const
{
    return ((v1 == V.v1) && (v2 == V.v2));
}
 
 
UE_FORCEINLINE_HINT bool FTwoVectors::operator!=( const FTwoVectors& V ) const
{
    return ((v1 != V.v1) || (v2 != V.v2));
}
 
 
UE_FORCEINLINE_HINT bool FTwoVectors::Equals( const FTwoVectors& V, float Tolerance ) const
{
    return v1.Equals(V.v1, Tolerance) && v2.Equals(V.v2, Tolerance);
}
 
 
inline FTwoVectors FTwoVectors::operator-() const
{
    return FTwoVectors(
        FVector(-v1),
        FVector(-v2)
    );
}
 
 
inline FTwoVectors FTwoVectors::operator+=( const FTwoVectors& V )
{
    v1 += V.v1;
    v2 += V.v2;
 
    return *this;
}
 
 
inline FTwoVectors FTwoVectors::operator-=( const FTwoVectors& V )
{
    v1 -= V.v1;
    v2 -= V.v2;
 
    return *this;
}
 
 
inline FTwoVectors FTwoVectors::operator*=( float Scale )
{
    v1 *= Scale;
    v2 *= Scale;
 
    return *this;
}
 
 
inline FTwoVectors FTwoVectors::operator/=( float V )
{
    const float RV = 1.f/V;
 
    v1 *= RV;
    v2 *= RV;
 
    return *this;
}
 
 
inline FTwoVectors FTwoVectors::operator*=( const FTwoVectors& V )
{
    v1 *= V.v1;
    v2 *= V.v2;
    return *this;
}
 
 
inline FTwoVectors FTwoVectors::operator/=( const FTwoVectors& V )
{
    v1 /= V.v1;
    v2 /= V.v2;
 
    return *this;
}
 
 
inline FVector::FReal FTwoVectors::GetMax() const
{
    const FVector::FReal MaxMax = FMath::Max(FMath::Max(v1.X, v1.Y), v1.Z);
    const FVector::FReal MaxMin = FMath::Max(FMath::Max(v2.X, v2.Y), v2.Z);
 
    return FMath::Max(MaxMax, MaxMin);
}
 
 
inline FVector::FReal FTwoVectors::GetMin() const
{
    const FVector::FReal MinMax = FMath::Min(FMath::Min(v1.X, v1.Y), v1.Z);
    const FVector::FReal MinMin = FMath::Min(FMath::Min(v2.X, v2.Y), v2.Z);
 
    return FMath::Min(MinMax, MinMin);
}
 
 
inline FVector::FReal& FTwoVectors::operator[]( int32 i )
{
    check(i > -1);
    check(i < 6);
 
    switch(i)
    {
    case 0:     return v1.X;
    case 1:     return v2.X;
    case 2:     return v1.Y;
    case 3:     return v2.Y;
    case 4:     return v1.Z;
    default:    return v2.Z;
    }
}
 
 
UE_FORCEINLINE_HINT FString FTwoVectors::ToString() const
{
    return FString::Printf(TEXT("V1=(%s) V2=(%s)"), *v1.ToString(), *v2.ToString());
}
 
template <> struct TIsPODType<FTwoVectors> { enum { Value = true }; };