1. Epic GamesDeveloper
  3. Math

Math

API > API/Runtime > API/Runtime/Core

Classes

  Type Name Description
Public struct AlignedDouble4 Helper for conveniently aligning a double array for extraction from VectorRegister4Double.  
Public struct AlignedFloat4 Helper for conveniently aligning a float array for extraction from VectorRegister4Float.  
Public struct ConcatenateRules Provides default rules defining the result of concatenating two types.  
Public class FBasicMathExpressionEvaluator A basic math expression evaluator  
Public class FBoxCenterAndExtent An unquantized bounding box.  
Public struct FColor FColor Stores a color with 8 bits of precision per channel.  
Public class FColorList    
Public class FCurveEdInterface Interface that allows the CurveEditor to edit this type of object.  
Public struct FDateRange    
Public struct FDateRangeBound    
Public struct FDecryptedSignature    
Public struct FDFInverseMatrix Transforms from absolute world space.  
Public struct FDFMatrix Transforms to absolute world space.  
Public struct FDFScalar A high-precision floating point type, consisting of two 32-bit floats (High & Low).  
Public struct FDFVector2    
Public struct FDFVector3    
Public struct FDFVector4    
Public struct FDoubleInterval    
Public struct FDoubleRange    
Public struct FDoubleRangeBound    
Public struct FDXT1 Structure encompassing single DXT1 block.  
Public struct FDXT5 Structure encompassing single DXT5 block  
Public struct FDXTColor16 Helper struct for a 16 bit 565 color of a DXT1/3/5 block.  
Public struct FDXTColor565 Helper struct for a 16 bit 565 color of a DXT1/3/5 block.  
Public struct FEdge Implements an edge consisting of two vertices.  
Public struct FEncryptedSignature    
Public class FFixedRGBASigned8 4 component vector corresponding to PF_R8G8B8A8_SNORM.  
Public class FFloat16 16 bit float components and conversion  
Public class FFloat16Color RGBA Color made up of FFloat16  
Public class FFloat32 32 bit float components  
Public class FFloat3Packed 3 component vector corresponding to DXGI_FORMAT_R11G11B10_FLOAT.  
Public class FFloat3PackedSE 3 component vector corresponding to PF_R9G9B9EXP5.  
Public class FFloatInfo_IEEE32    
Public struct FFloatInterval    
Public struct FFloatRange    
Public struct FFloatRangeBound    
Public struct FForwardSlash    
Public struct FForwardSlashEquals    
Public struct FFrameNumberRange    
Public struct FFrameNumberRangeBound    
Public struct FInt16Range    
Public struct FInt16RangeBound    
Public struct FInt32Interval    
Public struct FInt32Range    
Public struct FInt32RangeBound    
Public struct FInt64Range    
Public struct FInt64RangeBound    
Public struct FInt8Range    
Public struct FInt8RangeBound    
Public class FInterpCurve Template for interpolation curves.  
Public struct FInterpCurveFloat    
Public struct FInterpCurveLinearColor    
Public class FInterpCurvePoint Template for interpolation points.  
Public struct FInterpCurveQuat    
Public struct FInterpCurveTwoVectors    
Public struct FInterpCurveVector    
Public struct FInterpCurveVector2D    
Public struct FLinearColor A linear, 32-bit/component floating point RGBA color.  
Public class FLinearFeedbackShiftRegister See https://en.wikipedia.org/wiki/Linear-feedback_shift_register This implements maximal-length feedback polynomials LFSR for N bits in [2, 12].  
Public struct FMath Structure for all math helper functions, inherits from platform math to pick up platform-specific implementations Check GenericPlatformMath.h for additional math functions  
Public struct FMinus    
Public struct FMinusEquals    
Public class FMovingWindowAverageFast Copyright Epic Games, Inc. All Rights Reserved.  
Public struct FNumericUnit FNumericUnit is a numeric type that wraps the templated type, whilst a specified unit.  
Public class FOctreeChildNodeRef A reference to a child of an octree node.  
Public class FOctreeChildNodeSubset A subset of an octree node's children that intersect a bounding box.  
Public class FOctreeElementId An identifier for an element in the octree.  
Public class FOctreeElementId2 An identifier for an element in the octree.  
Public class FOctreeNodeContext The context of an octree node, derived from the traversal of the tree.  
Public struct FOrientedBox Structure for arbitrarily oriented boxes (not necessarily axis-aligned).  
Public struct FPercent    
Public struct FPlus    
Public struct FPlusEquals    
Public struct FPower    
Public struct FQuantizationInfo Structure used to define the factor required to get from one unit type to the next.  
Public struct FRandomStream Implements a thread-safe SRand based RNG.  
Public struct FScopedFTZFloatMode    
Public struct FSignatureBase    
Public class FSobol Support for Sobol quasi-random numbers  
Public struct FSquareRoot    
Public struct FStar    
Public struct FStarEquals    
Public struct FStatisticalValue Used to measure a distribution.  
Public struct FSubExpressionEnd    
Public struct FSubExpressionStart    
Public struct FTwoVectors A pair of 3D vectors.  
Public class FUInt128    
Public struct FUnitConversion    
Public class FUnitSettings Unit settings accessed globally through FUnitConversion::Settings()  
Public struct FVector2DHalf Structure for two dimensional vectors with half floating point precision.  
Public struct TBasisVectorMatrix    
Public class TBigInt N-bit integer.  
Public struct TBounds    
Public struct TBox    
Public struct TBox2    
Public struct TBoxConstInit    
Public struct TBoxSphereBounds    
Public struct TCapsuleShape    
Public struct TClipProjectionMatrix Realigns the near plane for an existing projection matrix with an arbitrary clip plane from: http://sourceforge.net/mailarchive/message.php?msg_id=000901c26324%242181ea90%24a1e93942%40firefly Updated for the fact that our FPlane uses Ax+By+Cz=D.  
Public struct TCustomLerp Template helper for FMath::Lerp<>() and related functions.  
Public struct TDualQuat    
Public struct TEncryptionKey Encryption key - exponent and modulus pair  
Public class TFloatPacker    
Public class TGuardedInt Overflow- and error-checked integer.  
Public struct TInterval Template for numeric interval  
Public struct TIntervalTraits Type traits for Arithmetic interval.  
Public struct TIntPoint Structure for integer points in 2-d space.  
Public struct TIntRect Structure for integer rectangles in 2-d space.  
Public struct TIntVector2    
Public struct TIntVector3 Structure for integer vectors in 3-d space.  
Public struct TIntVector4    
Public struct TInverseRotationMatrix Inverse Rotation matrix  
Public struct TIsTransform2    
Public struct TLookAtMatrix    
Public struct TLookFromMatrix    
Public struct TMatrix    
Public class TMatrix2x2 Transform calculus for 2D types.  
Public struct TMirrorMatrix Mirrors a point about an arbitrary plane  
Public struct TNumericLimits Numeric type traits Helper class to map a numeric type to its limits  
Public class TOctree    
Public class TOctree_DEPRECATED An octree.  
Public class TOctree2 An octree.  
Public struct TOrthoMatrix    
Public struct TPerspectiveMatrix    
Public struct TPlane    
Public struct TQuat Floating point quaternion that can represent a rotation about an axis in 3-D space.  
Public class TQuat2 Represents a 2D rotation as a complex number (analagous to quaternions).  
Public struct TQuatRotationMatrix Rotation matrix using quaternion rotation  
Public struct TQuatRotationTranslationMatrix Rotation and translation matrix using quaternion rotation  
Public class TRange Template for ranges.  
Public class TRangeBound Template for range bounds.  
Public class TRangeSet Template for range sets.  
Public struct TransformConverter Transform calculus.  
Public struct TRay    
Public struct TReversedZOrthoMatrix    
Public struct TReversedZPerspectiveMatrix    
Public struct TRotationAboutPointMatrix Rotates about an Origin point.  
Public struct TRotationMatrix Rotation matrix no translation  
Public struct TRotationTranslationMatrix Combined rotation and translation matrix  
Public struct TRotator Implements a container for rotation information.  
Public class TScale Transform calculus for 3D types.  
Public class TScale2 Represents a 2D non-uniform scale (to disambiguate from an FVector2D, which is used for translation)  
Public struct TScaleMatrix Scale matrix.  
Public struct TScaleRotationTranslationMatrix Combined Scale rotation and translation matrix  
Public class TShear2 Represents a 2D shear: [1 YY] [XX 1] XX represents a shear parallel to the X axis.  
Public class TSHVector A vector of spherical harmonic coefficients.  
Public class TSHVectorRGB A vector of colored spherical harmonic coefficients.  
Public struct TSphere    
Public struct TTransform    
Public class TTransform2 Support for generalized 2D affine transforms.  
Public struct TTranslationMatrix    
Public struct TUnrealPlatformMathSSE4Base    
Public struct TUnrealPlatformMathSSEBase    
Public struct TVector Forward declaration of templates.  
Public struct TVector2    
Public struct TVector4 A 4D homogeneous vector, 4x1 FLOATs, 16-byte aligned.  
Public struct TVectorConstInit    
Public struct VectorRegister2Double    
Public struct VectorRegister4Double Double[4] vector register type, where the first double (X) is stored in the lowest 64 bits, and so on.  
Public struct VectorRegister4Float Float4 vector register type, where the first float (X) is stored in the lowest 32 bits, and so on.  
Public struct VectorRegister4Int Int32[4] vector register type, where the first int32 (X) is stored in the lowest 32 bits, and so on.  
Public struct VectorRegister4x4Float    
Public struct VectorRegisterConstInit Platform specific vector intrinsics include.  

Typedefs

Name Description
AlignedRegister4  
FBasisVectorMatrix  
FBasisVectorMatrix  
FBasisVectorMatrix44d  
FBasisVectorMatrix44d  
FBasisVectorMatrix44f  
FBasisVectorMatrix44f  
FBounds3d  
FBounds3f  
FBox  
FBox  
FBox2d  
FBox2d  
FBox2D  
FBox2D  
FBox2f  
FBox2f  
FBox3d  
FBox3d  
FBox3f  
FBox3f  
FBoxSphereBounds  
FBoxSphereBounds3d  
FBoxSphereBounds3f  
FCapsuleShape  
FCapsuleShape3d  
FCapsuleShape3f  
FClipProjectionMatrix  
FClipProjectionMatrix44d  
FClipProjectionMatrix44f  
FCompactBoxSphereBounds  
FCompactBoxSphereBounds3d FCompactBoxSphereBounds always stores float extents.
FDualQuat  
FDualQuat4d  
FDualQuat4f  
FEncryptionKey  
FGuardedInt32 Guarded 32-bit integer class.
FGuardedInt64 Guarded 64-bit integer class.
FInt32Point Int points.
FInt32Rect Int rects.
FInt32Vector  
FInt32Vector2  
FInt32Vector3  
FInt32Vector4  
FInt64Point  
FInt64Rect  
FInt64Vector  
FInt64Vector2  
FInt64Vector3  
FInt64Vector4  
FInterpCurvePointFloat Native implementation of NOEXPORT FInterpCurvePoint structures.
FInterpCurvePointLinearColor  
FInterpCurvePointQuat  
FInterpCurvePointTwoVectors  
FInterpCurvePointVector  
FInterpCurvePointVector2D  
FIntPoint  
FIntRect  
FIntVector  
FIntVector2 Int vectors.
FIntVector3  
FIntVector4  
FInverseRotationMatrix  
FInverseRotationMatrix44d  
FInverseRotationMatrix44f  
FLookAtMatrix  
FLookAtMatrix  
FLookAtMatrix44d  
FLookAtMatrix44d  
FLookAtMatrix44f  
FLookAtMatrix44f  
FLookFromMatrix  
FLookFromMatrix44d  
FLookFromMatrix44f  
FMatrix  
FMatrix  
FMatrix2x2  
FMatrix2x2d  
FMatrix2x2f Base typedefs
FMatrix44d  
FMatrix44d  
FMatrix44f  
FMatrix44f  
FMirrorMatrix  
FMirrorMatrix44d  
FMirrorMatrix44f  
FOrthoMatrix  
FOrthoMatrix44d  
FOrthoMatrix44f  
FPerspectiveMatrix  
FPerspectiveMatrix44d  
FPerspectiveMatrix44f  
FPlane  
FPlane  
FPlane4d  
FPlane4d  
FPlane4f  
FPlane4f  
FQuat  
FQuat  
FQuat  
FQuat2d  
FQuat2D  
FQuat2f Base typedefs
FQuat4d  
FQuat4d  
FQuat4d  
FQuat4f  
FQuat4f  
FQuat4f  
FQuatRotationMatrix  
FQuatRotationMatrix44d  
FQuatRotationMatrix44f  
FQuatRotationTranslationMatrix  
FQuatRotationTranslationMatrix44d  
FQuatRotationTranslationMatrix44f  
FRay  
FRay  
FRay3d  
FRay3d  
FRay3f  
FRay3f  
FReversedZOrthoMatrix  
FReversedZOrthoMatrix44d  
FReversedZOrthoMatrix44f  
FReversedZPerspectiveMatrix  
FReversedZPerspectiveMatrix44d  
FReversedZPerspectiveMatrix44f  
FRotationAboutPointMatrix  
FRotationAboutPointMatrix44d  
FRotationAboutPointMatrix44f  
FRotationMatrix  
FRotationMatrix44d  
FRotationMatrix44f  
FRotationTranslationMatrix  
FRotationTranslationMatrix44d  
FRotationTranslationMatrix44f  
FRotator  
FRotator  
FRotator3d  
FRotator3d  
FRotator3f  
FRotator3f  
FScale2d  
FScale2D  
FScale2f Base typedefs
FScale3d  
FScale3D  
FScale3f Core typedefs
FScaleMatrix  
FScaleMatrix44d  
FScaleMatrix44f  
FScaleRotationTranslationMatrix  
FScaleRotationTranslationMatrix44d  
FScaleRotationTranslationMatrix44f  
FShear2d  
FShear2D  
FShear2f Base typedefs
FSHVector2  
FSHVector3  
FSHVectorRGB2  
FSHVectorRGB3  
FSphere  
FSphere  
FSphere3d  
FSphere3d  
FSphere3f  
FSphere3f  
FStatisticalFloat  
FTransform  
FTransform  
FTransform2d  
FTransform2D  
FTransform2f Core typedefs
FTransform3d  
FTransform3d  
FTransform3f  
FTransform3f  
FTranslationMatrix  
FTranslationMatrix44d  
FTranslationMatrix44f  
FUint32Point  
FUint32Rect  
FUint32Vector  
FUint32Vector2  
FUint32Vector3  
FUint32Vector4  
FUint64Point  
FUint64Rect  
FUint64Vector  
FUint64Vector2  
FUint64Vector3  
FUint64Vector4  
FUintPoint  
FUintRect  
FUintVector  
FUintVector2  
FUintVector3  
FUintVector4  
FVector Forward declaration of concrete types // Macro version - declares all three variants.
FVector2d  
FVector2d  
FVector2D  
FVector2D  
FVector2f  
FVector2f  
FVector3d  
FVector3f  
FVector4  
FVector4  
FVector4d  
FVector4d  
FVector4f  
FVector4f  
int256 Predefined big int types.
int512  
PersistentVectorRegister4Double 'Cross-platform' vector intrinsics (built on the platform-specific ones defined above)
PersistentVectorRegister4Float Suitable to just use regular VectorRegister4Float as persistent variables.
TEncryptionInt  
TGuardedSignedInt Legacy alias for the previously signed-integer-only implementation.
TPersistentVectorRegisterType Alias for VectorRegister type to be used as member variables of structs, when alignment should not be over 16 bytes.
TVectorRegisterType Alias which helps resolve a template type (float/double) to the appropriate VectorRegister type (VectorRegister4Float/VectorRegister4Double).
VectorRegister We're in non-managed mode, ignore warnings about _M_CEE and _MANAGED for DirectXMath.h.
VectorRegister Backwards compatibility.
VectorRegister2d  
VectorRegister4  
VectorRegister4d  
VectorRegister4f  
VectorRegister4i Aliases.
VectorRegister4Int  
VectorRegisterInt  

Enums

  Type Name Description
Public enum EAxis::Type Generic axis enum (mirrored for property use in Object.h)  
Public enum EAxisList::Type Extended axis enum for more specialized usage.  
Public enum EGammaSpace Enum for the different kinds of gamma spaces we expect to need to convert from/to.  
Public enum EInterpCurveMode    
Public enum ERangeBoundTypes::Type Enumerates the valid types of range bounds.  
Public enum EUnit Enum must be zero-indexed and sequential.  
Public enum EUnitType Enumeration that specifies particular classes of unit  

Functions

  Type Name Description
Public function uint32 Counts the number of trailing zeros in the bit representation of the value, counting from least-significant bit to most.
Public function void

AutoCalcTangent ( const FQuat& PrevP,
const FQuat& P,
const FQuat& NextP,
const U& Tension,
FQuat& OutTan
)

 This actually returns the control point not a tangent.
Public function void

AutoCalcTangent ( const T& PrevP,
const T& P,
const T& NextP,
const U& Tension,
T& OutTan
)

 Computes Tangent for a curve segment
Public function float

ClampFloatTangent ( float PrevPointVal,
float PrevTime,
float CurPointVal,
float CurTime,
float NextPointVal,
float NextTime
)

 Clamps a tangent formed by the specified control point values
Public function UE::Math::TVector< T >

ClampVector ( const UE::Math::TVector< T >& V,
const UE::Math::TVector< T >& Min,
const UE::Math::TVector< T >& Max
)

 Component-wise clamp for TVector
Public function void

ComputeAndFixedColorAndIntensity ( const FLinearColor& InLinearColor,
FColor& OutColor,
float& OutIntensity
)

 Computes a brightness and a fixed point color from a floating point color.
Public function void

ComputeClampableFloatVectorCurveTangent ( float PrevTime,
const T& PrevPoint,
float CurTime,
const T& CurPoint,
float NextTime,
const T& NextPoint,
float Tension,
bool bWantClamping,
T& OutTangent
)

 Computes a tangent for the specified control point; supports clamping, but only works with floats or contiguous arrays of floats.
Public function void

ComputeCurveTangent ( float PrevTime,
const T& PrevPoint,
float CurTime,
const T& CurPoint,
float NextTime,
const T& NextPoint,
float Tension,
bool bWantClamping,
T& OutTangent
)

 Computes a tangent for the specified control point. General case, doesn't support clamping.
Public function void

ComputeCurveTangent ( float PrevTime,
const FTwoVectors& PrevPoint,
float CurTime,
const FTwoVectors& CurPoint,
float NextTime,
const FTwoVectors& NextPoint,
float Tension,
bool bWantClamping,
FTwoVectors& OutTangent
)

 Computes a tangent for the specified control point.
Public function void

ComputeCurveTangent ( float PrevTime,
const float& PrevPoint,
float CurTime,
const float& CurPoint,
float NextTime,
const float& NextPoint,
float Tension,
bool bWantClamping,
float& OutTangent
)

 Computes a tangent for the specified control point.
Public function void

ComputeCurveTangent ( float PrevTime,
const FVector& PrevPoint,
float CurTime,
const FVector& CurPoint,
float NextTime,
const FVector& NextPoint,
float Tension,
bool bWantClamping,
FVector& OutTangent
)

 Computes a tangent for the specified control point.
Public function void

ComputeCurveTangent ( float PrevTime,
const FVector2D& PrevPoint,
float CurTime,
const FVector2D& CurPoint,
float NextTime,
const FVector2D& NextPoint,
float Tension,
bool bWantClamping,
FVector2D& OutTangent
)

 Computes a tangent for the specified control point.
Public function T

ComputeSquaredDistanceFromBoxToPoint ( const UE::Math::TVector< T >& Mins,
const UE::Math::TVector< T >& Maxs,
const UE::Math::TVector< U >& Point
)

 Util to calculate distance from a point to a bounding box
Public function ConcatenateRules< TransformTypeA, TransformTypeB >::ResultType

Concatenate ( const TransformTypeA& LHS,
const TransformTypeB& RHS
)

 Concatenates two transforms.
Public function decltype(Concatenate(Concatenate(TransformAToB, TransformBToC, TransformCToD, TransformDToE), Transf...

Concatenate ( const TransformType1& TransformAToB,
const TransformType2& TransformBToC,
const TransformType3& TransformCToD,
const TransformType4& TransformDToE,
const TransformType5& TransformEToF
)

 Concatenates five transforms.
Public function decltype(Concatenate(Concatenate(TransformAToB, TransformBToC, TransformCToD), TransformDToE))

Concatenate ( const TransformType1& TransformAToB,
const TransformType2& TransformBToC,
const TransformType3& TransformCToD,
const TransformType4& TransformDToE
)

 Concatenates four transforms.
Public function decltype(Concatenate(Concatenate(TransformAToB, TransformBToC), TransformCToD))

Concatenate ( const TransformType1& TransformAToB,
const TransformType2& TransformBToC,
const TransformType3& TransformCToD
)

 Concatenates three transforms.
Public function UE::Math::TRotator< T >

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

 Specialization for concatenating two rotations.
Public function TTransform2< T >

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

 Specialization for concatenating 2D Translation and transform.
Public function TTransform2< T >

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

 Specialization for concatenating 2D Translation and 2D generalized transform.
Public function TTransform2< T >

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

 Specialization for concatenating 2D Translation and 2D Rotation.
Public function TTransform2< T >

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

 Specialization for concatenating a 2D Translation and 2D shear.
Public function TTransform2< T >

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

 Specialization for concatenating 2D generalized transform and 2D Translation.
Public function TTransform2< T >

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

 Specialization for concatenating 2D Rotation and 2D Translation.
Public function TTransform2< T >

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

 Specialization for concatenating a 2D shear and 2D Translation.
Public function TTransform2< T >

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

 Concatenate overloads.
Public function FloatType

Concatenate ( FloatType LHS,
FloatType RHS
)

 Overloads for uniform Scale.
Public function decltype(LHS.Concatenate(RHS))

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

 Specialization for concatenating two transforms of the same type.
Public function 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.
Public function TTransform2< T >

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

 Specialization for concatenating a 2D Translation and 2D scale.
Public function TTransform2< T >

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

 Specialization for concatenating transform and 2D Translation.
Public function void

ConvertFLinearColorsToFColorSRGB ( const FLinearColor* InLinearColors,
FColor* OutColorsSRGB,
int64 InCount
)

 Convert multiple FLinearColors to sRGB FColor; array version of FLinearColor::ToFColorSRGB.
Public function bool Returns true if 'a' is more lower-left than 'b'.
Public function void

ConvexHull2D::ComputeConvexHull ( const TArray< VectorType, Allocator >& Points,
TArray< int32, Allocator >& OutIndices
)

 Andrew's monotone chain convex hull algorithm for 2-dimensional points.
Public function void

ConvexHull2D::ComputeConvexHullLegacy ( const TArray< FVector, Allocator >& Points,
TArray< int32, Allocator >& OutIndices
)

 Calculates convex hull on xy-plane of points on 'Points' and stores the indices of the resulting hull in 'OutIndices'.
Public function void

ConvexHull2D::ComputeConvexHullLegacy2 ( const TArray< FVector2D, Allocator >& Points,
TArray< int32, Allocator >& OutIndices
)

 Alternate simple implementation that was found to work correctly for points that are very close together (inside the 0-1 range).
Public function FVector::FReal

ConvexHull2D::ComputeDeterminant ( const FVector& A,
const FVector& B,
const FVector& C
)

 Returns <0 if C is left of A-B
Public function FVector2D::FReal Returns <0 if C is left of A-B
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< FVector2D >& Start,
const FInterpCurvePoint< FVector2D >& End,
FVector2D& CurrentMin,
FVector2D& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< FLinearColor >& Start,
const FInterpCurvePoint< FLinearColor >& End,
FLinearColor& CurrentMin,
FLinearColor& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< FTwoVectors >& Start,
const FInterpCurvePoint< FTwoVectors >& End,
FTwoVectors& CurrentMin,
FTwoVectors& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< FVector >& Start,
const FInterpCurvePoint< FVector >& End,
FVector& CurrentMin,
FVector& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< float >& Start,
const FInterpCurvePoint< float >& End,
float& CurrentMin,
float& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFindIntervalBounds ( const FInterpCurvePoint< T >& Start,
const FInterpCurvePoint< T >& End,
T& CurrentMin,
T& CurrentMax,
const U& Dummy
)

  
Public function void

CurveFloatFindIntervalBounds ( const FInterpCurvePoint< float >& Start,
const FInterpCurvePoint< float >& End,
float& CurrentMin,
float& CurrentMax
)

 Calculate bounds of float intervals
Public function void Calculate bounds of color intervals
Public function void Calculate bounds of twovector intervals
Public function void

CurveVector2DFindIntervalBounds ( const FInterpCurvePoint< FVector2D >& Start,
const FInterpCurvePoint< FVector2D >& End,
FVector2D& CurrentMin,
FVector2D& CurrentMax
)

 Calculate bounds of 2D vector intervals
Public function void

CurveVectorFindIntervalBounds ( const FInterpCurvePoint< FVector >& Start,
const FInterpCurvePoint< FVector >& End,
FVector& CurrentMin,
FVector& CurrentMax
)

 Calculate bounds of vector intervals
Public function T

Dot3 ( const UE::Math::TVector4< T >& V1,
const UE::Math::TVector4< T >& V2
)

 Calculates 3D Dot product of two 4D vectors.
Public function T

Dot3 ( const UE::Math::TVector< T >& V1,
const UE::Math::TVector4< T >& V2
)

  
Public function T

Dot3 ( const UE::Math::TVector4< T >& V1,
const UE::Math::TVector< T >& V2
)

 Calculates 3D Dot product of one 4D vectors and one 3D vector
Public function T

Dot4 ( const UE::Math::TVector4< T >& V1,
const UE::Math::TVector4< T >& V2
)

 Calculates 4D Dot product.
Public function TOptional< FExpressionError > Consume a symbol from the specified consumer's stream, if one exists at the current read position
Public function IntType

FEncryption::CalculateGCD ( IntType ValueA,
IntType ValueB
)

 Greatest common divisor of ValueA and ValueB.
Public function IntType

FEncryption::CalculateMultiplicativeInverseOfExponent ( IntType Exponent,
IntType Totient
)

 Multiplicative inverse of exponent using extended GCD algorithm.
Public function void

FEncryption::DecryptBytes ( uint8* DecryptedData,
const IntType* Data,
const int64 DataLength,
const FEncryptionKey& DecryptionKey
)

 Decrypts a stream of bytes
Public function void

FEncryption::DecryptSignature ( const FEncryptedSignature& InEncryptedSignature,
FDecryptedSignature& OutUnencryptedSignature,
const FEncryptionKey& EncryptionKey
)

  
Public function void

FEncryption::EncryptBytes ( IntType* EncryptedData,
const uint8* Data,
const int64 DataLength,
const FEncryptionKey& EncryptionKey
)

 Encrypts a stream of bytes
Public function void

FEncryption::EncryptSignature ( const FDecryptedSignature& InUnencryptedSignature,
FEncryptedSignature& OutEncryptedSignature,
const FEncryptionKey& EncryptionKey
)

  
Public function void

FEncryption::GenerateKeyPair ( const IntType& P,
const IntType& Q,
FEncryptionKey& PublicKey,
FEncryptionKey& PrivateKey
)

 Generate Key Pair for encryption and decryption.
Public function IntType

FEncryption::ModularPow ( IntType Base,
IntType Exponent,
IntType Modulus
)

 Raise Base to power of Exponent in mod Modulus.
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Float Vector full of positive infinity
Public function VectorRegister4Float Bitmask to AND out the sign bit of each components in a vector
Public function VectorRegister4Float  
Public function VectorRegister4Float Bitmask to AND out the XYZ components in a vector
Public function float

Halton ( int32 Index,
int32 Base
)

 [ Halton 1964, "Radical-inverse quasi-random point sequence" ]
Public function Static UE::Math::TVector< T >  
Public function FloatType

Inverse ( FloatType Scale
)

 Inverts a transform from space A to space B so it transforms from space B to space A.
Public function UE::Math::TVector2< T >

Inverse ( const UE::Math::TVector2< T >& Transform
)

 Specialization for inverting a 2D translation.
Public function UE::Math::TMatrix< T >

Inverse ( const UE::Math::TMatrix< T >& Transform
)

 Inverse overloads.
Public function UE::Math::TRotator< T >

Inverse ( const UE::Math::TRotator< T >& Transform
)

 Inverts a transform from space A to space B so it transforms from space B to space A.
Public function UE::Math::TQuat< T >

Inverse ( const UE::Math::TQuat< T >& Transform
)

 Inverts a transform from space A to space B so it transforms from space B to space A.
Public function decltype(Transform.Inverse())

Inverse ( const TransformType& Transform
)

 Inverts a transform from space A to space B so it transforms from space B to space A.
Public function UE::Math::TVector< T >

Inverse ( const UE::Math::TVector< T >& Transform
)

 Inverts a transform from space A to space B so it transforms from space B to space A.
Public function Static bool

Inverse4x4 ( double* dst,
const FArg* src
)

 Very high quality 4x4 matrix inverse
Public function float

LegendrePolynomial ( int32 L,
int32 M,
float X
)

 Evaluates the LegendrePolynomial for L,M at X
Public function void

LexFromString ( FNumericUnit< T >& OutValue,
const TCHAR* String
)

  
Public function void

LexFromString ( FNumericUnit< T >& OutValue,
const TCHAR* String
)

  
Public function FString

LexToSanitizedString ( const FNumericUnit< T >& NumericUnit
)

  
Public function FString

LexToSanitizedString ( const FNumericUnit< T >& NumericUnit
)

  
Public function FString

LexToString ( const FNumericUnit< T >& NumericUnit
)

  
Public function FString

LexToString ( const FNumericUnit< T >& NumericUnit
)

  
Public function bool

LexTryParseString ( FNumericUnit< T >& OutValue,
const TCHAR* String
)

  
Public function bool

LexTryParseString ( FNumericUnit< T >& OutValue,
const TCHAR* String
)

  
Public function VectorRegister Returns a bitwise equivalent vector based on 4 DWORDs.
Public function VectorRegister

MakeVectorRegister ( float X,
float Y,
float Z,
float W
)

 Returns a vector based on 4 FLOATs.
Public function VectorRegister4Float  
Public function VectorRegister4Float

MakeVectorRegister ( float X,
float Y,
float Z,
float W
)

  
Public function VectorRegister4Double

MakeVectorRegister ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Double

MakeVectorRegister ( double X,
double Y,
double Z,
float W
)

 Overload to resolve compiler ambiguity for things like MakeVectorRegister(V.X, V.Y, V.Z, 0.f) when V is a double type.
Public function VectorRegister2Double

MakeVectorRegister2Double ( double X,
double Y
)

  
Public function VectorRegister2Double

MakeVectorRegister2DoubleConstant ( double X,
double Y
)

  
Public function VectorRegister2Double

MakeVectorRegister2DoubleConstant ( double X,
double Y
)

  
Public function VectorRegister4Float

MakeVectorRegisterConstant ( float X,
float Y,
float Z,
float W
)

  
Public function VectorRegister4Double

MakeVectorRegisterConstant ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Double Make double register from float register.
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double

MakeVectorRegisterDouble ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Double HEADER_UNIT_SKIP - Not included directly IWYU pragma: private constexpr floating point vector constant creation functions that bypass SIMD intrinsic setters
Public function VectorRegister4Double

MakeVectorRegisterDoubleConstant ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns a bitwise equivalent vector based on 4 DWORDs.
Public function VectorRegister4Float

MakeVectorRegisterFloat ( float X,
float Y,
float Z,
float W
)

 Returns a vector based on 4 FLOATs.
Public function VectorRegister4Float

MakeVectorRegisterFloatConstant ( float X,
float Y,
float Z,
float W
)

  
Public function VectorRegister4Float

MakeVectorRegisterFloatConstant ( float X,
float Y,
float Z,
float W
)

  
Public function VectorRegister4Float Lossy conversion: double->float vector.
Public function VectorRegister4Float Nicer aliases.
Public function VectorRegister4Int Returns a vector based on 4 int32.
Public function VectorRegister4Int Returns a vector based on 4 int32.
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function FLinearColor

operator* ( float Scalar,
const FLinearColor& Color
)

  
Public function TSHVectorRGB< Order >

operator* ( const TSHVector< Order >& A,
const FLinearColor& B
)

 Color multiplication operator.
Public function FTwoVectors

operator* ( float Scale,
const FTwoVectors& V
)

 FTwoVectors inline functions
Public function int32 Returns the basis index of the SH basis L,M.
Public function FLinearColor  
Public function UE::Math::TMatrix< double >

ToMatrix ( const UE::Math::TQuat< double >& Rotation
)

  
Public function UE::Math::TMatrix< float >

ToMatrix ( const UE::Math::TQuat< float >& Rotation
)

 Specialization for rotation.
Public function const UE::Math::TMatrix< float > &

ToMatrix ( const UE::Math::TMatrix< float >& Transform
)

 Specialization for the NULL Matrix conversion.
Public function UE::Math::TMatrix< float >

ToMatrix ( const UE::Math::TRotator< float >& Rotation
)

 Specialization for rotation.
Public function decltype(Transform.ToMatrix())

ToMatrix ( const TransformType& Transform
)

 UE::Math::TMatrix Support.
Public function const UE::Math::TMatrix< double > &

ToMatrix ( const UE::Math::TMatrix< double >& Transform
)

  
Public function UE::Math::TMatrix< float >

ToMatrix ( float Scale
)

 Specialization for floats as a uniform scale.
Public function UE::Math::TMatrix< double >

ToMatrix ( const UE::Math::TVector< double >& Translation
)

  
Public function UE::Math::TMatrix< double >

ToMatrix ( double Scale
)

  
Public function UE::Math::TMatrix< float >

ToMatrix ( const TScale< float >& Scale
)

 Specialization for non-uniform Scale.
Public function UE::Math::TMatrix< double >

ToMatrix ( const TScale< double >& Scale
)

  
Public function UE::Math::TMatrix< float >

ToMatrix ( const UE::Math::TVector< float >& Translation
)

 Specialization for translation.
Public function UE::Math::TMatrix< double >

ToMatrix ( const UE::Math::TRotator< double >& Rotation
)

  
Public function decltype(TransformConverter< ResultType >::Convert(Transform))

TransformCast ( const TransformType& Transform
)

 Casts one TransformType to ResultType using rules laid out by TransformConverter<>::Convert<>().
Public function UE::Math::TVector< T >

TransformPoint ( const TScale< T >& Transform,
const UE::Math::TVector< T >& Point
)

 Specialization for Scale.
Public function UE::Math::TVector< T >

TransformPoint ( const UE::Math::TRotator< T >& Transform,
const UE::Math::TVector< T >& Point
)

 Specialization for UE::Math::TRotator as it's member function is called something slightly different.
Public function UE::Math::TVector< T >

TransformPoint ( const UE::Math::TQuat< T >& Transform,
const UE::Math::TVector< T >& Point
)

 Specialization for UE::Math::TQuat as it's member function is called something slightly different.
Public function UE::Math::TVector< T >

TransformPoint ( const UE::Math::TMatrix< T >& Transform,
const UE::Math::TVector< T >& Point
)

 TransformPoint overloads.
Public function UE::Math::TVector2< PositionType >

TransformPoint ( double Transform,
const UE::Math::TVector2< PositionType >& Point
)

  
Public function UE::Math::TVector2< PositionType >

TransformPoint ( float Transform,
const UE::Math::TVector2< PositionType >& Point
)

 Adapters for 2D uniform scale.
Public function UE::Math::TVector< PositionType >

TransformPoint ( double Transform,
const UE::Math::TVector< PositionType >& Point
)

  
Public function UE::Math::TVector< PositionType >

TransformPoint ( float Transform,
const UE::Math::TVector< PositionType >& Point
)

 Specialization for uniform Scale.
Public function PositionType

TransformPoint ( const TransformType& Transform,
const PositionType& Point
)

 Generic implementation of TransformPoint. Attempts to use a member function of the TransformType.
Public function UE::Math::TVector< T >

TransformPoint ( const UE::Math::TVector< T >& Transform,
const UE::Math::TVector< T >& Point
)

 Specialization for UE::Math::TVector Translation.
Public function UE::Math::TVector2< T >

TransformPoint ( const UE::Math::TVector2< T >& Transform,
const UE::Math::TVector2< T >& Point
)

 Specialization for TVector2 Translation.
Public function VectorType

TransformVector ( const TransformType& Transform,
const VectorType& Vector
)

 Generic implementation of TransformVector. Attempts to use a member function of the TransformType.
Public function UE::Math::TVector< VectorType >

TransformVector ( float Transform,
const UE::Math::TVector< VectorType >& Vector
)

 Specialization for uniform Scale.
Public function UE::Math::TVector< T >

TransformVector ( const UE::Math::TRotator< T >& Transform,
const UE::Math::TVector< T >& Vector
)

 Specialization for UE::Math::TRotator as it's member function is called something slightly different.
Public function UE::Math::TVector2< VectorType >

TransformVector ( double Transform,
const UE::Math::TVector2< VectorType >& Vector
)

  
Public function UE::Math::TVector2< VectorType >

TransformVector ( float Transform,
const UE::Math::TVector2< VectorType >& Vector
)

 Specialization for uniform Scale.
Public function UE::Math::TVector< T >

TransformVector ( const TScale< T >& Transform,
const UE::Math::TVector< T >& Vector
)

 Specialization for Scale.
Public function const UE::Math::TVector2< T > &

TransformVector ( const UE::Math::TVector2< T >& Transform,
const UE::Math::TVector2< T >& Vector
)

 Specialization for FVector2D Translation (does nothing).
Public function UE::Math::TVector< VectorType >

TransformVector ( double Transform,
const UE::Math::TVector< VectorType >& Vector
)

  
Public function const UE::Math::TVector< T > &

TransformVector ( const UE::Math::TVector< T >& Transform,
const UE::Math::TVector< T >& Vector
)

 Specialization for UE::Math::TVector Translation (does nothing).
Public function UE::Math::TVector< T >

TransformVector ( const UE::Math::TQuat< T >& Transform,
const UE::Math::TVector< T >& Vector
)

 Specialization for UE::Math::TQuat as it's member function is called something slightly different.
Public function TArray< TDest, InAllocatorType >

UE::LWC::ConvertArrayType ( const TArray< TSrc, InAllocatorType >& From
)

 Convert array to a new type.
Public function TArray< TDest, InAllocatorType >

UE::LWC::ConvertArrayTypeClampMax ( const TArray< TSrc, InAllocatorType >& From
)

 Convert array to a new type and clamps values to the Max of TDest type.
Public function int64

UE::LWC::FloatToIntCastChecked ( float FloatValue
)

 Float->int64
Public function int32

UE::LWC::FloatToIntCastChecked ( double FloatValue
)

 Double->int32
Public function int64

UE::LWC::FloatToIntCastChecked ( double FloatValue
)

 Double->int64
Public function OutIntType

UE::LWC::FloatToIntCastChecked ( InFloatType FloatValue
)

 Generic float type to int type, to enable specializations below.
Public function int32

UE::LWC::FloatToIntCastChecked ( float FloatValue
)

 Float->int32
Public function FVector3f

UE::LWC::NarrowWorldPositionChecked ( const FVector& WorldPosition
)

 Validated narrowing cast for world positions. FVector -> FVector3f.
Public function FVector3f Validated narrowing cast for world positions. FVector -> FVector3f.
Public function UE::Math::TVector2< T >

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

 Specialization for concatenating two 2D Translations.
Public function UE::Math::TMatrix< T >

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

 Specialization for concatenating two Matrices.
Public function UE::Math::TVector< T >

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

 Specialization for concatenating two translations.
Public function UE::Math::TQuat< T >

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

 Specialization for concatenating two rotations.
Public function uint32

UE::Math::GetTypeHash ( const TVector2< T >& Vector
)

 Creates a hash value from a TVector2.
Public function uint32

UE::Math::GetTypeHash ( const TVector< T >& Vector
)

 Creates a hash value from an FVector.
Public function uint32

UE::Math::GetTypeHash ( const TIntVector2< T >& Vector
)

 Creates a hash value from an IntVector2.
Public function uint32

UE::Math::GetTypeHash ( const TQuat< T >& Quat
)

 Creates a hash value from an FQuat.
Public function uint32

UE::Math::GetTypeHash ( const TIntVector4< T >& Vector
)

 Creates a hash value from an IntVector4.
Public function uint32

UE::Math::GetTypeHash ( const TIntVector3< T >& Vector
)

 Creates a hash value from an IntVector3.
Public function uint32

UE::Math::GetTypeHash ( const TIntRect< IntType >& InRect
)

  
Public function uint32

UE::Math::GetTypeHash ( const TTransform< T >& Transform
)

 Creates a hash value from an FTransform.
Public function uint32

UE::Math::GetTypeHash ( const TIntPoint< IntType >& InPoint
)

  
Public function bool

UE::Math::MakeFrustumPlane ( T A,
T B,
T C,
T D,
TPlane< T >& OutPlane
)

  
Public function TVector2< T >

UE::Math::operator* ( T2 Scale,
const TVector2< T >& V
)

 Multiplies a Vector2 by a scaling factor.
Public function TVector< T >

UE::Math::operator* ( T2 Scale,
const TVector< T >& V
)

 Multiplies a vector by a scaling factor.
Public function TQuat< T >

UE::Math::operator* ( const float Scale,
const TQuat< T >& Q
)

 Global operator for (float * Quat)
Public function TQuat< T >

UE::Math::operator* ( const double Scale,
const TQuat< T >& Q
)

 Global operator for (double * Quat)
Public function TRotator< T >

UE::Math::operator* ( FArg Scale,
const TRotator< T >& R
)

 FRotator inline functions Scale a rotator and return.
Public function TVector4< T >

UE::Math::operator* ( T2 Scale,
const TVector4< T >& V
)

 Scales a vector.
Public function double Find the common quantization factor for the specified temperature unit. Quantizes to Kelvin.
Public function VectorRegister4Float Returns the absolute value (component-wise).
Public function VectorRegister4Double  
Public function VectorRegister4Float A and B are quaternions. The result is A + (|A.B| >= 0 ? 1 : -1) * B.
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister

VectorACos ( const VectorRegister& X
)

  
Public function VectorRegister4Float

VectorAdd ( const VectorRegister4Float& Vec1,
const VectorRegister4Float& Vec2
)

 Adds two vectors (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function uint32 Returns non-zero if all elements in Vec1 are greater than the corresponding elements in Vec2, otherwise 0.
Public function uint32  
Public function uint32 Returns non-zero if all elements in Vec1 are lesser than the corresponding elements in Vec2, otherwise 0.
Public function uint32  
Public function uint32 Returns non-zero if any element in Vec1 is greater than the corresponding element in Vec2, otherwise 0.
Public function uint32  
Public function uint32

VectorAnyGreaterThan ( const VectorRegister& Vec1,
const VectorRegister& Vec2
)

 Returns non-zero if any element in Vec1 is greater than the corresponding element in Vec2, otherwise 0.
Public function uint32 Returns non-zero if any element in Vec1 is lesser than the corresponding element in Vec2, otherwise 0.
Public function uint32  
Public function VectorRegister4Double  
Public function VectorRegister

VectorASin ( const VectorRegister& X
)

  
Public function VectorRegister4Float  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister

VectorATan ( const VectorRegister& X
)

  
Public function VectorRegister

VectorATan2 ( const VectorRegister& X,
const VectorRegister& Y
)

  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Float Bi-Linear Quaternion interpolation for quaternions stored in VectorRegisters.
Public function VectorRegister4Double  
Public function VectorRegister4Float Combines two vectors using bitwise AND (treating each vector as a 128 bit field)
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Combines two vectors using bitwise OR (treating each vector as a 128 bit field)
Public function VectorRegister4Float Combines two vectors using bitwise XOR (treating each vector as a 128 bit field)
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister

VectorCeil ( const VectorRegister& X
)

  
Public function VectorRegister4Float

VectorClamp ( const VectorRegister4Float& X,
const VectorRegister4Float& VecMin,
const VectorRegister4Float& VecMax
)

 Clamps X to be between VecMin and VecMax, inclusive.
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister

VectorCombineHigh ( const VectorRegister& Vec1,
const VectorRegister& Vec2
)

 Creates a vector by combining two high components from each vector
Public function VectorRegister4Float Creates a vector by combining two high components from each vector
Public function VectorRegister

VectorCombineLow ( const VectorRegister& Vec1,
const VectorRegister& Vec2
)

 Creates a vector by combining two low components from each vector
Public function VectorRegister4Float Creates a vector by combining two low components from each vector
Public function VectorRegister4Double  
Public function VectorRegister4Float Creates a four-part mask based on component-wise == compares of the input vectors
Public function VectorRegister4Double  
Public function VectorRegister4Float Creates a four-part mask based on component-wise >= compares of the input vectors
Public function VectorRegister4Double  
Public function VectorRegister4Float Creates a four-part mask based on component-wise > compares of the input vectors
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Creates a four-part mask based on component-wise <= compares of the input vectors
Public function VectorRegister4Float Creates a four-part mask based on component-wise < compares of the input vectors
Public function VectorRegister4Double  
Public function VectorRegister4Float Creates a four-part mask based on component-wise != compares of the input vectors
Public function VectorRegister4Double  
Public function bool Returns true if the vector contains a component that is either NAN or +/-infinite.
Public function bool Returns true if the vector contains a component that is either NAN or +/-infinite.
Public function bool  
Public function VectorRegister

VectorCos ( const VectorRegister& X
)

  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Float Calculates the cross product of two vectors (XYZ components).
Public function VectorRegister4Double  
Public function void

VectorDeinterleave ( VectorRegister4Float&__restrict OutEvens,
VectorRegister4Float&__restrict OutOdds,
const VectorRegister4Float&__restrict Lo,
const VectorRegister4Float&__restrict Hi
)

 Deinterleaves the components of the two given vectors such that the even components are in one vector and the odds in another.
Public function void

VectorDeinterleave ( VectorRegister4Double&__restrict OutEvens,
VectorRegister4Double&__restrict OutOdds,
const VectorRegister4Double&__restrict Lo,
const VectorRegister4Double&__restrict Hi
)

  
Public function void

VectorDeinterleave ( VectorRegister& OutEvens,
VectorRegister& OutOdds,
const VectorRegister& Lo,
const VectorRegister& Hi
)

 Deinterleaves the components of the two given vectors such that the even components are in one vector and the odds in another.
Public function VectorRegister4Double  
Public function VectorRegister4Float Divides two vectors (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float Calculates the dot3 product of two vectors and returns a vector with the result in all 4 components.
Public function double  
Public function float Calculates the dot3 product of two vectors and returns a scalar value.
Public function VectorRegister4Double  
Public function VectorRegister4Float Calculates the dot4 product of two vectors and returns a vector with the result in all 4 components.
Public function VectorRegister2Double

VectorDoubleLoad ( const void* Ptr
)

 Loads 2 doubles from unaligned memory.
Public function VectorRegister4Int  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister

VectorExp ( const VectorRegister& X
)

  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister

VectorExp2 ( const VectorRegister& X
)

  
Public function VectorRegister4Int TODO: LWC: potential loss of data.
Public function VectorRegister4Int  
Public function VectorRegister4Double  
Public function VectorRegister  
Public function VectorRegister4Float  
Public function VectorRegister  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function float

VectorGetComponent ( VectorRegister Vec,
uint32 ComponentIndex
)

 Returns an component from a vector.
Public function float

VectorGetComponentDynamic ( const VectorRegister4Float& Vec,
uint32 ComponentIndex
)

  
Public function double

VectorGetComponentDynamic ( const VectorRegister4Double& Vec,
uint32 ComponentIndex
)

  
Public function float Returns an component from a vector.
Public function double  
Public function VectorRegister4Int

VectorInt64Load ( const void* Ptr
)

 Loads 2 int64s from unaligned memory.
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int Arithmetic.
Public function VectorRegister4Int Bitwise.
Public function VectorRegister4Int = (~a) & b to match _mm_andnot_si128
Public function VectorRegister4Int Comparison.
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int

VectorIntLoad ( const void* Ptr
)

 Loads 4 int32s from unaligned memory.
Public function VectorRegister4Int

VectorIntLoad1 ( const void* Ptr
)

 Loads 1 int32 from unaligned memory into all components of a vector register.
Public function VectorRegister4Int

VectorIntLoadAligned ( const void* Ptr
)

 Loads 4 int32s from aligned memory.
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Int = ~a
Public function VectorRegister4Int = a | b
Public function VectorRegister4Int

VectorIntSelect ( const VectorRegister4Int& Mask,
const VectorRegister4Int& Vec1,
const VectorRegister4Int& Vec2
)

  
Public function VectorRegister4Int

VectorIntSelect ( const VectorRegister4Int& Mask,
const VectorRegister4Int& Vec1,
const VectorRegister4Int& Vec2
)

  
Public function void

VectorIntStore ( const VectorRegister4Int& A,
const void* Ptr
)

 Stores a vector to memory (aligned or unaligned).
Public function void

VectorIntStoreAligned ( const VectorRegister4Int& A,
const void* Ptr
)

 Stores a vector to memory (aligned).
Public function VectorRegister4Int  
Public function VectorRegister4Float  
Public function VectorRegister4Int = a ^ b
Public function VectorRegister4Float Lerp between two vectors
Public function VectorRegister4Double  
Public function VectorRegister4Float Fast Linear Quaternion Interpolation for quaternions stored in VectorRegisters.
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function TVectorRegisterType< T >

VectorLoad ( const UE::Math::TQuat< T >* Ptr
)

 VectorLoad.
Public function VectorRegister4Double

VectorLoad ( const double* Ptr
)

  
Public function VectorRegister4Float

VectorLoad ( const float* Ptr
)

 Loads 4 FLOATs from unaligned memory.
Public function TVectorRegisterType< T >

VectorLoad ( const UE::Math::TVector4< T >* Ptr
)

  
Public function VectorRegister4x4Float

VectorLoad16 ( const float* Ptr
)

 Loads 16 floats from unaligned memory into 4 vector registers.
Public function VectorRegister4Float  
Public function VectorRegister4Float

VectorLoadAligned ( const float* Ptr
)

 Forward declarations.
Public function VectorRegister4Double

VectorLoadAligned ( const double* Ptr
)

  
Public function TVectorRegisterType< T >

VectorLoadAligned ( const UE::Math::TQuat< T >* Ptr
)

 VectorLoadAligned.
Public function TVectorRegisterType< T >  
Public function TVectorRegisterType< T >

VectorLoadAligned ( const UE::Math::TPlane< T >* Ptr
)

  
Public function VectorRegister4Double  
Public function VectorRegister

VectorLoadByte4Reverse ( const uint8* Ptr
)

 Loads 4 BYTEs from unaligned memory and converts them into 4 FLOATs in reversed order.
Public function VectorRegister4Double

VectorLoadDouble1 ( const double* Ptr
)

  
Public function VectorRegister4Double

VectorLoadDouble3 ( const double* Ptr
)

  
Public function VectorRegister4Double

VectorLoadDouble3_W0 ( const double* Ptr
)

  
Public function VectorRegister4Double

VectorLoadDouble3_W1 ( const double* Ptr
)

  
Public function VectorRegister4Float

VectorLoadFloat1 ( const float* Ptr
)

 Loads 1 float from unaligned memory and replicates it to all 4 elements.
Public function VectorRegister4Float VectorLoadFloat1.
Public function VectorRegister4Double  
Public function VectorRegister4Double

VectorLoadFloat1 ( const double* Ptr
)

  
Public function VectorRegister4Double

VectorLoadFloat2 ( const double* Ptr
)

  
Public function VectorRegister4Float

VectorLoadFloat2 ( const float* Ptr
)

 Loads 2 floats from unaligned memory into X and Y and duplicates them in Z and W.
Public function VectorRegister4Double

VectorLoadFloat3 ( const double* Ptr
)

 Loads 3 FLOATs from unaligned memory and sets W=0.
Public function TVectorRegisterType< T >

VectorLoadFloat3 ( const UE::Math::TVector< T >* Ptr
)

  
Public function VectorRegister4Float

VectorLoadFloat3 ( const float* Ptr
)

 VectorLoadFloat3.
Public function TVectorRegisterType< T >  
Public function TVectorRegisterType< T >  
Public function VectorRegister4Double

VectorLoadFloat3_W0 ( const double* Ptr
)

  
Public function VectorRegister4Float

VectorLoadFloat3_W0 ( const float* Ptr
)

 VectorLoadFloat3_W0.
Public function TVectorRegisterType< T >  
Public function VectorRegister4Float

VectorLoadFloat3_W1 ( const float* Ptr
)

 VectorLoadFloat3_W1.
Public function VectorRegister4Double

VectorLoadFloat3_W1 ( const double* Ptr
)

 Loads 3 FLOATs from unaligned memory and sets W=1.
Public function VectorRegister4Float

VectorLoadSRGBA16N ( void* Ptr
)

 Loads packed signed RGBA16(4 bytes) from unaligned memory and converts them into 4 FLOATs.
Public function VectorRegister4Double

VectorLoadTwoPairsFloat ( const double* Ptr1,
const double* Ptr2
)

  
Public function VectorRegister4Float

VectorLoadTwoPairsFloat ( const float* Ptr1,
const float* Ptr2
)

 Loads 4 unaligned floats - 2 from the first pointer, 2 from the second, and packs them in to 1 vector.
Public function VectorRegister

VectorLoadTwoPairsFloat ( const float* Ptr1,
const float* Ptr2
)

 Loads 4 unaligned floats - 2 from the first pointer, 2 from the second, and packs them in to 1 vector.
Public function VectorRegister4Float

VectorLoadURGB10A2N ( void* Ptr
)

 Loads packed RGB10A2(4 bytes) from unaligned memory and converts them into 4 FLOATs.
Public function VectorRegister4Float

VectorLoadURGBA16N ( void* Ptr
)

 Loads packed RGBA16(4 bytes) from unaligned memory and converts them into 4 FLOATs.
Public function VectorRegister4Double  
Public function VectorRegister

VectorLog ( const VectorRegister& X
)

  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister

VectorLog2 ( const VectorRegister& X
)

  
Public function int32  
Public function int32 Returns an integer bit-mask (0x00 - 0x0f) based on the sign-bit for each component in a vector.
Public function bool

VectorMatrixInverse ( FMatrix44d* DstMatrix,
const FMatrix44d* SrcMatrix
)

 Calculate the inverse of an FMatrix44. Src == Dst is allowed
Public function bool

VectorMatrixInverse ( FMatrix44f* DstMatrix,
const FMatrix44f* SrcMatrix
)

  
Public function bool

VectorMatrixInverse ( FMatrix* DstMatrix,
const FMatrix* SrcMatrix
)

 Calculate the inverse of an FMatrix.
Public function void

VectorMatrixMultiply ( FMatrix44f* Result,
const FMatrix44f* Matrix1,
const FMatrix44f* Matrix2
)

  
Public function void

VectorMatrixMultiply ( FMatrix44d* Result,
const FMatrix44d* Matrix1,
const FMatrix44d* Matrix2
)

 Multiplies two 4x4 matrices.
Public function void

VectorMatrixMultiply ( FMatrix* Result,
const FMatrix* Matrix1,
const FMatrix* Matrix2
)

 Multiplies two 4x4 matrices.
Public function VectorRegister4Double  
Public function VectorRegister4Float

VectorMax ( const VectorRegister4Float& Vec1,
const VectorRegister4Float& Vec2
)

 Returns the maximum values of two vectors (component-wise).
Public function VectorRegister4Double  
Public function VectorRegister

VectorMergeVecXYZ_VecW ( const VectorRegister& VecXYZ,
const VectorRegister& VecW
)

 Merges the XYZ components of one vector with the W component of another vector and returns the result.
Public function VectorRegister4Float Merges the XYZ components of one vector with the W component of another vector and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float

VectorMin ( const VectorRegister4Float& Vec1,
const VectorRegister4Float& Vec2
)

 Returns the minimum values of two vectors (component-wise).
Public function VectorRegister4Float  
Public function VectorRegister

VectorMod ( const VectorRegister& X,
const VectorRegister& Y
)

  
Public function VectorRegister4Double  
Public function VectorRegister4Float VectorMod360: Essentially VectorMod(X, 360) but using faster computation that is still accurate given the known input constraints.
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Multiplies two vectors (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float Multiplies two vectors (component-wise), adds in the third vector and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns the negated value (component-wise).
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Multiplies two vectors (component-wise), negates the results and adds it to the third vector i.e. -AB + C = C - AB
Public function TVectorRegisterType Returns a normalized 4 vector = Vector / |Vector|.
Public function TVectorRegisterType  
Public function TVectorRegisterType  
Public function VectorRegister4Float

VectorNormalizeQuaternion ( const VectorRegister4Float& UnnormalizedQuat
)

 Normalize quaternion ( result = (Q.Q >= 1e-8) ? (Q / |Q|) : (0,0,0,1) )
Public function VectorRegister4Double

VectorNormalizeQuaternion ( const VectorRegister4Double& UnnormalizedQuat
)

  
Public function VectorRegister4Double

VectorNormalizeRotator ( const VectorRegister4Double& UnnormalizedRotator
)

  
Public function VectorRegister4Float

VectorNormalizeRotator ( const VectorRegister4Float& UnnormalizedRotator
)

 Normalize Rotator.
Public function VectorRegister4Double

VectorNormalizeSafe ( const VectorRegister4Double& Vector,
const VectorRegister4Double& DefaultValue
)

  
Public function VectorRegister4Float

VectorNormalizeSafe ( const VectorRegister4Float& Vector,
const VectorRegister4Float& DefaultValue
)

 Returns ((Vector dot Vector) >= 1e-8) ? (Vector / |Vector|) : DefaultValue Uses accurate 1/sqrt, not the estimate
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns a vector with all ones.
Public function VectorRegister4Float

VectorPow ( const VectorRegister4Float& Base,
const VectorRegister4Float& Exponent
)

 Calculates x raised to the power of y (component-wise).
Public function VectorRegister4Double

VectorPow ( const VectorRegister4Double& Base,
const VectorRegister4Double& Exponent
)

  
Public function VectorRegister4Float

VectorQuaternionInverse ( const VectorRegister4Float& NormalizedQuat
)

 Inverse quaternion ( -X, -Y, -Z, W)
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float Rotate a vector using the inverse of a unit Quaternion (rotation in the opposite direction).
Public function void

VectorQuaternionMultiply ( VectorRegister* VResult,
const VectorRegister* VQuat1,
const VectorRegister* VQuat2
)

 Multiplies two quaternions; the order matters.
Public function void

VectorQuaternionMultiply ( FQuat* Result,
const FQuat* Quat1,
const FQuat* Quat2
)

 Multiplies two quaternions; the order matters.
Public function void

VectorQuaternionMultiply ( VectorRegister4Double*__restrict Result,
const VectorRegister4Double*__restrict Quat1,
const VectorRegister4Double*__restrict Quat2
)

  
Public function void

VectorQuaternionMultiply ( FQuat4f*RESTRICT Result,
const FQuat4f*RESTRICT Quat1,
const FQuat4f*RESTRICT Quat2
)

  
Public function void

VectorQuaternionMultiply ( VectorRegister4Float*__restrict Result,
const VectorRegister4Float*__restrict Quat1,
const VectorRegister4Float*__restrict Quat2
)

 Multiplies two quaternions; the order matters.
Public function void

VectorQuaternionMultiply ( FQuat4d*RESTRICT Result,
const FQuat4d*RESTRICT Quat1,
const FQuat4d*RESTRICT Quat2
)

  
Public function VectorRegister4Double  
Public function VectorRegister4Float Multiplies two quaternions; the order matters.
Public function VectorRegister Multiplies two quaternions; the order matters.
Public function VectorRegister4Double  
Public function VectorRegister4Float Rotate a vector using a unit Quaternion.
Public function void

VectorQuaternionVector3InverseRotate ( FVector* Result,
const FVector* Vec,
const FQuat* Quat
)

  
Public function void

VectorQuaternionVector3Rotate ( FVector* Result,
const FVector* Vec,
const FQuat* Quat
)

  
Public function VectorRegister4Double  
Public function VectorRegister4Float Computes the reciprocal of a vector (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float Computes the reciprocal of a vector (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float Computes an estimate of the reciprocal of a vector (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float Return Reciprocal Length of the vector
Public function VectorRegister4Double  
Public function VectorRegister4Float Return Reciprocal Length of the vector (estimate)
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns an estimate of 1/sqrt(c) for each component of the vector
Public function VectorRegister4Float Returns accurate reciprocal square root.
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns an estimate of 1/sqrt(c) for each component of the vector
Public function VectorRegister4Double  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Int  
Public function VectorRegister4Int  
Public function VectorRegister4Float Does a bitwise vector selection based on a mask (e.g., created from VectorCompareXX)
Public function VectorRegister4Double  
Public function VectorRegister4Float

VectorSet ( float X,
float Y,
float Z,
float W
)

 Creates a vector out of four FLOATs.
Public function VectorRegister4Double

VectorSet ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Float Overload to resolve ambiguous mixes of ints and floats.
Public function VectorRegister4Float Loads XYZ and sets W=0
Public function VectorRegister4Double  
Public function VectorRegister4Float Loads XYZ and sets W=1
Public function VectorRegister4Double  
Public function VectorRegister4Double

VectorSetDouble ( double X,
double Y,
double Z,
double W
)

  
Public function VectorRegister4Double

VectorSetDouble1 ( double D
)

  
Public function VectorRegister4Double

VectorSetDouble3 ( double X,
double Y,
double Z
)

  
Public function VectorRegister4Float

VectorSetFloat1 ( float F
)

 Propagates passed in float to all registers
Public function VectorRegister4Double

VectorSetFloat1 ( double D
)

  
Public function VectorRegister4Double

VectorSetFloat3 ( double X,
double Y,
double Z
)

  
Public function VectorRegister4Float

VectorSetFloat3 ( float X,
float Y,
float Z
)

 Creates a vector out of three FLOATs and leaves W undefined.
Public function VectorRegister4Int  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister

VectorSign ( const VectorRegister& X
)

 TODO: Vectorize.
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister

VectorSin ( const VectorRegister& X
)

  
Public function void

VectorSinCos ( VectorRegister4Double*__restrict VSinAngles,
VectorRegister4Double*__restrict VCosAngles,
const VectorRegister4Double*__restrict VAngles
)

  
Public function void

VectorSinCos ( VectorRegister4Float*__restrict VSinAngles,
VectorRegister4Float*__restrict VCosAngles,
const VectorRegister4Float*__restrict VAngles
)

 Computes the sine and cosine of each component of a Vector.
Public function void

VectorSinCos ( VectorRegister*__restrict VSinAngles,
VectorRegister*__restrict VCosAngles,
const VectorRegister*__restrict VAngles
)

 Computes the sine and cosine of each component of a Vector.
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister

VectorStep ( const VectorRegister& X
)

 TODO: Vectorize.
Public function void

VectorStore ( const VectorRegister4Float& Vec,
float* Dst
)

 Stores a vector to memory (aligned or unaligned).
Public function void

VectorStore ( const VectorRegister4Double& Vec,
double* Dst
)

  
Public function void VectorStore.
Public function void

VectorStore ( const TVectorRegisterType< T >& Vec,
UE::Math::TQuat< T >* Dst
)

  
Public function void

VectorStore ( const VectorRegister4Float& Vec,
UE::Math::TQuat< double >* Dst
)

 Specific overload to support promoting float->double vector and storing in TQuat
Public function void  
Public function void  
Public function void  
Public function void

VectorStore16 ( const VectorRegister4x4Float& Vec,
float* Dst
)

 Stores 4 vectors to memory (aligned or unaligned).
Public function void  
Public function void  
Public function void Specific overload to support promoting float->double vector and storing in TQuat
Public function void Specific overload to support promoting float->double vector and storing in TVector4
Public function void VectorStoreAligned.
Public function void

VectorStoreAligned ( const VectorRegister4Double& Vec,
double* Dst
)

  
Public function void

VectorStoreAligned ( const VectorRegister4Float& Vec,
float* Ptr
)

 Stores a vector to aligned memory.
Public function void

VectorStoreAligned ( const TVectorRegisterType< T >& Vec,
UE::Math::TQuat< T >* Dst
)

  
Public function void  
Public function void Performs non-temporal store of a vector to aligned memory without polluting the caches
Public function void

VectorStoreByte4 ( const VectorRegister4Float& Vec,
void* Ptr
)

 Converts the 4 FLOATs in the vector to 4 BYTEs, clamped to [0,255], and stores to unaligned memory.
Public function void

VectorStoreDouble1 ( const VectorRegister4Double& Vec,
double* Ptr
)

  
Public function void

VectorStoreDouble3 ( const VectorRegister4Double& Vec,
double* Ptr
)

  
Public function void

VectorStoreFloat1 ( const VectorRegister4Double& Vec,
double* Dst
)

  
Public function void  
Public function void  
Public function void

VectorStoreFloat1 ( const VectorRegister4Float& Vec,
float* Dst
)

 Stores the X component of a vector to unaligned memory.
Public function void VectorStoreFloat1.
Public function void VectorStoreFloat3.
Public function void

VectorStoreFloat3 ( const VectorRegister4Double& Vec,
double* Dst
)

  
Public function void

VectorStoreFloat3 ( const VectorRegister4Float& Vec,
float* Dst
)

 Stores the XYZ components of a vector to unaligned memory.
Public function void  
Public function void  
Public function void  
Public function void

VectorStoreSignedByte4 ( const VectorRegister4Float& Vec,
void* Ptr
)

 Converts the 4 FLOATs in the vector to 4 BYTEs, clamped to [-127,127], and stores to unaligned memory.
Public function void

VectorStoreURGB10A2N ( const VectorRegister4Float& Vec,
void* Ptr
)

 Converts the 4 FLOATs in the vector RGB10A2, clamped to [0, 1023] and [0, 3], and stores to unaligned memory.
Public function void

VectorStoreURGBA16N ( const VectorRegister4Float& Vec,
void* Ptr
)

 Converts the 4 FLOATs in the vector RGBA16, clamped to [0, 65535], and stores to unaligned memory.
Public function VectorRegister4Float Subtracts a vector from another (component-wise) and returns the result.
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister

VectorTan ( const VectorRegister& X
)

  
Public function VectorRegister

VectorTransformVector ( const VectorRegister& VecP,
const FMatrix* MatrixM
)

 Calculate Homogeneous transform.
Public function VectorRegister4Double

VectorTransformVector ( const VectorRegister4Double& VecP,
const FMatrix44d* MatrixM
)

  
Public function VectorRegister4Double

VectorTransformVector ( const VectorRegister4Double& VecP,
const FMatrix44f* MatrixM
)

  
Public function VectorRegister4Float

VectorTransformVector ( const VectorRegister4Float& VecP,
const FMatrix44f* MatrixM
)

 Calculate Homogeneous transform.
Public function VectorRegister4Float

VectorTransformVector ( const VectorRegister4Float& VecP,
const FMatrix44d* MatrixM
)

  
Public function VectorRegister  
Public function VectorRegister4Double  
Public function VectorRegister4Float  
Public function VectorRegister4Float  
Public function VectorRegister4Double  
Public function VectorRegister4Float Returns a vector with all zeros.

Variables

  Type Name Description
Public variable uint32 AlmostTwoBits  
Public variable VectorRegister AnimWeightThreshold  
Public variable int32[9] BasisL  
Public variable int32[9] BasisM  
Public variable VectorRegister4Float BigNumber  
Public variable FVector::FReal DefaultFloatPrecision  
Public variable VectorRegister4Float DEG_TO_RAD  
Public variable VectorRegister4Float DEG_TO_RAD_HALF  
Public variable VectorRegister4Double DOUBLE_DEG_TO_RAD  
Public variable VectorRegister4Double DOUBLE_DEG_TO_RAD_HALF  
Public variable VectorRegister4Double DOUBLE_QINV_SIGN_MASK  
Public variable VectorRegister4Double DOUBLE_QMULTI_SIGN_MASK0  
Public variable VectorRegister4Double DOUBLE_QMULTI_SIGN_MASK1  
Public variable VectorRegister4Double DOUBLE_QMULTI_SIGN_MASK2  
Public variable VectorRegister4Double DOUBLE_RAD_TO_DEG  
Public variable VectorRegister4Double Double0001  
Public variable VectorRegister4Double Double1000  
Public variable VectorRegister4Double Double111_Minus1  
Public variable VectorRegister4Double Double1110  
Public variable VectorRegister4Double Double127  
Public variable VectorRegister4Double Double180  
Public variable VectorRegister4Double Double255  
Public variable VectorRegister4Double Double360  
Public variable uint64 DoubleAlmostTwoBits  
Public variable VectorRegister4Double DoubleBigNumber  
Public variable VectorRegister4Double DoubleKindaSmallNumber  
Public variable VectorRegister4Double DoubleMinus1_111  
Public variable VectorRegister4Double DoubleMinusOne  
Public variable VectorRegister4Double DoubleMinusOneHalf  
Public variable VectorRegister4Double DoubleNeg127  
Public variable VectorRegister4Double DoubleNonFractional  
Public variable VectorRegister4Double DoubleOne  
Public variable VectorRegister2Double DoubleOne2d  
Public variable VectorRegister4Double DoubleOneHalf  
Public variable VectorRegister4Double DoubleOneHundredth  
Public variable VectorRegister4Double DoubleOneOverPi  
Public variable VectorRegister4Double DoubleOneOverTwoPi  
Public variable VectorRegister4Double DoublePi  
Public variable VectorRegister4Double DoublePiByFour  
Public variable VectorRegister4Double DoublePiByTwo  
Public variable VectorRegister4Double DoubleSmallLengthThreshold  
Public variable VectorRegister4Double DoubleSmallNumber  
Public variable VectorRegister4Double DoubleThreshQuatNormalized  
Public variable VectorRegister4Double DoubleTwo  
Public variable VectorRegister4Double DoubleTwoPi  
Public variable VectorRegister4Double DoubleZero  
Public variable VectorRegister4Float Float0001  
Public variable VectorRegister4Float Float1000  
Public variable VectorRegister4Float Float111_Minus1  
Public variable VectorRegister4Float Float1110  
Public variable VectorRegister4Float Float127  
Public variable VectorRegister4Float Float180  
Public variable VectorRegister4Float Float255  
Public variable VectorRegister4Float Float360  
Public variable VectorRegister4Float FloatMinus1_111  
Public variable VectorRegister4Float FloatMinusOne  
Public variable VectorRegister4Float FloatMinusOneHalf  
Public variable VectorRegister4Float FloatNeg127  
Public variable VectorRegister4Float FloatNonFractional All float numbers greater than or equal to this have no fractional value.
Public variable VectorRegister4Float FloatOne  
Public variable VectorRegister4Float FloatOneHalf  
Public variable VectorRegister4Float FloatOneHundredth  
Public variable VectorRegister4Float FloatTwo  
Public variable VectorRegister4Float FloatZero  
Public variable FColorList GColorList Global instance of color list helper class.
Public variable VectorRegister4Int IntAllMask  
Public variable VectorRegister4Int IntMinusOne  
Public variable VectorRegister4Int IntOne  
Public variable VectorRegister4Int IntSignBit  
Public variable VectorRegister4Int IntSignMask  
Public variable VectorRegister4Int IntZero  
Public variable VectorRegister4Float KindaSmallNumber  
Public variable float[9] NormalizationConstants Constants.
Public variable VectorRegister4Float OneOverPi  
Public variable VectorRegister4Float OneOverTwoPi  
Public variable VectorRegister4Float Pi  
Public variable VectorRegister4Float PiByFour  
Public variable VectorRegister4Float PiByTwo  
Public variable VectorRegister4Float QINV_SIGN_MASK This is to speed up Quaternion Inverse. Static variable to keep sign of inverse
Public variable VectorRegister4Float QMULTI_SIGN_MASK0  
Public variable VectorRegister4Float QMULTI_SIGN_MASK1  
Public variable VectorRegister4Float QMULTI_SIGN_MASK2  
Public variable VectorRegister4Float RAD_TO_DEG  
Public variable VectorRegister RotationSignificantThreshold  
Public variable VectorRegister4Float SmallLengthThreshold  
Public variable VectorRegister4Float SmallNumber  
Public variable VectorRegister4Float ThreshQuatNormalized  
Public variable VectorRegister4Float TwoPi  
Public variable VectorRegister VECTOR_INV_255 Vector that represents (1/255,1/255,1/255,1/255)
Public variable VectorRegister Vector0001  
Public variable VectorRegister Vector1110  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page