1. Epic GamesDeveloper
  3. UKismetMathLibrary

UKismetMathLibrary

API > API/Runtime > API/Runtime/Engine > API/Runtime/Engine/Kismet

Inheritance Hierarchy

References

   
Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Kismet/KismetMathLibrary.h
Include #include "Kismet/KismetMathLibrary.h"

Syntax

class UKismetMathLibrary : public UBlueprintFunctionLibrary

Variables

  Type Name Description
Public variable   DeprecationMessage  

Constructors

  Type Name Description
Public function  

UKismetMathLibrary ( const FObjectInitializer& ObjectInitializer
)

  

Functions

  Type Name Description
Public function Static double

Abs ( double A
)

 Returns the absolute (positive) value of A
Public function Static int32

Abs_Int ( int32 A
)

 Returns the absolute (positive) value of A
Public function Static int64

Abs_Int64 ( int64 A
)

 Returns the absolute (positive) value of A
Public function Static double

Acos ( double A
)

 Returns the inverse cosine (arccos) of A (result is in Radians)
Public function Static uint8

Add_ByteByte ( uint8 A,
uint8 B
)

 Addition (A + B)
Public function Static FDateTime Addition (A + B)
Public function Static FDateTime Addition (A + B)DateTime functions
Public function Static double

Add_DoubleDouble ( double A,
double B
)

 Addition (A + B)
Public function Static int64

Add_Int64Int64 ( int64 A,
int64 B
)

 Addition (A + B)
Public function Static int32

Add_IntInt ( int32 A,
int32 B
)

 Addition (A + B)
Public function Static FIntPoint

Add_IntPointInt ( FIntPoint A,
int32 B
)

 Addition (A - B)
Public function Static FIntPoint

Add_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns IntPoint A added by B
Public function Static FLinearColor Element-wise addition of two linear colors (R+R, G+G, B+B, A+A)
Public function Static FMatrix

Add_MatrixMatrix ( const FMatrix& A,
const FMatrix& B
)

 Gets the result of adding a matrix to this.
Public function Static FQuat

Add_QuatQuat ( const FQuat& A,
const FQuat& B
)

 Returns addition of Vector A and Vector B (A + B)
Public function Static FTimespan Addition (A + B)Timespan functions
Public function Static FVector2D

Add_Vector2DFloat ( FVector2D A,
double B
)

 Returns Vector A added by B
Public function Static FVector2D

Add_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Returns addition of Vector A and Vector B (A + B)
Public function Static FVector4

Add_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Returns addition of Vector A and Vector B (A + B)
Public function Static FVector

Add_VectorFloat ( FVector A,
double B
)

 Adds a float to each component of a vector
Public function Static FVector

Add_VectorInt ( FVector A,
int32 B
)

 Adds an integer to each component of a vector
Public function Static FVector

Add_VectorVector ( FVector A,
FVector B
)

 Vector addition
Public function Static int64

And_Int64Int64 ( int64 A,
int64 B
)

 Bitwise AND (A & B)
Public function Static int32

And_IntInt ( int32 A,
int32 B
)

 Bitwise AND (A & B)
Public function Static double

Asin ( double A
)

 Returns the inverse sine (arcsin) of A (result is in Radians)
Public function Static double

Atan ( double A
)

 Returns the inverse tan (atan) (result is in Radians)
Public function Static double

Atan2 ( double Y,
double X
)

 Returns the inverse tan (atan2) of A/B (result is in Radians)
Public function Static void

AverageOfIntArray ( const TArray< int32 >& IntArray,
float& AverageValue
)

 Returns average of all array entries. Returns value of 0 if the supplied array is empty.
Public function Static uint8

BMax ( uint8 A,
uint8 B
)

 Returns the maximum value of A and B
Public function Static uint8

BMin ( uint8 A,
uint8 B
)

 Returns the minimum value of A and B
Public function Static bool

BooleanAND ( bool A,
bool B
)

 Returns the logical AND of two values (A AND B)
Public function Static bool

BooleanNAND ( bool A,
bool B
)

 Returns the logical NAND of two values (A AND B)
Public function Static bool

BooleanNOR ( bool A,
bool B
)

 Returns the logical Not OR of two values (A NOR B)
Public function Static bool

BooleanOR ( bool A,
bool B
)

 Returns the logical OR of two values (A OR B)
Public function Static bool

BooleanXOR ( bool A,
bool B
)

 Returns the logical eXclusive OR of two values (A XOR B)
Public function Static void

BreakBoxSphereBounds ( const FBoxSphereBounds& InBoxSphereBounds,
FVector& Origin,
FVector& BoxExtent,
float& SphereRadius
)

 Breaks an FBoxSphereBounds into origin, extent, and radius
Public function Static void

BreakColor ( FLinearColor InColor,
float& R,
float& G,
float& B,
float& A
)

 Breaks apart a color into individual RGB components (as well as alpha)
Public function Static void

BreakDateTime ( FDateTime InDateTime,
int32& Year,
int32& Month,
int32& Day,
int32& Hour,
int32& Minute,
int32& Second,
int32& Millisecond
)

 Breaks a DateTime into its components
Public function Static void

BreakFrameRate ( const FFrameRate& InFrameRate,
int32& Numerator,
int32& Denominator
)

 Breaks a FFrameRate into a numerator and denominator.
Public function Static void

BreakQualifiedFrameTime ( const FQualifiedFrameTime& InFrameTime,
FFrameNumber& Frame,
FFrameRate& FrameRate,
float& SubFrame
)

 Breaks a FQualifiedFrameTime into its component parts again.
Public function Static void

BreakQuat ( const FQuat& InQuat,
float& X,
float& Y,
float& Z,
float& W
)

 Breaks a quat apart into X, Y, Z, W
Public function Static void

BreakRandomStream ( const FRandomStream& InRandomStream,
int32& InitialSeed
)

 Breaks apart a random number generator
Public function Static void

BreakRotator ( FRotator InRot,
float& Roll,
float& Pitch,
float& Yaw
)

 Breaks apart a rotator into {Roll, Pitch, Yaw} angles in degrees
Public function Static void

BreakRotIntoAxes ( const FRotator& InRot,
FVector& X,
FVector& Y,
FVector& Z
)

 Breaks apart a rotator into its component axes
Public function Static void

BreakTimespan ( FTimespan InTimespan,
int32& Days,
int32& Hours,
int32& Minutes,
int32& Seconds,
int32& Milliseconds
)

 Breaks a Timespan into its components
Public function Static void

BreakTimespan2 ( FTimespan InTimespan,
int32& Days,
int32& Hours,
int32& Minutes,
int32& Seconds,
int32& FractionNano
)

 Breaks a Timespan into its components
Public function Static void

BreakTransform ( const FTransform& InTransform,
FVector& Location,
FRotator& Rotation,
FVector& Scale
)

 Breaks apart a transform into location, rotation and scale
Public function Static void

BreakVector ( FVector InVec,
double& X,
double& Y,
double& Z
)

 Breaks a vector apart into X, Y, Z
Public function Static void

BreakVector_NetQuantize ( FVector_NetQuantize InVec,
double& X,
double& Y,
double& Z
)

  
Public function Static void

BreakVector_NetQuantize10 ( FVector_NetQuantize10 InVec,
double& X,
double& Y,
double& Z
)

  
Public function Static void

BreakVector_NetQuantize100 ( FVector_NetQuantize100 InVec,
double& X,
double& Y,
double& Z
)

  
Public function Static void

BreakVector_NetQuantizeNormal ( FVector_NetQuantizeNormal InVec,
double& X,
double& Y,
double& Z
)

  
Public function Static void

BreakVector2D ( FVector2D InVec,
double& X,
double& Y
)

 Breaks a 2D vector apart into X, Y.
Public function Static void

BreakVector4 ( const FVector4& InVec,
double& X,
double& Y,
double& Z,
double& W
)

 Breaks a 4D vector apart into X, Y, Z, W.
Public function Static FLinearColor

CInterpTo ( FLinearColor Current,
FLinearColor Target,
float DeltaTime,
float InterpSpeed
)

 Interpolate Linear Color from Current to Target.
Public function Static int32

Clamp ( int32 Value,
int32 Min,
int32 Max
)

 Returns Value clamped to be between A and B (inclusive)
Public function Static double

ClampAngle ( double AngleDegrees,
double MinAngleDegrees,
double MaxAngleDegrees
)

 Clamps an arbitrary angle to be between the given angles. Will clamp to nearest boundary.
Public function Static FVector2D

ClampAxes2D ( FVector2D A,
double MinAxisVal,
double MaxAxisVal
)

 Creates a copy of this vector with both axes clamped to the given range.
Public function Static float

ClampAxis ( float Angle
)

 Clamps an angle to the range of [0, 360].
Public function Static int64

ClampInt64 ( int64 Value,
int64 Min,
int64 Max
)

 Returns Value clamped to be between A and B (inclusive)
Public function Static FVector

ClampVectorSize ( FVector A,
double Min,
double Max
)

 Create a copy of this vector, with its magnitude/size/length clamped between Min and Max.
Public function Static bool

ClassIsChildOf ( TSubclassOf< class UObject > TestClass,
TSubclassOf< class UObject > ParentClass
)

 Determine if a class is a child of another class.
Public function Static FRotator

ComposeRotators ( FRotator A,
FRotator B
)

 Combine 2 rotations to give you the resulting rotation of first applying A, then B.
Public function Static FTransform

ComposeTransforms ( const FTransform& A,
const FTransform& B
)

 Compose two transforms in order: A * B.
Public function Static uint8

Conv_BoolToByte ( bool InBool
)

 Converts a bool to a byte
Public function Static double

Conv_BoolToDouble ( bool InBool
)

 Converts a bool to a float (0.0 or 1.0)
Public function Static int32

Conv_BoolToInt ( bool InBool
)

 Converts a bool to an int
Public function Static double

Conv_ByteToDouble ( uint8 InByte
)

 Converts a byte to a float
Public function Static int32

Conv_ByteToInt ( uint8 InByte
)

 Converts a byte to an integer
Public function Static int64

Conv_ByteToInt64 ( uint8 InByte
)

 Converts a byte to an integer
Public function Static FLinearColor Converts a color to LinearColor
Public function Static float

Conv_DoubleToFloat ( double InDouble
)

 Converts a 64 bit floating point to a 32 bit floating point (if the float is too large, returns the low 32 bits)
Public function Static int64

Conv_DoubleToInt64 ( double InDouble
)

 Converts a float to a 64 bit integer
Public function Static FLinearColor

Conv_DoubleToLinearColor ( double InDouble
)

 Converts a float into a LinearColor, where each RGB element is that float
Public function Static FVector

Conv_DoubleToVector ( double InDouble
)

 Converts a double into a vector, where each element is that float
Public function Static FVector2D

Conv_DoubleToVector2D ( double InDouble
)

 Convert a float into a vector, where each element is that float
Public function Static double

Conv_FloatToDouble ( float InFloat
)

 Converts a 32 bit floating point to a 64 bit floating point
Public function Static uint8

Conv_Int64ToByte ( int64 InInt
)

 Converts a 64 bit integer to a byte (if the integer is too large, returns the low 8 bits)
Public function Static double

Conv_Int64ToDouble ( int64 InInt
)

 Converts a 64 bit integer to a float
Public function Static int32

Conv_Int64ToInt ( int64 InInt
)

 Converts a 64 bit integer to a 32 bit integer (if the integer is too large, returns the low 32 bits)
Public function Static FVector2D

Conv_IntPointToVector2D ( FIntPoint InIntPoint
)

 IntPoint functionsConverts an IntPoint to a Vector2D
Public function Static bool

Conv_IntToBool ( int32 InInt
)

 Converts a int to a bool
Public function Static uint8

Conv_IntToByte ( int32 InInt
)

 Converts an integer to a byte (if the integer is too large, returns the low 8 bits)
Public function Static double

Conv_IntToDouble ( int32 InInt
)

 Converts an integer to a float
Public function Static int64

Conv_IntToInt64 ( int32 InInt
)

 Converts an integer to a 64 bit integer
Public function Static FIntVector

Conv_IntToIntVector ( int32 InInt
)

 Converts an integer to an IntVector
Public function Static FVector

Conv_IntToVector ( int32 InInt
)

 Converts an integer to a FVector
Public function Static FVector

Conv_IntVectorToVector ( const FIntVector& InIntVector
)

 Converts an IntVector to a vector
Public function Static FColor

Conv_LinearColorToColor ( FLinearColor InLinearColor,
bool InUseSRGB
)

 Quantizes the linear color and returns the result as a FColor with optional sRGB conversion and quality as goal.
Public function Static FVector Converts a LinearColor to a vector
Public function Static FRotator

Conv_MatrixToRotator ( const FMatrix& InMatrix
)

 Converts a Matrix to a Rotator (Assumes Matrix represents a transform)
Public function Static FTransform

Conv_MatrixToTransform ( const FMatrix& InMatrix
)

 Matrix functions Converts a Matrix to a Transform (Assumes Matrix represents a transform)
Public function Static FQuat

Conv_RotatorToQuaternion ( FRotator InRot
)

 Converts to Quaternion representation of this Rotator.
Public function Static FTransform

Conv_RotatorToTransform ( const FRotator& InRotator
)

 Converts Rotator to Transform
Public function Static FVector

Conv_RotatorToVector ( FRotator InRot
)

 Get the X direction vector after this rotation
Public function Static FMatrix

Conv_TransformToMatrix ( const FTransform& Transform
)

 Converts a Transform to a Matrix with scale
Public function Static FIntPoint

Conv_Vector2DToIntPoint ( FVector2D InVector2D
)

 Converts a Vector2D to an IntPoint
Public function Static FVector

Conv_Vector2DToVector ( FVector2D InVector2D,
float Z
)

 Converts a Vector2D to a Vector
Public function Static FQuat

Conv_Vector4ToQuaternion ( const FVector4& InVec
)

 Return the Quaternion orientation corresponding to the direction in which the vector points.
Public function Static FRotator

Conv_Vector4ToRotator ( const FVector4& InVec
)

 Return the FRotator orientation corresponding to the direction in which the vector points.
Public function Static FVector

Conv_Vector4ToVector ( const FVector4& InVector4
)

 Converts a Vector4 to a Vector (dropping the W element)
Public function Static FLinearColor

Conv_VectorToLinearColor ( FVector InVec
)

 Converts a vector to LinearColor
Public function Static FQuat

Conv_VectorToQuaternion ( FVector InVec
)

 Return the Quaternion orientation corresponding to the direction in which the vector points.
Public function Static FRotator

Conv_VectorToRotator ( FVector InVec
)

 Return the FRotator orientation corresponding to the direction in which the vector points.
Public function Static FTransform

Conv_VectorToTransform ( FVector InLocation
)

 Converts a vector to a transform. Uses vector as location
Public function Static FVector2D

Conv_VectorToVector2D ( FVector InVector
)

 Converts a Vector to a Vector2D using the Vector's (X, Y) coordinates
Public function Static double

Cos ( double A
)

 Returns the cosine of A (expects Radians)
Public function Static FVector

CreateVectorFromYawPitch ( float Yaw,
float Pitch,
float Length
)

 Creates a directional vector from rotation values {Pitch, Yaw} supplied in degrees with specified Length
Public function Static FVector

Cross_VectorVector ( FVector A,
FVector B
)

 Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html
Public function Static double

CrossProduct2D ( FVector2D A,
FVector2D B
)

 Returns the cross product of two 2d vectors - see http://mathworld.wolfram.com/CrossProduct.html
Public function Static bool

DateTimeFromIsoString ( FString IsoString,
FDateTime& Result
)

 Converts a date string in ISO-8601 format to a DateTime object
Public function Static bool

DateTimeFromString ( FString DateTimeString,
FDateTime& Result
)

 Converts a date string to a DateTime object
Public function Static FDateTime Returns the maximum date and time value
Public function Static FDateTime Returns the minimum date and time value
Public function Static int32

DaysInMonth ( int32 Year,
int32 Month
)

 Returns the number of days in the given year and month
Public function Static int32

DaysInYear ( int32 Year
)

 Returns the number of days in the given year
Public function Static double

DegAcos ( double A
)

 Returns the inverse cos (arccos) of A (result is in Degrees)
Public function Static double

DegAsin ( double A
)

 Returns the inverse sin (arcsin) of A (result is in Degrees)
Public function Static double

DegAtan ( double A
)

 Returns the inverse tan (atan) (result is in Degrees)
Public function Static double

DegAtan2 ( double Y,
double X
)

 Returns the inverse tan (atan2) of A/B (result is in Degrees)
Public function Static double

DegCos ( double A
)

 Returns the cos of A (expects Degrees)
Public function Static double

DegreesToRadians ( double A
)

 Returns radians value based on the input degrees
Public function Static double

DegSin ( double A
)

 Returns the sin of A (expects Degrees)
Public function Static double

DegTan ( double A
)

 Returns the tan of A (expects Degrees)
Public function Static double

Distance2D ( FVector2D V1,
FVector2D V2
)

 Distance between two 2D points.
Public function Static double

DistanceSquared2D ( FVector2D V1,
FVector2D V2
)

 Squared distance between two 2D points.
Public function Static uint8

Divide_ByteByte ( uint8 A,
uint8 B
)

 Division (A / B)
Public function Static double

Divide_DoubleDouble ( double A,
double B
)

 Division (A / B)
Public function Static int64

Divide_Int64Int64 ( int64 A,
int64 B
)

 Division (A / B)
Public function Static int32

Divide_IntInt ( int32 A,
int32 B
)

 Division (A / B)
Public function Static FIntPoint

Divide_IntPointInt ( FIntPoint A,
int32 B
)

 Division (A * B)
Public function Static FIntPoint

Divide_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns IntPoint A divided by B
Public function Static FLinearColor Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A)
Public function Static FTimespan

Divide_TimespanFloat ( FTimespan A,
float Scalar
)

 Scalar division (A / s)
Public function Static FVector2D

Divide_Vector2DFloat ( FVector2D A,
double B
)

 Returns Vector A divided by B
Public function Static FVector2D

Divide_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y})
Public function Static FVector4

Divide_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w})
Public function Static FVector

Divide_VectorFloat ( FVector A,
double B
)

 Vector divide by a float
Public function Static FVector

Divide_VectorInt ( FVector A,
int32 B
)

 Vector divide by an integer
Public function Static FVector

Divide_VectorVector ( FVector A,
FVector B
)

 Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z})
Public function Static double

Dot_VectorVector ( FVector A,
FVector B
)

 Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html
Public function Static double

DotProduct2D ( FVector2D A,
FVector2D B
)

 Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html
Public function Static float

DynamicWeightedMovingAverage_Float ( float CurrentSample,
float PreviousSample,
float MaxDistance,
float MinWeight,
float MaxWeight
)

 Calculates the new value in a weighted moving average series using the previous value and a weight range.
Public function Static FRotator

DynamicWeightedMovingAverage_FRotator ( FRotator CurrentSample,
FRotator PreviousSample,
float MaxDistance,
float MinWeight,
float MaxWeight
)

 Calculates the new value in a weighted moving average series using the previous value and a weight range.
Public function Static FVector

DynamicWeightedMovingAverage_FVector ( FVector CurrentSample,
FVector PreviousSample,
float MaxDistance,
float MinWeight,
float MaxWeight
)

 Calculates the new value in a weighted moving average series using the previous value and a weight range.
Public function Static double

Ease ( double A,
double B,
double Alpha,
TEnumAsByte< EEasingFunc::Type > EasingFunc,
double BlendExp,
int32 Steps
)

 Easeing between A and B using a specified easing function
Public function Static bool

Equal_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns true if IntPoint A is equal to IntPoint B (A == B)
Public function Static bool

EqualEqual_BoolBool ( bool A,
bool B
)

 Returns true if the values are equal (A == B)
Public function Static bool

EqualEqual_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is equal to B (A == B)
Public function Static bool Class operators and functions.Returns true if A and B are equal (A == B)
Public function Static bool Returns true if the values are equal (A == B)
Public function Static bool

EqualEqual_DoubleDouble ( double A,
double B
)

 Returns true if A is exactly equal to B (A == B)
Public function Static bool

EqualEqual_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is equal to B (A == B)
Public function Static bool

EqualEqual_IntInt ( int32 A,
int32 B
)

 Returns true if A is equal to B (A == B)
Public function Static bool Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
Public function Static bool

EqualEqual_MatrixMatrix ( const FMatrix& A,
const FMatrix& B,
float Tolerance
)

 Checks whether another Matrix is equal to this, within specified tolerance.
Public function Static bool Name operators.Returns true if A and B are equal (A == B)
Public function Static bool Object operators and functions.Returns true if A and B are equal (A == B)
Public function Static bool

EqualEqual_QuatQuat ( const FQuat& A,
const FQuat& B,
float Tolerance
)

 Quat functionsReturns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance
Public function Static bool

EqualEqual_RotatorRotator ( FRotator A,
FRotator B,
float ErrorTolerance
)

 Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance
Public function Static bool Returns true if the values are equal (A == B)
Public function Static bool

EqualEqual_TransformTransform ( const FTransform& A,
const FTransform& B
)

 Returns true if transform A is equal to transform B
Public function Static bool

EqualEqual_Vector2DVector2D ( FVector2D A,
FVector2D B,
float ErrorTolerance
)

 Returns true if vector2D A is equal to vector2D B (A == B) within a specified error tolerance
Public function Static bool

EqualEqual_Vector4Vector4 ( const FVector4& A,
const FVector4& B,
float ErrorTolerance
)

 Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
Public function Static bool

EqualEqual_VectorVector ( FVector A,
FVector B,
float ErrorTolerance
)

 Returns true if vector A is equal to vector B (A == B) within a specified error tolerance
Public function Static bool

EqualExactly_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Returns true if vector A is equal to vector B (A == B)
Public function Static bool

EqualExactly_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Returns true if vector A is equal to vector B (A == B)
Public function Static bool

EqualExactly_VectorVector ( FVector A,
FVector B
)

 Returns true if vector A is equal to vector B (A == B)
Public function Static double

Exp ( double A
)

 Returns exponential(e) to the power A (e^A)
Public function Static int32

FCeil ( double A
)

 Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)
Public function Static int64

FCeil64 ( double A
)

 Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2)
Public function Static double

FClamp ( double Value,
double Min,
double Max
)

 Returns Value clamped between A and B (inclusive)
Public function Static int32

FFloor ( double A
)

 Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)
Public function Static int64

FFloor64 ( double A
)

 Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1)
Public function Static FVector

FindClosestPointOnLine ( FVector Point,
FVector LineOrigin,
FVector LineDirection
)

 Find the closest point on an infinite line to a given point.
Public function Static FVector

FindClosestPointOnSegment ( FVector Point,
FVector SegmentStart,
FVector SegmentEnd
)

 Find the closest point on a segment to a given point.
Public function Static FRotator

FindLookAtRotation ( const FVector& Start,
const FVector& Target
)

 Find a rotation for an object at Start location to point at Target location.
Public function Static void

FindNearestPointsOnLineSegments ( FVector Segment1Start,
FVector Segment1End,
FVector Segment2Start,
FVector Segment2End,
FVector& Segment1Point,
FVector& Segment2Point
)

 Find closest points between 2 segments.
Public function Static FRotator

FindRelativeLookAtRotation ( const FTransform& StartTransform,
const FVector& TargetLocation
)

 Find a local rotation (range of [-180, 180]) for an object with StartTransform to point at TargetLocation.
Public function Static double

FInterpEaseInOut ( double A,
double B,
double Alpha,
double Exponent
)

 Interpolate between A and B, applying an ease in/out function.
Public function Static double

FInterpTo ( double Current,
double Target,
double DeltaTime,
double InterpSpeed
)

 Interpolation functions Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
Public function Static double

FInterpTo_Constant ( double Current,
double Target,
double DeltaTime,
double InterpSpeed
)

 Tries to reach Target at a constant rate.
Public function Static float

FixedTurn ( float InCurrent,
float InDesired,
float InDeltaRate
)

 Returns a new rotation component value
Public function Static float

FloatSpringInterp ( float Current,
float Target,
FFloatSpringState& SpringState,
float Stiffness,
float CriticalDampingFactor,
float DeltaTime,
float Mass,
float TargetVelocityAmount,
bool bClamp,
float MinValue,
float MaxValue,
bool bInitializeFromTarget
)

 Uses a simple spring model to interpolate a float from Current to Target.
Public function Static double

FMax ( double A,
double B
)

 Returns the maximum value of A and B
Public function Static double

FMin ( double A,
double B
)

 Returns the minimum value of A and B
Public function Static int32

FMod ( double Dividend,
double Divisor,
double& Remainder
)

 Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder
Public function Static int64

FMod64 ( double Dividend,
double Divisor,
double& Remainder
)

 Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder
Public function Static double

Fraction ( double A
)

 Returns the fractional part of a float.
Public function Static FTimespan

FromDays ( float Days
)

 Returns a time span that represents the specified number of days
Public function Static FTimespan

FromHours ( float Hours
)

 Returns a time span that represents the specified number of hours
Public function Static FTimespan

FromMilliseconds ( float Milliseconds
)

 Returns a time span that represents the specified number of milliseconds
Public function Static FTimespan

FromMinutes ( float Minutes
)

 Returns a time span that represents the specified number of minutes
Public function Static FTimespan

FromSeconds ( float Seconds
)

 Returns a time span that represents the specified number of seconds
Public function Static FDateTime

FromUnixTimestamp ( const int64 UnixTime
)

 Returns the date from Unix time (seconds from midnight 1970-01-01)
Public function Static int32

FTrunc ( double A
)

 Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)
Public function Static int64

FTrunc64 ( double A
)

 Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1)
Public function Static FIntVector

FTruncVector ( const FVector& InVector
)

 Rounds A to an integer with truncation towards zero for each element in a vector.
Public function Static double

FWrap ( double Value,
double Min,
double Max
)

 Returns Value wrapped from A and B (inclusive)
Public function Static double

GenericPercent_FloatFloat ( double A,
double B
)

  
Public function Static FVector2D

GetAbs2D ( FVector2D A
)

 Get a copy of this vector with absolute value of each component.
Public function Static double

GetAbsMax2D ( FVector2D A
)

 Get the maximum absolute value of the vector's components.
Public function Static void

GetAxes ( FRotator A,
FVector& X,
FVector& Y,
FVector& Z
)

 Get the reference frame direction vectors (axes) described by this rotation
Public function Static void

GetAzimuthAndElevation ( FVector InDirection,
const FTransform& ReferenceFrame,
float& Azimuth,
float& Elevation
)

 Breaks a direction vector apart into Azimuth (Yaw) and Elevation (Pitch) rotation values given in degrees.
Public function Static FDateTime Returns the date component of A
Public function Static int32 Returns the day component of A (1 to 31)
Public function Static int32 Returns the day of year of A
Public function Static int32 Returns the days component of A
Public function Static FVector

GetDirectionUnitVector ( FVector From,
FVector To
)

 Find the unit direction vector from one position to another or (0,0,0) if positions are the same.
Public function Static FTimespan Returns the absolute value of A
Public function Static FVector

GetForwardVector ( FRotator InRot
)

 Rotate the world forward vector by the given rotation
Public function Static int32 Returns the hour component of A (24h format)
Public function Static int32 Returns the hour component of A (12h format)
Public function Static int32 Returns the hours component of A
Public function Static double

GetMax2D ( FVector2D A
)

 Get the maximum value of the vector's components.
Public function Static double

GetMaxElement ( FVector A
)

 Find the maximum element (X, Y or Z) of a vector
Public function Static int32 Returns the millisecond component of A
Public function Static int32 Returns the milliseconds component of A
Public function Static double

GetMin2D ( FVector2D A
)

 Get the minimum value of the vector's components.
Public function Static double

GetMinElement ( FVector A
)

 Find the minimum element (X, Y or Z) of a vector
Public function Static int32 Returns the minute component of A
Public function Static int32 Returns the minutes component of A
Public function Static int32 Returns the month component of A
Public function Static double

GetPI ()

 Returns the value of PI
Public function Static float

GetPointDistanceToLine ( FVector Point,
FVector LineOrigin,
FVector LineDirection
)

 Find the distance from a point to the closest point on an infinite line.
Public function Static float

GetPointDistanceToSegment ( FVector Point,
FVector SegmentStart,
FVector SegmentEnd
)

 Find the distance from a point to the closest point on a segment.
Public function Static FVector

GetReflectionVector ( FVector Direction,
FVector SurfaceNormal
)

 Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
Public function Static FVector

GetRightVector ( FRotator InRot
)

 Rotate the world right vector by the given rotation
Public function Static FVector2D

GetRotated2D ( FVector2D A,
float AngleDeg
)

 Rotates around axis (0,0,1)
Public function Static int32 Returns the second component of A
Public function Static int32 Returns the seconds component of A
Public function Static void

GetSlopeDegreeAngles ( const FVector& MyRightYAxis,
const FVector& FloorNormal,
const FVector& UpVector,
float& OutSlopePitchDegreeAngle,
float& OutSlopeRollDegreeAngle
)

 Returns Slope Pitch and Roll angles in degrees based on the following information:
Public function Static double

GetTAU ()

 Returns the value of TAU (= 2 * PI)
Public function Static FTimespan Returns the time elapsed since midnight of A
Public function Static float Returns the total number of days in A
Public function Static float Returns the total number of hours in A
Public function Static float Returns the total number of milliseconds in A
Public function Static float Returns the total number of minutes in A
Public function Static float Returns the total number of seconds in A
Public function Static FVector

GetUpVector ( FRotator InRot
)

 Rotate the world up vector by the given rotation
Public function Static FVector

GetVectorArrayAverage ( const TArray< FVector >& Vectors
)

 Find the average of an array of vectors
Public function Static void

GetYawPitchFromVector ( FVector InVec,
float& Yaw,
float& Pitch
)

 Breaks a vector apart into Yaw, Pitch rotation values given in degrees. (non-clamped)
Public function Static int32 Returns the year component of A
Public function Static bool

Greater_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is greater than B (A > B)
Public function Static bool Returns true if A is greater than B (A > B)
Public function Static bool

Greater_DoubleDouble ( double A,
double B
)

 Returns true if A is greater than B (A > B)
Public function Static bool

Greater_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is greater than B (A > B)
Public function Static bool

Greater_IntInt ( int32 A,
int32 B
)

 Returns true if A is greater than B (A > B)
Public function Static bool Returns true if A is greater than B (A > B)
Public function Static bool

GreaterEqual_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is greater than or equal to B (A >= B)
Public function Static bool Returns true if A is greater than or equal to B (A >= B)
Public function Static bool

GreaterEqual_DoubleDouble ( double A,
double B
)

 Returns true if A is greater than or equal to B (A >= B)
Public function Static bool

GreaterEqual_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is greater than or equal to B (A >= B)
Public function Static bool

GreaterEqual_IntInt ( int32 A,
int32 B
)

 Returns true if A is greater than or equal to B (A >= B)
Public function Static bool Returns true if A is greater than or equal to B (A >= B)
Public function Static FVector

GreaterGreater_VectorRotator ( FVector A,
FRotator B
)

 Returns result of vector A rotated by Rotator B
Public function Static double

GridSnap_Float ( double Location,
double GridSize
)

 Snaps a value to the nearest grid multiple.
Public function Static FLinearColor

HSVToRGB ( float H,
float S,
float V,
float A
)

 Make a color from individual color components (HSV space; Hue is [0..360) while Saturation and Value are 0..1)
Public function Static void Converts a HSV linear color (where H is in R (0..360), S is in G (0..1), and V is in B (0..1)) to RGB
Public function Static FLinearColor Converts a HSV linear color (where H is in R, S is in G, and V is in B) to linear RGB
Public function Static double

Hypotenuse ( double Width,
double Height
)

 Returns the hypotenuse of a right-angled triangle given the width and height.
Public function Static bool

InRange_FloatFloat ( double Value,
double Min,
double Max,
bool InclusiveMin,
bool InclusiveMax
)

 Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
Public function Static bool

InRange_Int64Int64 ( int64 Value,
int64 Min,
int64 Max,
bool InclusiveMin,
bool InclusiveMax
)

 Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
Public function Static bool

InRange_IntInt ( int32 Value,
int32 Min,
int32 Max,
bool InclusiveMin,
bool InclusiveMax
)

 Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller
Public function Static FIntPoint Down Int Point (0, 1)
Public function Static FIntPoint Left Int Point (-1, 0)
Public function Static FIntPoint One Int Point (1, 1)
Public function Static FIntPoint Right Int Point (1, 0)
Public function Static FIntPoint Up Int Point (0, -1)
Public function Static FIntPoint IntPoint constantsZero Int Point (0, 0)FIntPoint
Public function Static FVector

InverseTransformDirection ( const FTransform& T,
FVector Direction
)

 Transform a direction vector by the inverse of the supplied transform - will not change its length.
Public function Static FVector

InverseTransformLocation ( const FTransform& T,
FVector Location
)

 Transform a position by the inverse of the supplied transform.
Public function Static FRotator

InverseTransformRotation ( const FTransform& T,
FRotator Rotation
)

 Transform a rotator by the inverse of the supplied transform.
Public function Static FTransform

InvertTransform ( const FTransform& T
)

 Returns the inverse of the given transform T.
Public function Static bool Returns whether A's time is in the afternoon
Public function Static bool

IsLeapYear ( int32 Year
)

 Returns whether given year is a leap year
Public function Static bool Returns whether A's time is in the morning
Public function Static bool

IsNearlyZero2D ( const FVector2D& A,
float Tolerance
)

 Checks whether vector is near to zero within a specified tolerance.
Public function Static bool

IsPointInBox ( FVector Point,
FVector BoxOrigin,
FVector BoxExtent
)

 Determines whether the given point is in a box. Includes points on the box.
Public function Static bool

IsPointInBox_Box ( FVector Point,
FBox Box
)

 Determines whether the given point is in a box. Includes points on the box.
Public function Static bool

IsPointInBoxWithTransform ( FVector Point,
const FTransform& BoxWorldTransform,
FVector BoxExtent
)

 Determines whether a given point is in a box with a given transform. Includes points on the box.
Public function Static bool

IsPointInBoxWithTransform_Box ( FVector Point,
const FTransform& BoxWorldTransform,
FBox BoxExtent
)

 Determines whether a given point is in a box with a given transform. Includes points on the box.
Public function Static bool

IsZero2D ( const FVector2D& A
)

 Checks whether all components of the vector are exactly zero.
Public function Static double

Lerp ( double A,
double B,
double Alpha
)

 Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
Public function Static bool

Less_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is less than B (A < B)
Public function Static bool Returns true if A is less than B (A < B)
Public function Static bool

Less_DoubleDouble ( double A,
double B
)

 Returns true if A is Less than B (A < B)
Public function Static bool

Less_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is less than B (A < B)
Public function Static bool

Less_IntInt ( int32 A,
int32 B
)

 Returns true if A is less than B (A < B)
Public function Static bool Returns true if A is less than B (A < B)
Public function Static bool

LessEqual_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is less than or equal to B (A <= B)
Public function Static bool Returns true if A is less than or equal to B (A <= B)
Public function Static bool

LessEqual_DoubleDouble ( double A,
double B
)

 Returns true if A is Less than or equal to B (A <= B)
Public function Static bool

LessEqual_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is less than or equal to B (A <= B)
Public function Static bool

LessEqual_IntInt ( int32 A,
int32 B
)

 Returns true if A is less than or equal to B (A <= B)
Public function Static bool Returns true if A is less than or equal to B (A <= B)
Public function Static FVector

LessLess_VectorRotator ( FVector A,
FRotator B
)

 Returns result of vector A rotated by the inverse of Rotator B
Public function Static FLinearColor Black linear color
Public function Static FLinearColor Blue linear color
Public function Static FLinearColor

LinearColor_Desaturated ( FLinearColor InColor,
float InDesaturation
)

 Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation
Public function Static float Euclidean distance between two color points.
Public function Static float Returns the perceived brightness of a color on a display taking into account the impact on the human eye per color channel: green > red > blue.
Public function Static float Returns the maximum color channel value in this color structure
Public function Static float Returns the minimum color channel value in this color structure
Public function Static FLinearColor Grey linear color
Public function Static FLinearColor Green linear color
Public function Static bool Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance
Public function Static FColor Quantizes the linear color and returns the result as an 8-bit color.
Public function Static FColor Quantizes the linear color with rounding and returns the result as an 8-bit color.
Public function Static FLinearColor Red linear color
Public function Static void

LinearColor_Set ( FLinearColor& InOutColor,
FLinearColor InColor
)

 Assign contents of InColor
Public function Static void

LinearColor_SetFromHSV ( FLinearColor& InOutColor,
float H,
float S,
float V,
float A
)

 Assigns an HSV color to a linear space RGB color
Public function Static void

LinearColor_SetFromPow22 ( FLinearColor& InOutColor,
const FColor& InColor
)

 Assigns an FColor coming from an observed Pow(1/2.2) output, into a linear color.
Public function Static void

LinearColor_SetFromSRGB ( FLinearColor& InOutColor,
const FColor& InSRGB
)

 Assigns an FColor coming from an observed sRGB output, into a linear color.
Public function Static void Sets to a random color. Choses a quite nice color based on a random hue.
Public function Static void

LinearColor_SetRGBA ( FLinearColor& InOutColor,
float R,
float G,
float B,
float A
)

 Assign individual linear RGBA components.
Public function Static void

LinearColor_SetTemperature ( FLinearColor& InOutColor,
float InTemperature
)

 Converts temperature in Kelvins of a black body radiator to RGB chromaticity.
Public function Static FLinearColor

LinearColor_ToNewOpacity ( FLinearColor InColor,
float InOpacity
)

 Returns a copy of this color using the specified opacity/alpha.
Public function Static FColor

LinearColor_ToRGBE ( FLinearColor InLinearColor
)

 Converts from linear to 8-bit RGBE as outlined in Gregory Ward's Real Pixels article, Graphics Gems II, page 80.
Public function Static FLinearColor Transparent linear color - black with 0 opacity/alpha
Public function Static FLinearColor LinearColor constants - exposed for scriptingWhite linear color
Public function Static FLinearColor Yellow linear color
Public function Static FLinearColor

LinearColorLerp ( FLinearColor A,
FLinearColor B,
float Alpha
)

 Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
Public function Static FLinearColor Linearly interpolates between two colors by the specified Alpha amount (100% of A when Alpha=0 and 100% of B when Alpha=1).
Public function Static bool

LinePlaneIntersection ( const FVector& LineStart,
const FVector& LineEnd,
const FPlane& APlane,
float& T,
FVector& Intersection
)

 Intersection Computes the intersection point between a line and a plane.
Public function Static bool

LinePlaneIntersection_OriginNormal ( const FVector& LineStart,
const FVector& LineEnd,
FVector PlaneOrigin,
FVector PlaneNormal,
float& T,
FVector& Intersection
)

 Computes the intersection point between a line and a plane.
Public function Static double

Log ( double A,
double Base
)

 Returns log of A base B (if B^R == A, returns R)
Public function Static double

Loge ( double A
)

 Returns natural log of A (if e^R == A, returns R)
Public function Static FBox

MakeBox ( FVector Min,
FVector Max
)

 Box functionsMakes an FBox from Min and Max and sets IsValid to true
Public function Static FBox2D

MakeBox2D ( FVector2D Min,
FVector2D Max
)

 Box2D functionsMakes an FBox2D from Min and Max and sets IsValid to true
Public function Static FBoxSphereBounds

MakeBoxSphereBounds ( FVector Origin,
FVector BoxExtent,
float SphereRadius
)

 BoxSphereBounds functionsMakes an FBoxSphereBounds given an origin, extent, and radius
Public function Static FLinearColor

MakeColor ( float R,
float G,
float B,
float A
)

 LinearColor functionsMake a color from individual color components (RGB space)
Public function Static FDateTime

MakeDateTime ( int32 Year,
int32 Month,
int32 Day,
int32 Hour,
int32 Minute,
int32 Second,
int32 Millisecond
)

 DateTime functions.Makes a DateTime struct
Public function Static FFrameRate

MakeFrameRate ( int32 Numerator,
int32 Denominator
)

 Creates a FFrameRate from a Numerator and a Denominator.
Public function Static FPlane

MakePlaneFromPointAndNormal ( FVector Point,
FVector Normal
)

 Plane functions. Creates a plane with a facing direction of Normal at the given Point
Public function Static float

MakePulsatingValue ( float InCurrentTime,
float InPulsesPerSecond,
float InPhase
)

 Simple function to create a pulsating scalar value
Public function Static FQualifiedFrameTime

MakeQualifiedFrameTime ( FFrameNumber Frame,
FFrameRate FrameRate,
float SubFrame
)

 Frame Time and Frame Rate FunctionsCreates a FQualifiedFrameTime out of a frame number, frame rate, and optional 0-1 clamped subframe.
Public function Static FQuat

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

 Makes a quat {X, Y, Z, W}
Public function Static FRandomStream

MakeRandomStream ( int32 InitialSeed
)

 Misc functionsMakes a SRand-based random number generator
Public function Static FTransform

MakeRelativeTransform ( const FTransform& A,
const FTransform& RelativeTo
)

 Computes a relative transform of one transform compared to another.
Public function Static FRotator

MakeRotationFromAxes ( FVector Forward,
FVector Right,
FVector Up
)

 Build a reference frame from three axes.
Public function Static FRotator

MakeRotator ( float Roll,
float Pitch,
float Yaw
)

 Rotator functions.Makes a rotator {Roll, Pitch, Yaw} from rotation values supplied in degrees
Public function Static FRotator

MakeRotFromX ( const FVector& X
)

 Builds a rotator given only a XAxis.
Public function Static FRotator

MakeRotFromXY ( const FVector& X,
const FVector& Y
)

 Builds a matrix with given X and Y axes.
Public function Static FRotator

MakeRotFromXZ ( const FVector& X,
const FVector& Z
)

 Builds a matrix with given X and Z axes.
Public function Static FRotator

MakeRotFromY ( const FVector& Y
)

 Builds a rotation matrix given only a YAxis.
Public function Static FRotator

MakeRotFromYX ( const FVector& Y,
const FVector& X
)

 Builds a matrix with given Y and X axes.
Public function Static FRotator

MakeRotFromYZ ( const FVector& Y,
const FVector& Z
)

 Builds a matrix with given Y and Z axes.
Public function Static FRotator

MakeRotFromZ ( const FVector& Z
)

 Builds a rotation matrix given only a ZAxis.
Public function Static FRotator

MakeRotFromZX ( const FVector& Z,
const FVector& X
)

 Builds a matrix with given Z and X axes.
Public function Static FRotator

MakeRotFromZY ( const FVector& Z,
const FVector& Y
)

 Builds a matrix with given Z and Y axes.
Public function Static FTimespan

MakeTimespan ( int32 Days,
int32 Hours,
int32 Minutes,
int32 Seconds,
int32 Milliseconds
)

 Timespan functions.Makes a Timespan struct
Public function Static FTimespan

MakeTimespan2 ( int32 Days,
int32 Hours,
int32 Minutes,
int32 Seconds,
int32 FractionNano
)

 Makes a Timespan struct
Public function Static FTransform

MakeTransform ( FVector Location,
FRotator Rotation,
FVector Scale
)

 Transform functionsMake a transform from location, rotation and scaleFTransform
Public function Static FVector

MakeVector ( double X,
double Y,
double Z
)

 Vector (3D) functions.Makes a vector {X, Y, Z}
Public function Static FVector_NetQuantize

MakeVector_NetQuantize ( double X,
double Y,
double Z
)

 NetQuantized vector make/breaks.
Public function Static FVector_NetQuantize10

MakeVector_NetQuantize10 ( double X,
double Y,
double Z
)

  
Public function Static FVector_NetQuantize100

MakeVector_NetQuantize100 ( double X,
double Y,
double Z
)

  
Public function Static FVector_NetQuantizeNormal

MakeVector_NetQuantizeNormal ( double X,
double Y,
double Z
)

  
Public function Static FVector2D

MakeVector2D ( double X,
double Y
)

 Vector2D functionsMakes a 2d vector {X, Y}
Public function Static FVector4

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

 Vector4 functionsMakes a 4D vector {X, Y, Z, W}
Public function Static double

MapRangeClamped ( double Value,
double InRangeA,
double InRangeB,
double OutRangeA,
double OutRangeB
)

 Returns Value mapped from one range into another where the Value is clamped to the Input Range.
Public function Static double

MapRangeUnclamped ( double Value,
double InRangeA,
double InRangeB,
double OutRangeA,
double OutRangeB
)

 Returns Value mapped from one range into another.
Public function Static FMatrix

Matrix_ApplyScale ( const FMatrix& M,
float Scale
)

 Apply Scale to this matrix (Assumes Matrix represents a transform)
Public function Static FMatrix

Matrix_ConcatenateTranslation ( const FMatrix& M,
FVector Translation
)

 Returns a matrix with an additional translation concatenated.
Public function Static bool

Matrix_ContainsNaN ( const FMatrix& M
)

 Returns true if any element of this matrix is NaN
Public function Static FVector

Matrix_GetColumn ( const FMatrix& M,
TEnumAsByte< EMatrixColumns::Type > Column
)

 Get a column of this matrix
Public function Static float

Matrix_GetDeterminant ( const FMatrix& M
)

  
Public function Static bool

Matrix_GetFrustumBottomPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the bottom plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static bool

Matrix_GetFrustumFarPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the far plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static bool

Matrix_GetFrustumLeftPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the left plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static bool

Matrix_GetFrustumNearPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the near plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static bool

Matrix_GetFrustumRightPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the right plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static bool

Matrix_GetFrustumTopPlane ( const FMatrix& M,
FPlane& OutPlane
)

 Get the top plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix)
Public function Static FMatrix

Matrix_GetInverse ( const FMatrix& M
)

 Get the inverse of the Matrix. Handles nil matrices.
Public function Static FMatrix

Matrix_GetMatrixWithoutScale ( const FMatrix& M,
float Tolerance
)

 Returns matrix after RemoveScaling with error Tolerance (Assumes Matrix represents a transform)
Public function Static float

Matrix_GetMaximumAxisScale ( const FMatrix& M
)

  
Public function Static FVector

Matrix_GetOrigin ( const FMatrix& InMatrix
)

 Get the origin of the co-ordinate system (Assumes Matrix represents a transform)
Public function Static FRotator

Matrix_GetRotator ( const FMatrix& M
)

 Get the rotator representation of this matrix (Assumes Matrix represents a transform)
Public function Static float

Matrix_GetRotDeterminant ( const FMatrix& M
)

  
Public function Static void

Matrix_GetScaledAxes ( const FMatrix& M,
FVector& X,
FVector& Y,
FVector& Z
)

 Get axes of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform)
Public function Static FVector

Matrix_GetScaledAxis ( const FMatrix& M,
TEnumAsByte< EAxis::Type > Axis
)

 Get axis of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform)
Public function Static FVector

Matrix_GetScaleVector ( const FMatrix& M,
float Tolerance
)

 Return a 3D scale vector calculated from this matrix (where each component is the magnitude of a row vector) with error Tolerance.
Public function Static FMatrix

Matrix_GetTransposeAdjoint ( const FMatrix& M
)

 Get the Transose Adjoint of the Matrix.
Public function Static FMatrix

Matrix_GetTransposed ( const FMatrix& M
)

 Transpose.
Public function Static void

Matrix_GetUnitAxes ( const FMatrix& M,
FVector& X,
FVector& Y,
FVector& Z
)

 Get unit length axes of this matrix (Assumes Matrix represents a transform)
Public function Static FVector

Matrix_GetUnitAxis ( const FMatrix& M,
TEnumAsByte< EAxis::Type > Axis
)

 Get unit length axis of this matrix (Assumes Matrix represents a transform)
Public function Static FMatrix Identity matrix.
Public function Static FVector

Matrix_InverseTransformPosition ( const FMatrix& M,
FVector V
)

 Inverts the matrix and then transforms V - correctly handles scaling in this matrix.
Public function Static FVector

Matrix_InverseTransformVector ( const FMatrix& M,
FVector V
)

 Transform a direction vector by the inverse of this matrix - will not take into account translation part.
Public function Static FMatrix

Matrix_Mirror ( const FMatrix& M,
TEnumAsByte< EAxis::Type > MirrorAxis,
TEnumAsByte< EAxis::Type > FlipAxis
)

 Utility for mirroring this transform across a certain plane, and flipping one of the axis as well.
Public function Static void

Matrix_RemoveScaling ( FMatrix& M,
float Tolerance
)

 Remove any scaling from this matrix (ie magnitude of each row is 1) with error Tolerance (Assumes Matrix represents a transform)
Public function Static FMatrix

Matrix_RemoveTranslation ( const FMatrix& M
)

 Remove any translation from this matrix (Assumes Matrix represents a transform)
Public function Static FMatrix

Matrix_ScaleTranslation ( const FMatrix& M,
FVector Scale3D
)

 Scale the translation part of the matrix by the supplied vector.
Public function Static void

Matrix_SetAxis ( FMatrix& M,
TEnumAsByte< EAxis::Type > Axis,
FVector AxisVector
)

 Set an axis of this matrix (Assumes Matrix represents a transform)
Public function Static void

Matrix_SetColumn ( FMatrix& M,
TEnumAsByte< EMatrixColumns::Type > Column,
FVector Value
)

  
Public function Static void

Matrix_SetOrigin ( FMatrix& M,
FVector NewOrigin
)

 Set the origin of the coordinate system to the given vector (Assumes Matrix represents a transform)
Public function Static FQuat

Matrix_ToQuat ( const FMatrix& M
)

 Transform a rotation matrix into a quaternion.
Public function Static FVector4

Matrix_TransformPosition ( const FMatrix& M,
FVector V
)

 Transform a location - will take into account translation part of the FMatrix.
Public function Static FVector4

Matrix_TransformVector ( const FMatrix& M,
FVector V
)

 Transform a direction vector - will not take into account translation part of the FMatrix.
Public function Static FVector4

Matrix_TransformVector4 ( const FMatrix& M,
FVector4 V
)

 Transform a vector by the matrix. (Assumes Matrix represents a transform)
Public function Static int32

Max ( int32 A,
int32 B
)

 Returns the maximum value of A and B
Public function Static int64

MaxInt64 ( int64 A,
int64 B
)

 Returns the maximum value of A and B
Public function Static void

MaxOfByteArray ( const TArray< uint8 >& ByteArray,
int32& IndexOfMaxValue,
uint8& MaxValue
)

 Returns max of all array entries and the index at which it was found.
Public function Static void

MaxOfFloatArray ( const TArray< float >& FloatArray,
int32& IndexOfMaxValue,
float& MaxValue
)

 Returns max of all array entries and the index at which it was found.
Public function Static void

MaxOfIntArray ( const TArray< int32 >& IntArray,
int32& IndexOfMaxValue,
int32& MaxValue
)

 Returns max of all array entries and the index at which it was found.
Public function Static void

MedianOfIntArray ( TArray< int32 > IntArray,
float& MedianValue
)

 Returns median of all array entries. Returns value of 0 if the supplied array is empty.
Public function Static int32

Min ( int32 A,
int32 B
)

 Returns the minimum value of A and B
Public function Static void

MinAreaRectangle ( UObject* WorldContextObject,
const TArray< FVector >& InPoints,
const FVector& SampleSurfaceNormal,
FVector& OutRectCenter,
FRotator& OutRectRotation,
float& OutRectLengthX,
float& OutRectLengthY,
bool bDebugDraw
)

 Finds the minimum area rectangle that encloses a set of coplanar points.
Public function Static int64

MinInt64 ( int64 A,
int64 B
)

 Returns the minimum value of A and B
Public function Static void

MinOfByteArray ( const TArray< uint8 >& ByteArray,
int32& IndexOfMinValue,
uint8& MinValue
)

 Returns min of all array entries and the index at which it was found.
Public function Static void

MinOfFloatArray ( const TArray< float >& FloatArray,
int32& IndexOfMinValue,
float& MinValue
)

 Returns min of all array entries and the index at which it was found.
Public function Static void

MinOfIntArray ( const TArray< int32 >& IntArray,
int32& IndexOfMinValue,
int32& MinValue
)

 Returns min of all array entries and the index at which it was found.
Public function Static FVector

MirrorVectorByNormal ( FVector InVect,
FVector InNormal
)

 Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
Public function Static uint8

Multiply_ByteByte ( uint8 A,
uint8 B
)

 Byte functions.Multiplication (A * B)
Public function Static double

Multiply_DoubleDouble ( double A,
double B
)

 Multiplication (A * B)
Public function Static int64

Multiply_Int64Int64 ( int64 A,
int64 B
)

 Integer64 functions.Multiplication (A * B)
Public function Static double

Multiply_IntFloat ( int32 A,
double B
)

 Multiplication (A * B)
Public function Static int32

Multiply_IntInt ( int32 A,
int32 B
)

 Integer functions.Multiplication (A * B)
Public function Static FIntPoint

Multiply_IntPointInt ( FIntPoint A,
int32 B
)

 Multiplication (A * B)
Public function Static FIntPoint

Multiply_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns IntPoint A multiplied by B
Public function Static FLinearColor Element-wise multiplication of a linear color by a float (F*R, F*G, F*B, F*A)
Public function Static FLinearColor Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A)
Public function Static FMatrix

Multiply_MatrixFloat ( const FMatrix& A,
double B
)

 Multiplies all values of the matrix by a float.
Public function Static FMatrix

Multiply_MatrixMatrix ( const FMatrix& A,
const FMatrix& B
)

 Gets the result of multiplying a Matrix to this.
Public function Static FQuat

Multiply_QuatQuat ( const FQuat& A,
const FQuat& B
)

 Gets the result of multiplying two quaternions (A * B).
Public function Static FRotator

Multiply_RotatorFloat ( FRotator A,
float B
)

 Returns rotator representing rotator A scaled by B
Public function Static FRotator

Multiply_RotatorInt ( FRotator A,
int32 B
)

 Returns rotator representing rotator A scaled by B
Public function Static FTimespan

Multiply_TimespanFloat ( FTimespan A,
float Scalar
)

 Scalar multiplication (A * s)
Public function Static FVector2D

Multiply_Vector2DFloat ( FVector2D A,
double B
)

 Returns Vector A scaled by B
Public function Static FVector2D

Multiply_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y})
Public function Static FVector4

Multiply_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w})
Public function Static FVector

Multiply_VectorFloat ( FVector A,
double B
)

 Scales Vector A by B
Public function Static FVector

Multiply_VectorInt ( FVector A,
int32 B
)

 Scales Vector A by B
Public function Static FVector

Multiply_VectorVector ( FVector A,
FVector B
)

 Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z})
Public function Static double

MultiplyByPi ( double Value
)

 Multiplies the input value by pi.
Public function Static double

MultiplyMultiply_FloatFloat ( double Base,
double Exp
)

 Float functions.Power (Base to the Exp-th power)
Public function Static bool

NearlyEqual_FloatFloat ( double A,
double B,
double ErrorTolerance
)

 Returns true if A is nearly equal to B (|A - B| < ErrorTolerance)
Public function Static bool

NearlyEqual_TransformTransform ( const FTransform& A,
const FTransform& B,
float LocationTolerance,
float RotationTolerance,
float Scale3DTolerance
)

 Returns true if transform A is nearly equal to B
Public function Static FVector2D

Negated2D ( const FVector2D& A
)

 Gets a negated copy of the vector.
Public function Static FRotator

NegateRotator ( FRotator A
)

 Negate a rotator
Public function Static FVector

NegateVector ( FVector A
)

 Negate a vector.
Public function Static FVector

Normal ( FVector A,
float Tolerance
)

 Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length.
Public function Static FVector2D

Normal2D ( FVector2D A
)

 Returns a unit normal version of the 2D vector
Public function Static void

Normalize2D ( FVector2D& A,
float Tolerance
)

 Normalize this vector in-place if it is large enough, set it to (0,0) otherwise.
Public function Static float

NormalizeAxis ( float Angle
)

 Clamps an angle to the range of [-180, 180].
Public function Static FRotator

NormalizedDeltaRotator ( FRotator A,
FRotator B
)

 Normalized A-B
Public function Static double

NormalizeToRange ( double Value,
double RangeMin,
double RangeMax
)

 Returns Value normalized to the given range.
Public function Static FVector2D

NormalSafe2D ( FVector2D A,
float Tolerance
)

 Gets a normalized copy of the vector, checking it is safe to do so based on the length.
Public function Static int32

Not_Int ( int32 A
)

 Bitwise NOT (~A)
Public function Static int64

Not_Int64 ( int64 A
)

 Bitwise NOT (~A)
Public function Static bool

Not_PreBool ( bool A
)

 Returns the logical complement of the Boolean value (NOT A)
Public function Static bool

NotEqual_BoolBool ( bool A,
bool B
)

 Returns true if the values are not equal (A != B)
Public function Static bool

NotEqual_ByteByte ( uint8 A,
uint8 B
)

 Returns true if A is not equal to B (A != B)
Public function Static bool Returns true if A and B are not equal (A != B)
Public function Static bool Returns true if the values are not equal (A != B)
Public function Static bool

NotEqual_DoubleDouble ( double A,
double B
)

 Returns true if A does not equal B (A != B)
Public function Static bool

NotEqual_Int64Int64 ( int64 A,
int64 B
)

 Returns true if A is not equal to B (A != B)
Public function Static bool

NotEqual_IntInt ( int32 A,
int32 B
)

 Returns true if A is not equal to B (A != B)
Public function Static bool

NotEqual_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns true if IntPoint A is NOT equal to IntPoint B (A != B)
Public function Static bool Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance
Public function Static bool

NotEqual_MatrixMatrix ( const FMatrix& A,
const FMatrix& B,
float Tolerance
)

 Checks whether another Matrix is not equal to this, within specified tolerance.
Public function Static bool Returns true if A and B are not equal (A != B)
Public function Static bool Returns true if A and B are not equal (A != B)
Public function Static bool

NotEqual_QuatQuat ( const FQuat& A,
const FQuat& B,
float ErrorTolerance
)

 Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance
Public function Static bool

NotEqual_RotatorRotator ( FRotator A,
FRotator B,
float ErrorTolerance
)

 Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance
Public function Static bool Returns true if the values are not equal (A != B)
Public function Static bool

NotEqual_Vector2DVector2D ( FVector2D A,
FVector2D B,
float ErrorTolerance
)

 Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
Public function Static bool

NotEqual_Vector4Vector4 ( const FVector4& A,
const FVector4& B,
float ErrorTolerance
)

 Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
Public function Static bool

NotEqual_VectorVector ( FVector A,
FVector B,
float ErrorTolerance
)

 Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
Public function Static bool

NotEqualExactly_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance
Public function Static bool

NotEqualExactly_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance
Public function Static bool

NotEqualExactly_VectorVector ( FVector A,
FVector B
)

 Returns true if vector A is not equal to vector B (A != B)
Public function Static FDateTime

Now ()

 Returns the local date and time on this computer
Public function Static int64

Or_Int64Int64 ( int64 A,
int64 B
)

 Bitwise OR (A | B)
Public function Static int32

Or_IntInt ( int32 A,
int32 B
)

 Bitwise OR (A | B)
Public function Static uint8

Percent_ByteByte ( uint8 A,
uint8 B
)

 Modulo (A % B)
Public function Static double

Percent_FloatFloat ( double A,
double B
)

  
Public function Static int64

Percent_Int64Int64 ( int64 A,
int64 B
)

 Modulo (A % B)
Public function Static int32

Percent_IntInt ( int32 A,
int32 B
)

 Modulo (A % B)
Public function Static float

PerlinNoise1D ( const float Value
)

 Generates a 1D Perlin noise from the given value.
Public function Static bool

PointsAreCoplanar ( const TArray< FVector >& Points,
float Tolerance
)

 Determines whether a given set of points are coplanar, with a tolerance.
Public function Static FVector

ProjectPointOnToPlane ( FVector Point,
FVector PlaneBase,
FVector PlaneNormal
)

 Projects/snaps a point onto a plane defined by a point on the plane and a plane normal.
Public function Static FVector

ProjectVectorOnToPlane ( FVector V,
FVector PlaneNormal
)

 Projects a vector onto a plane defined by a normalized vector (PlaneNormal).
Public function Static FVector

ProjectVectorOnToVector ( FVector V,
FVector Target
)

 Projects one vector (V) onto another (Target) and returns the projected vector.
Public function Static float

Quat_AngularDistance ( const FQuat& A,
const FQuat& B
)

 Find the angular distance/difference between two rotation quaternions.
Public function Static void

Quat_EnforceShortestArcWith ( FQuat& A,
const FQuat& B
)

 Modify the quaternion to ensure that the delta between it and B represents the shortest possible rotation angle.
Public function Static FVector

Quat_Euler ( const FQuat& Q
)

 Convert a Quaternion into floating-point Euler angles (in degrees).
Public function Static FQuat

Quat_Exp ( const FQuat& Q
)

 Used in combination with Log().
Public function Static FQuat

Quat_FindBetweenNormals ( FVector StartNormal,
FVector EndNormal
)

 Generates the 'smallest' (geodesic) rotation around a sphere between two normals (assumed to be unit length).
Public function Static FQuat

Quat_FindBetweenVectors ( FVector Start,
FVector End
)

 Generates the 'smallest' (geodesic) rotation around a sphere between two vectors of arbitrary length.
Public function Static float

Quat_GetAngle ( const FQuat& Q
)

 Get the angle of this quaternion
Public function Static FVector

Quat_GetAxisX ( const FQuat& Q
)

 Get the forward direction (X axis) after it has been rotated by this Quaternion.
Public function Static FVector

Quat_GetAxisY ( const FQuat& Q
)

 Get the right direction (Y axis) after it has been rotated by this Quaternion.
Public function Static FVector

Quat_GetAxisZ ( const FQuat& Q
)

 Get the up direction (Z axis) after it has been rotated by this Quaternion.
Public function Static FVector

Quat_GetRotationAxis ( const FQuat& Q
)

 Get the axis of rotation of the Quaternion.
Public function Static FQuat Quat constants - exposed for scriptingIdentity quaternion constantFQuat
Public function Static FQuat

Quat_Inversed ( const FQuat& Q
)

 Return an inversed copy of this quaternion.
Public function Static bool

Quat_IsFinite ( const FQuat& Q
)

 Determine if all the values are finite (not NaN nor Inf) in this Quat.
Public function Static bool

Quat_IsIdentity ( const FQuat& Q,
float Tolerance
)

 Checks whether this Quaternion is an Identity Quaternion. Assumes Quaternion tested is normalized.
Public function Static bool

Quat_IsNonFinite ( const FQuat& Q
)

 Determine if there are any non-finite values (NaN or Inf) in this Quat.
Public function Static bool

Quat_IsNormalized ( const FQuat& Q
)

 Return true if this quaternion is normalized
Public function Static FQuat

Quat_Log ( const FQuat& Q
)

 Quaternion with W=0 and V=theta*v.
Public function Static FQuat

Quat_MakeFromEuler ( const FVector& Euler
)

 Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
Public function Static void

Quat_Normalize ( FQuat& Q,
float Tolerance
)

 Normalize this quaternion if it is large enough as compared to the supplied tolerance.
Public function Static FQuat

Quat_Normalized ( const FQuat& Q,
float Tolerance
)

 Get a normalized copy of this quaternion. If it is too small, returns an identity quaternion.
Public function Static FVector

Quat_RotateVector ( const FQuat& Q,
const FVector& V
)

 Rotate a vector by this quaternion.
Public function Static FRotator

Quat_Rotator ( const FQuat& Q
)

 Converts to Rotator representation of this Quaternion.
Public function Static void

Quat_SetComponents ( FQuat& Q,
float X,
float Y,
float Z,
float W
)

 Set X, Y, Z, W components of Quaternion.
Public function Static void

Quat_SetFromEuler ( FQuat& Q,
const FVector& Euler
)

 Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
Public function Static float

Quat_Size ( const FQuat& Q
)

 Get the length of the quaternion.
Public function Static float

Quat_SizeSquared ( const FQuat& Q
)

 Get the squared length of the quaternion.
Public function Static FQuat

Quat_Slerp ( const FQuat& A,
const FQuat& B,
double Alpha
)

 Spherical interpolation between Quaternions. Result is normalized.
Public function Static FVector

Quat_UnrotateVector ( const FQuat& Q,
const FVector& V
)

 Rotate a vector by the inverse of this quaternion.
Public function Static FVector

Quat_VectorForward ( const FQuat& Q
)

 Get the forward direction (X axis) after it has been rotated by this Quaternion.
Public function Static FVector

Quat_VectorRight ( const FQuat& Q
)

 Get the right direction (Y axis) after it has been rotated by this Quaternion.
Public function Static FVector

Quat_VectorUp ( const FQuat& Q
)

 Get the up direction (Z axis) after it has been rotated by this Quaternion.
Public function Static FQuat

QuaternionSpringInterp ( FQuat Current,
FQuat Target,
FQuaternionSpringState& SpringState,
float Stiffness,
float CriticalDampingFactor,
float DeltaTime,
float Mass,
float TargetVelocityAmount,
bool bInitializeFromTarget
)

 Uses a simple spring model to interpolate a quaternion from Current to Target.
Public function Static double

RadiansToDegrees ( double A
)

 Returns degrees value based on the input radians
Public function Static bool Boolean functions.Returns a uniformly distributed random bool
Public function Static bool Returns a random bool
Public function Static bool

RandomBoolWithWeight ( float Weight
)

 Get a random chance with the specified weight.
Public function Static bool

RandomBoolWithWeightFromStream ( const FRandomStream& RandomStream,
float Weight
)

 Get a random chance with the specified weight.
Public function Static double Returns a random float between 0 and 1
Public function Static float Returns a random float between 0 and 1
Public function Static double

RandomFloatInRange ( double Min,
double Max
)

 Generate a random number between Min and Max
Public function Static float

RandomFloatInRangeFromStream ( const FRandomStream& Stream,
float Min,
float Max
)

 Generate a random number between Min and Max
Public function Static int32

RandomInteger ( int32 Max
)

 Returns a uniformly distributed random number between 0 and Max - 1
Public function Static int64

RandomInteger64 ( int64 Max
)

 Returns a uniformly distributed random number between 0 and Max - 1
Public function Static int64

RandomInteger64InRange ( int64 Min,
int64 Max
)

 Return a random integer64 between Min and Max (>= Min and <= Max)
Public function Static int32

RandomIntegerFromStream ( const FRandomStream& Stream,
int32 Max
)

 Random stream functionsReturns a uniformly distributed random number between 0 and Max - 1
Public function Static int32

RandomIntegerInRange ( int32 Min,
int32 Max
)

 Return a random integer between Min and Max (>= Min and <= Max)
Public function Static int32

RandomIntegerInRangeFromStream ( const FRandomStream& Stream,
int32 Min,
int32 Max
)

 Return a random integer between Min and Max (>= Min and <= Max)
Public function Static FVector

RandomPointInBoundingBox ( const FVector Center,
const FVector HalfSize
)

 Returns a random point within the specified bounding box using the first vector as an origin and the second as the box extents.
Public function Static FVector

RandomPointInBoundingBox_Box ( const FBox Box
)

 Returns a random point within the specified bounding box.
Public function Static FVector

RandomPointInBoundingBoxFromStream ( const FRandomStream& Stream,
const FVector Center,
const FVector HalfSize
)

 Returns a random point within the specified bounding box using the first vector as an origin and the second as the half size of the AABB.
Public function Static FVector

RandomPointInBoundingBoxFromStream_Box ( const FRandomStream& Stream,
const FBox Box
)

 Returns a random point within the specified bounding box.
Public function Static FRotator

RandomRotator ( bool bRoll
)

 Generates a random rotation, with optional random roll.
Public function Static FRotator

RandomRotatorFromStream ( const FRandomStream& Stream,
bool bRoll
)

 Create a random rotation
Public function Static FVector Returns a random vector with length of 1
Public function Static FVector Returns a random vector with length of 1.0
Public function Static FVector

RandomUnitVectorInConeInDegrees ( FVector ConeDir,
float ConeHalfAngleInDegrees
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInConeInDegreesFromStream ( const FRandomStream& Stream,
const FVector& ConeDir,
float ConeHalfAngleInDegrees
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInConeInRadians ( FVector ConeDir,
float ConeHalfAngleInRadians
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInConeInRadiansFromStream ( const FRandomStream& Stream,
const FVector& ConeDir,
float ConeHalfAngleInRadians
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInEllipticalConeInDegrees ( FVector ConeDir,
float MaxYawInDegrees,
float MaxPitchInDegrees
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInEllipticalConeInDegreesFromStream ( const FRandomStream& Stream,
const FVector& ConeDir,
float MaxYawInDegrees,
float MaxPitchInDegrees
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInEllipticalConeInRadians ( FVector ConeDir,
float MaxYawInRadians,
float MaxPitchInRadians
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FVector

RandomUnitVectorInEllipticalConeInRadiansFromStream ( const FRandomStream& Stream,
const FVector& ConeDir,
float MaxYawInRadians,
float MaxPitchInRadians
)

 Returns a random vector with length of 1, within the specified cone, with uniform random distribution.
Public function Static FRotator

REase ( FRotator A,
FRotator B,
float Alpha,
bool bShortestPath,
TEnumAsByte< EEasingFunc::Type > EasingFunc,
float BlendExp,
int32 Steps
)

 Easing between A and B using a specified easing function
Public function Static void Resets the state of a float spring
Public function Static void Resets the state of a quaternion spring
Public function Static void

ResetRandomStream ( const FRandomStream& Stream
)

 Reset a random stream
Public function Static void Resets the state of a vector spring
Public function Static FLinearColor Converts a RGB linear color to HSV (where H is in R, S is in G, and V is in B)
Public function Static void

RGBToHSV ( FLinearColor InColor,
float& H,
float& S,
float& V,
float& A
)

 Breaks apart a color into individual HSV components (as well as alpha) (Hue is [0..360) while Saturation and Value are 0..1)
Public function Static void Converts a RGB linear color to HSV (where H is in R (0..360), S is in G (0..1), and V is in B (0..1))
Public function Static FRotator

RInterpTo ( FRotator Current,
FRotator Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target rotation based on Current rotation, giving a nice smooth feeling when rotating to Target rotation.
Public function Static FRotator

RInterpTo_Constant ( FRotator Current,
FRotator Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target rotation at a constant rate.FRotator
Public function Static FRotator

RLerp ( FRotator A,
FRotator B,
float Alpha,
bool bShortestPath
)

 Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
Public function Static FVector

RotateAngleAxis ( FVector InVect,
float AngleDeg,
FVector Axis
)

 Returns result of vector A rotated by AngleDeg around Axis
Public function Static FRotator

RotatorFromAxisAndAngle ( FVector Axis,
float Angle
)

 Create a rotation from an axis and supplied angle (in degrees)
Public function Static int32

Round ( double A
)

 Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2)
Public function Static int64

Round64 ( double A
)

 Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2)
Public function Static double

SafeDivide ( double A,
double B
)

 This functions returns 0 if B (the denominator) is zero
Public function Static void Create a new random seed for a random stream
Public function Static UClass *

SelectClass ( UClass* A,
UClass* B,
bool bSelectA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static FLinearColor

SelectColor ( FLinearColor A,
FLinearColor B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static double

SelectFloat ( double A,
double B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static int32

SelectInt ( int32 A,
int32 B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static UObject *

SelectObject ( UObject* A,
UObject* B,
bool bSelectA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static FRotator

SelectRotator ( FRotator A,
FRotator B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static FString

SelectString ( const FString& A,
const FString& B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static FTransform

SelectTransform ( const FTransform& A,
const FTransform& B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static FVector

SelectVector ( FVector A,
FVector B,
bool bPickA
)

 If bPickA is true, A is returned, otherwise B is
Public function Static void

Set2D ( FVector2D& A,
double X,
double Y
)

 Set the values of the vector directly.
Public function Static void

SetFloatSpringStateVelocity ( FFloatSpringState& SpringState,
float Velocity
)

 Sets the state velocity of a float spring
Public function Static void

SetQuaternionSpringStateAngularVelocity ( FQuaternionSpringState& SpringState,
FVector AngularVelocity
)

 Sets the state angular velocity of a quaternion spring
Public function Static void

SetRandomStreamSeed ( FRandomStream& Stream,
int32 NewSeed
)

 Set the seed of a random stream to a specific number
Public function Static void

SetVectorSpringStateVelocity ( FVectorSpringState& SpringState,
FVector Velocity
)

 Sets the state velocity of a vector spring
Public function Static double

SignOfFloat ( double A
)

 Sign (float, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
Public function Static int32

SignOfInteger ( int32 A
)

 Sign (integer, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
Public function Static int64

SignOfInteger64 ( int64 A
)

 Sign (integer64, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)
Public function Static double

Sin ( double A
)

 Returns the sine of A (expects Radians)
Public function Static FVector

Spherical2DToUnitCartesian ( FVector2D A
)

 Converts spherical coordinates on the unit sphere into a Cartesian unit length vector.
Public function Static double

Sqrt ( double A
)

 Returns square root of A
Public function Static double

Square ( double A
)

 Returns square of A (A*A)
Public function Static uint8

Subtract_ByteByte ( uint8 A,
uint8 B
)

 Subtraction (A - B)
Public function Static FTimespan Subtraction (A - B)
Public function Static FDateTime Subtraction (A - B)
Public function Static double

Subtract_DoubleDouble ( double A,
double B
)

 Subtraction (A - B)
Public function Static int64

Subtract_Int64Int64 ( int64 A,
int64 B
)

 Subtraction (A - B)
Public function Static int32

Subtract_IntInt ( int32 A,
int32 B
)

 Subtraction (A - B)
Public function Static FIntPoint

Subtract_IntPointInt ( FIntPoint A,
int32 B
)

 Subtraction (A - B)
Public function Static FIntPoint

Subtract_IntPointIntPoint ( FIntPoint A,
FIntPoint B
)

 Returns IntPoint A subtracted by B
Public function Static FLinearColor Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A)
Public function Static FQuat

Subtract_QuatQuat ( const FQuat& A,
const FQuat& B
)

 Returns subtraction of Vector B from Vector A (A - B)
Public function Static FTimespan Subtraction (A - B)
Public function Static FVector2D

Subtract_Vector2DFloat ( FVector2D A,
double B
)

 Returns Vector A subtracted by B
Public function Static FVector2D

Subtract_Vector2DVector2D ( FVector2D A,
FVector2D B
)

 Returns subtraction of Vector B from Vector A (A - B)
Public function Static FVector4

Subtract_Vector4Vector4 ( const FVector4& A,
const FVector4& B
)

 Returns subtraction of Vector B from Vector A (A - B)
Public function Static FVector

Subtract_VectorFloat ( FVector A,
double B
)

 Subtracts a float from each component of a vector
Public function Static FVector

Subtract_VectorInt ( FVector A,
int32 B
)

 Subtracts an integer from each component of a vector
Public function Static FVector

Subtract_VectorVector ( FVector A,
FVector B
)

 Vector subtraction
Public function Static double

Tan ( double A
)

 Returns the tan of A (expects Radians)
Public function Static FTransform

TEase ( const FTransform& A,
const FTransform& B,
float Alpha,
TEnumAsByte< EEasingFunc::Type > EasingFunc,
float BlendExp,
int32 Steps
)

 Ease between A and B using a specified easing function.
Public function Static bool

TimespanFromString ( FString TimespanString,
FTimespan& Result
)

 Converts a time span string to a Timespan object
Public function Static FTimespan Timespan constantsReturns the maximum time span value
Public function Static FTimespan Returns the minimum time span value
Public function Static float Returns the ratio between two time spans (A / B), handles zero values
Public function Static FTimespan Returns a zero time span value
Public function Static FTransform

TInterpTo ( const FTransform& Current,
const FTransform& Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target transform based on distance from Current position, giving a nice smooth feeling when tracking a position.
Public function Static FTransform

TLerp ( const FTransform& A,
const FTransform& B,
float Alpha,
TEnumAsByte< ELerpInterpolationMode::Type > InterpMode
)

 Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1).
Public function Static FDateTime

Today ()

 Returns the local date on this computer
Public function Static void

ToDirectionAndLength2D ( FVector2D A,
FVector2D& OutDir,
double& OutLength
)

 Util to convert this vector into a unit direction vector and its original length.
Public function Static FString Converts this color value to a hexadecimal string. The format of the string is RRGGBBAA.
Public function Static FVector2D

ToRounded2D ( FVector2D A
)

 Get this vector as a vector where each component has been rounded to the nearest int.
Public function Static FVector2D

ToSign2D ( FVector2D A
)

 Get a copy of the vector as sign only.
Public function Static int64

ToUnixTimestamp ( const FDateTime& Time
)

 Returns this date as the number of seconds since the Unix Epoch (January 1st of 1970).
Public function Static double Returns this date as the number of seconds since the Unix Epoch (January 1st of 1970).
Public function Static float

Transform_Determinant ( const FTransform& Transform
)

 Calculates the determinant of the transform (converts to FMatrix internally)
Public function Static FVector

TransformDirection ( const FTransform& T,
FVector Direction
)

 Transform a direction vector by the supplied transform - will not change its length.
Public function Static FVector

TransformLocation ( const FTransform& T,
FVector Location
)

 Transform a position by the supplied transform.
Public function Static FRotator

TransformRotation ( const FTransform& T,
FRotator Rotation
)

 Transform a rotator by the supplied transform.
Public function Static FVector4

TransformVector4 ( const FMatrix& Matrix,
const FVector4& Vec4
)

 Transform the input vector4 by a provided matrix4x4 and returns the resulting vector4.
Public function Static FDateTime

UtcNow ()

 Returns the UTC date and time on this computer
Public function Static FVector

VEase ( FVector A,
FVector B,
float Alpha,
TEnumAsByte< EEasingFunc::Type > EasingFunc,
float BlendExp,
int32 Steps
)

 Easing between A and B using a specified easing function
Public function Static void

Vector_AddBounded ( FVector& A,
FVector InAddVect,
float InRadius
)

 Add a vector to this and clamp the result to an axis aligned cube centered at the origin.
Public function Static void

Vector_Assign ( FVector& A,
const FVector& InVector
)

 Assign the values of the supplied vector.
Public function Static FVector 3D vector Unreal backward direction constant (-1,0,0)
Public function Static FVector

Vector_BoundedToBox ( FVector InVect,
FVector InBoxMin,
FVector InBoxMax
)

 Get a copy of this vector, clamped inside of the specified axis aligned cube.
Public function Static FVector

Vector_BoundedToCube ( FVector InVect,
float InRadius
)

 Get a copy of this vector, clamped inside of an axis aligned cube centered at the origin.
Public function Static FVector

Vector_ClampSize2D ( FVector A,
double Min,
double Max
)

 Create a copy of this vector, with the 2D magnitude/size/length clamped between Min and Max.
Public function Static FVector

Vector_ClampSizeMax ( FVector A,
double Max
)

 Create a copy of this vector, with its maximum magnitude/size/length clamped to MaxSize.
Public function Static FVector

Vector_ClampSizeMax2D ( FVector A,
double Max
)

 Create a copy of this vector, with the maximum 2D magnitude/size/length clamped to MaxSize.
Public function Static FVector

Vector_ComponentMax ( FVector A,
FVector B
)

 Find the maximum elements (X, Y and Z) between the two vector's components
Public function Static FVector

Vector_ComponentMin ( FVector A,
FVector B
)

 Find the minimum elements (X, Y and Z) between the two vector's components
Public function Static double

Vector_CosineAngle2D ( FVector A,
FVector B
)

 Returns the cosine of the angle between this vector and another projected onto the XY plane (no Z).
Public function Static double

Vector_Distance ( FVector V1,
FVector V2
)

 Distance between two points.
Public function Static double

Vector_Distance2D ( FVector V1,
FVector V2
)

 Euclidean distance between two points in the XY plane (ignoring Z).
Public function Static double

Vector_Distance2DSquared ( FVector V1,
FVector V2
)

 Squared euclidean distance between two points in the XY plane (ignoring Z).
Public function Static double

Vector_DistanceSquared ( FVector V1,
FVector V2
)

 Squared distance between two points.
Public function Static FVector 3D vector Unreal down direction constant (0,0,-1)
Public function Static FVector 3D vector Unreal forward direction constant (1,0,0)
Public function Static FVector

Vector_GetAbs ( FVector A
)

 Get a copy of this vector with absolute value of each component.
Public function Static double

Vector_GetAbsMax ( FVector A
)

 Find the maximum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
Public function Static double

Vector_GetAbsMin ( FVector A
)

 Find the minimum absolute element (abs(X), abs(Y) or abs(Z)) of a vector
Public function Static FVector

Vector_GetProjection ( FVector A
)

 Projects 2D components of vector based on Z.
Public function Static FVector

Vector_GetSignVector ( FVector A
)

 Get a copy of the vector as sign only.
Public function Static double

Vector_HeadingAngle ( FVector A
)

 Convert a direction vector into a 'heading' angle.
Public function Static bool

Vector_IsNAN ( const FVector& A
)

 Determines if any component is not a number (NAN)
Public function Static bool

Vector_IsNearlyZero ( const FVector& A,
float Tolerance
)

 Checks whether vector is near to zero within a specified tolerance.
Public function Static bool

Vector_IsNormal ( const FVector& A
)

 Determines if vector is normalized / unit (length 1).
Public function Static bool

Vector_IsUniform ( const FVector& A,
float Tolerance
)

 Checks whether all components of this vector are the same, within a tolerance.
Public function Static bool

Vector_IsUnit ( const FVector& A,
float SquaredLenthTolerance
)

 Determines if vector is normalized / unit (length 1) within specified squared tolerance.
Public function Static bool

Vector_IsZero ( const FVector& A
)

 Checks whether all components of the vector are exactly zero.
Public function Static FVector 3D vector Unreal left direction constant (0,-1,0)
Public function Static FVector

Vector_MirrorByPlane ( FVector A,
const FPlane& InPlane
)

 Mirrors a vector about a plane.
Public function Static FVector

Vector_Normal2D ( FVector A,
float Tolerance
)

 Gets a normalized unit copy of the 2D components of the vector, ensuring it is safe to do so.
Public function Static void

Vector_Normalize ( FVector& A,
float Tolerance
)

 Normalize this vector in-place if it is large enough or set it to (0,0,0) otherwise.
Public function Static FVector

Vector_NormalUnsafe ( const FVector& A
)

 Calculates normalized unit version of vector without checking for zero length.
Public function Static FVector 3D vector one constant (1,1,1)
Public function Static FVector

Vector_ProjectOnToNormal ( FVector V,
FVector InNormal
)

 Gets a copy of this vector projected onto the input vector, which is assumed to be unit length.
Public function Static FVector

Vector_Reciprocal ( const FVector& A
)

 Gets the reciprocal of this vector, avoiding division by zero.
Public function Static FVector 3D vector Unreal right direction constant (0,1,0)
Public function Static void

Vector_Set ( FVector& A,
double X,
double Y,
double Z
)

 Set the values of the vector directly.
Public function Static FVector

Vector_SlerpNormals ( FVector NormalA,
FVector NormalB,
double Alpha
)

 Interpolate from normalized vector A to normalized vector B along a spherical path.
Public function Static FVector

Vector_SlerpVectorToDirection ( FVector Vector,
FVector Direction,
double Alpha
)

 Interpolate from a vector to the direction of another vector along a spherical path.
Public function Static FVector

Vector_SnappedToGrid ( FVector InVect,
float InGridSize
)

 Gets a copy of this vector snapped to a grid.
Public function Static FVector

Vector_ToDegrees ( FVector A
)

 Converts a vector containing radian values to a vector containing degree values.
Public function Static FVector

Vector_ToRadians ( FVector A
)

 Converts a vector containing degree values to a vector containing radian values.
Public function Static FVector2D Converts a Cartesian unit vector into spherical coordinates on the unit sphere.
Public function Static void

Vector_UnwindEuler ( FVector& A
)

 When this vector contains Euler angles (degrees), ensure that angles are between +/-180
Public function Static FVector 3D vector Unreal up direction constant (0,0,1)
Public function Static FVector Vector (3D) constants - exposed for scripting3D vector zero constant (0,0,0)FVector
Public function Static FVector2D Vector2D constants - exposed for scripting2D one vector constant (1,1)FVector2D
Public function Static FVector2D 2D unit vector constant along the 45 degree angle or symmetrical positive axes (sqrt(.5),sqrt(.5)) or (.707,.707).
Public function Static FVector2D 2D zero vector constant (0,0)
Public function Static FVector2D

Vector2DInterpTo ( FVector2D Current,
FVector2D Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
Public function Static FVector2D

Vector2DInterpTo_Constant ( FVector2D Current,
FVector2D Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target at a constant rate.
Public function Static void

Vector4_Assign ( FVector4& A,
const FVector4& InVector
)

 Assign the values of the supplied vector.
Public function Static FVector4

Vector4_CrossProduct3 ( const FVector4& A,
const FVector4& B
)

 Returns the cross product of two vectors - see http://mathworld.wolfram.com/CrossProduct.html
Public function Static double

Vector4_DotProduct ( const FVector4& A,
const FVector4& B
)

 Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html
Public function Static double

Vector4_DotProduct3 ( const FVector4& A,
const FVector4& B
)

 Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html The W element is ignored.
Public function Static bool

Vector4_IsNAN ( const FVector4& A
)

 Determines if any component is not a number (NAN)
Public function Static bool

Vector4_IsNearlyZero3 ( const FVector4& A,
float Tolerance
)

 Checks whether vector is near to zero within a specified tolerance. The W element is ignored.
Public function Static bool

Vector4_IsNormal3 ( const FVector4& A
)

 Determines if vector is normalized / unit (length 1). The W element is ignored.
Public function Static bool

Vector4_IsUnit3 ( const FVector4& A,
float SquaredLenthTolerance
)

 Determines if vector is normalized / unit (length 1) within specified squared tolerance.
Public function Static bool

Vector4_IsZero ( const FVector4& A
)

 Checks whether all components of the vector are exactly zero.
Public function Static FVector4

Vector4_MirrorByVector3 ( const FVector4& Direction,
const FVector4& SurfaceNormal
)

 Given a direction vector and a surface normal, returns the vector reflected across the surface normal.
Public function Static FVector4

Vector4_Negated ( const FVector4& A
)

 Gets a negated copy of the vector. Equivalent to -Vector for scripts.
Public function Static FVector4

Vector4_Normal3 ( const FVector4& A,
float Tolerance
)

 Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length.
Public function Static void

Vector4_Normalize3 ( FVector4& A,
float Tolerance
)

 Normalize this vector in-place if it is large enough or set it to (0,0,0,0) otherwise.
Public function Static FVector4

Vector4_NormalUnsafe3 ( const FVector4& A
)

 Calculates normalized unit version of vector without checking for zero length.
Public function Static void

Vector4_Set ( FVector4& A,
double X,
double Y,
double Z,
double W
)

 Set the values of the vector directly.
Public function Static double

Vector4_Size ( const FVector4& A
)

 Returns the length of the vector.
Public function Static double

Vector4_Size3 ( const FVector4& A
)

 Returns the length of the vector. The W element is ignored.
Public function Static double

Vector4_SizeSquared ( const FVector4& A
)

 Returns the squared length of the vector.
Public function Static double

Vector4_SizeSquared3 ( const FVector4& A
)

 Returns the squared length of the vector. The W element is ignored.
Public function Static FVector4 Vector4 constants - exposed for scripting4D vector zero constant (0,0,0)FVector4
Public function Static FVector

VectorSpringInterp ( FVector Current,
FVector Target,
FVectorSpringState& SpringState,
float Stiffness,
float CriticalDampingFactor,
float DeltaTime,
float Mass,
float TargetVelocityAmount,
bool bClamp,
FVector MinValue,
FVector MaxValue,
bool bInitializeFromTarget
)

 Uses a simple spring model to interpolate a vector from Current to Target.
Public function Static FVector

VInterpTo ( FVector Current,
FVector Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position.
Public function Static FVector

VInterpTo_Constant ( FVector Current,
FVector Target,
float DeltaTime,
float InterpSpeed
)

 Tries to reach Target at a constant rate.
Public function Static FVector

VLerp ( FVector A,
FVector B,
float Alpha
)

 Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1)
Public function Static double

VSize ( FVector A
)

 Returns the length of the vector
Public function Static double

VSize2D ( FVector2D A
)

 Returns the length of a 2D Vector.
Public function Static double

VSize2DSquared ( FVector2D A
)

 Returns the squared length of a 2D Vector.
Public function Static double

VSizeSquared ( FVector A
)

 Returns the squared length of the vector
Public function Static double

VSizeXY ( FVector A
)

 Returns the length of the vector's XY components.
Public function Static double

VSizeXYSquared ( FVector A
)

 Returns the squared length of the vector's XY components.
Public function Static float

WeightedMovingAverage_Float ( float CurrentSample,
float PreviousSample,
float Weight
)

 Calculates the new value in a weighted moving average series using the previous value and the weight
Public function Static FRotator

WeightedMovingAverage_FRotator ( FRotator CurrentSample,
FRotator PreviousSample,
float Weight
)

 Calculates the new value in a weighted moving average series using the previous value and the weight
Public function Static FVector

WeightedMovingAverage_FVector ( FVector CurrentSample,
FVector PreviousSample,
float Weight
)

 Calculates the new value in a weighted moving average series using the previous value and the weight
Public function Static int32

Wrap ( int32 Value,
int32 Min,
int32 Max
)

 Returns Value between A and B (inclusive) that wraps around
Public function Static int64

Xor_Int64Int64 ( int64 A,
int64 B
)

 Bitwise XOR (A ^ B)
Public function Static int32

Xor_IntInt ( int32 A,
int32 B
)

 Bitwise XOR (A ^ B)

Deprecated Variables

  Type Name Description
Public variable   DeprecatedFunction Use MinAreaRectangle instead. This deprecated version incorrectly returns the average of all input points as the rectangle center.

Deprecated Functions

  Type Name Description
Public function Static float

Add_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static void

BreakVector ( FVector InVec,
float& X,
float& Y,
float& Z
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static void

BreakVector2D ( FVector2D InVec,
float& X,
float& Y
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static void

BreakVector3f ( FVector3f InVec,
float& X,
float& Y,
float& Z
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static void

BreakVector4 ( const FVector4& InVec,
float& X,
float& Y,
float& Z,
float& W
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static float

Conv_BoolToFloat ( bool InBool
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static float

Conv_ByteToFloat ( uint8 InByte
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static FLinearColor

Conv_FloatToLinearColor ( float InFloat
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static FVector

Conv_FloatToVector ( float InFloat
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static float

Conv_IntToFloat ( int32 InInt
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static float

Divide_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

EqualEqual_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static int32

FMod ( float Dividend,
float Divisor,
float& Remainder
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

Greater_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

GreaterEqual_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

Less_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

LessEqual_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static float

Multiply_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

NotEqual_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static bool

RandomBoolWithWeightFromStream ( float Weight,
const FRandomStream& RandomStream
)

 Use RandomBoolWithWeightFromStream taking the FRandomStream as the first argument.
Public function Static float

RandomFloatInRangeFromStream ( float Min,
float Max,
const FRandomStream& Stream
)

 Use RandomFloatInRangeFromStream taking the FRandomStream as the first argument.
Public function Static int32

RandomIntegerFromStream ( int32 Max,
const FRandomStream& Stream
)

 Use RandomIntegerFromStream taking the FRandomStream as the first argument.
Public function Static int32

RandomIntegerInRangeFromStream ( int32 Min,
int32 Max,
const FRandomStream& Stream
)

 Use RandomIntegerInRangeFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomPointInBoundingBoxFromStream ( const FVector Center,
const FVector HalfSize,
const FRandomStream& Stream
)

 Use RandomPointInBoundingBoxFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomPointInBoundingBoxFromStream_Box ( const FBox Box,
const FRandomStream& Stream
)

 Use RandomPointInBoundingBoxFromStream_Box taking the FRandomStream as the first argument.
Public function Static FRotator

RandomRotatorFromStream ( bool bRoll,
const FRandomStream& Stream
)

 Use RandomRotatorFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomUnitVectorInConeInDegreesFromStream ( const FVector& ConeDir,
float ConeHalfAngleInDegrees,
const FRandomStream& Stream
)

 Use RandomUnitVectorInConeInDegreesFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomUnitVectorInConeInRadiansFromStream ( const FVector& ConeDir,
float ConeHalfAngleInRadians,
const FRandomStream& Stream
)

 Use RandomUnitVectorInConeInRadiansFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomUnitVectorInEllipticalConeInDegreesFromStream ( const FVector& ConeDir,
float MaxYawInDegrees,
float MaxPitchInDegrees,
const FRandomStream& Stream
)

 Use RandomUnitVectorInEllipticalConeInDegreesFromStream taking the FRandomStream as the first argument.
Public function Static FVector

RandomUnitVectorInEllipticalConeInRadiansFromStream ( const FVector& ConeDir,
float MaxYawInRadians,
float MaxPitchInRadians,
const FRandomStream& Stream
)

 Use RandomUnitVectorInEllipticalConeInRadiansFromStream taking the FRandomStream as the first argument.
Public function Static float

Subtract_FloatFloat ( float A,
float B
)

 This method has been deprecated and will be removed. Use the double version instead.
Public function Static void

ToDirectionAndLength2D ( FVector2D A,
FVector2D& OutDir,
float& OutLength
)

 This method has been deprecated and will be removed. Use the double version instead.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page