UE::Geometry::Spline Namespace Reference

Namespaces
namespace	Internal
namespace	Math
namespace	Param

Classes
struct	BSplineNameSelector
struct	BSplineNameSelector< 2 >
struct	BSplineNameSelector< 3 >
struct	FFoo
struct	FKnot
class	FSplineTypeId
class	FSplineTypeRegistry
class	ISplineInterface
class	TBSpline
struct	TChooseVectorType
struct	TDependentFalse
struct	TDerivativePolicy
struct	THasAdditionOperator
struct	THasAdditionOperator< T, std::void_t< decltype(std::declval< T >()+std::declval< T >())> >
struct	THasArchiveOperator
struct	THasArchiveOperator< T, std::void_t< decltype(std::declval< FArchive & >()<< std::declval< T & >())> >
struct	THasDotMethod
struct	THasDotMethod< T, std::void_t< decltype(std::declval< T >().Dot(std::declval< T >()))> >
struct	THasEqualsMethod
struct	THasEqualsMethod< T, std::void_t< decltype(std::declval< T >().Equals(std::declval< T >()))> >
struct	THasEqualToMethod
struct	THasEqualToMethod< T, std::void_t< decltype(T::EqualTo(std::declval< T >(), std::declval< T >()))> >
struct	THasGetSafeNormalMethod
struct	THasGetSafeNormalMethod< T, std::void_t< decltype(std::declval< T >().GetSafeNormal())> >
struct	THasScalarMultiplicationOperator
struct	THasScalarMultiplicationOperator< T, std::void_t< decltype(std::declval< T >() *std::declval< float >())> >
struct	THasSerializeMethod
struct	THasSerializeMethod< T, std::void_t< decltype(std::declval< T >().Serialize(std::declval< FArchive & >()))> >
struct	THasSizeMethod
struct	THasSizeMethod< T, std::void_t< decltype(std::declval< T >().Size())> >
struct	THasSizeSquaredMethod
struct	THasSizeSquaredMethod< T, std::void_t< decltype(std::declval< T >().SizeSquared())> >
struct	THasSubtractionOperator
struct	THasSubtractionOperator< T, std::void_t< decltype(std::declval< T >() - std::declval< T >())> >
struct	THasZeroVectorMember
struct	THasZeroVectorMember< T, std::void_t< decltype(T::ZeroVector)> >
struct	TIsMathInterpolable
struct	TIsMathInterpolable< T, std::void_t< decltype(FMath::Lerp(std::declval< T >(), std::declval< T >(), 0.5f)), decltype(std::declval< T >()+std::declval< T >()), decltype(std::declval< T >() *std::declval< float >()) > >
struct	TIsValidVectorType
class	TLinearSpline
class	TMultiSpline
class	TPolyBezierSpline
class	TSelfRegisteringSpline
class	TSplineInterface
class	TSplineInterpolationPolicy
class	TSplineInterpolationPolicy< FFoo >
class	TSplineInterpolationPolicy< FLinearColor >
class	TSplineInterpolationPolicy< FTransform >
class	TSplineInterpolationPolicy< int32 >
class	TSplineInterpolationPolicy< UE::Math::TQuat< RealType > >
struct	TSplineValueTypeTraits
struct	TSplineValueTypeTraits< bool >
struct	TSplineValueTypeTraits< double >
struct	TSplineValueTypeTraits< FColor >
struct	TSplineValueTypeTraits< FFoo >
struct	TSplineValueTypeTraits< FLinearColor >
struct	TSplineValueTypeTraits< float >
struct	TSplineValueTypeTraits< FName >
struct	TSplineValueTypeTraits< FQuat >
struct	TSplineValueTypeTraits< FRotator >
struct	TSplineValueTypeTraits< FString >
struct	TSplineValueTypeTraits< FText >
struct	TSplineValueTypeTraits< FTransform >
struct	TSplineValueTypeTraits< FVector2D >
struct	TSplineValueTypeTraits< FVector3d >
struct	TSplineValueTypeTraits< FVector3f >
struct	TSplineValueTypeTraits< FVector4 >
struct	TSplineValueTypeTraits< int32 >
class	TSplineWrapper
struct	TTangentBezierControlPoint
class	TTangentBezierSpline
struct	TVectorPolicy
struct	TVectorPolicy< double, 2 >
struct	TVectorPolicy< double, 3 >
struct	TVectorPolicy< double, 4 >
struct	TVectorPolicy< float, 2 >
struct	TVectorPolicy< float, 3 >
struct	TVectorPolicy< float, 4 >
struct	TVectorPolicy< int32, 2 >
struct	TVectorPolicy< int32, 3 >
struct	TVectorPolicy< int32, 4 >

Typedefs
using	FBSpline2f = TBSpline< FVector2f, 2 >
using	FBSpline3f = TBSpline< FVector3f, 3 >
using	FBSpline2d = TBSpline< FVector2d, 2 >
using	FBSpline3d = TBSpline< FVector3d, 3 >
using	FQuadraticBSpline2f = TBSpline< FVector2f, 2 >
using	FCubicBSpline3f = TBSpline< FVector3f, 3 >
using	FQuarticBSpline3f = TBSpline< FVector3f, 4 >
using	FQuinticBSpline2d = TBSpline< FVector2d, 5 >
using	FLinearSplineFloat = TLinearSpline< float >
using	FLinearSplineVector3d = TLinearSpline< FVector3d >
using	FPolyBezierSpline2f = TPolyBezierSpline< FVector2f >
using	FPolyBezierSpline3f = TPolyBezierSpline< FVector3f >
using	FPolyBezierSpline2d = TPolyBezierSpline< FVector2d >
using	FPolyBezierSpline3d = TPolyBezierSpline< FVector3d >
using	FTangentBezierSpline3f = TTangentBezierSpline< FVector3f >
using	FTangentBezierSpline3d = TTangentBezierSpline< FVector3d >

Functions
struct	UE_EXPERIMENTAL (5.7, "New spline APIs are experimental.") FKnot
template<typename VALUETYPE , int32 DEGREE>
class	UE_EXPERIMENTAL (5.7, "New spline APIs are experimental.") TBSpline
void	CreatePolyBezierWithFooAttributes ()
template<typename T >
class	UE_EXPERIMENTAL (5.7, "") TLinearSpline
template<typename VALUETYPE >
class	UE_EXPERIMENTAL (5.7, "New spline APIs are experimental.") TPolyBezierSpline
TUniquePtr< ISplineInterface >	CreateSplineFromArchive (FArchive &Ar)
	DEFINE_LOG_CATEGORY_STATIC (LogSpline, Log, All)
template<typename VALUETYPE >
struct	UE_EXPERIMENTAL (5.7, "New spline APIs are experimental.") TTangentBezierControlPoint

Typedef Documentation

FBSpline2d

using UE::Geometry::Spline::FBSpline2d = typedef TBSpline<FVector2d, 2>

FBSpline2f

using UE::Geometry::Spline::FBSpline2f = typedef TBSpline<FVector2f, 2>

FBSpline3d

using UE::Geometry::Spline::FBSpline3d = typedef TBSpline<FVector3d, 3>

FBSpline3f

using UE::Geometry::Spline::FBSpline3f = typedef TBSpline<FVector3f, 3>

FCubicBSpline3f

using UE::Geometry::Spline::FCubicBSpline3f = typedef TBSpline<FVector3f, 3>

FLinearSplineFloat

using UE::Geometry::Spline::FLinearSplineFloat = typedef TLinearSpline<float>

FLinearSplineVector3d

using UE::Geometry::Spline::FLinearSplineVector3d = typedef TLinearSpline<FVector3d>

FPolyBezierSpline2d

using UE::Geometry::Spline::FPolyBezierSpline2d = typedef TPolyBezierSpline<FVector2d>

FPolyBezierSpline2f

using UE::Geometry::Spline::FPolyBezierSpline2f = typedef TPolyBezierSpline<FVector2f>

FPolyBezierSpline3d

using UE::Geometry::Spline::FPolyBezierSpline3d = typedef TPolyBezierSpline<FVector3d>

FPolyBezierSpline3f

using UE::Geometry::Spline::FPolyBezierSpline3f = typedef TPolyBezierSpline<FVector3f>

FQuadraticBSpline2f

using UE::Geometry::Spline::FQuadraticBSpline2f = typedef TBSpline<FVector2f, 2>

FQuarticBSpline3f

using UE::Geometry::Spline::FQuarticBSpline3f = typedef TBSpline<FVector3f, 4>

FQuinticBSpline2d

using UE::Geometry::Spline::FQuinticBSpline2d = typedef TBSpline<FVector2d, 5>

FTangentBezierSpline3d

using UE::Geometry::Spline::FTangentBezierSpline3d = typedef TTangentBezierSpline<FVector3d>

FTangentBezierSpline3f

using UE::Geometry::Spline::FTangentBezierSpline3f = typedef TTangentBezierSpline<FVector3f>

Function Documentation

CreatePolyBezierWithFooAttributes()

void UE::Geometry::Spline::CreatePolyBezierWithFooAttributes

(

)

Example function demonstrating the FFoo type with the MultiSpline

FFoo implements all the necessary methods for use with splines:

• Basic arithmetic operators
• Size() and SizeSquared() for distance calculations
• Dot() for dot product calculations
• GetSafeNormal() for normalization

These methods are automatically detected by the UE::Geometry::Spline::Math functions, allowing FFoo to work seamlessly with all spline operations.

CreateSplineFromArchive()

TUniquePtr< ISplineInterface > UE::Geometry::Spline::CreateSplineFromArchive ( FArchive &  Ar )

inline

Creates a spline from an archive

DEFINE_LOG_CATEGORY_STATIC()

UE::Geometry::Spline::DEFINE_LOG_CATEGORY_STATIC	(	LogSpline	,
		Log	,
		All
	)

UE_EXPERIMENTAL() [1/5]

template<typename T >

class UE::Geometry::Spline::UE_EXPERIMENTAL	(	5.	7,
		""
	)

UE_EXPERIMENTAL() [2/5]

enum UE::Geometry::Spline::UE_EXPERIMENTAL ( 5.  7, "New spline APIs are experimental."    )

strong

Enumeration for out-of-bounds handling modes

Equal spacing between knots regardless of control point positions

Spacing based on actual distances between control points - good for uneven point distribution

Uses square root of distances - helps prevent loops and cusps in the curve

Equal spacing between knots regardless of control point positions

Spacing based on actual distances between control points - good for uneven point distribution

Uses square root of distances - helps prevent loops and cusps in the curve

UE_EXPERIMENTAL() [3/5]

template<typename VALUETYPE , int32 DEGREE>

class UE::Geometry::Spline::UE_EXPERIMENTAL	(	5.	7,
		"New spline APIs are experimental."
	)

UE_EXPERIMENTAL() [4/5]

template<typename VALUETYPE >

class UE::Geometry::Spline::UE_EXPERIMENTAL	(	5.	7,
		"New spline APIs are experimental."
	)

UE_EXPERIMENTAL() [5/5]

template<typename VALUETYPE >

struct UE::Geometry::Spline::UE_EXPERIMENTAL	(	5.	7,
		"New spline APIs are experimental."
	)