className: Turquoise

code: static const [FColor](API\Runtime\Core\Math\FColor) Turquoise;


className: Thistle

module: Core

code: static const [FColor](API\Runtime\Core\Math\FColor) Thistle;


className: VeryDarkBrown

code: static const [FColor](API\Runtime\Core\Math\FColor) VeryDarkBrown;


className: VeryLightGrey

code: static const [FColor](API\Runtime\Core\Math\FColor) VeryLightGrey;


className: Violet

code: static const [FColor](API\Runtime\Core\Math\FColor) Violet;


className: VioletRed

code: static const [FColor](API\Runtime\Core\Math\FColor) VioletRed;


className: Wheat

code: static const [FColor](API\Runtime\Core\Math\FColor) Wheat;


className: White

description: Common colors.

code: static const [FColor](API\Runtime\Core\Math\FColor) White;


className: Yellow

code: static const [FColor](API\Runtime\Core\Math\FColor) Yellow;


className: YellowGreen

code: static const [FColor](API\Runtime\Core\Math\FColor) YellowGreen;


className: FColorList

code: class FColorList

ColorsLookup

type: TColorsLookup

description: Array of colors for fast lookup when using index.

ColorsMap

type: TColorsMap

description: List of common colors.


description: Add a new key to the curve with the specified input. Its initial value is set using EvalSub at that location. Returns the index of the new key.

code: virtual int32 CreateNewKey ( float KeyIn )


description: Remove the specified key from the curve. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual void DeleteKey ( int32 KeyIndex )


description: Evaluate a subcurve at an arbitary point. Outside the keyframe range, curves are assumed to continue their end values.

code: virtual float EvalSub ( int32 SubIndex, float InVal )


description:
Provides the color for the given key at the given sub-curve.
The color that is associated the given key at the given sub-curve

code: virtual [FColor](API\Runtime\Core\Math\FColor) GetKeyColor ( int32 SubIndex, int32 KeyIndex, const [FColor](API\Runtime\Core\Math\FColor) & CurveColor )


description: Get input range of keys. Outside this region curve continues constantly the start/end values.

code: virtual void GetInRange ( float & MinIn, float & MaxIn ) const


description: Get the input value for the Key with the specified index. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual float GetKeyIn ( int32 KeyIndex )


description: Get the interpolation mode of the specified keyframe. This can be CIM_Constant, CIM_Linear or CIM_Curve. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual EInterpCurveMode GetKeyInterpMode ( int32 KeyIndex ) const


description: Get the output value for the key with the specified index on the specified sub-curve. SubIndex must be within range ie >=0 and < NumSubCurves. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual float GetKeyOut ( int32 SubIndex, int32 KeyIndex )


description: Get number of keyframes in curve.

code: virtual int32 GetNumKeys() const


description: Get number of 'sub curves' in this Curve. For example, a vector curve will have 3 sub-curves, for X, Y and Z.

code: virtual int32 GetNumSubCurves() const


description: Get overall range of output values.

code: virtual void GetOutRange ( float & MinOut, float & MaxOut ) const


description:
Provides the color for the sub-curve button that is present on the curve tab.
The color associated to the given sub-curve index.

code: virtual [FColor](API\Runtime\Core\Math\FColor) GetSubCurveButtonColor ( int32 SubCurveIndex, bool bIsSubCurveHidden ) const


description: Get the incoming and outgoing tangent for the given subcurve and key. SubIndex must be within range ie >=0 and < NumSubCurves. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual void GetTangents ( int32 SubIndex, int32 KeyIndex, float & ArriveTangent, float & LeaveTangent ) const


description: Set the input value of the specified Key. This may change the index of the key, so the new index of the key is retured. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual int32 SetKeyIn ( int32 KeyIndex, float NewInVal )


description: Set the method to use for interpolating between the give keyframe and the next one. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual void SetKeyInterpMode ( int32 KeyIndex, EInterpCurveMode NewMode )


description: Set the output values of the specified key. SubIndex must be within range ie >=0 and < NumSubCurves. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual void SetKeyOut ( int32 SubIndex, int32 KeyIndex, float NewOutVal )


description: Set the incoming and outgoing tangent for the given subcurve and key. SubIndex must be within range ie >=0 and < NumSubCurves. KeyIndex must be within range ie >=0 and < NumKeys.

code: virtual void SetTangents ( int32 SubIndex, int32 KeyIndex, float ArriveTangent, float LeaveTangent )


className: FCurveEdInterface

description: Interface that allows the CurveEditor to edit this type of object.

code: class FCurveEdInterface


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FDateRange](API\Runtime\Core\Math\FDateRange) > Difference ( const [FDateRange](API\Runtime\Core\Math\FDateRange) & X, const [FDateRange](API\Runtime\Core\Math\FDateRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FDateRange](API\Runtime\Core\Math\FDateRange) > & Ranges )


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) Hull ( const [FDateRange](API\Runtime\Core\Math\FDateRange) & X, const [FDateRange](API\Runtime\Core\Math\FDateRange) & Y )


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FDateRange](API\Runtime\Core\Math\FDateRange) > & Ranges )


code: static [FDateRange](API\Runtime\Core\Math\FDateRange) Intersection ( const [FDateRange](API\Runtime\Core\Math\FDateRange) & X, const [FDateRange](API\Runtime\Core\Math\FDateRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FDateRange](API\Runtime\Core\Math\FDateRange) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


className: Super

code: typedef [TRange](API\Runtime\Core\Math\TRange)< [FDateTime](API\Runtime\Core\Misc\FDateTime) > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FDateRange](API\Runtime\Core\Math\FDateRange) > Union ( const [FDateRange](API\Runtime\Core\Math\FDateRange) & X, const [FDateRange](API\Runtime\Core\Math\FDateRange) & Y )


code: FDateRange ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FDateRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FDateRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FDateRange ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FDateTime](API\Runtime\Core\Misc\FDateTime) > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FDateTime](API\Runtime\Core\Misc\FDateTime) > & InUpperBound )


className: FDateRange

code: struct FDateRange : public [TRange< FDateTime >](API\Runtime\Core\Math\TRange)


code: static [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) FlipInclusion ( const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & Bound )


code: static [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & MaxLower ( const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & A, const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & B )


code: static const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & MaxUpper ( const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & A, const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & B )


code: static const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & MinLower ( const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & A, const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & B )


code: static const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & MinUpper ( const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & A, const [FDateRangeBound](API\Runtime\Core\Math\FDateRangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FDateTime](API\Runtime\Core\Misc\FDateTime) > Super


code: FDateRangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FDateRangeBound ( const [FDateTime](API\Runtime\Core\Misc\FDateTime) InValue )


className: FDateRangeBound

code: struct FDateRangeBound : public [TRangeBound< FDateTime >](API\Runtime\Core\Math\TRangeBound)


className: FDecryptedSignature

code: struct FDecryptedSignature : public [FSignatureBase< uint32 >](API\Runtime\Core\Math\FSignatureBase)


code: typedef [TInterval](API\Runtime\Core\Math\TInterval)< double > Super


code: FDoubleInterval ( const [Super](API\Runtime\Core\Math\TInterval) & Other )


code: FDoubleInterval ( double InMin, double InMax )


className: FDoubleInterval

code: struct FDoubleInterval : public [TInterval< double >](API\Runtime\Core\Math\TInterval)


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) > Difference ( const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & X, const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) > & Ranges )


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) Hull ( const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & X, const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & Y )


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) > & Ranges )


code: static [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) Intersection ( const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & X, const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< double > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) > Union ( const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & X, const [FDoubleRange](API\Runtime\Core\Math\FDoubleRange) & Y )


code: FDoubleRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FDoubleRange ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FDoubleRange ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< double > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< double > & InUpperBound )


code: FDoubleRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


className: FDoubleRange

code: struct FDoubleRange : public [TRange< double >](API\Runtime\Core\Math\TRange)


code: static [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) FlipInclusion ( const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & Bound )


code: static const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & MaxLower ( const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & A, const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & B )


code: static const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & MaxUpper ( const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & A, const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & B )


code: static const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & MinLower ( const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & A, const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & B )


code: static const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & MinUpper ( const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & A, const [FDoubleRangeBound](API\Runtime\Core\Math\FDoubleRangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< double > Super


code: FDoubleRangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FDoubleRangeBound ( const double InValue )


className: FDoubleRangeBound

code: struct FDoubleRangeBound : public [TRangeBound< double >](API\Runtime\Core\Math\TRangeBound)


description: Structure encompassing single DXT1 block.

code: struct FDXT1

type: union FDXT1::@3...

description: Color 0/1

Indices

description: Indices controlling how to blend colors.


description: Structure encompassing single DXT5 block

code: struct FDXT5

Alpha

description: Alpha component of DXT5

description: DXT1 color component.


description: Helper struct for a 16 bit 565 color of a DXT1/3/5 block.

code: struct FDXTColor16

type: union FDXTColor...

description: 565 Color

Value

description: 16 bit entity representation for easy access.


code: struct FDXTColor565

B

type: uint16: 5

description: Blue component, 5 bit.

G

type: uint16: 6

description: Green component, 6 bit.

R

description: Red component, 5 bit


description:
Compares this edge with another.
true if the two edges are identical, false otherwise.

code: bool operator== ( const [FEdge](API\Runtime\Core\Math\FEdge) & E ) const


description: Default constructor (no initialization).

code: FEdge()


description: Creates and initializes a new edge from two vertices.

code: FEdge ( FVector V1, FVector V2 )


className: FEdge

description: Implements an edge consisting of two vertices.

code: struct FEdge

Count

description: Holds a temporary variable used when creating arrays of unique edges.

Vertex

description: Holds the edge vertices.


className: FEncryptedSignature

code: struct FEncryptedSignature : public [FSignatureBase< TEncryptionInt >](API\Runtime\Core\Math\FSignatureBase)


description: Greatest common divisor of ValueA and ValueB.

code: namespace FEncryption { template<typename IntType> IntType FEncryption::CalculateGCD ( IntType ValueA, IntType ValueB ) }


description: Extended gcd: ax + by = gcd(a, b), where a = exponent, b = fi(n), gcd(a, b) = gcd(e, fi(n)) = 1, fi(n) is the Euler's totient function of n We only care to find d = x, which is our multiplicatve inverse of e (a).

code: namespace FEncryption { template<typename IntType> IntType FEncryption::CalculateMultiplicativeInverseOfExponent ( IntType Exponent, IntType Totient ) }


description: Decrypts a stream of bytes

code: namespace FEncryption { template<typename IntType> void FEncryption::DecryptBytes ( uint8 * DecryptedData, const IntType * Data, const int64 DataLength, const FEncryptionKey & DecryptionKey ) }


code: namespace FEncryption { void FEncryption::DecryptSignature ( const [FEncryptedSignature](API\Runtime\Core\Math\FEncryptedSignature) & InEncryptedSignature, [FDecryptedSignature](API\Runtime\Core\Math\FDecryptedSignature) & OutUnencryptedSignature, const FEncryptionKey & EncryptionKey ) }


description: Encrypts a stream of bytes

code: namespace FEncryption { template<typename IntType> void FEncryption::EncryptBytes ( IntType * EncryptedData, const uint8 * Data, const int64 DataLength, const FEncryptionKey & EncryptionKey ) }


code: namespace FEncryption { void FEncryption::EncryptSignature ( const [FDecryptedSignature](API\Runtime\Core\Math\FDecryptedSignature) & InUnencryptedSignature, [FEncryptedSignature](API\Runtime\Core\Math\FEncryptedSignature) & OutEncryptedSignature, const FEncryptionKey & EncryptionKey ) }


description: Generate Key Pair for encryption and decryption.

code: namespace FEncryption { template<typename IntType> void FEncryption::GenerateKeyPair ( const IntType & P, const IntType & Q, FEncryptionKey & PublicKey, FEncryptionKey & PrivateKey ) }


description: Raise Base to power of Exponent in mod Modulus.

code: namespace FEncryption { template<typename IntType> IntType FEncryption::ModularPow ( IntType Base, IntType Exponent, IntType Modulus ) }


description: 4 component vector corresponding to PF_R8G8B8A8_SNORM. This differs fromFColorwhich is BGRA.

code: class FFixedRGBASigned8

type: union FFixedRGB...


description: Return float clamp in [-MaxF16Float,MaxF16Float] , no infinites or nans returned


code: FFixedRGBASigned8 ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Src )


description: Return float clamp in [0,MaxF16Float] , no negatives or infinites or nans returned


description: Convert from Fp16 to Fp32.

code: float GetFloat() const


description: Is the float negative without converting NOTE: returns true for negative zero!

code: bool IsNegative() const


description: Float16 can store values in [-MaxF16Float,MaxF16Float]

code: static constexpr float MaxF16Float = 65504.f;


description: Assignment operator. Convert from Fp32 to Fp16.

code: [FFloat16](API\Runtime\Core\Math\FFloat16) & operator= ( float FP32Value )


className: FFloat16::operator float

description: Convert from Fp16 to Fp32.

code: operator float() const


description: Assignment operator. Copy Fp16 value.

code: [FFloat16](API\Runtime\Core\Math\FFloat16) & operator= ( const [FFloat16](API\Runtime\Core\Math\FFloat16) & FP16Value )


description: Convert from Fp32 to Fp16, round-to-nearest-even. (RTNE) Stores values out of range as +-Inf

code: void Set ( float FP32Value )


description: Convert from Fp32 to Fp16, round-to-nearest-even. (RTNE) Clamps values out of range as +-MaxF16Float

code: void SetClamped ( float FP32Value )


description: Set to 1.0

code: void SetOne()


description: Convert from Fp32 to Fp16, truncating low bits. (backward-compatible conversion; was used bySet()previously) Clamps values out of range to [-MaxF16Float,MaxF16Float] Convert from Fp32 to Fp16, round-to-nearest-even. (RTNE) Stores values out of range as +-Inf

code: void SetTruncate ( float FP32Value )


description: Set to 0.0

code: void SetZero()


description: Default constructor


description: Copy constructor.

code: FFloat16 ( const [FFloat16](API\Runtime\Core\Math\FFloat16) & FP16Value )


description: Conversion constructor. Convert from Fp32 to Fp16.

code: FFloat16 ( float FP32Value )


description: Legacy code truncated in the conversion. SetTruncate can be used for backwards compatibility.

code: class FFloat16


code: const [FLinearColor](API\Runtime\Core\Math\FLinearColor) GetFloats() const


description: Get as a pointer to four half floats

code: uint16 * GetFourHalves()


code: const uint16 * GetFourHalves() const


description: Assignment operator

code: [FFloat16Color](API\Runtime\Core\Math\FFloat16Color) & operator= ( const [FFloat16Color](API\Runtime\Core\Math\FFloat16Color) & Src )


description:
Checks whether two colors are identical.
true if the two colors are identical, otherwise false.

code: bool operator== ( const [FFloat16Color](API\Runtime\Core\Math\FFloat16Color) & Src ) const


description: Copy constructor.

code: FFloat16Color ( const [FFloat16Color](API\Runtime\Core\Math\FFloat16Color) & Src )


description: Constructor from a linear color.

code: FFloat16Color ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Src )


description: Constructor

code: FFloat32 ( float InValue )


description: RGBA Color made up ofFFloat16

code: class FFloat16Color


description: 32 bit float components

code: class FFloat32

type: union FFloat32:...

Exponent

type: uint32:  8

FloatValue

type: float

Sign

type: uint32:  1


code: FFloat3Packed ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Src )


description: 3 component vector corresponding to DXGI_FORMAT_R11G11B10_FLOAT. Conversion code from XMFLOAT3PK in DirectXPackedVector.h

code: class FFloat3Packed

type: union FFloat3Pa...

xe

type: uint32_t:  5

xm

type: uint32_t:  6


code: FFloat3PackedSE ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Src )


code: FFloat3PackedSE ( uint32 InEncodedValue )


description: 3 component vector corresponding to PF_R9G9B9EXP5.

code: class FFloat3PackedSE

BMantissa

type: uint32:  9

SharedExponent

type: uint32:  5


className: ExponentBias

code: enum { ExponentBias = 127 }


className: ExponentBits

code: enum { ExponentBits = 8 }


className: ExponentMask

code: enum { ExponentMask = 0x7f800000 }


className: MantissaBits

code: enum { MantissaBits = 23 }


className: MantissaMask

code: enum { MantissaMask = 0x007fffff }


className: SignMask

code: enum { SignMask = 0x80000000 }


code: static [PackedType](API\Runtime\Core\Math\FFloatInfo_IEEE32\PackedType) ToPackedType ( [FloatType](API\Runtime\Core\Math\FFloatInfo_IEEE32\FloatType) Value )


code: static [FloatType](API\Runtime\Core\Math\FFloatInfo_IEEE32\FloatType) ToFloatType ( [PackedType](API\Runtime\Core\Math\FFloatInfo_IEEE32\PackedType) Value )


code: typedef [TInterval](API\Runtime\Core\Math\TInterval)< float > Super


code: FFloatInterval ( float InMin, float InMax )


className: FFloatInterval

code: struct FFloatInterval : public [TInterval< float >](API\Runtime\Core\Math\TInterval)


code: FFloatInterval ( const [Super](API\Runtime\Core\Math\TInterval) & Other )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FFloatRange](API\Runtime\Core\Math\FFloatRange) > Difference ( const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & X, const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FFloatRange](API\Runtime\Core\Math\FFloatRange) > & Ranges )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) Hull ( const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & X, const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & Y )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FFloatRange](API\Runtime\Core\Math\FFloatRange) > & Ranges )


code: static [FFloatRange](API\Runtime\Core\Math\FFloatRange) Intersection ( const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & X, const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FFloatRange](API\Runtime\Core\Math\FFloatRange) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


className: Super

code: typedef [TRange](API\Runtime\Core\Math\TRange)< float > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FFloatRange](API\Runtime\Core\Math\FFloatRange) > Union ( const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & X, const [FFloatRange](API\Runtime\Core\Math\FFloatRange) & Y )


code: FFloatRange ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FFloatRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FFloatRange ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< float > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< float > & InUpperBound )


code: FFloatRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


className: FFloatRange

code: struct FFloatRange : public [TRange< float >](API\Runtime\Core\Math\TRange)


code: static [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) FlipInclusion ( const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & Bound )


code: static [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & MaxLower ( const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & A, const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & B )


code: static const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & MaxUpper ( const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & A, const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & B )


code: static const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & MinLower ( const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & A, const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & B )


code: static const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & MinUpper ( const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & A, const [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) & B )


code: static [FFloatRangeBound](API\Runtime\Core\Math\FFloatRangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< float > Super


code: FFloatRangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FFloatRangeBound ( const float InValue )


className: FFloatRangeBound

code: struct FFloatRangeBound : public [TRangeBound< float >](API\Runtime\Core\Math\TRangeBound)


className: Moniker

code: static const TCHAR *const Moniker = TEXT("/");


code: static const TCHAR *const Moniker = TEXT("/=");


className: FForwardSlashEquals

code: struct FForwardSlashEquals


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) > Difference ( const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & X, const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) > & Ranges )


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) Hull ( const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & X, const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & Y )


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) > & Ranges )


code: static [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) Intersection ( const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & X, const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & Y )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< [FFrameNumber](API\Runtime\Core\Misc\FFrameNumber) > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) > Union ( const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & X, const [FFrameNumberRange](API\Runtime\Core\Math\FFrameNumberRange) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: FFrameNumberRange ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FFrameNumberRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FFrameNumberRange ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FFrameNumberRange ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FFrameNumber](API\Runtime\Core\Misc\FFrameNumber) > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FFrameNumber](API\Runtime\Core\Misc\FFrameNumber) > & InUpperBound )


className: FFrameNumberRange

code: struct FFrameNumberRange : public [TRange< FFrameNumber >](API\Runtime\Core\Math\TRange)


code: static [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) FlipInclusion ( const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & Bound )


code: static const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & MaxLower ( const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & A, const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & B )


code: static const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & MaxUpper ( const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & A, const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & B )


code: static const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & MinLower ( const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & A, const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & B )


code: static const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & MinUpper ( const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & A, const [FFrameNumberRangeBound](API\Runtime\Core\Math\FFrameNumberRangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< [FFrameNumber](API\Runtime\Core\Misc\FFrameNumber) > Super


code: FFrameNumberRangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FFrameNumberRangeBound ( const [FFrameNumber](API\Runtime\Core\Misc\FFrameNumber) InValue )


className: FFrameNumberRangeBound

code: struct FFrameNumberRangeBound : public [TRangeBound< FFrameNumber >](API\Runtime\Core\Math\TRangeBound)


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt16Range](API\Runtime\Core\Math\FInt16Range) > Difference ( const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & X, const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt16Range](API\Runtime\Core\Math\FInt16Range) > & Ranges )


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) Hull ( const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & X, const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & Y )


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) Intersection ( const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & X, const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FInt16Range](API\Runtime\Core\Math\FInt16Range) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< int16 > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt16Range](API\Runtime\Core\Math\FInt16Range) > Union ( const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & X, const [FInt16Range](API\Runtime\Core\Math\FInt16Range) & Y )


code: FInt16Range ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FInt16Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: static [FInt16Range](API\Runtime\Core\Math\FInt16Range) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt16Range](API\Runtime\Core\Math\FInt16Range) > & Ranges )


code: FInt16Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FInt16Range ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int16 > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int16 > & InUpperBound )


code: struct FInt16Range : public [TRange< int16 >](API\Runtime\Core\Math\TRange)


code: static [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) FlipInclusion ( const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & Bound )


code: static [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & MaxLower ( const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & A, const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & B )


code: static const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & MaxUpper ( const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & A, const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & B )


code: static const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & MinLower ( const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & A, const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & B )


code: static const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & MinUpper ( const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & A, const [FInt16RangeBound](API\Runtime\Core\Math\FInt16RangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int16 > Super


code: FInt16RangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FInt16RangeBound ( const int16 InValue )


code: struct FInt16RangeBound : public [TRangeBound< int16 >](API\Runtime\Core\Math\TRangeBound)


code: typedef [TInterval](API\Runtime\Core\Math\TInterval)< int32 > Super


code: FInt32Interval ( const [Super](API\Runtime\Core\Math\TInterval) & Other )


code: FInt32Interval ( int32 InMin, int32 InMax )


code: struct FInt32Interval : public [TInterval< int32 >](API\Runtime\Core\Math\TInterval)


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt32Range](API\Runtime\Core\Math\FInt32Range) > Difference ( const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & X, const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt32Range](API\Runtime\Core\Math\FInt32Range) > & Ranges )


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) Hull ( const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & X, const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & Y )


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt32Range](API\Runtime\Core\Math\FInt32Range) > & Ranges )


code: static [FInt32Range](API\Runtime\Core\Math\FInt32Range) Intersection ( const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & X, const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FInt32Range](API\Runtime\Core\Math\FInt32Range) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< int32 > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt32Range](API\Runtime\Core\Math\FInt32Range) > Union ( const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & X, const [FInt32Range](API\Runtime\Core\Math\FInt32Range) & Y )


code: FInt32Range ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FInt32Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FInt32Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FInt32Range ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int32 > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int32 > & InUpperBound )


code: struct FInt32Range : public [TRange< int32 >](API\Runtime\Core\Math\TRange)


code: static [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) FlipInclusion ( const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & Bound )


code: static [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & MaxLower ( const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & A, const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & B )


code: static const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & MaxUpper ( const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & A, const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & B )


code: static const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & MinLower ( const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & A, const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & B )


code: static const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & MinUpper ( const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & A, const [FInt32RangeBound](API\Runtime\Core\Math\FInt32RangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int32 > Super


code: FInt32RangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FInt32RangeBound ( const int32 InValue )


code: struct FInt32RangeBound : public [TRangeBound< int32 >](API\Runtime\Core\Math\TRangeBound)


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt64Range](API\Runtime\Core\Math\FInt64Range) > Difference ( const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & X, const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) Hull ( const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & X, const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & Y )


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) Intersection ( const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & X, const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & Y )


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt64Range](API\Runtime\Core\Math\FInt64Range) > & Ranges )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FInt64Range](API\Runtime\Core\Math\FInt64Range) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< int64 > Super


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt64Range](API\Runtime\Core\Math\FInt64Range) > Union ( const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & X, const [FInt64Range](API\Runtime\Core\Math\FInt64Range) & Y )


code: static [FInt64Range](API\Runtime\Core\Math\FInt64Range) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt64Range](API\Runtime\Core\Math\FInt64Range) > & Ranges )


code: FInt64Range ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FInt64Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FInt64Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FInt64Range ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int64 > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int64 > & InUpperBound )


code: struct FInt64Range : public [TRange< int64 >](API\Runtime\Core\Math\TRange)


code: static [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) FlipInclusion ( const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & Bound )


code: static [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & MaxLower ( const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & A, const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & B )


code: static const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & MaxUpper ( const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & A, const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & B )


code: static const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & MinLower ( const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & A, const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & B )


code: static const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & MinUpper ( const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & A, const [FInt64RangeBound](API\Runtime\Core\Math\FInt64RangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int64 > Super


code: FInt64RangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


code: FInt64RangeBound ( const int64 InValue )


code: struct FInt64RangeBound : public [TRangeBound< int64 >](API\Runtime\Core\Math\TRangeBound)


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) AtLeast ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) AtMost ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt8Range](API\Runtime\Core\Math\FInt8Range) > Difference ( const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & X, const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) GreaterThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) Hull ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt8Range](API\Runtime\Core\Math\FInt8Range) > & Ranges )


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) Hull ( const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & X, const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & Y )


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) Intersection ( const [TArray](API\Runtime\Core\Containers\TArray)< [FInt8Range](API\Runtime\Core\Math\FInt8Range) > & Ranges )


code: static [FInt8Range](API\Runtime\Core\Math\FInt8Range) Intersection ( const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & X, const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & Y )


code: static [TRange](API\Runtime\Core\Math\TRange) LessThan ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Value )


code: static [TArray](API\Runtime\Core\Containers\TArray)< [FInt8Range](API\Runtime\Core\Math\FInt8Range) > Union ( const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & X, const [FInt8Range](API\Runtime\Core\Math\FInt8Range) & Y )


code: [TArray](API\Runtime\Core\Containers\TArray)< [FInt8Range](API\Runtime\Core\Math\FInt8Range) > Split ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) Element ) const


code: typedef [TRange](API\Runtime\Core\Math\TRange)< int8 > Super


code: FInt8Range ( const [Super](API\Runtime\Core\Math\TRange) & Rhs )


code: FInt8Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A )


code: FInt8Range ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) A, [ElementValueOrConstRef](API\Runtime\Core\Math\TRange\ElementValueOrConstRef) B )


code: FInt8Range ( const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int8 > & InLowerBound, const [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int8 > & InUpperBound )


code: static [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) Exclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: struct FInt8Range : public [TRange< int8 >](API\Runtime\Core\Math\TRange)


code: static [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) FlipInclusion ( const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & Bound )


code: static [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) Inclusive ( [ElementValueOrConstRef](API\Runtime\Core\Math\TRangeBound\ElementValueOrConstRef) Value )


code: static const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & MaxLower ( const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & A, const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & B )


code: static const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & MaxUpper ( const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & A, const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & B )


code: static const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & MinLower ( const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & A, const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & B )


code: static const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & MinUpper ( const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & A, const [FInt8RangeBound](API\Runtime\Core\Math\FInt8RangeBound) & B )


code: typedef [TRangeBound](API\Runtime\Core\Math\TRangeBound)< int8 > Super


code: FInt8RangeBound ( const int8 InValue )


code: struct FInt8RangeBound : public [TRangeBound< int8 >](API\Runtime\Core\Math\TRangeBound)


description:
FInterpCurveinline functions
The index of the new key.

code: int32 AddPoint ( const float InVal, const T & OutVal )


description: Automatically set the tangents on the curve based on surrounding points

code: void AutoSetTangents ( float Tension, bool bStationaryEndpoints )


code: FInt8RangeBound ( const [Super](API\Runtime\Core\Math\TRangeBound) & Other )


description: Calculate the min/max out value that can be returned by this InterpCurve.

code: void CalcBounds ( T & OutMin, T & OutMax, const T & Default ) const


description: Clear loop key for curve

code: void ClearLoopKey()


description: Evaluate the output for an arbitary input value. For inputs outside the range of the keys, the first/last key value is assumed.

code: T Eval ( const float InVal, const T & Default ) const


description: Evaluate the second derivative at a point on the curve.

code: T EvalSecondDerivative ( const float InVal, const T & Default ) const


description: Evaluate the derivative at a point on the curve.

code: T EvalDerivative ( const float InVal, const T & Default ) const


description:
Find the nearest point on spline to the given point.
The key (the 't' parameter) of the nearest point.

code: float FindNearest ( const T & PointInSpace, float & OutDistanceSq ) const


code: float FindNearest ( const T & PointInSpace, float & OutDistanceSq, float & OutSegment ) const


description:
Find the nearest point (to the given point) on segment between Points[PtIdx] and Points[PtIdx+1]
The key (the 't' parameter) of the found point.

code: float FindNearestOnSegment ( const T & PointInSpace, int32 PtIdx, float & OutSquaredDistance ) const


description: Finds the lower index of the two points whose input values bound the supplied input value.

code: int32 GetPointIndexForInputValue ( const float InValue ) const


description: Deprecated* Use FindNearest instead.

code: float InaccurateFindNearest ( const T & PointInSpace, float & OutDistanceSq ) const


description: Deprecated* Use FindNearest instead.

code: float InaccurateFindNearest ( const T & PointInSpace, float & OutDistanceSq, float & OutSegment ) const


description: Deprecated* Use FindNearestOnSegment instead.

code: float InaccurateFindNearestOnSegment ( const T & PointInSpace, int32 PtIdx, float & OutSquaredDistance ) const


description: This may change the index of the keypoint, so the new key index is returned.

code: int32 MovePoint ( int32 PointIndex, float NewInVal )


description: Clears all keypoints from InterpCurve.

code: void Reset()


description: Set loop key for curve

code: void SetLoopKey ( float InLoopKey )


description: Default constructor.

code: FInterpCurve()


className: FInterpCurve

description: FInterpCurvePoint

code: template<class T> class FInterpCurve

bIsLooped

type: bool

description: Specify whether the curve is looped or not

LoopKeyOffset

description: Specify the offset from the last point's input key corresponding to the loop point

Points

type: TArray<FInterp...

description: Holds the collection of interpolation points.


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< float > Super


code: FInterpCurveFloat ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


className: FInterpCurveFloat

code: struct FInterpCurveFloat : public [FInterpCurve< float >](API\Runtime\Core\Math\FInterpCurve)


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< [FLinearColor](API\Runtime\Core\Math\FLinearColor) > Super


code: FInterpCurveLinearColor ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


className: FInterpCurveLinearColor

code: struct FInterpCurveLinearColor : public [FInterpCurve< FLinearColor >](API\Runtime\Core\Math\FInterpCurve)


description: true if the key value is using a curve interp mode, otherwise false

code: bool IsCurveKey() const


description: Default constructor (no initialization).

code: FInterpCurvePoint()


description: Constructor which initializes all components to zero.

code: FInterpCurvePoint ( EForceInit )


description: uses linear interpolationFInterpCurvePointinline functions

code: FInterpCurvePoint ( const float In, const T & Out )


description: Constructor

code: FInterpCurvePoint ( const float In, const T & Out, const T & InArriveTangent, const T & InLeaveTangent, const EInterpCurveMode InInterpMode )


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< FQuat > Super


className: FInterpCurvePoint

description: FInterpCurve

code: template<class T> class FInterpCurvePoint

ArriveTangent

type: T

description: Tangent of curve arrive this point.

InterpMode

type: TEnumAsByte< EI...

description: Interpolation mode between this point and the next one.

InVal

description: Float input value that corresponds to this key (eg. time).

LeaveTangent

description: Tangent of curve leaving this point.

OutVal

description: Output value of templated type when input is equal to InVal.


code: FInterpCurveQuat ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


className: FInterpCurveQuat

code: struct FInterpCurveQuat : public [FInterpCurve< FQuat >](API\Runtime\Core\Math\FInterpCurve)


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< [FTwoVectors](API\Runtime\Core\Math\FTwoVectors) > Super


code: FInterpCurveTwoVectors ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


className: FInterpCurveTwoVectors

code: struct FInterpCurveTwoVectors : public [FInterpCurve< FTwoVectors >](API\Runtime\Core\Math\FInterpCurve)


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< FVector > Super


code: FInterpCurveVector ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


className: FInterpCurveVector

code: struct FInterpCurveVector : public [FInterpCurve< FVector >](API\Runtime\Core\Math\FInterpCurve)


code: typedef [FInterpCurve](API\Runtime\Core\Math\FInterpCurve)< FVector2D > Super


code: FInterpCurveVector2D ( const [Super](API\Runtime\Core\Math\FInterpCurve) & Other )


code: struct FInterpCurveVector2D : public [FInterpCurve< FVector2D >](API\Runtime\Core\Math\FInterpCurve)


className: Black

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Black;


className: Blue

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Blue;


description:
Helper for pixel format conversions. Clamps to [0,1], mapping NaNs to 0, for consistency with GPU conversions.
InValue clamped to [0,1]. NaNs map to 0.

code: static float Clamp01NansTo0 ( float InValue )


code: const float & Component ( int32 Index ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) CopyWithNewOpacity ( float NewOpacicty ) const


description:
Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation
Desaturated color

code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) Desaturate ( float Desaturation ) const


description: Euclidean distance between two points.

code: static float Dist ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & V1, const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & V2 )


description: Error-tolerant comparison.

code: bool Equals ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB, float Tolerance ) const


description:
Generates a list of sample points on a Bezier curve defined by 2 points.
Path length.

code: static float EvaluateBezier ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) * ControlPoints, int32 NumPoints, [TArray](API\Runtime\Core\Containers\TArray)< [FLinearColor](API\Runtime\Core\Math\FLinearColor) > & OutPoints )


description: Old version of MakeFromHSV8, formula is not correct

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) FGetHSV ( uint8 H, uint8 S, uint8 V )


description: Converts anFColorcoming from an observed Pow(1/2.2) output, into a linear color.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) FromPow22Color ( const [FColor](API\Runtime\Core\Math\FColor) & Color )


description: Converts anFColorcoming from an observed sRGB output, into a linear color.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) FromSRGBColor ( const [FColor](API\Runtime\Core\Math\FColor) & Color )


description: Clamped in 0..1 range

code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) GetClamped ( float InMin, float InMax ) const


description: Computes the perceptually weighted luminance value of a color.

code: float GetLuminance() const


description:
Returns the maximum value in this color structure
The maximum color channel value

code: float GetMax() const


description:
Returns the minimum value in this color structure
The minimum color channel value

code: float GetMin() const


className: Gray

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Gray;


className: Green

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Green;


description: Converts an HSV color to a linear space RGB color


description:
Initialize this Color based on anFString. The String is expected to contain R=, G=, B=, A=. TheFLinearColorwill be bogus when InitFromString returns false.
true if the R,G,B values were read successfully; false otherwise.

code: bool InitFromString ( const [FString](API\Runtime\Core\Containers\FString) & InSourceString )


description: Useful to detect if a light contribution needs to be rendered

code: bool IsAlmostBlack() const


description:
Linearly interpolates between two colors by the specified progress amount. The interpolation is performed in HSV color space taking the shortest path to the new color's hue. This can give better results thanFMath::Lerp(), but is much more expensive. The incoming colors are in RGB space, and the output color will be RGB. The alpha value will also be interpolated.
The interpolated color in linear RGB space along with the interpolated alpha value

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) LerpUsingHSV ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & From, const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & To, const float Progress )


description: Converts a linear space RGB color to an HSV color


description: Converts temperature in Kelvins of a black body radiator to RGB chromaticity.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) MakeFromColorTemperature ( float Temp )


description: Converts byte hue-saturation-brightness to floating point red-green-blue.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) MakeFromHSV8 ( uint8 H, uint8 S, uint8 V )


description: Makes a random but quite nice color.


description: Makes a random color based on a seed.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) MakeRandomSeededColor ( int32 Seed )


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator+ ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator+= ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB )


description: Comparison operators

code: bool operator== ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB ) const


code: bool operator!= ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Other ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator/ ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator/ ( float Scalar ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator/= ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB )


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator/= ( float Scalar )


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator* ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator* ( float Scalar ) const


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator*= ( float Scalar )


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator-= ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB )


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) operator- ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB ) const


description: FMath::Pow( i / 255.f, 2.2f )

code: static float Pow22OneOver255Table;


description: Backwards compatible Quantize function name, does QuantizeFloor.


description: Quantizes the linear color and returns the result as aFColor. This bypasses the SRGB conversion. Uses floor quantization, which does not match the GPU standard conversion. Restoration to float should be done with a +0.5 bias to restore to centered buckets. Do NOT use this for graphics or textures or images, use QuantizeRound instead.


description: Quantizes the linear color with rounding and returns the result as aFColor. This bypasses the SRGB conversion. QuantizeRound can be dequantized back to linear withFColor::ReinterpretAsLinear(just /255.f) this matches the GPU UNORM<->float conversion spec and should be preferred


className: Red

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Red;


code: [FLinearColor](API\Runtime\Core\Math\FLinearColor) & operator*= ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & ColorB )


code: bool Serialize ( [FStructuredArchive::FSlot](API\Runtime\Core\Serialization\FStructuredArchive\FSlot) Slot )


code: [FColor](API\Runtime\Core\Math\FColor) ToFColor ( const bool bSRGB ) const


className: sRGBToLinearTable

code: static float sRGBToLinearTable;


description: Quantizes the linear color and returns the result as aFColorwith optional sRGB conversion and quality as goal.


description: Converts from a linear float color to RGBE as outlined in Gregory Ward's Real Pixels article, Graphics Gems II, page 80. Implementation details inhttps://cbloomrants.blogspot.com/2020/06/widespread-error-in-radiance-hdr-rgbe.html


className: Transparent

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Transparent;


className: White

description: Common colors.

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) White;


className: Yellow

code: static const [FLinearColor](API\Runtime\Core\Math\FLinearColor) Yellow;


description: Converts anFColorwhich is assumed to be in sRGB space, into linear color space.

code: constexpr FLinearColor ( const [FColor](API\Runtime\Core\Math\FColor) & Color )


code: FLinearColor ( const FVector3f & Vector )


code: FLinearColor ( const FVector3d & Vector )


code: FLinearColor ( const FVector4f & Vector )


code: FLinearColor ( const FVector4d & Vector )


description: Use Float16Color::GetFloats() directly

code: FLinearColor ( const [FFloat16Color](API\Runtime\Core\Math\FFloat16Color) & C )


code: constexpr FLinearColor ( float InR, float InG, float InB, float InA )


className: FLinearColor

description: A linear, 32-bit/component floating point RGBA color.

code: struct FLinearColor

type: union FLinearCo...


description: Handy to apply scaling in the editor

code: static void ApplyScaleToFloat ( float & Dst, const FVector & DeltaScale, float Magnitude )


description: Performs a 2D linear interpolation between four values values, FracX, FracY ranges from 0-1

code: template<typename T, typename U UE_REQUIRES> static constexpr T BiLerp ( const T & P00, const T & P10, const T & P01, const T & P11, const U & FracX, const U & FracY )


description: Custom lerps defined for those classes not suited to the default implemenation.

code: template<typename T, typename U UE_REQUIRES> static T BiLerp ( const T & P00, const T & P10, const T & P01, const T & P11, const U & FracX, const U & FracY )


className: BitFlag

description: 32 bit values where BitFlag[x] == (1<


description: Converts given Cartesian coordinate pair to Polar coordinate system.

code: template<typename T> static void CartesianToPolar ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > InCart, [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & OutPolar )


code: template<typename T> static void CartesianToPolar ( const T X, const T Y, T & OutRad, T & OutAng )


description: Interpolate Linear Color from Current to Target. Scaled by distance to Target, so it has a strong start speed and ease out.

code: static [FLinearColor](API\Runtime\Core\Math\FLinearColor) CInterpTo ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Current, const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Target, float DeltaTime, float InterpSpeed )


description: Clamps X to be between Min and Max, inclusive

code: template<class T> static constexpr T Clamp ( const T X, const T MinValue, const T MaxValue )


description: Allow mixing float/double arguments, promoting to highest precision type.

code: template<typename Arg1, typename Arg2, typename Arg3 UE_REQUIRES> static auto Clamp ( Arg1 X, Arg2 Y, Arg3 Z )


description: Clamps X to be between Min and Max, inclusive. Explicitly defined here for floats/doubles because static analysis gets confused between template and int versions.

code: static constexpr float Clamp ( const float X, const float Min, const float Max )


code: static constexpr double Clamp ( const double X, const double Min, const double Max )


description: Clamps X to be between Min and Max, inclusive. Overload to support mixed int64/int32 types.

code: static constexpr int64 Clamp ( const int64 X, const int32 Min, const int32 Max )


description:
Clamps an arbitrary angle to be between the given angles. Will clamp to nearest boundary.
Returns clamped angle in the range -180..180.

code: template<typename T> static T ClampAngle ( T AngleDegrees, T MinAngleDegrees, T MaxAngleDegrees )


code: template<typename Arg1, typename Arg2, typename Arg3 UE_REQUIRES> static auto ClampAngle ( Arg1 X, Arg2 Y, Arg3 Z )


description: Find the point on the infinite line between two points (LineStart, LineEnd) which is closest to Point

code: static FVector ClosestPointOnInfiniteLine ( const FVector & LineStart, const FVector & LineEnd, const FVector & Point )


description:
Returns closest point on a segment to a given point. The idea is to project point on line formed by segment. Then we see if the closest point on the line is outside of segment or inside.
point on the segment defined by (StartPoint, EndPoint) that is closest to Point.

code: static FVector ClosestPointOnSegment ( const FVector & Point, const FVector & StartPoint, const FVector & EndPoint )


description: Find the point on the line segment from LineStart to LineEnd which is closest to Point

code: static FVector ClosestPointOnLine ( const FVector & LineStart, const FVector & LineEnd, const FVector & Point )


description:
FVector2D version of ClosestPointOnSegment. Returns closest point on a segment to a given 2D point. The idea is to project point on line formed by segment. Then we see if the closest point on the line is outside of segment or inside.
point on the segment defined by (StartPoint, EndPoint) that is closest to Point.

code: static FVector2D ClosestPointOnSegment2D ( const FVector2D & Point, const FVector2D & StartPoint, const FVector2D & EndPoint )


description:
Returns closest point on a tetrahedron to a point. The idea is to identify the halfplanes that the point is in relative to each face of the tetrahedron
Point on tetrahedron ABCD closest to given point

code: static FVector ClosestPointOnTetrahedronToPoint ( const FVector & Point, const FVector & A, const FVector & B, const FVector & C, const FVector & D )


description:
Returns closest point on a triangle to a point. The idea is to identify the halfplanes that the point is in relative to each triangle segment "plane"
Point on triangle ABC closest to given point

code: static FVector ClosestPointOnTriangleToPoint ( const FVector & Point, const FVector & A, const FVector & B, const FVector & C )


description:
Computes the barycentric coordinates for a given point in a triangle
Vector containing the three weights a,b,c such that Point = a*A + b*B + c*C or Point = A + b*(B-A) + c*(C-A) = (1-b-c)*A + b*B + c*C

code: static FVector ComputeBaryCentric2D ( const FVector & Point, const FVector & A, const FVector & B, const FVector & C )


description:
Computes the barycentric coordinates for a given point on a tetrahedron (3D)
Vector containing the four weights a,b,c,d such that Point = a*A + b*B + c*C + d*D

code: static FVector4 ComputeBaryCentric3D ( const FVector & Point, const FVector & A, const FVector & B, const FVector & C, const FVector & D )


description:
FMathinline functions Computes minimal bounding sphere encompassing given cone
Minimal bounding sphere encompassing given cone

code: template<typename FReal> static [UE::Math::TSphere](API\Runtime\Core\Math\TSphere)< FReal > ComputeBoundingSphereForCone ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > const & ConeOrigin, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > const & ConeDirection, FReal ConeRadius, FReal CosConeAngle, FReal SinConeAngle )


description:
InOutScissorRect should be set to View.ViewRect before the call
0: light is not visible, 1:use scissor rect, 2: no scissor rect needed

code: static uint32 ComputeProjectedSphereScissorRect ( FIntRect & InOutScissorRect, FVector SphereOrigin, float Radius, FVector ViewOrigin, const FMatrix & ViewMatrix, const FMatrix & ProjMatrix )


description: When starting from zero velocity, the maximum velocity is reached after time InSmoothingTime * 0.5

code: template<class T> static constexpr void CriticallyDampedSmoothing ( T & InOutValue, T & InOutValueRate, const T & InTargetValue, const T & InTargetValueRate, const float InDeltaTime, const float InSmoothingTime )


description: Cubes the value

code: template<class T> static constexpr T Cube ( const T A )


description: Cubic Catmull-Rom Spline interpolation. Based onhttp://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdfCurves are guaranteed to pass through the control points and are easily chained together. Equation supports abitrary parameterization. eg. Uniform=0,1,2,3 ; chordal= |Pn - Pn-1| ; centripetal = |Pn - Pn-1|^0.5 P0 - The control point preceding the interpolation range. P1 - The control point starting the interpolation range. P2 - The control point ending the interpolation range. P3 - The control point following the interpolation range. T0-3 - The interpolation parameters for the corresponding control points. T - The interpolation factor in the range 0 to 1. 0 returns P1. 1 returns P2.

code: template<class U> static constexpr U CubicCRSplineInterp ( const U & P0, const U & P1, const U & P2, const U & P3, const float T0, const float T1, const float T2, const float T3, const float T )


description: Same as CubicCRSplineInterp but with additional saftey checks. If the checks fail P1 is returned.

code: template<class U> static constexpr U CubicCRSplineInterpSafe ( const U & P0, const U & P1, const U & P2, const U & P3, const float T0, const float T1, const float T2, const float T3, const float T )


description:
Performs a cubic interpolation
Interpolated value

code: template<typename T, typename U UE_REQUIRES> static constexpr T CubicInterp ( const T & P0, const T & T0, const T & P1, const T & T1, const U & A )


description: Custom lerps defined for those classes not suited to the default implemenation.

code: template<typename T, typename U UE_REQUIRES> static T CubicInterp ( const T & P0, const T & T0, const T & P1, const T & T1, const U & A )


description:
Performs a first derivative cubic interpolation
Interpolated value

code: template<typename T, typename U UE_REQUIRES> static constexpr T CubicInterpDerivative ( const T & P0, const T & T0, const T & P1, const T & T1, const U & A )


description:
Performs a second derivative cubic interpolation
Interpolated value

code: template<typename T, typename U UE_REQUIRES> static constexpr T CubicInterpSecondDerivative ( const T & P0, const T & T0, const T & P1, const T & T1, const U & A )


code: static constexpr float DegreesToRadians ( float const & DegVal )


description:
Converts degrees to radians.
Value in radians.

code: template<class T> static constexpr auto DegreesToRadians ( T const & DegVal )


code: static constexpr double DegreesToRadians ( double const & DegVal )


description: Divides two integers and rounds down

code: template<class T> static constexpr T DivideAndRoundDown ( T Dividend, T Divisor )


description: Divides two integers and rounds to nearest

code: template<class T> static constexpr T DivideAndRoundNearest ( T Dividend, T Divisor )


description: Divides two integers and rounds up

code: template<class T> static constexpr T DivideAndRoundUp ( T Dividend, T Divisor )


description:
Calculates the new value in a weighted moving average series using the previous value and a weight range. The weight range is used to dynamically adjust based upon distance between the samples This allows you to smooth a value more aggressively for small noise and let large movements be smoothed less (or vice versa)
the next value in the series

code: template<typename T> static T DynamicWeightedMovingAverage ( T CurrentSample, T PreviousSample, T MaxDistance, T MinWeight, T MaxWeight )


description:
Operators and precedence: 1:+- 2:/% 3:* 4:^ 5:&| Unary: - Types: Numbers (0-9.), Hex ($0-$f) Grouping: ( )
1 if successful, 0 if equation fails.

code: static bool Eval ( [FString](API\Runtime\Core\Containers\FString) Str, float & OutValue )


description: An approximation is used that is accurate so long as InDeltaTime < 0.5 * InSmoothingTime

code: template<class T> static constexpr void ExponentialSmoothingApprox ( T & InOutValue, const T & InTargetValue, const float InDeltaTime, const float InSmoothingTime )


description: Get a bit in memory created from bitflags (uint32 Value:1), used for EngineShowFlags, TestBitFieldFunctions() tests the implementation

code: static constexpr bool ExtractBoolFromBitfield ( const uint8 * Ptr, uint32 Index )


description:
Computes the ASin of a scalar value.
ASin of Value

code: static float FastAsin ( float Value )


code: static double FastAsin ( double Value )


description: Find the smallest angle between two headings (in degrees)

code: template<typename T, typename T2 UE_REQUIRES> static constexpr auto FindDeltaAngleDegrees ( T A1, T2 A2 )


description: Find the smallest angle between two headings (in radians)

code: template<typename T, typename T2 UE_REQUIRES> static constexpr auto FindDeltaAngleRadians ( T A1, T2 A2 )


description: Interpolate float from Current to Target with constant step

code: template<typename T1, typename T2, typename T3, typename T4> static auto FInterpConstantTo ( T1 Current, T2 Target, T3 DeltaTime, T4 InterpSpeed )


description: Interpolate float from Current to Target. Scaled by distance to Target, so it has a strong start speed and ease out.

code: template<typename T1, typename T2, typename T3, typename T4> static auto FInterpTo ( T1 Current, T2 Target, T3 DeltaTime, T4 InterpSpeed )


description:
Returns a new rotation component value
a new rotation component value

code: static float FixedTurn ( float InCurrent, float InDesired, float InDeltaRate )


description: Converts a float to a nearest less or equal integer.

code: static float Floor ( float F )


description: Converts a double to a nearest less or equal integer.

code: static double Floor ( double F )


description: Converts an integral type to a nearest less or equal integer. Unlike std::floor, it returns an IntegralType.

code: template<typename IntegralType UE_REQUIRES> static constexpr IntegralType Floor ( IntegralType I )


description: Formats an integer value into a human readable string (i.e. 12345 becomes "12,345")FStringThe human readable string

code: static [FString](API\Runtime\Core\Containers\FString) FormatIntToHumanReadable ( int32 Val )


description: Util to generate a random number in a range.

code: static float FRandRange ( float InMin, float InMax )


code: static double FRandRange ( double InMin, double InMax )


code: template<typename Arg1, typename Arg2 UE_REQUIRES> static auto FRandRange ( Arg1 X, Arg2 Y )


description: Orientation: (consider 'O' the first person view of the player, and 'Direction' a vector pointing to an enemy)

code: static FVector2D GetAzimuthAndElevation ( const FVector & Direction, const FVector & AxisX, const FVector & AxisY, const FVector & AxisZ )


description:
Computes the barycentric coordinates for a given point in a triangle, only considering the XY coordinates - simpler than the Compute versions
Vector containing the three weights a,b,c such that Point = a*A + b*B + c*C or Point = A + b*(B-A) + c*(C-A) = (1-b-c)*A + b*B + c*C

code: static FVector GetBaryCentric2D ( const FVector & Point, const FVector & A, const FVector & B, const FVector & C )


description:
Computes the barycentric coordinates for a given point in a triangle - simpler than the Compute versions
Vector containing the three weights a,b,c such that Point = a*A + b*B + c*C or Point = A + b*(B-A) + c*(C-A) = (1-b-c)*A + b*B + c*C

code: static FVector GetBaryCentric2D ( const FVector2D & Point, const FVector2D & A, const FVector2D & B, const FVector2D & C )


description:
Calculates whether a Point is within a cone segment, and also what percentage within the cone (100% is along the center line, whereas 0% is along the edge)
true if the point is within the cone, false otherwise.

code: static bool GetDistanceWithinConeSegment ( FVector Point, FVector ConeStartPoint, FVector ConeLine, float RadiusAtStart, float RadiusAtEnd, float & PercentageOut )


description:
: 'Azimuth' (.X) sign is changed to represent left/right and not front/behind. front/behind is the funtion's return value.
true if 'Direction' is facing AxisX (Direction dot AxisX >= 0.f)

code: static bool GetDotDistance ( FVector2D & OutDotDist, const FVector & Direction, const FVector & AxisX, const FVector & AxisY, const FVector & AxisZ )


description: For the given Value clamped to the [Input:Range] inclusive, returns the corresponding percentage in [Output:Range] Inclusive.

code: template<typename T, typename T2> static auto GetMappedRangeValueClamped ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & InputRange, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & OutputRange, const T2 Value )


code: template<class T> static T GetMappedRangeValueClamped ( const [TRange](API\Runtime\Core\Math\TRange)< T > & InputRange, const [TRange](API\Runtime\Core\Math\TRange)< T > & OutputRange, const T Value )


description: Transform the given Value relative to the input range to the Output Range.

code: template<typename T, typename T2> static auto GetMappedRangeValueUnclamped ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & InputRange, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & OutputRange, const T2 Value )


description: Same as above, but taking a 2d vector as the range.

code: template<typename T, typename T2 UE_REQUIRES> static auto GetRangePct ( [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > const & Range, T2 Value )


code: template<class T> static double GetRangePct ( [TRange](API\Runtime\Core\Math\TRange)< T > const & Range, T Value )


description: Calculates the percentage along a line from MinValue to MaxValue that Value is.

code: template<typename T, typename T2 UE_REQUIRES> static constexpr auto GetRangePct ( T MinValue, T MaxValue, T2 Value )


description: Basically a Vector2d version of Lerp.

code: template<typename T, typename T2 UE_REQUIRES> static auto GetRangeValue ( [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > const & Range, T2 Pct )


code: template<class T> static T GetRangeValue ( [TRange](API\Runtime\Core\Math\TRange)< T > const & Range, T Pct )


description:
Given a direction vector and a surface normal, returns the vector reflected across the surface normal. Produces a result like shining a laser at a mirror!
Reflected vector.

code: static FVector GetReflectionVector ( const FVector & Direction, const FVector & SurfaceNormal )


code: static float GetTForSegmentPlaneIntersect ( const FVector & StartPoint, const FVector & EndPoint, const FPlane & Plane )


description: Use the Euclidean method to find the GCD.

code: static constexpr int32 GreatestCommonDivisor ( int32 a, int32 b )


description: Snaps a value to the nearest grid multiple

code: template<class T> static constexpr T GridSnap ( T Location, T Grid )


description: Allow mixing float/double arguments, promoting to highest precision type.

code: template<typename Arg1, typename Arg2 UE_REQUIRES> static auto GridSnap ( Arg1 X, Arg2 Y )


description: Interpolation between A and B, applying a circular in function.

code: template<class T> static T InterpCircularIn ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying a circular in/out function.

code: template<class T> static T InterpCircularInOut ( const T & A, const T & B, float Alpha )


description: Interpolate between A and B, applying an ease in/out function. Exp controls the degree of the curve.

code: template<class T> static T InterpEaseInOut ( const T & A, const T & B, float Alpha, float Exp )


description: Interpolation between A and B, applying a circular out function.

code: template<class T> static T InterpCircularOut ( const T & A, const T & B, float Alpha )


description: Interpolate between A and B, applying an ease in function. Exp controls the degree of the curve.

code: template<class T> static T InterpEaseIn ( const T & A, const T & B, float Alpha, float Exp )


description: Interpolation between A and B, applying an exponential in function.

code: template<class T> static T InterpExpoIn ( const T & A, const T & B, float Alpha )


description: Interpolate between A and B, applying an ease out function. Exp controls the degree of the curve.

code: template<class T> static T InterpEaseOut ( const T & A, const T & B, float Alpha, float Exp )


description: Interpolation between A and B, applying an exponential in/out function.

code: template<class T> static T InterpExpoInOut ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying an exponential out function.

code: template<class T> static T InterpExpoOut ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying a sinusoidal in function.

code: template<class T> static T InterpSinIn ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying a sinusoidal out function.

code: template<class T> static T InterpSinOut ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying a sinusoidal in/out function.

code: template<class T> static T InterpSinInOut ( const T & A, const T & B, float Alpha )


description: Interpolation between A and B, applying a step function.

code: template<class T> static constexpr T InterpStep ( const T & A, const T & B, float Alpha, int32 Steps )


description: Compute intersection point and direction of line joining two planes. Return 1 if valid, 0 if infinite.

code: template<typename FReal> static bool IntersectPlanes2 ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & I, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & D, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & P1, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & P2 )


description: Compute intersection point of three planes. Return 1 if valid, 0 if infinite.

code: template<typename FReal> static bool IntersectPlanes3 ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & I, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & P1, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & P2, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & P3 )


code: template<typename Arg1, typename Arg2 UE_REQUIRES> static bool IsNearlyEqual ( Arg1 X, Arg2 Y )


code: template<class T> static constexpr T InvExpApprox ( T X )


code: static bool IsNearlyEqual ( double A, double B, double ErrorTolerance )


code: template<typename Arg1, typename Arg2, typename Arg3 UE_REQUIRES> static bool IsNearlyEqual ( Arg1 X, Arg2 Y, Arg3 Z )


description:
Note: Since IEEE 754 floating point operations are guaranteed to be exact to 0.5 ULP, a value of 4 ought to be sufficient for all but the most complex float operations.
true if the two values are nearly equal.

code: static bool IsNearlyEqualByULP ( float A, float B, int32 MaxUlps )


code: static bool IsNearlyEqualByULP ( double A, double B, int32 MaxUlps )


description:
Checks if a floating point number is nearly zero.
true if Value is nearly zero

code: static bool IsNearlyZero ( float Value, float ErrorTolerance )


code: static bool IsNearlyZero ( double Value, double ErrorTolerance )


description:
Checks if two floating point numbers are nearly equal.
true if A and B are nearly equal

code: static bool IsNearlyEqual ( float A, float B, float ErrorTolerance )


code: template<typename Arg1, typename Arg2 UE_REQUIRES> static bool IsNearlyZero ( Arg1 X, Arg2 Y )


description:
Checks whether a number is a power of two.
true if Value is a power of two

code: template<typename T> static constexpr bool IsPowerOfTwo ( T Value )


description: Checks if value is within a range, exclusive on MaxValue)

code: template<class T, class U> static constexpr bool IsWithin ( const T & TestValue, const U & MinValue, const U & MaxValue )


description: Checks if value is within a range, inclusive on MaxValue)

code: template<class T, class U> static constexpr bool IsWithinInclusive ( const T & TestValue, const U & MinValue, const U & MaxValue )


description: LCM = a/gcd * b a and b are the number we want to find the lcm

code: static constexpr int32 LeastCommonMultiplier ( int32 a, int32 b )


description: Performs a linear interpolation between two values, Alpha ranges from 0-1

code: template<typename T, typename U UE_REQUIRES> static constexpr T Lerp ( const T & A, const T & B, const U & Alpha )


description: Custom lerps defined for those classes not suited to the default implemenation.

code: template<typename T, typename U UE_REQUIRES> static T Lerp ( const T & A, const T & B, const U & Alpha )


description: Allow passing of differing A/B types.

code: template<typename T1, typename T2, typename T3 UE_REQUIRES> static auto Lerp ( const T1 & A, const T2 & B, const T3 & Alpha )


description: Rotator specific interpolation Similar to Lerp, but does not take the shortest path. Allows interpolation over more than 180 degrees.

code: template<typename T, typename U> static [UE::Math::TRotator](API\Runtime\Core\Math\TRotator)< T > LerpRange ( const [UE::Math::TRotator](API\Runtime\Core\Math\TRotator)< T > & A, const [UE::Math::TRotator](API\Runtime\Core\Math\TRotator)< T > & B, U Alpha )


description: Performs a linear interpolation between two values, Alpha ranges from 0-1. Handles full numeric range of T

code: template<class T> static constexpr T LerpStable ( const T & A, const T & B, double Alpha )


code: template<class T> static constexpr T LerpStable ( const T & A, const T & B, float Alpha )


description: Allow passing of differing A/B types.

code: template<typename T1, typename T2, typename T3 UE_REQUIRES> static auto LerpStable ( const T1 & A, const T2 & B, const T3 & Alpha )


description: Determines whether a line intersects a box. This overload avoids the need to do the reciprocal every time.

code: template<typename FReal> static bool LineBoxIntersection ( const [UE::Math::TBox](API\Runtime\Core\Math\TBox)< FReal > & Box, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Start, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & End, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Direction, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & OneOverDirection )


description: Determines whether a line intersects a box.

code: template<typename FReal> static bool LineBoxIntersection ( const [UE::Math::TBox](API\Runtime\Core\Math\TBox)< FReal > & Box, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Start, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & End, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Direction )


description: Swept-Box vs Box test

code: static bool LineExtentBoxIntersection ( const FBox & inBox, const FVector & Start, const FVector & End, const FVector & Extent, FVector & HitLocation, FVector & HitNormal, float & HitTime )


description:
Find the intersection of a line and a plane. Assumes that the line and plane do indeed intersect; you must make sure they're not parallel before calling.
The point of intersection between the line and the plane.

code: template<typename FReal> static [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > LinePlaneIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Point1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Point2, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< FReal > & Plane )


code: template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > LinePlaneIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Point1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Point2, const [UE::Math::TPlane](API\Runtime\Core\Math\TPlane)< T > & Plane )


description:
Find the intersection of a line and an offset plane. Assumes that the line and plane do indeed intersect; you must make sure they're not parallel before calling.
The point of intersection between the line and the plane.

code: template<typename FReal> static [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > LinePlaneIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Point1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Point2, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & PlaneOrigin, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & PlaneNormal )


description: FMathinline functions

code: template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > LinePlaneIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Point1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Point2, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & PlaneOrigin, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & PlaneNormal )


description: Determines whether a line intersects a sphere.

code: template<typename FReal> static bool LineSphereIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Start, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Dir, FReal Length, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Origin, FReal Radius )


description:
Computes the base 2 logarithm of the specified value
the base 2 log of the value

code: static float Log2 ( float Value )


code: static double Log2 ( double Value )


description:
Simple function to create a pulsating scalar value
Pulsating value (0.0-1.0)

code: static float MakePulsatingValue ( const double InCurrentTime, const float InPulsesPerSecond, const float InPhase )


description:
Do not call this directly, use VectorMatrixInverse or Matrix::Inverse this is the fallback scalar implementation used by VectorMatrixInverse
bool returns false if matrix is not invertable and stores identity

code: static bool MatrixInverse ( FMatrix44f * DstMatrix, const FMatrix44f * SrcMatrix )


description:
Src == Dst is allowed
bool returns false if matrix is not invertable and stores identity

code: static bool MatrixInverse ( FMatrix44d * DstMatrix, const FMatrix44d * SrcMatrix )


description: Returns highest of 3 values

code: template<class T> static constexpr T Max3 ( const T A, const T B, const T C )


code: template<class T> static constexpr int32 Max3Index ( const T A, const T B, const T C )


description:
Tests a memory region to see that it's working properly.
true if the memory region passed the test

code: static bool MemoryTest ( void * BaseAddress, uint32 NumBytes )


description:
Generates a 1D Perlin noise from the given value. Returns a continuous random value between -1.0 and 1.0.
Perlin noise in the range of -1.0 to 1.0

code: static float PerlinNoise1D ( float Value )


description: Returns index of the lowest value

code: template<class T> static constexpr int32 Min3Index ( const T A, const T B, const T C )


description: Returns lowest of 3 values

code: template<class T> static constexpr T Min3 ( const T A, const T B, const T C )


description:
Generates a 2D Perlin noise sample at the given location. Returns a continuous random value between -1.0 and 1.0.
Perlin noise in the range of -1.0 to 1.0

code: static float PerlinNoise2D ( const FVector2D & Location )


description:
Determine if a plane and an AABB intersect
if collision occurs

code: static bool PlaneAABBIntersection ( const FPlane & P, const FBox & AABB )


description:
Generates a 3D Perlin noise sample at the given location. Returns a continuous random value between -1.0 and 1.0.
Perlin noise in the range of -1.0 to 1.0

code: static float PerlinNoise3D ( const FVector & Location )


description:
Determine the position of an AABB relative to a plane: completely above (in the direction of the normal of the plane), completely below or intersects it
-1 if below, 1 if above, 0 if intersects

code: static int32 PlaneAABBRelativePosition ( const FPlane & P, const FBox & AABB )


description: FMathinline functions

code: template<typename FReal> static bool PointBoxIntersection ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< FReal > & Point, const [UE::Math::TBox](API\Runtime\Core\Math\TBox)< FReal > & Box )


description:
Calculates the distance of a given Point in world space to a given line, defined by the vector couple (Origin, Direction).
distance of Point from line defined by (Origin, Direction)

code: static float PointDistToLine ( const FVector & Point, const FVector & Direction, const FVector & Origin )


code: static float PointDistToLine ( const FVector & Point, const FVector & Direction, const FVector & Origin, FVector & OutClosestPoint )


description:
Returns distance from a point to the closest point on a segment.
closest distance from Point to segment defined by (StartPoint, EndPoint).

code: static float PointDistToSegment ( const FVector & Point, const FVector & StartPoint, const FVector & EndPoint )


description:
Returns square of the distance from a point to the closest point on a segment.
square of the closest distance from Point to segment defined by (StartPoint, EndPoint).

code: static float PointDistToSegmentSquared ( const FVector & Point, const FVector & StartPoint, const FVector & EndPoint )


description:
Determines whether a given set of points are coplanar, with a tolerance. Any three points or less are always coplanar.
Whether the points are relatively coplanar, based on the tolerance

code: static bool PointsAreCoplanar ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & Points, const float Tolerance )