| UObjectBase
|
Module |
|
Header |
/Engine/Source/Runtime/Engine/Classes/Kismet/KismetMathLibrary.h |
Include |
#include "Kismet/KismetMathLibrary.h" |
class UKismetMathLibrary : public UBlueprintFunctionLibrary
Name | Description | |
---|---|---|
|
UKismetMathLibrary ( |
Name | Description | ||
---|---|---|---|
|
float |
Abs ( |
Returns the absolute (positive) value of A |
|
Abs_Int ( |
Returns the absolute (positive) value of A |
|
|
Abs_Int64 ( |
Returns the absolute (positive) value of A |
|
|
float |
Acos ( |
Returns the inverse cosine (arccos) of A (result is in Radians) |
|
Add_ByteByte |
Addition (A + B) |
|
|
Add_DateTimeDateTime |
Addition (A + B) |
|
|
Add_DateTimeTimespan |
Addition (A + B) DateTime functions |
|
|
float |
Add_FloatFloat ( |
Addition (A + B) |
|
Add_Int64Int64 |
Addition (A + B) |
|
|
Add_IntInt |
Addition (A + B) |
|
|
Add_IntPointInt |
Addition (A - B) |
|
|
Add_IntPointIntPoint |
Returns IntPoint A added by B |
|
|
Add_LinearColorLinearColor ( |
Element-wise addition of two linear colors (R+R, G+G, B+B, A+A) |
|
|
Add_MatrixMatrix |
Gets the result of adding a matrix to this. |
|
|
Add_QuatQuat |
Returns addition of Vector A and Vector B (A + B) |
|
|
Add_TimespanTimespan |
Addition (A + B) Timespan functions |
|
|
Add_Vector2DFloat ( |
Returns Vector A added by B |
|
|
Add_Vector2DVector2D |
Returns addition of Vector A and Vector B (A + B) |
|
|
Add_Vector4Vector4 |
Returns addition of Vector A and Vector B (A + B) |
|
|
Add_VectorFloat ( |
Adds a float to each component of a vector |
|
|
Add_VectorInt |
Adds an integer to each component of a vector |
|
|
Add_VectorVector |
Vector addition |
|
|
And_Int64Int64 |
Bitwise AND (A & B) |
|
|
And_IntInt |
Bitwise AND (A & B) |
|
|
float |
Asin ( |
Returns the inverse sine (arcsin) of A (result is in Radians) |
|
float |
Atan ( |
Returns the inverse tan (atan) (result is in Radians) |
|
float |
Atan2 ( |
Returns the inverse tan (atan2) of A/B (result is in Radians) |
|
BMax |
Returns the maximum value of A and B |
|
|
BMin |
Returns the minimum value of A and B |
|
|
BooleanAND |
Returns the logical AND of two values (A AND B) |
|
|
BooleanNAND |
Returns the logical NAND of two values (A AND B) |
|
|
BooleanNOR |
Returns the logical Not OR of two values (A NOR B) |
|
|
BooleanOR |
Returns the logical OR of two values (A OR B) |
|
|
BooleanXOR |
Returns the logical eXclusive OR of two values (A XOR B) |
|
|
BreakColor ( |
Breaks apart a color into individual RGB components (as well as alpha) |
|
|
BreakDateTime |
Breaks a DateTime into its components |
|
|
BreakFrameRate ( |
Breaks a FFrameRate into a numerator and denominator. |
|
|
BreakQualifiedFrameTime ( |
Breaks a FQualifiedFrameTime into its component parts again. |
|
|
BreakRandomStream ( |
Breaks apart a random number generator |
|
|
BreakRotator ( |
Breaks apart a rotator into {Roll, Pitch, Yaw} angles in degrees |
|
|
BreakRotIntoAxes |
Breaks apart a rotator into its component axes |
|
|
BreakTimespan |
Breaks a Timespan into its components |
|
|
BreakTimespan2 |
Breaks a Timespan into its components |
|
|
BreakTransform ( |
Breaks apart a transform into location, rotation and scale |
|
|
BreakVector ( |
Breaks a vector apart into X, Y, Z |
|
|
BreakVector2D ( |
Breaks a 2D vector apart into X, Y. |
|
|
BreakVector4 ( |
Breaks a 4D vector apart into X, Y, Z, W. |
|
|
CInterpTo ( |
Interpolate Linear Color from Current to Target. |
|
|
Clamp |
Returns Value clamped to be between A and B (inclusive) |
|
|
float |
ClampAngle ( |
Clamps an arbitrary angle to be between the given angles. Will clamp to nearest boundary. |
|
ClampAxes2D ( |
Creates a copy of this vector with both axes clamped to the given range. |
|
|
float |
ClampAxis ( |
Clamps an angle to the range of [0, 360]. |
|
ClampInt64 |
Returns Value clamped to be between A and B (inclusive) |
|
|
ClampVectorSize ( |
Create a copy of this vector, with its magnitude/size/length clamped between Min and Max. |
|
|
ClassIsChildOf ( |
Determine if a class is a child of another class. |
|
|
ComposeRotators |
Combine 2 rotations to give you the resulting rotation of first applying A, then B. |
|
|
ComposeTransforms ( |
Compose two transforms in order: A * B. |
|
|
Conv_BoolToByte ( |
Converts a bool to a byte |
|
|
float |
Conv_BoolToFloat ( |
Converts a bool to a float (0.0f or 1.0f) |
|
Conv_BoolToInt ( |
Converts a bool to an int |
|
|
float |
Conv_ByteToFloat ( |
Converts a byte to a float K2 Utilities |
|
Conv_ByteToInt ( |
Converts a byte to an integer |
|
|
Conv_ColorToLinearColor ( |
Converts a color to LinearColor |
|
|
Conv_FloatToLinearColor ( |
Convert a float into a LinearColor, where each element is that float |
|
|
Conv_FloatToVector ( |
Convert a float into a vector, where each element is that float |
|
|
Conv_Int64ToByte ( |
Converts a 64 bit integer to a byte (if the integer is too large, returns the low 8 bits) |
|
|
Conv_Int64ToInt ( |
Converts a 64 bit integer to a 32 bit integer (if the integer is too large, returns the low 32 bits) |
|
|
Conv_IntPointToVector2D ( |
IntPoint functionsConvert an IntPoint to a Vector2D |
|
|
Conv_IntToBool ( |
Converts a int to a bool |
|
|
Conv_IntToByte ( |
Converts an integer to a byte (if the integer is too large, returns the low 8 bits) |
|
|
float |
Conv_IntToFloat ( |
Converts an integer to a float |
|
Conv_IntToInt64 ( |
Converts an integer to a 64 bit integer |
|
|
Conv_IntToIntVector ( |
Converts an integer to an IntVector |
|
|
Conv_IntVectorToVector ( |
Convert an IntVector to a vector |
|
|
Conv_LinearColorToColor ( |
Quantizes the linear color and returns the result as a FColor with optional sRGB conversion and quality as goal. |
|
|
Conv_LinearColorToVector ( |
Converts a LinearColor to a vector |
|
|
Conv_MatrixToRotator ( |
Convert a Matrix to a Rotator (Assumes Matrix represents a transform) |
|
|
Conv_MatrixToTransform ( |
Matrix functions Convert a Matrix to a Transform (Assumes Matrix represents a transform) |
|
|
Conv_RotatorToTransform ( |
Convert Rotator to Transform |
|
|
Conv_RotatorToVector ( |
Get the X direction vector after this rotation |
|
|
Conv_TransformToMatrix ( |
Convert a Transform to a Matrix with scale |
|
|
Conv_Vector2DToIntPoint ( |
Convert a Vector2D to an IntPoint |
|
|
Conv_Vector2DToVector ( |
Convert a Vector2D to a Vector |
|
|
Conv_Vector4ToQuaternion ( |
Return the Quaternion orientation corresponding to the direction in which the vector points. |
|
|
Conv_Vector4ToRotator ( |
Return the FRotator orientation corresponding to the direction in which the vector points. |
|
|
Conv_Vector4ToVector ( |
Convert a Vector4 to a Vector (dropping the W element) |
|
|
Conv_VectorToLinearColor ( |
Converts a vector to LinearColor |
|
|
Conv_VectorToQuaternion ( |
Return the Quaternion orientation corresponding to the direction in which the vector points. |
|
|
Conv_VectorToRotator ( |
Return the FRotator orientation corresponding to the direction in which the vector points. |
|
|
Conv_VectorToTransform ( |
Convert a vector to a transform. Uses vector as location |
|
|
Conv_VectorToVector2D ( |
Convert a Vector to a Vector2D using the Vector's (X, Y) coordinates |
|
|
float |
Cos ( |
Returns the cosine of A (expects Radians) |
|
CreateVectorFromYawPitch ( |
Creates a directional vector from rotation values {Pitch, Yaw} supplied in degrees with specified Length |
|
|
Cross_VectorVector |
Returns the cross product of two 3d vectors - see http://mathworld.wolfram.com/CrossProduct.html |
|
|
float |
CrossProduct2D |
Returns the cross product of two 2d vectors - see http://mathworld.wolfram.com/CrossProduct.html |
|
DateTimeFromIsoString |
Converts a date string in ISO-8601 format to a DateTime object |
|
|
DateTimeFromString |
Converts a date string to a DateTime object |
|
|
DateTimeMaxValue() |
Returns the maximum date and time value |
|
|
DateTimeMinValue() |
Returns the minimum date and time value |
|
|
DaysInMonth |
Returns the number of days in the given year and month |
|
|
DaysInYear ( |
Returns the number of days in the given year |
|
|
float |
DegAcos ( |
Returns the inverse cos (arccos) of A (result is in Degrees) |
|
float |
DegAsin ( |
Returns the inverse sin (arcsin) of A (result is in Degrees) |
|
float |
DegAtan ( |
Returns the inverse tan (atan) (result is in Degrees) |
|
float |
DegAtan2 ( |
Returns the inverse tan (atan2) of A/B (result is in Degrees) |
|
float |
DegCos ( |
Returns the cos of A (expects Degrees) |
|
float |
DegreesToRadians ( |
Returns radians value based on the input degrees |
|
float |
DegSin ( |
Returns the sin of A (expects Degrees) |
|
float |
DegTan ( |
Returns the tan of A (expects Degrees) |
|
float |
Distance2D |
Distance between two 2D points. |
|
float |
DistanceSquared2D |
Squared distance between two 2D points. |
|
Divide_ByteByte |
Division (A / B) |
|
|
float |
Divide_FloatFloat ( |
Division (A / B) |
|
Divide_Int64Int64 |
Division (A / B) |
|
|
Divide_IntInt |
Division (A / B) |
|
|
Divide_IntPointInt |
Division (A * B) |
|
|
Divide_IntPointIntPoint |
Returns IntPoint A divided by B |
|
|
Divide_LinearColorLinearColor ( |
Element-wise multiplication of two linear colors (R/R, G/G, B/B, A/A) |
|
|
Divide_TimespanFloat ( |
Scalar division (A / s) |
|
|
Divide_Vector2DFloat ( |
Returns Vector A divided by B |
|
|
Divide_Vector2DVector2D |
Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y}) |
|
|
Divide_Vector4Vector4 |
Element-wise Vector divide (Result = {A.x/B.x, A.y/B.y, A.z/B.z, A.w/B.w}) |
|
|
Divide_VectorFloat ( |
Vector divide by a float |
|
|
Divide_VectorInt |
Vector divide by an integer |
|
|
Divide_VectorVector |
Element-wise Vector division (Result = {A.x/B.x, A.y/B.y, A.z/B.z}) |
|
|
float |
Dot_VectorVector |
Returns the dot product of two 3d vectors - see http://mathworld.wolfram.com/DotProduct.html |
|
float |
DotProduct2D |
Returns the dot product of two 2d vectors - see http://mathworld.wolfram.com/DotProduct.html |
|
float |
DynamicWeightedMovingAverage_Float ( |
Calculates the new value in a weighted moving average series using the previous value and a weight range. |
|
DynamicWeightedMovingAverage_FRotator |
Calculates the new value in a weighted moving average series using the previous value and a weight range. |
|
|
DynamicWeightedMovingAverage_FVector |
Calculates the new value in a weighted moving average series using the previous value and a weight range. |
|
|
float |
Ease ( |
Easeing between A and B using a specified easing function |
|
Equal_IntPointIntPoint |
Returns true if IntPoint A is equal to IntPoint B (A == B) |
|
|
EqualEqual_BoolBool |
Returns true if the values are equal (A == B) |
|
|
EqualEqual_ByteByte |
Returns true if A is equal to B (A == B) |
|
|
EqualEqual_ClassClass |
Class operators and functions.Returns true if A and B are equal (A == B) |
|
|
EqualEqual_DateTimeDateTime |
Returns true if the values are equal (A == B) |
|
|
EqualEqual_FloatFloat ( |
Returns true if A is exactly equal to B (A == B) |
|
|
EqualEqual_Int64Int64 |
Returns true if A is equal to B (A == B) |
|
|
EqualEqual_IntInt |
Returns true if A is equal to B (A == B) |
|
|
EqualEqual_LinearColorLinearColor ( |
Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance |
|
|
EqualEqual_MatrixMatrix |
Checks whether another Matrix is equal to this, within specified tolerance. |
|
|
EqualEqual_NameName |
Name operators.Returns true if A and B are equal (A == B) |
|
|
EqualEqual_ObjectObject |
Object operators and functions.Returns true if A and B are equal (A == B) |
|
|
EqualEqual_QuatQuat |
Quat functionsReturns true if Quaternion A is equal to Quaternion B (A == B) within a specified error tolerance |
|
|
EqualEqual_RotatorRotator |
Returns true if rotator A is equal to rotator B (A == B) within a specified error tolerance |
|
|
EqualEqual_TimespanTimespan |
Returns true if the values are equal (A == B) |
|
|
EqualEqual_TransformTransform ( |
Returns true if transform A is equal to transform B |
|
|
EqualEqual_Vector2DVector2D |
Returns true if vector2D A is equal to vector2D B (A == B) within a specified error tolerance |
|
|
EqualEqual_Vector4Vector4 |
Returns true if vector A is equal to vector B (A == B) within a specified error tolerance |
|
|
EqualEqual_VectorVector |
Returns true if vector A is equal to vector B (A == B) within a specified error tolerance |
|
|
EqualExactly_Vector2DVector2D |
Returns true if vector A is equal to vector B (A == B) |
|
|
EqualExactly_Vector4Vector4 |
Returns true if vector A is equal to vector B (A == B) |
|
|
EqualExactly_VectorVector |
Returns true if vector A is equal to vector B (A == B) |
|
|
float |
Exp ( |
Returns exponential(e) to the power A (e^A) |
|
FCeil ( |
Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2) |
|
|
FCeil64 ( |
Rounds A up towards positive infinity / up to the next integer (e.g., -1.6 becomes -1 and 1.6 becomes 2) |
|
|
float |
FClamp ( |
Returns Value clamped between A and B (inclusive) |
|
FFloor ( |
Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1) |
|
|
FFloor64 ( |
Rounds A down towards negative infinity / down to the previous integer (e.g., -1.6 becomes -2 and 1.6 becomes 1) |
|
|
FindClosestPointOnLine |
Find the closest point on an infinite line to a given point. |
|
|
FindClosestPointOnSegment |
Find the closest point on a segment to a given point. |
|
|
FindLookAtRotation |
Find a rotation for an object at Start location to point at Target location. |
|
|
FindNearestPointsOnLineSegments |
Find closest points between 2 segments. |
|
|
float |
FInterpEaseInOut ( |
Interpolate between A and B, applying an ease in/out function. |
|
float |
FInterpTo ( |
Interpolation functions Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position. |
|
float |
FInterpTo_Constant ( |
Tries to reach Target at a constant rate. |
|
float |
FixedTurn ( |
Returns a new rotation component value |
|
float |
FloatSpringInterp ( |
Uses a simple spring model to interpolate a float from Current to Target. |
|
float |
FMax ( |
Returns the maximum value of A and B |
|
float |
FMin ( |
Returns the minimum value of A and B |
|
FMod ( |
Returns the number of times Divisor will go into Dividend (i.e., Dividend divided by Divisor), as well as the remainder |
|
|
float |
Fraction ( |
Returns the fractional part of a float. |
|
FromDays ( |
Returns a time span that represents the specified number of days |
|
|
FromHours ( |
Returns a time span that represents the specified number of hours |
|
|
FromMilliseconds ( |
Returns a time span that represents the specified number of milliseconds |
|
|
FromMinutes ( |
Returns a time span that represents the specified number of minutes |
|
|
FromSeconds ( |
Returns a time span that represents the specified number of seconds |
|
|
FTrunc ( |
Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1) |
|
|
FTrunc64 ( |
Rounds A towards zero, truncating the fractional part (e.g., -1.6 becomes -1 and 1.6 becomes 1) |
|
|
FTruncVector ( |
Rounds A to an integer with truncation towards zero for each element in a vector. |
|
|
float |
FWrap ( |
Returns Value wrapped from A and B (inclusive) |
|
float |
GenericDivide_FloatFloat ( |
|
|
float |
GenericPercent_FloatFloat ( |
|
|
GetAbs2D ( |
Get a copy of this vector with absolute value of each component. |
|
|
float |
GetAbsMax2D ( |
Get the maximum absolute value of the vector's components. |
|
GetAxes |
Get the reference frame direction vectors (axes) described by this rotation |
|
|
GetAzimuthAndElevation ( |
Breaks a direction vector apart into Azimuth (Yaw) and Elevation (Pitch) rotation values given in degrees. |
|
|
GetDate ( |
Returns the date component of A |
|
|
GetDay ( |
Returns the day component of A (1 to 31) |
|
|
GetDayOfYear ( |
Returns the day of year of A |
|
|
GetDays ( |
Returns the days component of A |
|
|
GetDirectionUnitVector |
Find the unit direction vector from one position to another or (0,0,0) if positions are the same. |
|
|
GetDuration ( |
Returns the absolute value of A |
|
|
GetForwardVector ( |
Rotate the world forward vector by the given rotation |
|
|
GetHour ( |
Returns the hour component of A (24h format) |
|
|
GetHour12 ( |
Returns the hour component of A (12h format) |
|
|
GetHours ( |
Returns the hours component of A |
|
|
float |
GetMax2D ( |
Get the maximum value of the vector's components. |
|
float |
GetMaxElement ( |
Find the maximum element (X, Y or Z) of a vector |
|
GetMillisecond ( |
Returns the millisecond component of A |
|
|
GetMilliseconds ( |
Returns the milliseconds component of A |
|
|
float |
GetMin2D ( |
Get the minimum value of the vector's components. |
|
float |
GetMinElement ( |
Find the minimum element (X, Y or Z) of a vector |
|
GetMinute ( |
Returns the minute component of A |
|
|
GetMinutes ( |
Returns the minutes component of A |
|
|
GetMonth ( |
Returns the month component of A |
|
|
float |
GetPI() |
Returns the value of PI |
|
float |
GetPointDistanceToLine |
Find the distance from a point to the closest point on an infinite line. |
|
float |
GetPointDistanceToSegment |
Find the distance from a point to the closest point on a segment. |
|
GetReflectionVector |
Given a direction vector and a surface normal, returns the vector reflected across the surface normal. |
|
|
GetRightVector ( |
Rotate the world right vector by the given rotation |
|
|
GetRotated2D ( |
Rotates around axis (0,0,1) |
|
|
GetSecond ( |
Returns the second component of A |
|
|
GetSeconds ( |
Returns the seconds component of A |
|
|
GetSlopeDegreeAngles |
Returns Slope Pitch and Roll angles in degrees based on the following information: |
|
|
float |
GetTAU() |
Returns the value of TAU (= 2 * PI) |
|
GetTimeOfDay ( |
Returns the time elapsed since midnight of A |
|
|
float |
GetTotalDays ( |
Returns the total number of days in A |
|
float |
GetTotalHours ( |
Returns the total number of hours in A |
|
float |
GetTotalMilliseconds ( |
Returns the total number of milliseconds in A |
|
float |
GetTotalMinutes ( |
Returns the total number of minutes in A |
|
float |
GetTotalSeconds ( |
Returns the total number of seconds in A |
|
GetUpVector ( |
Rotate the world up vector by the given rotation |
|
|
GetVectorArrayAverage |
Find the average of an array of vectors |
|
|
GetYawPitchFromVector ( |
Breaks a vector apart into Yaw, Pitch rotation values given in degrees. (non-clamped) |
|
|
GetYear ( |
Returns the year component of A |
|
|
Greater_ByteByte |
Returns true if A is greater than B (A > B) |
|
|
Greater_DateTimeDateTime |
Returns true if A is greater than B (A > B) |
|
|
Greater_FloatFloat ( |
Returns true if A is greater than B (A > B) |
|
|
Greater_Int64Int64 |
Returns true if A is greater than B (A > B) |
|
|
Greater_IntInt |
Returns true if A is greater than B (A > B) |
|
|
Greater_TimespanTimespan |
Returns true if A is greater than B (A > B) |
|
|
GreaterEqual_ByteByte |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterEqual_DateTimeDateTime |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterEqual_FloatFloat ( |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterEqual_Int64Int64 |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterEqual_IntInt |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterEqual_TimespanTimespan |
Returns true if A is greater than or equal to B (A >= B) |
|
|
GreaterGreater_VectorRotator |
Returns result of vector A rotated by Rotator B |
|
|
float |
GridSnap_Float ( |
Snaps a value to the nearest grid multiple. |
|
HSVToRGB ( |
Make a color from individual color components (HSV space; Hue is [0..360) while Saturation and Value are 0..1) |
|
|
HSVToRGB_Vector ( |
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 |
|
|
HSVToRGBLinear ( |
Converts a HSV linear color (where H is in R, S is in G, and V is in B) to linear RGB |
|
|
float |
Hypotenuse ( |
Returns the hypotenuse of a right-angled triangle given the width and height. |
|
InRange_FloatFloat |
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 |
|
|
InRange_Int64Int64 |
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 |
|
|
InRange_IntInt |
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 |
|
|
IntPoint_Down() |
Down Int Point (0, 1) |
|
|
IntPoint_Left() |
Left Int Point (-1, 0) |
|
|
IntPoint_One() |
One Int Point (1, 1) |
|
|
IntPoint_Right() |
Right Int Point (1, 0) |
|
|
IntPoint_Up() |
Up Int Point (0, -1) |
|
|
IntPoint_Zero() |
IntPoint constantsZero Int Point (0, 0) |
|
|
InverseTransformDirection ( |
Transform a direction vector by the inverse of the supplied transform - will not change its length. |
|
|
InverseTransformLocation ( |
Transform a position by the inverse of the supplied transform. |
|
|
InverseTransformRotation ( |
Transform a rotator by the inverse of the supplied transform. |
|
|
InvertTransform ( |
Returns the inverse of the given transform T. |
|
|
IsAfternoon ( |
Returns whether A's time is in the afternoon |
|
|
IsLeapYear ( |
Returns whether given year is a leap year |
|
|
IsMorning ( |
Returns whether A's time is in the morning |
|
|
IsNearlyZero2D ( |
Checks whether vector is near to zero within a specified tolerance. |
|
|
IsPointInBox |
Determines whether the given point is in a box. Includes points on the box. |
|
|
IsPointInBoxWithTransform ( |
Determines whether a given point is in a box with a given transform. Includes points on the box. |
|
|
IsZero2D ( |
Checks whether all components of the vector are exactly zero. |
|
|
float |
Lerp ( |
Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1) |
|
Less_ByteByte |
Returns true if A is less than B (A < B) |
|
|
Less_DateTimeDateTime |
Returns true if A is less than B (A < B) |
|
|
Less_FloatFloat ( |
Returns true if A is Less than B (A < B) |
|
|
Less_Int64Int64 |
Returns true if A is less than B (A < B) |
|
|
Less_IntInt |
Returns true if A is less than B (A < B) |
|
|
Less_TimespanTimespan |
Returns true if A is less than B (A < B) |
|
|
LessEqual_ByteByte |
Returns true if A is less than or equal to B (A <= B) |
|
|
LessEqual_DateTimeDateTime |
Returns true if A is less than or equal to B (A <= B) |
|
|
LessEqual_FloatFloat ( |
Returns true if A is Less than or equal to B (A <= B) |
|
|
LessEqual_Int64Int64 |
Returns true if A is less than or equal to B (A <= B) |
|
|
LessEqual_IntInt |
Returns true if A is less than or equal to B (A <= B) |
|
|
LessEqual_TimespanTimespan |
Returns true if A is less than or equal to B (A <= B) |
|
|
LessLess_VectorRotator |
Returns result of vector A rotated by the inverse of Rotator B |
|
|
LinearColor_Black() |
Black linear color |
|
|
LinearColor_Blue() |
Blue linear color |
|
|
LinearColor_Desaturated ( |
Returns a desaturated color, with 0 meaning no desaturation and 1 == full desaturation |
|
|
float |
LinearColor_Distance ( |
Euclidean distance between two color points. |
|
float |
LinearColor_GetLuminance ( |
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. |
|
float |
LinearColor_GetMax ( |
Returns the maximum color channel value in this color structure |
|
float |
LinearColor_GetMin ( |
Returns the minimum color channel value in this color structure |
|
LinearColor_Gray() |
Grey linear color |
|
|
LinearColor_Green() |
Green linear color |
|
|
LinearColor_IsNearEqual ( |
Returns true if linear color A is equal to linear color B (A == B) within a specified error tolerance |
|
|
LinearColor_Quantize ( |
Quantizes the linear color and returns the result as an 8-bit color. |
|
|
LinearColor_QuantizeRound ( |
Quantizes the linear color with rounding and returns the result as an 8-bit color. |
|
|
LinearColor_Red() |
Red linear color |
|
|
LinearColor_Set ( |
Assign contents of InColor |
|
|
LinearColor_SetFromHSV ( |
Assigns an HSV color to a linear space RGB color |
|
|
LinearColor_SetFromPow22 ( |
Assigns an FColor coming from an observed Pow(1/2.2) output, into a linear color. |
|
|
LinearColor_SetFromSRGB ( |
Assigns an FColor coming from an observed sRGB output, into a linear color. |
|
|
LinearColor_SetRandomHue ( |
Sets to a random color. Choses a quite nice color based on a random hue. |
|
|
LinearColor_SetRGBA ( |
Assign individual linear RGBA components. |
|
|
LinearColor_SetTemperature ( |
Converts temperature in Kelvins of a black body radiator to RGB chromaticity. |
|
|
LinearColor_ToNewOpacity ( |
Returns a copy of this color using the specified opacity/alpha. |
|
|
LinearColor_ToRGBE ( |
Convert from linear to 8-bit RGBE as outlined in Gregory Ward's Real Pixels article, Graphics Gems II, page 80. |
|
|
LinearColor_Transparent() |
Transparent linear color - black with 0 opacity/alpha |
|
|
LinearColor_White() |
LinearColor constants - exposed for scriptingWhite linear color |
|
|
LinearColor_Yellow() |
Yellow linear color |
|
|
LinearColorLerp ( |
Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1) |
|
|
LinearColorLerpUsingHSV ( |
Linearly interpolates between two colors by the specified Alpha amount (100% of A when Alpha=0 and 100% of B when Alpha=1). |
|
|
LinePlaneIntersection |
Intersection Computes the intersection point between a line and a plane. |
|
|
LinePlaneIntersection_OriginNormal |
Computes the intersection point between a line and a plane. |
|
|
float |
Log ( |
Returns log of A base B (if B^R == A, returns R) |
|
float |
Loge ( |
Returns natural log of A (if e^R == A, returns R) |
|
MakeBox |
Box functionsMakes an FBox from Min and Max and sets IsValid to true |
|
|
MakeBox2D |
Box2D functionsMakes an FBox2D from Min and Max and sets IsValid to true |
|
|
MakeColor ( |
LinearColor functionsMake a color from individual color components (RGB space) |
|
|
MakeDateTime |
DateTime functions.Makes a DateTime struct |
|
|
MakeFrameRate |
Creates a FFrameRate from a Numerator and a Denominator. |
|
|
MakePlaneFromPointAndNormal |
Plane functions. Creates a plane with a facing direction of Normal at the given Point |
|
|
float |
MakePulsatingValue ( |
Simple function to create a pulsating scalar value |
|
FQualifiedFr... |
MakeQualifiedFrameTime ( |
Frame Time and Frame Rate FunctionsCreates a FQualifiedFrameTime out of a frame number, frame rate, and optional 0-1 clamped subframe. |
|
FRandomStrea... |
MakeRandomStream ( |
Misc functionsMakes a SRand-based random number generator |
|
MakeRelativeTransform ( |
Computes a relative transform of one transform compared to another. |
|
|
MakeRotationFromAxes |
Build a reference frame from three axes. |
|
|
MakeRotator ( |
Rotator functions.Makes a rotator {Roll, Pitch, Yaw} from rotation values supplied in degrees |
|
|
MakeRotFromX ( |
Builds a rotator given only a XAxis. |
|
|
MakeRotFromXY |
Builds a matrix with given X and Y axes. |
|
|
MakeRotFromXZ |
Builds a matrix with given X and Z axes. |
|
|
MakeRotFromY ( |
Builds a rotation matrix given only a YAxis. |
|
|
MakeRotFromYX |
Builds a matrix with given Y and X axes. |
|
|
MakeRotFromYZ |
Builds a matrix with given Y and Z axes. |
|
|
MakeRotFromZ ( |
Builds a rotation matrix given only a ZAxis. |
|
|
MakeRotFromZX |
Builds a matrix with given Z and X axes. |
|
|
MakeRotFromZY |
Builds a matrix with given Z and Y axes. |
|
|
MakeTimespan |
Timespan functions.Makes a Timespan struct |
|
|
MakeTimespan2 |
Makes a Timespan struct |
|
|
MakeTransform |
Transform functionsMake a transform from location, rotation and scale |
|
|
MakeVector ( |
Vector (3D) functions.Makes a vector {X, Y, Z} |
|
|
MakeVector2D ( |
Vector2D functionsMakes a 2d vector {X, Y} |
|
|
MakeVector4 ( |
Vector4 functionsMakes a 4D vector {X, Y, Z, W} |
|
|
float |
MapRangeClamped ( |
Returns Value mapped from one range into another where the Value is clamped to the Input Range. |
|
float |
MapRangeUnclamped ( |
Returns Value mapped from one range into another. |
|
Matrix_ApplyScale ( |
Apply Scale to this matrix (Assumes Matrix represents a transform) |
|
|
Matrix_ConcatenateTranslation |
Returns a matrix with an additional translation concatenated. |
|
|
Matrix_ContainsNaN ( |
Returns true if any element of this matrix is NaN |
|
|
Matrix_GetColumn ( |
Get a column of this matrix |
|
|
float |
Matrix_GetDeterminant ( |
|
|
Matrix_GetFrustumBottomPlane |
Get the bottom plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetFrustumFarPlane |
Get the far plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetFrustumLeftPlane |
Get the left plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetFrustumNearPlane |
Get the near plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetFrustumRightPlane |
Get the right plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetFrustumTopPlane |
Get the top plane of the Frustum of this matrix (Assumes Matrix represents a View Projection Matrix) |
|
|
Matrix_GetInverse ( |
Get the inverse of the Matrix. Handles nil matrices. |
|
|
Matrix_GetMatrixWithoutScale ( |
Returns matrix after RemoveScaling with error Tolerance (Assumes Matrix represents a transform) |
|
|
float |
Matrix_GetMaximumAxisScale ( |
|
|
Matrix_GetOrigin ( |
Get the origin of the co-ordinate system (Assumes Matrix represents a transform) |
|
|
Matrix_GetRotator ( |
Get the rotator representation of this matrix (Assumes Matrix represents a transform) |
|
|
float |
Matrix_GetRotDeterminant ( |
|
|
Matrix_GetScaledAxes |
Get axes of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform) |
|
|
Matrix_GetScaledAxis ( |
Get axis of this matrix scaled by the scale of the matrix (Assumes Matrix represents a transform) |
|
|
Matrix_GetScaleVector ( |
Return a 3D scale vector calculated from this matrix (where each component is the magnitude of a row vector) with error Tolerance. |
|
|
Matrix_GetTransposeAdjoint ( |
Get the Transose Adjoint of the Matrix. |
|
|
Matrix_GetTransposed ( |
Transpose. |
|
|
Matrix_GetUnitAxes |
Get unit length axes of this matrix (Assumes Matrix represents a transform) |
|
|
Matrix_GetUnitAxis ( |
Get unit length axis of this matrix (Assumes Matrix represents a transform) |
|
|
Matrix_Identity() |
Identity matrix. |
|
|
Matrix_InverseTransformPosition |
Inverts the matrix and then transforms V - correctly handles scaling in this matrix. |
|
|
Matrix_InverseTransformVector |
Transform a direction vector by the inverse of this matrix - will not take into account translation part. |
|
|
Matrix_Mirror ( |
Utility for mirroring this transform across a certain plane, and flipping one of the axis as well. |
|
|
Matrix_RemoveScaling ( |
Remove any scaling from this matrix (ie magnitude of each row is 1) with error Tolerance (Assumes Matrix represents a transform) |
|
|
Matrix_RemoveTranslation ( |
Remove any translation from this matrix (Assumes Matrix represents a transform) |
|
|
Matrix_ScaleTranslation |
Scale the translation part of the matrix by the supplied vector. |
|
|
Matrix_SetAxis ( |
Set an axis of this matrix (Assumes Matrix represents a transform) |
|
|
Matrix_SetColumn ( |
||
|
Matrix_SetOrigin |
Set the origin of the coordinate system to the given vector (Assumes Matrix represents a transform) |
|
|
Matrix_ToQuat ( |
Transform a rotation matrix into a quaternion. |
|
|
Matrix_TransformPosition |
Transform a location - will take into account translation part of the FMatrix. |
|
|
Matrix_TransformVector |
Transform a direction vector - will not take into account translation part of the FMatrix. |
|
|
Matrix_TransformVector4 |
Transform a vector by the matrix. (Assumes Matrix represents a transform) |
|
|
Max |
Returns the maximum value of A and B |
|
|
MaxInt64 |
Returns the maximum value of A and B |
|
|
MaxOfByteArray |
Returns max of all array entries and the index at which it was found. |
|
|
MaxOfFloatArray |
Returns max of all array entries and the index at which it was found. |
|
|
MaxOfIntArray |
Returns max of all array entries and the index at which it was found. |
|
|
Min |
Returns the minimum value of A and B |
|
|
MinimumAreaRectangle |
Geometry Finds the minimum area rectangle that encloses all of the points in InVerts Uses algorithm found in http://www.geometrictools.com/Documentation/MinimumAreaRectangle.pdf |
|
|
MinInt64 |
Returns the minimum value of A and B |
|
|
MinOfByteArray |
Returns min of all array entries and the index at which it was found. |
|
|
MinOfFloatArray |
Returns min of all array entries and the index at which it was found. |
|
|
MinOfIntArray |
Returns min of all array entries and the index at which it was found. |
|
|
MirrorVectorByNormal |
Given a direction vector and a surface normal, returns the vector reflected across the surface normal. |
|
|
Multiply_ByteByte |
Byte functions.Multiplication (A * B) |
|
|
float |
Multiply_FloatFloat ( |
Multiplication (A * B) |
|
Multiply_Int64Int64 |
Integer64 functions.Multiplication (A * B) |
|
|
float |
Multiply_IntFloat ( |
Multiplication (A * B) |
|
Multiply_IntInt |
Integer functions.Multiplication (A * B) |
|
|
Multiply_IntPointInt |
Multiplication (A * B) |
|
|
Multiply_IntPointIntPoint |
Returns IntPoint A multiplied by B |
|
|
Multiply_LinearColorFloat ( |
Element-wise multiplication of a linear color by a float (F*R, F*G, F*B, F*A) |
|
|
Multiply_LinearColorLinearColor ( |
Element-wise multiplication of two linear colors (R*R, G*G, B*B, A*A) |
|
|
Multiply_MatrixFloat ( |
Multiplies all values of the matrix by a float. |
|
|
Multiply_MatrixMatrix |
Gets the result of multiplying a Matrix to this. |
|
|
Multiply_QuatQuat |
Gets the result of multiplying two quaternions (A * B). |
|
|
Multiply_RotatorFloat ( |
Returns rotator representing rotator A scaled by B |
|
|
Multiply_RotatorInt |
Returns rotator representing rotator A scaled by B |
|
|
Multiply_TimespanFloat ( |
Scalar multiplication (A * s) |
|
|
Multiply_Vector2DFloat ( |
Returns Vector A scaled by B |
|
|
Multiply_Vector2DVector2D |
Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y}) |
|
|
Multiply_Vector4Vector4 |
Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z, A.w*B.w}) |
|
|
Multiply_VectorFloat ( |
Scales Vector A by B |
|
|
Multiply_VectorInt |
Scales Vector A by B |
|
|
Multiply_VectorVector |
Element-wise Vector multiplication (Result = {A.x*B.x, A.y*B.y, A.z*B.z}) |
|
|
float |
MultiplyByPi ( |
Multiplies the input value by pi. |
|
float |
MultiplyMultiply_FloatFloat ( |
Float functions.Power (Base to the Exp-th power) |
|
NearlyEqual_FloatFloat ( |
Returns true if A is nearly equal to B (|A - B| < ErrorTolerance) |
|
|
NearlyEqual_TransformTransform ( |
Returns true if transform A is nearly equal to B |
|
|
Negated2D ( |
Gets a negated copy of the vector. |
|
|
NegateRotator ( |
Negate a rotator |
|
|
NegateVector ( |
Negate a vector. |
|
|
Normal ( |
Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length. |
|
|
Normal2D ( |
Returns a unit normal version of the 2D vector |
|
|
Normalize2D ( |
Normalize this vector in-place if it is large enough, set it to (0,0) otherwise. |
|
|
float |
NormalizeAxis ( |
Clamps an angle to the range of [-180, 180]. |
|
NormalizedDeltaRotator |
Normalized A-B |
|
|
float |
NormalizeToRange ( |
Returns Value normalized to the given range. |
|
NormalSafe2D ( |
Gets a normalized copy of the vector, checking it is safe to do so based on the length. |
|
|
Not_Int ( |
Bitwise NOT (~A) |
|
|
Not_Int64 ( |
Bitwise NOT (~A) |
|
|
Not_PreBool ( |
Returns the logical complement of the Boolean value (NOT A) |
|
|
NotEqual_BoolBool |
Returns true if the values are not equal (A != B) |
|
|
NotEqual_ByteByte |
Returns true if A is not equal to B (A != B) |
|
|
NotEqual_ClassClass |
Returns true if A and B are not equal (A != B) |
|
|
NotEqual_DateTimeDateTime |
Returns true if the values are not equal (A != B) |
|
|
NotEqual_FloatFloat ( |
Returns true if A does not equal B (A != B) |
|
|
NotEqual_Int64Int64 |
Returns true if A is not equal to B (A != B) |
|
|
NotEqual_IntInt |
Returns true if A is not equal to B (A != B) |
|
|
NotEqual_IntPointIntPoint |
Returns true if IntPoint A is NOT equal to IntPoint B (A != B) |
|
|
NotEqual_LinearColorLinearColor ( |
Returns true if linear color A is not equal to linear color B (A != B) within a specified error tolerance |
|
|
NotEqual_MatrixMatrix |
Checks whether another Matrix is not equal to this, within specified tolerance. |
|
|
NotEqual_NameName |
Returns true if A and B are not equal (A != B) |
|
|
NotEqual_ObjectObject |
Returns true if A and B are not equal (A != B) |
|
|
NotEqual_QuatQuat |
Returns true if Quat A is not equal to Quat B (A != B) within a specified error tolerance |
|
|
NotEqual_RotatorRotator |
Returns true if rotator A is not equal to rotator B (A != B) within a specified error tolerance |
|
|
NotEqual_TimespanTimespan |
Returns true if the values are not equal (A != B) |
|
|
NotEqual_Vector2DVector2D |
Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance |
|
|
NotEqual_Vector4Vector4 |
Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance |
|
|
NotEqual_VectorVector |
Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance |
|
|
NotEqualExactly_Vector2DVector2D |
Returns true if vector2D A is not equal to vector2D B (A != B) within a specified error tolerance |
|
|
NotEqualExactly_Vector4Vector4 |
Returns true if vector A is not equal to vector B (A != B) within a specified error tolerance |
|
|
NotEqualExactly_VectorVector |
Returns true if vector A is not equal to vector B (A != B) |
|
|
Now() |
Returns the local date and time on this computer |
|
|
Or_Int64Int64 |
Bitwise OR (A | B) |
|
|
Or_IntInt |
Bitwise OR (A | B) |
|
|
Percent_ByteByte |
Modulo (A % B) |
|
|
float |
Percent_FloatFloat ( |
Modulo (A % B) |
|
Percent_IntInt |
Modulo (A % B) |
|
|
float |
PerlinNoise1D ( |
Generates a 1D Perlin noise from the given value. |
|
PointsAreCoplanar |
Determines whether a given set of points are coplanar, with a tolerance. |
|
|
ProjectPointOnToPlane |
Projects/snaps a point onto a plane defined by a point on the plane and a plane normal. |
|
|
ProjectVectorOnToPlane |
Projects a vector onto a plane defined by a normalized vector (PlaneNormal). |
|
|
ProjectVectorOnToVector |
Projects one vector (V) onto another (Target) and returns the projected vector. |
|
|
float |
Quat_AngularDistance |
Find the angular distance/difference between two rotation quaternions. |
|
Quat_EnforceShortestArcWith |
Modify the quaternion to ensure that the delta between it and B represents the shortest possible rotation angle. |
|
|
Quat_Euler ( |
Convert a Quaternion into floating-point Euler angles (in degrees). |
|
|
Quat_Exp ( |
Used in combination with Log(). |
|
|
float |
Quat_GetAngle ( |
Get the angle of this quaternion |
|
Quat_GetAxisX ( |
Get the forward direction (X axis) after it has been rotated by this Quaternion. |
|
|
Quat_GetAxisY ( |
Get the right direction (Y axis) after it has been rotated by this Quaternion. |
|
|
Quat_GetAxisZ ( |
Get the up direction (Z axis) after it has been rotated by this Quaternion. |
|
|
Quat_GetRotationAxis ( |
Get the axis of rotation of the Quaternion. |
|
|
Quat_Identity() |
Quat constants - exposed for scriptingIdentity quaternion constant |
|
|
Quat_Inversed ( |
Return an inversed copy of this quaternion. |
|
|
Quat_IsFinite ( |
Determine if all the values are finite (not NaN nor Inf) in this Quat. |
|
|
Quat_IsIdentity ( |
Checks whether this Quaternion is an Identity Quaternion. Assumes Quaternion tested is normalized. |
|
|
Quat_IsNonFinite ( |
Determine if there are any non-finite values (NaN or Inf) in this Quat. |
|
|
Quat_IsNormalized ( |
Return true if this quaternion is normalized |
|
|
Quat_Log ( |
Quaternion with W=0 and V=theta*v. |
|
|
Quat_MakeFromEuler ( |
Convert a vector of floating-point Euler angles (in degrees) into a Quaternion. |
|
|
Quat_Normalize ( |
Normalize this quaternion if it is large enough as compared to the supplied tolerance. |
|
|
Quat_Normalized ( |
Get a normalized copy of this quaternion. If it is too small, returns an identity quaternion. |
|
|
Quat_RotateVector |
Rotate a vector by this quaternion. |
|
|
Quat_Rotator ( |
Convert to Rotator representation of this Quaternion. |
|
|
Quat_SetComponents ( |
Set X, Y, Z, W components of Quaternion. |
|
|
Quat_SetFromEuler |
Convert a vector of floating-point Euler angles (in degrees) into a Quaternion. |
|
|
float |
Quat_Size ( |
Get the length of the quaternion. |
|
float |
Quat_SizeSquared ( |
Get the squared length of the quaternion. |
|
Quat_UnrotateVector |
Rotate a vector by the inverse of this quaternion. |
|
|
Quat_VectorForward ( |
Get the forward direction (X axis) after it has been rotated by this Quaternion. |
|
|
Quat_VectorRight ( |
Get the right direction (Y axis) after it has been rotated by this Quaternion. |
|
|
Quat_VectorUp ( |
Get the up direction (Z axis) after it has been rotated by this Quaternion. |
|
|
float |
RadiansToDegrees ( |
Returns degrees value based on the input radians |
|
RandomBool() |
Boolean functions.Returns a uniformly distributed random bool |
|
|
RandomBoolFromStream ( |
Returns a random bool |
|
|
RandomBoolWithWeight ( |
Get a random chance with the specified weight. |
|
|
RandomBoolWithWeightFromStream ( |
Get a random chance with the specified weight. |
|
|
float |
RandomFloat() |
Returns a random float between 0 and 1 |
|
float |
RandomFloatFromStream ( |
Returns a random float between 0 and 1 |
|
float |
RandomFloatInRange ( |
Generate a random number between Min and Max |
|
float |
RandomFloatInRangeFromStream ( |
Generate a random number between Min and Max |
|
RandomInteger ( |
Returns a uniformly distributed random number between 0 and Max - 1 |
|
|
RandomInteger64 ( |
Returns a uniformly distributed random number between 0 and Max - 1 |
|
|
RandomInteger64InRange |
Return a random integer64 between Min and Max (>= Min and <= Max) |
|
|
RandomIntegerFromStream ( |
Random stream functionsReturns a uniformly distributed random number between 0 and Max - 1 |
|
|
RandomIntegerInRange |
Return a random integer between Min and Max (>= Min and <= Max) |
|
|
RandomIntegerInRangeFromStream ( |
Return a random integer between Min and Max (>= Min and <= Max) |
|
|
RandomPointInBoundingBox |
Returns a random point within the specified bounding box using the first vector as an origin and the second as the box extents. |
|
|
RandomRotator ( |
Generates a random rotation, with optional random roll. |
|
|
RandomRotatorFromStream ( |
Create a random rotation |
|
|
RandomUnitVector() |
Returns a random vector with length of 1 |
|
|
RandomUnitVectorFromStream ( |
Returns a random vector with length of 1.0 |
|
|
RandomUnitVectorInConeInDegrees ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInConeInDegreesFromStream ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInConeInRadians ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInConeInRadiansFromStream ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInEllipticalConeInDegrees ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInEllipticalConeInDegreesFromStream ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInEllipticalConeInRadians ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
RandomUnitVectorInEllipticalConeInRadiansFromStream ( |
Returns a random vector with length of 1, within the specified cone, with uniform random distribution. |
|
|
REase ( |
Easing between A and B using a specified easing function |
|
|
ResetFloatSpringState ( |
Resets the state of a given spring |
|
|
ResetRandomStream ( |
Reset a random stream |
|
|
ResetVectorSpringState ( |
Resets the state of a given spring |
|
|
RGBLinearToHSV ( |
Converts a RGB linear color to HSV (where H is in R, S is in G, and V is in B) |
|
|
RGBToHSV ( |
Breaks apart a color into individual HSV components (as well as alpha) (Hue is [0..360) while Saturation and Value are 0..1) |
|
|
RGBToHSV_Vector ( |
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)) |
|
|
RInterpTo |
Tries to reach Target rotation based on Current rotation, giving a nice smooth feeling when rotating to Target rotation. |
|
|
RInterpTo_Constant |
Tries to reach Target rotation at a constant rate. |
|
|
RLerp |
Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1) |
|
|
RotateAngleAxis |
Returns result of vector A rotated by AngleDeg around Axis |
|
|
RotatorFromAxisAndAngle ( |
Create a rotation from an this axis and supplied angle (in degrees) |
|
|
Round ( |
Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2) |
|
|
Round64 ( |
Rounds A to the nearest integer (e.g., -1.6 becomes -2 and 1.6 becomes 2) |
|
|
float |
SafeDivide ( |
This functions returns 0 if B (the denominator) is zero |
|
SeedRandomStream ( |
Create a new random seed for a random stream |
|
|
UClass * |
SelectClass |
If bPickA is true, A is returned, otherwise B is |
|
SelectColor ( |
If bPickA is true, A is returned, otherwise B is |
|
|
float |
SelectFloat ( |
If bPickA is true, A is returned, otherwise B is |
|
SelectInt |
If bPickA is true, A is returned, otherwise B is |
|
|
UObject *... |
SelectObject |
If bPickA is true, A is returned, otherwise B is |
|
SelectRotator |
If bPickA is true, A is returned, otherwise B is |
|
|
SelectString |
If bPickA is true, A is returned, otherwise B is |
|
|
SelectTransform ( |
If bPickA is true, A is returned, otherwise B is |
|
|
SelectVector |
If bPickA is true, A is returned, otherwise B is |
|
|
Set2D ( |
Set the values of the vector directly. |
|
|
SetRandomStreamSeed ( |
Set the seed of a random stream to a specific number |
|
|
float |
SignOfFloat ( |
Sign (float, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0) |
|
SignOfInteger ( |
Sign (integer, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0) |
|
|
SignOfInteger64 ( |
Sign (integer64, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0) |
|
|
float |
Sin ( |
Returns the sine of A (expects Radians) |
|
Spherical2DToUnitCartesian ( |
Converts spherical coordinates on the unit sphere into a Cartesian unit length vector. |
|
|
float |
Sqrt ( |
Returns square root of A |
|
float |
Square ( |
Returns square of A (A*A) |
|
Subtract_ByteByte |
Subtraction (A - B) |
|
|
Subtract_DateTimeDateTime |
Subtraction (A - B) |
|
|
Subtract_DateTimeTimespan |
Subtraction (A - B) |
|
|
float |
Subtract_FloatFloat ( |
Subtraction (A - B) |
|
Subtract_Int64Int64 |
Subtraction (A - B) |
|
|
Subtract_IntInt |
Subtraction (A - B) |
|
|
Subtract_IntPointInt |
Subtraction (A - B) |
|
|
Subtract_IntPointIntPoint |
Returns IntPoint A subtracted by B |
|
|
Subtract_LinearColorLinearColor ( |
Element-wise subtraction of two linear colors (R-R, G-G, B-B, A-A) |
|
|
Subtract_QuatQuat |
Returns subtraction of Vector B from Vector A (A - B) |
|
|
Subtract_TimespanTimespan |
Subtraction (A - B) |
|
|
Subtract_Vector2DFloat ( |
Returns Vector A subtracted by B |
|
|
Subtract_Vector2DVector2D |
Returns subtraction of Vector B from Vector A (A - B) |
|
|
Subtract_Vector4Vector4 |
Returns subtraction of Vector B from Vector A (A - B) |
|
|
Subtract_VectorFloat ( |
Subtracts a float from each component of a vector |
|
|
Subtract_VectorInt |
Subtracts an integer from each component of a vector |
|
|
Subtract_VectorVector |
Vector subtraction |
|
|
float |
Tan ( |
Returns the tan of A (expects Radians) |
|
TEase ( |
Ease between A and B using a specified easing function. |
|
|
TimespanFromString |
Converts a time span string to a Timespan object |
|
|
TimespanMaxValue() |
Timespan constantsReturns the maximum time span value |
|
|
TimespanMinValue() |
Returns the minimum time span value |
|
|
float |
TimespanRatio |
Returns the ratio between two time spans (A / B), handles zero values |
|
TimespanZeroValue() |
Returns a zero time span value |
|
|
TInterpTo ( |
Tries to reach Target transform based on distance from Current position, giving a nice smooth feeling when tracking a position. |
|
|
TLerp ( |
Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1). |
|
|
Today() |
Returns the local date on this computer |
|
|
ToDirectionAndLength2D |
Util to convert this vector into a unit direction vector and its original length. |
|
|
ToRounded2D ( |
Get this vector as a vector where each component has been rounded to the nearest int. |
|
|
ToSign2D ( |
Get a copy of the vector as sign only. |
|
|
float |
Transform_Determinant ( |
Calculates the determinant of the transform (converts to FMatrix internally) |
|
TransformDirection ( |
Transform a direction vector by the supplied transform - will not change its length. |
|
|
TransformLocation ( |
Transform a position by the supplied transform. |
|
|
TransformRotation ( |
Transform a rotator by the supplied transform. |
|
|
TransformVector4 |
Transform the input vector4 by a provided matrix4x4 and returns the resulting vector4. |
|
|
UtcNow() |
Returns the UTC date and time on this computer |
|
|
VEase ( |
Easing between A and B using a specified easing function |
|
|
Vector_AddBounded |
Add a vector to this and clamp the result to an axis aligned cube centered at the origin. |
|
|
Vector_Assign |
Assign the values of the supplied vector. |
|
|
Vector_Backward() |
3D vector Unreal backward direction constant (-1,0,0) |
|
|
Vector_BoundedToBox |
Get a copy of this vector, clamped inside of the specified axis aligned cube. |
|
|
Vector_BoundedToCube ( |
Get a copy of this vector, clamped inside of an axis aligned cube centered at the origin. |
|
|
Vector_ClampSize2D ( |
Create a copy of this vector, with the 2D magnitude/size/length clamped between Min and Max. |
|
|
Vector_ClampSizeMax ( |
Create a copy of this vector, with its maximum magnitude/size/length clamped to MaxSize. |
|
|
Vector_ClampSizeMax2D ( |
Create a copy of this vector, with the maximum 2D magnitude/size/length clamped to MaxSize. |
|
|
Vector_ComponentMax |
Find the maximum elements (X, Y and Z) between the two vector's components |
|
|
Vector_ComponentMin |
Find the minimum elements (X, Y and Z) between the two vector's components |
|
|
float |
Vector_CosineAngle2D |
Returns the cosine of the angle between this vector and another projected onto the XY plane (no Z). |
|
float |
Vector_Distance |
Distance between two points. |
|
float |
Vector_Distance2D |
Euclidean distance between two points in the XY plane (ignoring Z). |
|
float |
Vector_Distance2DSquared |
Squared euclidean distance between two points in the XY plane (ignoring Z). |
|
float |
Vector_DistanceSquared |
Squared distance between two points. |
|
Vector_Down() |
3D vector Unreal down direction constant (0,0,-1) |
|
|
Vector_Forward() |
3D vector Unreal forward direction constant (1,0,0) |
|
|
Vector_GetAbs ( |
Get a copy of this vector with absolute value of each component. |
|
|
float |
Vector_GetAbsMax ( |
Find the maximum absolute element (abs(X), abs(Y) or abs(Z)) of a vector |
|
float |
Vector_GetAbsMin ( |
Find the minimum absolute element (abs(X), abs(Y) or abs(Z)) of a vector |
|
Vector_GetProjection ( |
Projects 2D components of vector based on Z. |
|
|
Vector_GetSignVector ( |
Get a copy of the vector as sign only. |
|
|
float |
Vector_HeadingAngle ( |
Convert a direction vector into a 'heading' angle. |
|
Vector_IsNAN ( |
Determines if any component is not a number (NAN) |
|
|
Vector_IsNearlyZero ( |
Checks whether vector is near to zero within a specified tolerance. |
|
|
Vector_IsNormal ( |
Determines if vector is normalized / unit (length 1). |
|
|
Vector_IsUniform ( |
Checks whether all components of this vector are the same, within a tolerance. |
|
|
Vector_IsUnit ( |
Determines if vector is normalized / unit (length 1) within specified squared tolerance. |
|
|
Vector_IsZero ( |
Checks whether all components of the vector are exactly zero. |
|
|
Vector_Left() |
3D vector Unreal left direction constant (0,-1,0) |
|
|
Vector_MirrorByPlane |
Mirrors a vector about a plane. |
|
|
Vector_Normal2D ( |
Gets a normalized unit copy of the 2D components of the vector, ensuring it is safe to do so. |
|
|
Vector_Normalize ( |
Normalize this vector in-place if it is large enough or set it to (0,0,0) otherwise. |
|
|
Vector_NormalUnsafe ( |
Calculates normalized unit version of vector without checking for zero length. |
|
|
Vector_One() |
3D vector one constant (1,1,1) |
|
|
Vector_ProjectOnToNormal |
Gets a copy of this vector projected onto the input vector, which is assumed to be unit length. |
|
|
Vector_Reciprocal ( |
Gets the reciprocal of this vector, avoiding division by zero. |
|
|
Vector_Right() |
3D vector Unreal right direction constant (0,1,0) |
|
|
Vector_Set ( |
Set the values of the vector directly. |
|
|
Vector_SnappedToGrid ( |
Gets a copy of this vector snapped to a grid. |
|
|
Vector_ToDegrees ( |
Converts a vector containing radian values to a vector containing degree values. |
|
|
Vector_ToRadians ( |
Converts a vector containing degree values to a vector containing radian values. |
|
|
Vector_UnitCartesianToSpherical ( |
Converts a Cartesian unit vector into spherical coordinates on the unit sphere. |
|
|
Vector_UnwindEuler ( |
When this vector contains Euler angles (degrees), ensure that angles are between +/-180 |
|
|
Vector_Up() |
3D vector Unreal up direction constant (0,0,1) |
|
|
Vector_Zero() |
Vector (3D) constants - exposed for scripting3D vector zero constant (0,0,0) |
|
|
Vector2D_One() |
Vector2D constants - exposed for scripting2D one vector constant (1,1) |
|
|
Vector2D_Unit45Deg() |
2D unit vector constant along the 45 degree angle or symmetrical positive axes (sqrt(.5),sqrt(.5)) or (.707,.707). |
|
|
Vector2D_Zero() |
2D zero vector constant (0,0) |
|
|
Vector2DInterpTo |
Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position. |
|
|
Vector2DInterpTo_Constant |
Tries to reach Target at a constant rate. |
|
|
Vector4_Assign |
Assign the values of the supplied vector. |
|
|
Vector4_CrossProduct3 |
Returns the cross product of two vectors - see http://mathworld.wolfram.com/CrossProduct.html |
|
|
float |
Vector4_DotProduct |
Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html |
|
float |
Vector4_DotProduct3 |
Returns the dot product of two vectors - see http://mathworld.wolfram.com/DotProduct.html The W element is ignored. |
|
Vector4_IsNAN ( |
Determines if any component is not a number (NAN) |
|
|
Vector4_IsNearlyZero3 ( |
Checks whether vector is near to zero within a specified tolerance. The W element is ignored. |
|
|
Vector4_IsNormal3 ( |
Determines if vector is normalized / unit (length 1). The W element is ignored. |
|
|
Vector4_IsUnit3 ( |
Determines if vector is normalized / unit (length 1) within specified squared tolerance. |
|
|
Vector4_IsZero ( |
Checks whether all components of the vector are exactly zero. |
|
|
Vector4_MirrorByVector3 |
Given a direction vector and a surface normal, returns the vector reflected across the surface normal. |
|
|
Vector4_Negated ( |
Gets a negated copy of the vector. Equivalent to -Vector for scripts. |
|
|
Vector4_Normal3 ( |
Gets a normalized unit copy of the vector, ensuring it is safe to do so based on the length. |
|
|
Vector4_Normalize3 ( |
Normalize this vector in-place if it is large enough or set it to (0,0,0,0) otherwise. |
|
|
Vector4_NormalUnsafe3 ( |
Calculates normalized unit version of vector without checking for zero length. |
|
|
Vector4_Set ( |
Set the values of the vector directly. |
|
|
float |
Vector4_Size ( |
Returns the length of the vector. |
|
float |
Vector4_Size3 ( |
Returns the length of the vector. The W element is ignored. |
|
float |
Vector4_SizeSquared ( |
Returns the squared length of the vector. |
|
float |
Vector4_SizeSquared3 ( |
Returns the squared length of the vector. The W element is ignored. |
|
Vector4_Zero() |
Vector4 constants - exposed for scripting4D vector zero constant (0,0,0) |
|
|
VectorSpringInterp ( |
Uses a simple spring model to interpolate a vector from Current to Target. |
|
|
VInterpTo |
Tries to reach Target based on distance from Current position, giving a nice smooth feeling when tracking a position. |
|
|
VInterpTo_Constant |
Tries to reach Target at a constant rate. |
|
|
VLerp |
Linearly interpolates between A and B based on Alpha (100% of A when Alpha=0 and 100% of B when Alpha=1) |
|
|
float |
VSize ( |
Returns the length of the vector |
|
float |
VSize2D ( |
Returns the length of a 2D Vector. |
|
float |
VSize2DSquared ( |
Returns the squared length of a 2D Vector. |
|
float |
VSizeSquared ( |
Returns the squared length of the vector |
|
float |
VSizeXY ( |
Returns the length of the vector's XY components. |
|
float |
VSizeXYSquared ( |
Returns the squared length of the vector's XY components. |
|
float |
WeightedMovingAverage_Float ( |
Calculates the new value in a weighted moving average series using the previous value and the weight |
|
WeightedMovingAverage_FRotator |
Calculates the new value in a weighted moving average series using the previous value and the weight |
|
|
WeightedMovingAverage_FVector |
Calculates the new value in a weighted moving average series using the previous value and the weight |
|
|
Wrap |
Returns Value between A and B (inclusive) that wraps around |
|
|
Xor_Int64Int64 |
Bitwise XOR (A ^ B) |
|
|
Xor_IntInt |
Bitwise XOR (A ^ B) |
Name | Description | ||
---|---|---|---|
|
Conv_Vector4ToQuaterion ( |
Conv_Vector4ToQuaterion renamed to Conv_Vector4ToQuaternion |
|
|
Conv_VectorToQuaterion ( |
Conv_VectorToQuaterion was renamed to Conv_VectorToQuaternion |
|
|
ConvertTransformToRelative ( |
Use MakeRelativeTransform instead, with reversed order of arguments. |
|
|
float |
InverseLerp ( |
Use NormalizeToRange instead |