TransformCalculus2D.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 "Math/Vector2D.h"
#include "Math/TransformCalculus.h"
 
#include <type_traits>
 
// Transform calculus for 2D types. UE4 already has a 2D Vector class that we
// will adapt to be interpreted as a translate transform. The rest we create
// new classes for.
//
// The following types are supported
// * float/double    -> represents a uniform scale.
// * FScale2D        -> represents a 2D non-uniform scale.
// * FVector2D       -> represents a 2D translation.
// * FShear2D        -> represents a "2D shear", interpreted as a shear parallel to the X axis followed by a shear parallel to the Y axis.
// * FQuat2D         -> represents a pure 2D rotation.
// * FMatrix2x2      -> represents a general 2D transform.
//
 
template<typename T> class TMatrix2x2;
 
 
// Adapters for TVector2. 
// 
// Since it is an existing UE4 types, we cannot rely on the default
// template that calls member functions. Instead, we provide direct overloads.
 
namespace UE
{
namespace Math
{
 
template<typename T>
[[nodiscard]] inline UE::Math::TVector2<T> Concatenate(const UE::Math::TVector2<T>& LHS, const UE::Math::TVector2<T>& RHS)
{
    return LHS + RHS;
}
 
}   // namespace UE::Math
}   // namespace UE
 
template<typename T>
[[nodiscard]] inline UE::Math::TVector2<T> Inverse(const UE::Math::TVector2<T>& Transform)
{
    return -Transform;
}
 
template<typename T>
[[nodiscard]] inline UE::Math::TVector2<T> TransformPoint(const UE::Math::TVector2<T>& Transform, const UE::Math::TVector2<T>& Point)
{
    return Transform + Point;
}
 
template<typename T>
[[nodiscard]] inline const UE::Math::TVector2<T>& TransformVector(const UE::Math::TVector2<T>& Transform, const UE::Math::TVector2<T>& Vector)
{
    return Vector;
}
 
// Adapters for 2D uniform scale.
// 
// Since it is a fundamental type, we cannot rely on the default
// template that calls member functions. Instead, we provide direct overloads.
 
template<typename PositionType>
[[nodiscard]] inline UE::Math::TVector2<PositionType> TransformPoint(float Transform, const UE::Math::TVector2<PositionType>& Point)
{
    return Transform * Point;
}
 
template<typename PositionType>
[[nodiscard]] inline UE::Math::TVector2<PositionType> TransformPoint(double Transform, const UE::Math::TVector2<PositionType>& Point)
{
    return Transform * Point;
}
 
template<typename VectorType>
[[nodiscard]] inline UE::Math::TVector2<VectorType> TransformVector(float Transform, const UE::Math::TVector2<VectorType>& Vector)
{
    return Transform * Vector;
}
 
template<typename VectorType>
[[nodiscard]] inline UE::Math::TVector2<VectorType> TransformVector(double Transform, const UE::Math::TVector2<VectorType>& Vector)
{
    return Transform * Vector;
}
 
template<typename T>
class TScale2
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    using Vector2Type = UE::Math::TVector2<T>;
 
    [[nodiscard]] TScale2() : Scale(1.0f, 1.0f) {}
    [[nodiscard]] explicit TScale2(T InScale) :Scale(InScale, InScale) {}
    [[nodiscard]] explicit TScale2(T InScaleX, T InScaleY) :Scale(InScaleX, InScaleY) {}
    template<typename ArgType>
    [[nodiscard]] explicit TScale2(const UE::Math::TVector2<ArgType>& InScale) :Scale(InScale) {}
    
    template<typename ArgType>
    [[nodiscard]] UE::Math::TVector2<ArgType> TransformPoint(const UE::Math::TVector2<ArgType>& Point) const
    {
        return UE::Math::TVector2<ArgType>(Scale) * Point;
    }
 
    template<typename ArgType>
    [[nodiscard]] UE::Math::TVector2<ArgType> TransformVector(const UE::Math::TVector2<ArgType>& Vector) const
    {
        return TransformPoint(Vector);
    }
 
    [[nodiscard]] TScale2 Concatenate(const TScale2& RHS) const
    {
        return TScale2(Scale * RHS.Scale);
    }
    [[nodiscard]] TScale2 Inverse() const
    {
        return TScale2(1.0f / Scale.X, 1.0f / Scale.Y);
    }
 
    [[nodiscard]] bool operator==(const TScale2& Other) const
    {
        return Scale == Other.Scale;
    }
    
    [[nodiscard]] bool operator!=(const TScale2& Other) const
    {
        return !operator==(Other);
    }
 
    [[nodiscard]] const Vector2Type& GetVector() const
    {
        return Scale;
    }
 
private:
    Vector2Type Scale;
};
 
typedef TScale2<float> FScale2f;
typedef TScale2<double> FScale2d;
typedef FScale2f FScale2D; // Default type (for backwards compat)
 
template<typename T> struct ConcatenateRules<float      , TScale2<T>    > { typedef TScale2<T> ResultType; };
template<typename T> struct ConcatenateRules<double     , TScale2<T>    > { typedef TScale2<T> ResultType; };
template<typename T> struct ConcatenateRules<TScale2<T> , float         > { typedef TScale2<T> ResultType; };
template<typename T> struct ConcatenateRules<TScale2<T> , double        > { typedef TScale2<T> ResultType; };
 
template<typename T>
class TShear2
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    using Vector2Type = UE::Math::TVector2<T>;
 
    TShear2() :Shear(0, 0) {}
    explicit TShear2(T ShearX, T ShearY) :Shear(ShearX, ShearY) {}
    template<typename VType>
    explicit TShear2(const UE::Math::TVector2<VType>& InShear) :Shear((Vector2Type)InShear) {}
 
    template<typename VType>
    [[nodiscard]] static TShear2 FromShearAngles(const UE::Math::TVector2<VType>& InShearAngles)
    {
        // Compute the M (Shear Slot) = CoTan(90 - SlopeAngle)
 
        // 0 is a special case because Tan(90) == infinity
        T ShearX = InShearAngles.X == 0 ? 0 : (1.0f / FMath::Tan(FMath::DegreesToRadians(90 - FMath::Clamp<T>((T)InShearAngles.X, -89.0f, 89.0f))));
        T ShearY = InShearAngles.Y == 0 ? 0 : (1.0f / FMath::Tan(FMath::DegreesToRadians(90 - FMath::Clamp<T>((T)InShearAngles.Y, -89.0f, 89.0f))));
 
        return TShear2(ShearX, ShearY);
    }
 
    template<typename ArgType>
    [[nodiscard]] UE::Math::TVector2<ArgType> TransformPoint(const UE::Math::TVector2<ArgType>& Point) const
    {
        return Point + UE::Math::TVector2<ArgType>(Point.Y, Point.X) * UE::Math::TVector2<ArgType>(Shear);
    }
    template<typename ArgType>
    [[nodiscard]] UE::Math::TVector2<ArgType> TransformVector(const UE::Math::TVector2<ArgType>& Vector) const
    {
        return TransformPoint(Vector);
    }
 
    [[nodiscard]] inline TMatrix2x2<T> Concatenate(const TShear2& RHS) const;
 
    [[nodiscard]] TMatrix2x2<T> Inverse() const;
 
 
    [[nodiscard]] bool operator==(const TShear2& Other) const
    {
        return Shear == Other.Shear;
    }
 
    [[nodiscard]] bool operator!=(const TShear2& Other) const
    {
        return !operator==(Other);
    }
 
    [[nodiscard]] const Vector2Type& GetVector() const
    {
        return Shear;
    }
 
private:
    Vector2Type Shear;
};
 
typedef TShear2<float> FShear2f;
typedef TShear2<double> FShear2d;
typedef FShear2f FShear2D;  // Default type (for backwards compat)
 
 
template<typename T>
class TQuat2
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    using Vector2Type = UE::Math::TVector2<T>;
 
    TQuat2() :Rot(1.0f, 0.0f) {}
    explicit TQuat2(T RotRadians) :Rot(FMath::Cos(RotRadians), FMath::Sin(RotRadians)) {}
    template<typename VType>
    explicit TQuat2(const UE::Math::TVector2<VType>& InRot) :Rot((Vector2Type)InRot) {}
 
    template<typename ArgType>
    UE::Math::TVector2<ArgType> TransformPoint(const UE::Math::TVector2<ArgType>& Point) const
    {
        return UE::Math::TVector2<ArgType>(
            Point.X * (ArgType)Rot.X - Point.Y * (ArgType)Rot.Y,
            Point.X * (ArgType)Rot.Y + Point.Y * (ArgType)Rot.X);
    }
    template<typename ArgType>
    UE::Math::TVector2<ArgType> TransformVector(const UE::Math::TVector2<ArgType>& Vector) const
    {
        return TransformPoint(Vector);
    }
    TQuat2 Concatenate(const TQuat2& RHS) const
    {
        return TQuat2(TransformPoint(FVector2D(RHS.Rot)));
    }
    TQuat2 Inverse() const
    {
        return TQuat2(Vector2Type(Rot.X, -Rot.Y));
    }
 
    bool operator==(const TQuat2& Other) const
    {
        return Rot == Other.Rot;
    }
    
    bool operator!=(const TQuat2& Other) const
    {
        return !operator==(Other);
    }
 
    const Vector2Type& GetVector() const { return Rot; }
 
private:
    Vector2Type Rot;
};
 
typedef TQuat2<float> FQuat2f;
typedef TQuat2<double> FQuat2d;
typedef FQuat2f FQuat2D; // Default type (for backwards compat)
 
template<typename T>
class TMatrix2x2
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    using Vector2Type = UE::Math::TVector2<T>;
 
    TMatrix2x2()
    {
        M[0][0] = 1; M[0][1] = 0;
        M[1][0] = 0; M[1][1] = 1;
    }
 
    TMatrix2x2(T m00, T m01, T m10, T m11)
    {
        M[0][0] = m00; M[0][1] = m01;
        M[1][0] = m10; M[1][1] = m11;
        DiagnosticCheckNaN();
    }
 
 
    explicit TMatrix2x2(T UniformScale)
    {
        M[0][0] = UniformScale; M[0][1] = 0;
        M[1][0] = 0; M[1][1] = UniformScale;
        DiagnosticCheckNaN();
    }
 
    explicit TMatrix2x2(const TScale2<T>& Scale)
    {
        T ScaleX = (T)Scale.GetVector().X;
        T ScaleY = (T)Scale.GetVector().Y;
        M[0][0] = ScaleX; M[0][1] = 0;
        M[1][0] = 0; M[1][1] = ScaleY;
        DiagnosticCheckNaN();
    }
 
    explicit TMatrix2x2(const TShear2<T>& Shear)
    {
        T XX = (T)Shear.GetVector().X;
        T YY = (T)Shear.GetVector().Y;
        M[0][0] = 1; M[0][1] =YY;
        M[1][0] = XX; M[1][1] = 1;
        DiagnosticCheckNaN();
    }
 
    explicit TMatrix2x2(const TQuat2<T>& Rotation)
    {
        T CosAngle = (T)Rotation.GetVector().X;
        T SinAngle = (T)Rotation.GetVector().Y;
        M[0][0] = CosAngle; M[0][1] = SinAngle;
        M[1][0] = -SinAngle; M[1][1] = CosAngle;
        DiagnosticCheckNaN();
    }
 
    template<typename ArgType>
    UE::Math::TVector2<ArgType> TransformPoint(const UE::Math::TVector2<ArgType>& Point) const
    {
        return UE::Math::TVector2<ArgType>(
            Point.X * (ArgType)M[0][0] + Point.Y * (ArgType)M[1][0],
            Point.X * (ArgType)M[0][1] + Point.Y * (ArgType)M[1][1]);
    }
    template<typename ArgType>
    UE::Math::TVector2<ArgType> TransformVector(const UE::Math::TVector2<ArgType>& Vector) const
    {
        return TransformPoint(Vector);
    }
    TMatrix2x2 Concatenate(const TMatrix2x2& RHS) const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        T E, F, G, H;
        RHS.GetMatrix(E, F, G, H);
        TMatrix2x2 Result = TMatrix2x2(
            A*E + B*G, A*F + B*H,
            C*E + D*G, C*F + D*H);
        Result.DiagnosticCheckNaN();
        return Result;
    }
    TMatrix2x2 Inverse() const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        T InvDet = InverseDeterminant();
        TMatrix2x2 Result = TMatrix2x2(
             D*InvDet, -B*InvDet,
            -C*InvDet,  A*InvDet);
        Result.DiagnosticCheckNaN();
        return Result;
    }
 
    bool operator==(const TMatrix2x2& RHS) const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        T E, F, G, H;
        RHS.GetMatrix(E, F, G, H);
        return
            FMath::IsNearlyEqual(A, E, UE_KINDA_SMALL_NUMBER) &&
            FMath::IsNearlyEqual(B, F, UE_KINDA_SMALL_NUMBER) &&
            FMath::IsNearlyEqual(C, G, UE_KINDA_SMALL_NUMBER) &&
            FMath::IsNearlyEqual(D, H, UE_KINDA_SMALL_NUMBER);
    }
 
    bool operator!=(const TMatrix2x2& Other) const
    {
        return !operator==(Other);
    }
 
    void GetMatrix(float& A, float& B, float& C, float& D) const
    {
        A = (float)M[0][0]; B = (float)M[0][1];
        C = (float)M[1][0]; D = (float)M[1][1];
    }
 
    void GetMatrix(double& A, double& B, double& C, double& D) const
    {
        A = (double)M[0][0]; B = (double)M[0][1];
        C = (double)M[1][0]; D = (double)M[1][1];
    }
 
    T Determinant() const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        return (A*D - B*C);
    }
 
    T InverseDeterminant() const
    {
        T Det = Determinant();
        checkSlow(Det != 0.0f);
        return 1.0f / Det;
    }
 
    TScale2<T> GetScaleSquared() const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        return TScale2<T>(A*A + B*B, C*C + D*D);
    }
 
    TScale2<T> GetScale() const
    {
        TScale2<T> ScaleSquared = GetScaleSquared();
        return TScale2<T>(FMath::Sqrt(ScaleSquared.GetVector().X), FMath::Sqrt(ScaleSquared.GetVector().Y));
    }
 
    T GetRotationAngle() const
    {
        T A, B, C, D;
        GetMatrix(A, B, C, D);
        return FMath::Atan(C / D);
    }
 
    bool IsIdentity() const
    {
        return M[0][0] == 1.0f && M[0][1] == 0.0f
            && M[1][0] == 0.0f && M[1][1] == 1.0f;
    }
 
    bool IsNearlyIdentity(T ErrorTolerance = UE_KINDA_SMALL_NUMBER) const
    {
        return
            FMath::IsNearlyEqual(M[0][0], 1.0f, ErrorTolerance) &&
            FMath::IsNearlyEqual(M[0][1], 0.0f, ErrorTolerance) &&
            FMath::IsNearlyEqual(M[1][0], 0.0f, ErrorTolerance) &&
            FMath::IsNearlyEqual(M[1][1], 1.0f, ErrorTolerance);
    }
 
    bool ContainsNaN() const
    {
        return (!FMath::IsFinite(M[0][0]) ||
                !FMath::IsFinite(M[0][1]) ||
                !FMath::IsFinite(M[1][0]) ||
                !FMath::IsFinite(M[1][1]));
    }
 
#if ENABLE_NAN_DIAGNOSTIC
    inline void DiagnosticCheckNaN() const
    {
        if (ContainsNaN())
        {
            logOrEnsureNanError(TEXT("Matrix2x2 contains NaN"));
            *const_cast<TMatrix2x2<T>*>(static_cast<const TMatrix2x2<T>*>(this)) = TMatrix2x2<T>(ForceInitToZero);
        }
    }
#else
    UE_FORCEINLINE_HINT void DiagnosticCheckNaN() const {}
#endif
 
private:
    T M[2][2];
};
 
typedef TMatrix2x2<float> FMatrix2x2f;
typedef TMatrix2x2<double> FMatrix2x2d;
typedef FMatrix2x2f FMatrix2x2; // Default type (for backwards compat)
 
 
template<typename T>
inline TMatrix2x2<T> TShear2<T>::Concatenate(const TShear2<T>& RHS) const
{
    T XXA = (T)Shear.X;
    T YYA = (T)Shear.Y;
    T XXB = (T)RHS.Shear.X;
    T YYB = (T)RHS.Shear.Y;
    return TMatrix2x2<T>(
        1+YYA*XXB, YYB*YYA,
        XXA+XXB, XXA*XXB+1);
}
 
template<typename T>
inline TMatrix2x2<T> TShear2<T>::Inverse() const
{
    T InvDet = 1.0f / T(1.0f - Shear.X*Shear.Y);
    return TMatrix2x2<T>(
        InvDet, T(-Shear.Y * InvDet),
        T(-Shear.X * InvDet), InvDet);
}
 
template<typename T> struct ConcatenateRules<float          , TMatrix2x2<T> > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<double         , TMatrix2x2<T> > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TScale2<T>     , TMatrix2x2<T> > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TShear2<T>     , TMatrix2x2<T> > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TQuat2<T>      , TMatrix2x2<T> > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TMatrix2x2<T>  , float         > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TMatrix2x2<T>  , double        > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TMatrix2x2<T>  , TScale2<T>    > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TMatrix2x2<T>  , TShear2<T>    > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TMatrix2x2<T>  , TQuat2<T>     > { typedef TMatrix2x2<T> ResultType; };
 
template<typename T> struct ConcatenateRules<TScale2<T>  , TShear2<T>  > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TScale2<T>  , TQuat2<T>   > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TShear2<T>  , TScale2<T>  > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TQuat2<T>   , TScale2<T>  > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TShear2<T>  , TQuat2<T>   > { typedef TMatrix2x2<T> ResultType; };
template<typename T> struct ConcatenateRules<TQuat2<T>   , TShear2<T>  > { typedef TMatrix2x2<T> ResultType; };
 
template<typename T>
class TTransform2
{
    static_assert(std::is_floating_point_v<T>, "T must be floating point");
 
public:
    using FReal = T;
    using Vector2Type = UE::Math::TVector2<T>;
    using Matrix2Type = TMatrix2x2<T>;
 
    template<typename VType = float>
    TTransform2(const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType = float>
    explicit TTransform2(T UniformScale, const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : M(TScale2<T>(UniformScale)), Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType = float>
    explicit TTransform2(const TScale2<T>& Scale, const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : M(Scale), Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType = float>
    explicit TTransform2(const TShear2<T>& Shear, const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : M(Shear), Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType = float>
    explicit TTransform2(const TQuat2<T>& Rot, const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : M(Rot), Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType = float>
    explicit TTransform2(const TMatrix2x2<T>& Transform, const UE::Math::TVector2<VType>& Translation = UE::Math::TVector2<VType>(0.f, 0.f))
        : M(Transform), Trans((Vector2Type)Translation)
    {
    }
 
    template<typename VType>
    UE::Math::TVector2<VType> TransformPoint(const UE::Math::TVector2<VType>& Point) const
    {
        return (UE::Math::TVector2<VType>) ::TransformPoint(Trans, ::TransformPoint(M, (Vector2Type)Point));
    }
 
    template<typename VType>
    UE::Math::TVector2<VType> TransformVector(const UE::Math::TVector2<VType>& Vector) const
    {
        return (UE::Math::TVector2<VType>) ::TransformVector(M, (Vector2Type)Vector);
    }
 
    TTransform2 Concatenate(const TTransform2& RHS) const
    {
        return TTransform2(
            ::Concatenate(M, RHS.M),
            ::Concatenate(::TransformPoint(RHS.M, Trans), RHS.Trans));
    }
 
    TTransform2 Inverse() const
    {
        Matrix2Type InvM = ::Inverse(M);
        Vector2Type InvTrans = ::TransformPoint(InvM, ::Inverse(Trans));
        return TTransform2(InvM, InvTrans);
    }
    
    bool operator==(const TTransform2& Other) const
    {
        return M == Other.M && Trans == Other.Trans;
    }
    
    bool operator!=(const TTransform2& Other) const
    {
        return !operator==(Other);
    }
 
    const Matrix2Type& GetMatrix() const { return M; }
    //const Vector2Type GetTranslation() const { return Vector2Type(Trans); }
    const FVector2D GetTranslation() const { return (FVector2D)Trans; } // TODO: should be Vector2Type in general, but retaining FVector2D for now for compilation backwards compat.
 
    template<typename VType>
    void SetTranslation(const UE::Math::TVector2<VType>& InTrans) { Trans = (Vector2Type)InTrans; }
 
    bool IsIdentity() const
    {
        return M.IsIdentity() && Trans == Vector2Type::ZeroVector;
    }
 
    UE::Math::TMatrix<T> To3DMatrix() const
    {
        T A, B, C, D;
        M.GetMatrix(A, B, C, D);
 
        return UE::Math::TMatrix<T>(
            UE::Math::TPlane<T>(      A,      B, 0.0f, 0.0f),
            UE::Math::TPlane<T>(      C,      D, 0.0f, 0.0f),
            UE::Math::TPlane<T>(   0.0f,   0.0f, 1.0f, 0.0f),
            UE::Math::TPlane<T>(Trans.X, Trans.Y, 0.0f, 1.0f)
        );
    }
 
    bool ContainsNaN() const
    {
        return M.ContainsNaN() || Trans.ContainsNaN();
    }
 
private:
    Matrix2Type M;
    Vector2Type Trans;
};
 
typedef TTransform2<float> FTransform2f;
typedef TTransform2<double> FTransform2d;
typedef FTransform2f FTransform2D; // default type, for backwards compat
 
template<> struct TIsPODType<FTransform2f> { enum { Value = true }; };
template<> struct TIsPODType<FTransform2d> { enum { Value = true }; };
 
// Concatenate overloads. 
// 
// Efficient overloads for concatenating 2D affine transforms.
// Better than simply upcasting both to FTransform2D first.
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const TScale2<T>& Scale, const UE::Math::TVector2<V>& Translation)
{
    return TTransform2<T>(Scale, Translation);
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const TShear2<T>& Shear, const UE::Math::TVector2<V>& Translation)
{
    return TTransform2<T>(Shear, Translation);
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const TQuat2<T>& Rot, const UE::Math::TVector2<V>& Translation)
{
    return TTransform2<T>(Rot, Translation);
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const TMatrix2x2<T>& Transform, const UE::Math::TVector2<V>& Translation)
{
    return TTransform2<T>(Transform, Translation);
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const TTransform2<T>& Transform, const UE::Math::TVector2<V>& Translation)
{
    return TTransform2<T>(Transform.GetMatrix(), Concatenate((UE::Math::TVector2<T>)Transform.GetTranslation(), (UE::Math::TVector2<T>)Translation));
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const UE::Math::TVector2<V>& Translation, const TScale2<T>& Scale)
{
    return TTransform2<T>(Scale, ::TransformPoint(Scale, Translation));
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const UE::Math::TVector2<V>& Translation, const TShear2<T>& Shear)
{
    return TTransform2<T>(Shear, ::TransformPoint(Shear, Translation));
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const UE::Math::TVector2<V>& Translation, const TQuat2<T>& Rot)
{
    return TTransform2<T>(Rot, ::TransformPoint(Rot, Translation));
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const UE::Math::TVector2<V>& Translation, const TMatrix2x2<T>& Transform)
{
    return TTransform2<T>(Transform, ::TransformPoint(Transform, Translation));
}
 
template<typename T, typename V>
inline TTransform2<T> Concatenate(const UE::Math::TVector2<V>& Translation, const TTransform2<T>& Transform)
{
    return TTransform2<T>(Transform.GetMatrix(), Concatenate(::TransformPoint(Transform.GetMatrix(), (UE::Math::TVector2<T>)Translation), (UE::Math::TVector2<T>)Transform.GetTranslation()));
}
 
namespace TransformCalculusHelper
{
    template<typename T>
    struct TIsTransform2
    {
        enum { Value = false };
    };
 
    template<> struct TIsTransform2< FTransform2f > { enum { Value = true }; };
    template<> struct TIsTransform2< FTransform2d > { enum { Value = true }; };
}
 
template<typename TransformType> struct ConcatenateRules<std::enable_if_t<!TransformCalculusHelper::TIsTransform2<TransformType>::Value, FTransform2f>, TransformType> { typedef FTransform2f ResultType; };
template<typename TransformType> struct ConcatenateRules<std::enable_if_t<!TransformCalculusHelper::TIsTransform2<TransformType>::Value, FTransform2d>, TransformType> { typedef FTransform2d ResultType; };
template<typename TransformType> struct ConcatenateRules<TransformType, std::enable_if_t<!TransformCalculusHelper::TIsTransform2<TransformType>::Value, FTransform2f>> { typedef FTransform2f ResultType; };
template<typename TransformType> struct ConcatenateRules<TransformType, std::enable_if_t<!TransformCalculusHelper::TIsTransform2<TransformType>::Value, FTransform2d>> { typedef FTransform2d ResultType; };