1. Epic GamesDeveloper
  3. Concatenate

Concatenate

Function Overloads

API > API/Runtime > API/Runtime/Core

Overloads

Name Remarks Include Path Unreal Specifiers

ConcatenateRules< TransformTypeA, TransformTypeB >::ResultType Concatenate ( const TransformTypeA& LHS,
const TransformTypeB& RHS
)

 Concatenates two transforms. Math/TransformCalculus.h  

ReturnType Concatenate ( const LHSType& LHS,
const RHSType& RHS
)

 Special overload that allows one to explicitly define the result type, which applies TransformCast on each argument first. Math/TransformCalculus.h  

decltype(LHS.Concatenate(RHS)) Concatenate ( const TransformType& LHS,
const TransformType& RHS
)

 Specialization for concatenating two transforms of the same type. Math/TransformCalculus.h  

FloatType Concatenate ( FloatType LHS,
FloatType RHS
)

 Overloads for uniform Scale. Math/TransformCalculus.h  

TTransform2< T > Concatenate ( const TScale2< T >& Scale,
const UE::Math::TVector2< V >& Translation
)

 Concatenate overloads. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const TShear2< T >& Shear,
const UE::Math::TVector2< V >& Translation
)

 Specialization for concatenating a 2D shear and 2D Translation. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const TQuat2< T >& Rot,
const UE::Math::TVector2< V >& Translation
)

 Specialization for concatenating 2D Rotation and 2D Translation. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const TMatrix2x2< T >& Transform,
const UE::Math::TVector2< V >& Translation
)

 Specialization for concatenating 2D generalized transform and 2D Translation. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const TTransform2< T >& Transform,
const UE::Math::TVector2< V >& Translation
)

 Specialization for concatenating transform and 2D Translation. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const UE::Math::TVector2< V >& Translation,
const TScale2< T >& Scale
)

 Specialization for concatenating a 2D Translation and 2D scale. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const UE::Math::TVector2< V >& Translation,
const TShear2< T >& Shear
)

 Specialization for concatenating a 2D Translation and 2D shear. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const UE::Math::TVector2< V >& Translation,
const TQuat2< T >& Rot
)

 Specialization for concatenating 2D Translation and 2D Rotation. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const UE::Math::TVector2< V >& Translation,
const TMatrix2x2< T >& Transform
)

 Specialization for concatenating 2D Translation and 2D generalized transform. Math/TransformCalculus2D.h  

TTransform2< T > Concatenate ( const UE::Math::TVector2< V >& Translation,
const TTransform2< T >& Transform
)

 Specialization for concatenating 2D Translation and transform. Math/TransformCalculus2D.h  

UE::Math::TRotator< T > Concatenate ( const UE::Math::TRotator< T >& LHS,
const UE::Math::TRotator< T >& RHS
)

 Specialization for concatenating two rotations. Math/TransformCalculus3D.h  

decltype(auto) Concatenate ( const TransformType1& TransformAToB,
const TransformType2& TransformBToC,
TransformTypeRest&&... TransformCToRest
)

 Concatenates three or more transforms. Math/TransformCalculus.h  

Concatenate(const TransformTypeA &, const TransformTypeB &)

Description

Concatenates two transforms. Uses TransformCast<> to convert them first. If more efficient means are available to concatenate two transforms, provide a non-template overload (or possibly a specialization). Concatenation is performed in left to right order, so the output space of LHS must match the input space of RHS.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus.h
Include Path #include "Math/TransformCalculus.h" 
template<typename TransformTypeA, typename TransformTypeB>  
ConcatenateRules < TransformTypeA, TransformTypeB >::ResultType Concatenate  
(  
    const TransformTypeA & LHS,  
    const TransformTypeB & RHS  
)

a new transform representing the transformation from the input space of LHS to the output space of RHS.

Parameters

Name Remarks
LHS Transformation that goes from space A to space B
RHS Transformation that goes from space B to space C.

Concatenate(const LHSType &, const RHSType &)

Description

Special overload that allows one to explicitly define the result type, which applies TransformCast on each argument first.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus.h
Include Path #include "Math/TransformCalculus.h" 
template<typename ReturnType, typename LHSType, typename RHSType>  
ReturnType Concatenate  
(  
    const LHSType & LHS,  
    const RHSType & RHS  
)

Concatenate(const TransformType &, const TransformType &)

Description

Specialization for concatenating two transforms of the same type. By default we try to use a member function on the type.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus.h
Include Path #include "Math/TransformCalculus.h" 
template<typename TransformType>  
decltype(LHS.Concatenate(RHS)) Concatenate  
(  
    const TransformType & LHS,  
    const TransformType & RHS  
)

a new transform representing the transformation from the input space of LHS to the output space of RHS.

Parameters

Name Remarks
LHS Transformation that goes from space A to space B
RHS Transformation that goes from space B to space C.

Concatenate(FloatType, FloatType)

Description

Overloads for uniform Scale.

This isn't really 2D or 3D specific, but both 2D and 3D leverage uniform scale, and expect these overloads to be available, so we go ahead and define them here. Specialization for concatenating two scales.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus.h
Include Path #include "Math/TransformCalculus.h" 
template<typename FloatType, std::enable_if_t<(std::is_floating_point_v< FloatType >), int >>  
FloatType Concatenate  
(  
    FloatType LHS,  
    FloatType RHS  
)

a new Scale representing the transformation from the input space of LHS to the output space of RHS.

Parameters

Name Remarks
LHS Scale that goes from space A to space B
RHS Scale that goes from space B to space C.

Concatenate(const TScale2< T > &, const UE::Math::TVector2< V > &)

Description

Concatenate overloads.

Efficient overloads for concatenating 2D affine transforms. Better than simply upcasting both to FTransform2D first. Specialization for concatenating a 2D scale and 2D Translation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const TScale2 < T > & Scale,  
    const UE::Math::TVector2 < V > & Translation  
)

Concatenate(const TShear2< T > &, const UE::Math::TVector2< V > &)

Description

Specialization for concatenating a 2D shear and 2D Translation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const TShear2 < T > & Shear,  
    const UE::Math::TVector2 < V > & Translation  
)

Concatenate(const TQuat2< T > &, const UE::Math::TVector2< V > &)

Description

Specialization for concatenating 2D Rotation and 2D Translation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const TQuat2 < T > & Rot,  
    const UE::Math::TVector2 < V > & Translation  
)

Concatenate(const TMatrix2x2< T > &, const UE::Math::TVector2< V > &)

Description

Specialization for concatenating 2D generalized transform and 2D Translation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const TMatrix2x2 < T > & Transform,  
    const UE::Math::TVector2 < V > & Translation  
)

Concatenate(const TTransform2< T > &, const UE::Math::TVector2< V > &)

Description

Specialization for concatenating transform and 2D Translation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const TTransform2 < T > & Transform,  
    const UE::Math::TVector2 < V > & Translation  
)

Concatenate(const UE::Math::TVector2< V > &, const TScale2< T > &)

Description

Specialization for concatenating a 2D Translation and 2D scale.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const UE::Math::TVector2 < V > & Translation,  
    const TScale2 < T > & Scale  
)

Concatenate(const UE::Math::TVector2< V > &, const TShear2< T > &)

Description

Specialization for concatenating a 2D Translation and 2D shear.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const UE::Math::TVector2 < V > & Translation,  
    const TShear2 < T > & Shear  
)

Concatenate(const UE::Math::TVector2< V > &, const TQuat2< T > &)

Description

Specialization for concatenating 2D Translation and 2D Rotation.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const UE::Math::TVector2 < V > & Translation,  
    const TQuat2 < T > & Rot  
)

Concatenate(const UE::Math::TVector2< V > &, const TMatrix2x2< T > &)

Description

Specialization for concatenating 2D Translation and 2D generalized transform. See docs for TTransform2::Inverse for details on how this math is derived.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const UE::Math::TVector2 < V > & Translation,  
    const TMatrix2x2 < T > & Transform  
)

Concatenate(const UE::Math::TVector2< V > &, const TTransform2< T > &)

Description

Specialization for concatenating 2D Translation and transform. See docs for TTransform2::Inverse for details on how this math is derived.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus2D.h
Include Path #include "Math/TransformCalculus2D.h" 
template<typename T, typename V>  
TTransform2 < T > Concatenate  
(  
    const UE::Math::TVector2 < V > & Translation,  
    const TTransform2 < T > & Transform  
)

Concatenate(const UE::Math::TRotator< T > &, const UE::Math::TRotator< T > &)

Description

Specialization for concatenating two rotations.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus3D.h
Include Path #include "Math/TransformCalculus3D.h" 
template<typename T>  
UE::Math::TRotator < T > Concatenate  
(  
    const UE::Math::TRotator < T > & LHS,  
    const UE::Math::TRotator < T > & RHS  
)

a new rotation representing the transformation from the input space of LHS to the output space of RHS.

Parameters

Name Remarks
LHS rotation that goes from space A to space B
RHS rotation that goes from space B to space C.

Concatenate(const TransformType1 &, const TransformType2 &, TransformTypeRest &&...)

Description

Concatenates three or more transforms. Uses two-argument Concatenate to do its work, and infers the return type using decltype.

   
Name Concatenate
Type function
Header File /Engine/Source/Runtime/Core/Public/Math/TransformCalculus.h
Include Path #include "Math/TransformCalculus.h" 
template<typename TransformType1, typename TransformType2, typename... TransformTypeRest>  
decltype(auto) Concatenate  
(  
    const TransformType1 & TransformAToB,  
    const TransformType2 & TransformBToC,  
    TransformTypeRest &&... TransformCToRest  
)

a new Transform representing the complete transformation.

Parameters

Name Remarks
TransformAToB Transformation that goes from space A to space B
TransformBToC Transformation that goes from space B to space C.
TransformCToRest Transformation that goes from space C onwards.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page