Language:
Discover
By Skill Level
By Category

Math

Choose your OS:

Classes

Name

Description

Public struct

ConcatenateRules

Provides default rules defining the result of concatenating two types.

Public class

FBasicMathExpressionEvaluator

A basic math expression evaluator

Public struct

FBasisVectorMatrix

Public struct

FBox

Implements an axis-aligned box.

Public struct

FBox2D

Implements a rectangular 2D Box.

Public struct

FBoxSphereBounds

Structure for a combined axis aligned bounding box and bounding sphere with the same origin.

Public struct

FCapsuleShape

Structure for capsules.

A capsule consists of two sphere connected by a cylinder.

Public class

FClipProjectionMatrix

Realigns the near plane for an existing projection matrix with an arbitrary clip plane from: http:///sourceforge.net/mailarchive/message.php?msg_id=000901c26324%242181ea90%24a1e93942%40firefly Updated for the fact that our FPlane uses Ax+By+Cz=D.

Public struct

FColor

FColor Stores a color with 8 bits of precision per channel.

Public class

FColorList

Public class

FCurveEdInterface

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

Public struct

FDateRange

Public struct

FDateRangeBound

Public struct

FDecryptedSignature

Public struct

FDoubleRange

Public struct

FDoubleRangeBound

Public class

FDualQuat

Dual quaternion class

Public struct

FDXT1

Structure encompassing single DXT1 block.

Public struct

FDXT5

Structure encompassing single DXT5 block

Public struct

FDXTColor16

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

Public struct

FDXTColor565

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

Public struct

FEdge

Implements an edge consisting of two vertices.

Public struct

FEncryptedSignature

Public class

FFixedRGBASigned8

4 component vector corresponding to PF_R8G8B8A8_SNORM.

Public class

FFloat16

16 bit float components and conversion

Public class

FFloat16Color

RGBA Color made up of FFloat16

Public class

FFloat32

32 bit float components

Public class

FFloat3Packed

3 component vector corresponding to DXGI_FORMAT_R11G11B10_FLOAT.

Public class

FFloatInfo_IEEE32

Public struct

FFloatInterval

A float interval.

Public struct

FFloatRange

A float range.

Public struct

FFloatRangeBound

A float range bound.

Public struct

FForwardSlash

Public struct

FForwardSlashEquals

Public struct

FInt16Range

Public struct

FInt16RangeBound

Public struct

FInt32Interval

An int32 interval.

Public struct

FInt32Range

An int32 range.

Public struct

FInt32RangeBound

An int32 range bound.

Public struct

FInt64Range

Public struct

FInt64RangeBound

Public struct

FInt8Range

Public struct

FInt8RangeBound

Public class

FInterpCurve

Template for interpolation curves.

Public struct

FInterpCurveFloat

Public struct

FInterpCurveLinearColor

Public class

FInterpCurvePoint

Template for interpolation points.

Public struct

FInterpCurveQuat

Public struct

FInterpCurveTwoVectors

Public struct

FInterpCurveVector

Public struct

FInterpCurveVector2D

Public struct

FIntPoint

Structure for integer points in 2-d space.

Public struct

FIntRect

Structure for integer rectangles in 2-d space.

Public struct

FIntVector

Structure for integer vectors in 3-d space.

Public struct

FIntVector4

Public class

FInverseRotationMatrix

Inverse Rotation matrix

Public struct

FLinearColor

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

Public struct

FLookAtMatrix

Public struct

FMath

Global functions.

Public struct

FMatrix

4x4 matrix of floating point values.

Public class

FMatrix2x2

2x2 generalized matrix.

Public struct

FMinus

Public struct

FMinusEquals

Public class

FMirrorMatrix

Mirrors a point about an abitrary plane

Public struct

FNumericUnit

FNumericUnit is a numeric type that wraps the templated type, whilst a specified unit.

Public struct

FOrientedBox

Structure for arbitrarily oriented boxes (not necessarily axis-aligned).

Public class

FOrthoMatrix

Public struct

FPercent

Public class

FPerspectiveMatrix

Public struct

FPlane

Structure for three dimensional planes.

Public struct

FPlus

Public struct

FPlusEquals

Public struct

FPower

Public struct

FQuantizationInfo

Structure used to define the factor required to get from one unit type to the next.

Public struct

FQuat

Floating point quaternion that can represent a rotation about an axis in 3-D space.

Public class

FQuat2D

Represents a 2D rotation as a complex number (analagous to quaternions).

Public class

FQuatRotationMatrix

Rotation matrix using quaternion rotation

Public class

FQuatRotationTranslationMatrix

Rotation and translation matrix using quaternion rotation

Public struct

FRandomStream

Implements a thread-safe SRand based RNG.

Public class

FReversedZOrthoMatrix

Public class

FReversedZPerspectiveMatrix

Public class

FRotationAboutPointMatrix

Rotates about an Origin point.

Public class

FRotationMatrix

Rotation matrix no translation

Public class

FRotationTranslationMatrix

Combined rotation and translation matrix

Public struct

FRotator

Implements a container for rotation information.

Public class

FScale

Transform calculus for 3D types.

Public class

FScale2D

Represents a 2D non-uniform scale (to disambiguate from an FVector2D , which is used for translation)

Public class

FScaleMatrix

Scale matrix.

Public class

FScaleRotationTranslationMatrix

Combined Scale rotation and translation matrix

Public class

FShear2D

Represents a 2D shear: [1 YY] [XX 1] XX represents a shear parallel to the X axis.

Public struct

FSignatureBase

Public class

FSobol

Support for Sobol quasi-random numbers

Public class

FSphere

Implements a basic sphere.

Public struct

FSquareRoot

Public struct

FStar

Public struct

FStarEquals

Public struct

FStatisticalValue

Used to measure a distribution.

Public struct

FSubExpressionEnd

Public struct

FSubExpressionStart

Public struct

FTransform

Transform composed of Scale, Rotation (as a quaternion), and Translation.

Public class

FTransform2D

Support for generalized 2D affine transforms.

Public class

FTranslationMatrix

Public struct

FTwoVectors

A pair of 3D vectors.

Public struct

FUintVector4

Public struct

FUnitConversion

Public class

FUnitSettings

Unit settings accessed globally through FUnitConversion::Settings()

Public struct

FVector

A vector in 3-D space composed of components (X, Y, Z) with floating point precision.

Public struct

FVector2D

A vector in 2-D space composed of components (X, Y) with floating point precision.

Public struct

FVector2DHalf

Structure for two dimensional vectors with half floating point precision.

Public struct

FVector4

A 4D homogeneous vector, 4x1 FLOATs, 16-byte aligned.

Public class

TBigInt

N-bit integer.

Public struct

TEncryptionKey

Encyption key - exponent and modulus pair

Public class

TFloatPacker

Public struct

TInterval

Template for numeric interval

Public struct

TIntervalTraits

Type traits for Arithmetic interval.

Public class

TMatrix

A storage class for compile-time fixed size matrices.

Public struct

TNumericLimits

Numeric type traits Helper class to map a numeric type to its limits

Public class

TRange

Template for ranges.

Public class

TRangeBound

Template for range bounds.

Public class

TRangeSet

Template for range sets.

Public struct

TransformConverter

Transform calculus.

Public class

TSHVector

A vector of spherical harmonic coefficients.

Public class

TSHVectorRGB

A vector of colored spherical harmonic coefficients.

Public class

TValueOrError

Type used to return either some data, or an error

Public struct

VectorRegister

============================================================================= Helpers:

Public struct

VectorRegisterDouble

Double[2] vector register type, where the first double (X) is stored in the lowest 64 bits, and so on.

Public struct

VectorRegisterInt

Int32[4] vector register type, where the first int32 (X) is stored in the lowest 32 bits, and so on.

Constants

Name

Description

GlobalVectorConstants::AllMask

GlobalVectorConstants::AlmostTwoBits

GlobalVectorConstants::AnimWeightThreshold

GlobalVectorConstants::BigNumber

GlobalVectorConstants::DEG_TO_RAD

GlobalVectorConstants::DEG_TO_RAD_HALF

GlobalVectorConstants::Float0001

GlobalVectorConstants::Float111_Minus1

GlobalVectorConstants::Float127

GlobalVectorConstants::Float180

GlobalVectorConstants::Float255

GlobalVectorConstants::Float360

GlobalVectorConstants::FloatAlmostTwo

GlobalVectorConstants::FloatInfinity

Vector full of positive infinity

GlobalVectorConstants::FloatMinus1_111

GlobalVectorConstants::FloatMinusOne

GlobalVectorConstants::FloatMinusOneHalf

GlobalVectorConstants::FloatNeg127

GlobalVectorConstants::FloatOne

GlobalVectorConstants::FloatOneHalf

GlobalVectorConstants::FloatOneHundredth

GlobalVectorConstants::FloatTwo

GlobalVectorConstants::FloatZero

GlobalVectorConstants::IntAllMask

GlobalVectorConstants::IntMinusOne

GlobalVectorConstants::IntOne

GlobalVectorConstants::IntSignBit

GlobalVectorConstants::IntSignMask

GlobalVectorConstants::IntZero

GlobalVectorConstants::KindaSmallNumber

GlobalVectorConstants::OneOverPi

GlobalVectorConstants::OneOverTwoPi

GlobalVectorConstants::Pi

GlobalVectorConstants::PiByFour

GlobalVectorConstants::PiByTwo

GlobalVectorConstants::QINV_SIGN_MASK

This is to speed up Quaternion Inverse. Static variable to keep sign of inverse

GlobalVectorConstants::QMULTI_SIGN_MASK0

GlobalVectorConstants::QMULTI_SIGN_MASK1

GlobalVectorConstants::QMULTI_SIGN_MASK2

GlobalVectorConstants::RAD_TO_DEG

GlobalVectorConstants::RotationSignificantThreshold

GlobalVectorConstants::SignBit

GlobalVectorConstants::SignMask

GlobalVectorConstants::SmallLengthThreshold

GlobalVectorConstants::SmallNumber

GlobalVectorConstants::ThreshQuatNormalized

GlobalVectorConstants::TwoPi

GlobalVectorConstants::XYZMask

Bitmask to AND out the XYZ components in a vector

QMULTI_SIGN_MASK0

QMULTI_SIGN_MASK1

QMULTI_SIGN_MASK2

VectorSinConstantsSSE::a

VectorSinConstantsSSE::A

VectorSinConstantsSSE::b

VectorSinConstantsSSE::B

VectorSinConstantsSSE::p

Typedefs

Enums

Name

Description

Public enum

EAxis::Type

Generic axis enum (mirrored for property use in Object.h)

Public enum

EAxisList::Type

Extended axis enum for more specialized usage.

Public enum

EGammaSpace

Enum for the different kinds of gamma spaces we expect to need to convert from/to.

Public enum

EInterpCurveMode

Public enum

ERangeBoundTypes::Type

Enumerates the valid types of range bounds.

Public enum

EUnit

Enum must be zero-indexed and sequential.

Public enum

EUnitType

Enumeration that specifies particular classes of unit

Functions

Name Description

Public function

PRAGMA_DISAB...

 

__attribute

(
    (aligned(16))
)

Include the intrinsic functions header.

Public function

uint32

 

appCountTrailingZeros

(
    uint32 Value
)

((PLATFORM_WINDOWS && !PLATFORM_COMPILER_CLANG) || PLATFORM_XBOXONE)

Public function

void

 

AutoCalcTangent

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

Computes Tangent for a curve segment

Public function

void

 

AutoCalcTangent

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

This actually returns the control point not a tangent.

Public function

[CORE_API](API\Runtime\Core\Misc\CORE_API_1) flo...

 

ClampFloatTangent

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

Clamps a tangent formed by the specified control point values

Public function

FVector

 

ClampVector

(
    const FVector & V,
    const FVector & Min,
    const FVector & Max
)

Component-wise clamp for FVector

Public function

[CORE_API](API\Runtime\Core\Misc\CORE_API_1)void

 

ComputeAndFixedColorAndIntensity

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

Computes a brightness and a fixed point color from a floating point color.

Public function

void

 

ComputeClampableFloatVectorCurveTangent

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

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

Public function

void

 

ComputeCurveTangent

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

Computes a tangent for the specified control point.

Public function

void

 

ComputeCurveTangent

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

Computes a tangent for the specified control point.

Public function

void

 

ComputeCurveTangent

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

Computes a tangent for the specified control point.

Public function

void

 

ComputeCurveTangent

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

Computes a tangent for the specified control point.

Public function

void

 

ComputeCurveTangent

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

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

Public function

float

 

ComputeSquaredDistanceFromBoxToPoint

(
    const FVector & Mins,
    const FVector & Maxs,
    const FVector & Point
)

Util to calculate distance from a point to a bounding box

Public function

FVector

 

Concatenate

(
    const FVector & LHS,
    const FVector & RHS
)

Specialization for concatenating two translations.

Public function

ConcatenateR ...

 

Concatenate

(
    const TransformTypeA& LHS,
    const TransformTypeB& RHS
)

Concatenates two transforms.

Public function

auto

 

Concatenate

(
    const TransformType1& TransformATo...,
    const TransformType2& TransformBTo...,
    const TransformType3& TransformCTo...
)

Concatenates three transforms.

Public function

auto

 

Concatenate

(
    const TransformType1& TransformATo...,
    const TransformType2& TransformBTo...,
    const TransformType3& TransformCTo...,
    const TransformType4& TransformDTo...
)

Concatenates four transforms.

Public function

FRotator

 

Concatenate

(
    const FRotator & LHS,
    const FRotator & RHS
)

Specialization for concatenating two rotations.

Public function

ReturnType

 

Concatenate

(
    const LHSType& LHS,
    const RHSType& RHS
)

Special overload that allows one to explicitly define the result type, which applies TransformCast on each argument first.

Public function

FVector2D

 

Concatenate

(
    const FVector2D & LHS,
    const FVector2D & RHS
)

Adapters for FVector2D .

Public function

float

 

Concatenate

(
    float LHS,
    float RHS
)

Overloads for uniform Scale.

Public function

auto

 

Concatenate

(
    const TransformType1& TransformATo...,
    const TransformType2& TransformBTo...,
    const TransformType3& TransformCTo...,
    const TransformType4& TransformDTo...,
    const TransformType5& TransformETo...
)

Concatenates five transforms.

Public function

FTransform2D

 

Concatenate

(
    const FScale2D & Scale,
    const FVector2D & Translation
)

Concatenate overloads.

Public function

FTransform2D

 

Concatenate

(
    const FShear2D & Shear,
    const FVector2D & Translation
)

Specialization for concatenating a 2D shear and 2D Translation.

Public function

FTransform2D

 

Concatenate

(
    const FQuat2D & Rot,
    const FVector2D & Translation
)

Specialization for concatenating 2D Rotation and 2D Translation.

Public function

FTransform2D

 

Concatenate

(
    const FMatrix2x2 & Transform,
    const FVector2D & Translation
)

Specialization for concatenating 2D generalized transform and 2D Translation.

Public function

FTransform2D

 

Concatenate

(
    const FTransform2D & Transform,
    const FVector2D & Translation
)

Specialization for concatenating transform and 2D Translation.

Public function

FTransform2D

 

Concatenate

(
    const FVector2D & Translation,
    const FScale2D & Scale
)

Specialization for concatenating a 2D Translation and 2D scale.

Public function

FTransform2D

 

Concatenate

(
    const FVector2D & Translation,
    const FShear2D & Shear
)

Specialization for concatenating a 2D Translation and 2D shear.

Public function

FTransform2D

 

Concatenate

(
    const FVector2D & Translation,
    const FQuat2D & Rot
)

Specialization for concatenating 2D Translation and 2D Rotation.

Public function

FTransform2D

 

Concatenate

(
    const FVector2D & Translation,
    const FMatrix2x2 & Transform
)

Specialization for concatenating 2D Translation and 2D generalized transform.

Public function

FTransform2D

 

Concatenate

(
    const FVector2D & Translation,
    const FTransform2D & Transform
)

Specialization for concatenating 2D Translation and transform.

Public function

auto

 

Concatenate

(
    const TransformType& LHS,
    const TransformType& RHS
)

Specialization for concatenating two transforms of the same type.

Public function

FMatrix

 

Concatenate

(
    const FMatrix & LHS,
    const FMatrix & RHS
)

Concatenate overloads.

Public function

FQuat

 

Concatenate

(
    const FQuat & LHS,
    const FQuat & RHS
)

Specialization for concatenating two rotations.

Public function

bool

 

ConvexHull2D::ComparePoints

(
    const FVector & A,
    const FVector & B
)

Returns true if 'a' is more lower-left than 'b'.

Public function

void

 

ConvexHull2D::ComputeConvexHull

(
    const TArray < FVector , Allocator > ...,
    TArray < int32 , Allocator >& OutInd...
)

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

Public function

void

 

ConvexHull2D::ComputeConvexHull2

(
    const TArray < FVector2D , Allocator ...,
    TArray < int32 , Allocator >& OutInd...
)

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

Public function

float

 

ConvexHull2D::ComputeDeterminant

(
    const FVector & A,
    const FVector & B,
    const FVector & C
)

Returns <0 if C is left of A-B

Public function

float

 

ConvexHull2D::ComputeDeterminant2D

(
    const FVector2D & A,
    const FVector2D & B,
    const FVector2D & C
)

Returns <0 if C is left of A-B

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < T >& Star...,
    const FInterpCurvePoint < T >& End,
    T& CurrentMin,
    T& CurrentMax,
    const U& Dummy
)

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < FVector > ...,
    const FInterpCurvePoint < FVector > ...,
    FVector & CurrentMin,
    FVector & CurrentMax,
    const U& Dummy
)

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < FVector2D ...,
    const FInterpCurvePoint < FVector2D ...,
    FVector2D & CurrentMin,
    FVector2D & CurrentMax,
    const U& Dummy
)

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < float >& ...,
    const FInterpCurvePoint < float >& ...,
    float& CurrentMin,
    float& CurrentMax,
    const U& Dummy
)

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < FLinearCol ...,
    const FInterpCurvePoint < FLinearCol ...,
    FLinearColor & CurrentMin,
    FLinearColor & CurrentMax,
    const U& Dummy
)

Public function

void

 

CurveFindIntervalBounds

(
    const FInterpCurvePoint < FTwoVector ...,
    const FInterpCurvePoint < FTwoVector ...,
    FTwoVectors & CurrentMin,
    FTwoVectors & CurrentMax,
    const U& Dummy
)

Public function

void[CORE_API](API\Runtime\Core\Misc\CORE_API_1)

 

CurveFloatFindIntervalBounds

(
    const FInterpCurvePoint < float >& ...,
    const FInterpCurvePoint < float >& ...,
    float& CurrentMin,
    float& CurrentMax
)

Calculate bounds of float intervals

Public function

void[CORE_API](API\Runtime\Core\Misc\CORE_API_1)

 

CurveLinearColorFindIntervalBounds

(
    const FInterpCurvePoint < FLinearCol ...,
    const FInterpCurvePoint < FLinearCol ...,
    FLinearColor & CurrentMin,
    FLinearColor & CurrentMax
)

Calculate bounds of color intervals

Public function

void[CORE_API](API\Runtime\Core\Misc\CORE_API_1)

 

CurveTwoVectorsFindIntervalBounds

(
    const FInterpCurvePoint < FTwoVector ...,
    const FInterpCurvePoint < FTwoVector ...,
    FTwoVectors & CurrentMin,
    FTwoVectors & CurrentMax
)

Calculate bounds of twovector intervals

Public function

void[CORE_API](API\Runtime\Core\Misc\CORE_API_1)

 

CurveVector2DFindIntervalBounds

(
    const FInterpCurvePoint < FVector2D ...,
    const FInterpCurvePoint < FVector2D ...,
    FVector2D & CurrentMin,
    FVector2D & CurrentMax
)

Calculate bounds of 2D vector intervals

Public function

void[CORE_API](API\Runtime\Core\Misc\CORE_API_1)

 

CurveVectorFindIntervalBounds

(
    const FInterpCurvePoint < FVector > ...,
    const FInterpCurvePoint < FVector > ...,
    FVector & CurrentMin,
    FVector & CurrentMax
)

Calculate bounds of vector intervals

Public function

TOptional < F ...

 

ExpressionParser::ConsumeSymbol

(
    FExpressionTokenConsumer & Consumer
)

Consume a symbol from the specified consumer's stream, if one exists at the current read position

Public function Static

IntType

 

FEncryption::CalculateGCD

(
    IntType ValueA,
    IntType ValueB
)

Greatest common divisor of ValueA and ValueB.

Public function Static

IntType

 

FEncryption::CalculateMultiplicativeInverseOfExponent

(
    IntType Exponent,
    IntType Totient
)

Multiplicative inverse of exponent using extended GCD algorithm.

Public function Static

void

 

FEncryption::DecryptBytes

(
    uint8 * DecryptedData,
    const IntType* Data,
    const int64 DataLength,
    const FEncryptionKey & DecryptionKe...
)

Decrypts a stream of bytes

Public function Static

void

 

FEncryption::DecryptSignature

(
    const FEncryptedSignature & InEncry...,
    FDecryptedSignature & OutUnencrypte...,
    const FEncryptionKey & EncryptionKe...
)

Public function Static

void

 

FEncryption::EncryptBytes

(
    IntType* EncryptedData,
    const uint8 * Data,
    const int64 DataLength,
    const FEncryptionKey & EncryptionKe...
)

Encrypts a stream of bytes

Public function Static

void

 

FEncryption::EncryptSignature

(
    const FDecryptedSignature & InUnenc...,
    FEncryptedSignature & OutEncryptedS...,
    const FEncryptionKey & EncryptionKe...
)

Public function Static

void

 

FEncryption::GenerateKeyPair

(
    const IntType& P,
    const IntType& Q,
    FEncryptionKey & PublicKey,
    FEncryptionKey & PrivateKey
)

Generate Key Pair for encryption and decryption.

Public function Static

IntType

 

FEncryption::ModularPow

(
    IntType Base,
    IntType Exponent,
    IntType Modulus
)

Raise Base to power of Exponent in mod Modulus.

Public function

uint32

 

GetTypeHash

(
    const FColor & Color
)

Public function

uint32

 

GetTypeHash

(
    const FVector2D & Vector
)

Creates a hash value from a FVector2D .

Public function

uint32

 

GetTypeHash

(
    const FLinearColor & LinearColor
)

Public function

uint32

 

GetTypeHash

(
    const FIntVector & Vector
)

Public function

uint32

 

GetTypeHash

(
    const FVector & Vector
)

Creates a hash value from a FVector .

Public function

uint32

 

GetTypeHash

(
    const FVector4 & Vector
)

Creates a hash value from a FVector4 .

Public function

uint32

 

GetTypeHash

(
    const FIntPoint & InPoint
)

Public function Static

FVector

 

INTEL_ORDER_VECTOR

(
    FVector v
)

Public function

float

 

Inverse

(
    float Scale
)

Inverts a transform from space A to space B so it transforms from space B to space A.

Public function

FVector2D

 

Inverse

(
    const FVector2D & Transform
)

Specialization for inverting a 2D translation.

Public function

FMatrix

 

Inverse

(
    const FMatrix & Transform
)

Inverse overloads.

Public function

FRotator

 

Inverse

(
    const FRotator & Transform
)

Inverts a transform from space A to space B so it transforms from space B to space A.

Public function

FQuat

 

Inverse

(
    const FQuat & Transform
)

Inverts a transform from space A to space B so it transforms from space B to space A.

Public function

auto

 

Inverse

(
    const TransformType& Transform
)

Inverts a transform from space A to space B so it transforms from space B to space A.

Public function

FVector

 

Inverse

(
    const FVector & Transform
)

Inverts a transform from space A to space B so it transforms from space B to space A.

Public function Static

void

 

Inverse4x4

(
    double* dst,
    const float* src
)

Very high quality 4x4 matrix inverse

Public function

[CORE_API](API\Runtime\Core\Misc\CORE_API_1) flo...

 

LegendrePolynomial

(
    int32 L,
    int32 M,
    float X
)

Evaluates the LegendrePolynomial for L,M at X

Public function

void

 

LexFromString

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

Public function

void

 

LexFromString

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

Public function

FString

 

LexToSanitizedString

(
    const FNumericUnit < T >& NumericUn...
)

Public function

FString

 

LexToSanitizedString

(
    const FNumericUnit < T >& NumericUn...
)

Public function

FString

 

LexToString

(
    const FNumericUnit < T >& NumericUn...
)

Public function

FString

 

LexToString

(
    const FNumericUnit < T >& NumericUn...
)

Public function

bool

 

LexTryParseString

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

Public function

bool

 

LexTryParseString

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

Public function

bool

 

MakeFrustumPlane

(
    float A,
    float B,
    float C,
    float D,
    FPlane & OutPlane
)

Public function

VectorRegist ...

 

MakeVectorRegister

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

Returns a vector based on 4 FLOATs.

Vector of the 4 FLOATs

Public function

VectorRegist ...

 

MakeVectorRegister

(
    uint32 X,
    uint32 Y,
    uint32 Z,
    uint32 W
)

Returns a bitwise equivalent vector based on 4 DWORDs.

Bitwise equivalent vector with 4 floats

Public function

VectorRegist ...

 

MakeVectorRegister

(
    uint32 X,
    uint32 Y,
    uint32 Z,
    uint32 W
)

Returns a bitwise equivalent vector based on 4 uint32s.

Bitwise equivalent vector with 4 floats

Public function

VectorRegist ...

 

MakeVectorRegister

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

Returns a vector based on 4 FLOATs.

Vector of the 4 FLOATs

Public function

VectorRegist ...

 

MakeVectorRegister

(
    uint32 X,
    uint32 Y,
    uint32 Z,
    uint32 W
)

Returns a bitwise equivalent vector based on 4 DWORDs.

Bitwise equivalent vector with 4 floats

Public function

VectorRegist ...

 

MakeVectorRegister

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

Returns a vector based on 4 FLOATs.

Vector of the 4 FLOATs

Public function

VectorRegist ...

 

MakeVectorRegister

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

Returns a vector based on 4 floats.

Vector of the 4 floats

Public function

VectorRegist ...

 

MakeVectorRegister

(
    uint32 X,
    uint32 Y,
    uint32 Z,
    uint32 W
)

Returns a bitwise equivalent vector based on 4 DWORDs.

Bitwise equivalent vector with 4 floats

Public function

VectorRegist ...

 

MakeVectorRegisterInt

(
    int32 X,
    int32 Y,
    int32 Z,
    int32 W
)

Returns a vector based on 4 int32.

Vector of the 4 int32

Public function

VectorRegist ...

 

MakeVectorRegisterInt

(
    int32 X,
    int32 Y,
    int32 Z,
    int32 W
)

Returns a vector based on 4 int32.

Vector of the 4 int32

Public function

VectorRegist ...

 

MakeVectorRegisterInt

(
    int32 X,
    int32 Y,
    int32 Z,
    int32 W
)

Returns a vector based on 4 int32.

Vector of the 4 int32

Public function

VectorRegist ...

 

MakeVectorRegisterInt

(
    int32 X,
    int32 Y,
    int32 Z,
    int32 W
)

Returns a vector based on 4 int32.

Vector of the 4 int32

Public function

bool

 

operator!=

(
    const FNumericUnit < NumericType >&...,
    const FNumericUnit < OtherType >& R...
)

Public function

bool

 

operator!=

(
    const FNumericUnit < NumericType >&...,
    const FNumericUnit < OtherType >& R...
)

Public function

FVector

 

operator*

(
    float Scale,
    const FVector & V
)

FVector inline functions Multiplies a vector by a scaling factor.

Public function

FTwoVectors

 

operator*

(
    float Scale,
    const FTwoVectors & V
)

FTwoVectors inline functions

Public function

FVector2D

 

operator*

(
    float Scale,
    const FVector2D & V
)

FVector2D inline functions

Public function

FLinearColor

 

operator*

(
    float Scalar,
    const FLinearColor & Color
)

Public function

FRotator

 

operator*

(
    float Scale,
    const FRotator & R
)

FRotator inline functions Scale a rotator and return.

Public function

TSHVectorRGB ...

 

operator*

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

Color multiplication operator.

Public function

bool

 

operator==

(
    const FNumericUnit < NumericType >&...,
    const FNumericUnit < OtherType >& R...
)

Global arithmetic operators for number types. Deals with conversion from related units correctly.

Public function

bool

 

operator==

(
    const FNumericUnit < NumericType >&...,
    const FNumericUnit < OtherType >& R...
)

Global arithmetic operators for number types. Deals with conversion from related units correctly.

Public function

int32

 

SHGetBasisIndex

(
    int32 L,
    int32 M
)

Returns the basis index of the SH basis L,M.

Public function

FMatrix

 

ToMatrix

(
    const FVector & Translation
)

Specialization for translation.

Matrix that represents the translated space.

Public function

FMatrix

 

ToMatrix

(
    const FScale & Scale
)

Specialization for non-uniform Scale.

Matrix that represents the non-uniform Scale space.

Public function

FMatrix

 

ToMatrix

(
    float Scale
)

Specialization for floats as a uniform scale.

Matrix that represents the uniform Scale space.

Public function

FMatrix

 

ToMatrix

(
    const FQuat & Rotation
)

Specialization for rotation.

Matrix that represents the rotated space.

Public function

const FMatri ...

 

ToMatrix

(
    const FMatrix & Transform
)

Specialization for the NULL Matrix conversion.

Matrix that represents the uniform Scale space.

Public function

FMatrix

 

ToMatrix

(
    const FRotator & Rotation
)

Specialization for rotation.

Matrix that represents the rotated space.

Public function

auto

 

ToMatrix

(
    const TransformType& Transform
)

FMatrix Support.

Public function

auto

 

TransformCast

(
    const TransformType& Transform
)

Casts one TransformType to ResultType using rules laid out by TransformConverter<>::Convert<>().

Public function

PositionType

 

TransformPoint

(
    const TransformType& Transform,
    const PositionType& Point
)

Generic implementation of TransformPoint. Attempts to use a member function of the TransformType.

Public function

FVector2D

 

TransformPoint

(
    const TransformType& Transform,
    const FVector2D & Point
)

Generic implementation of TransformPoint for 2D vectors.

Public function

FVector

 

TransformPoint

(
    float Transform,
    const FVector & Point
)

Specialization for uniform Scale.

Public function

FVector2D

 

TransformPoint

(
    const FVector2D & Transform,
    const FVector2D & Point
)

Specialization for FVector2D Translation.

Public function

FVector2D

 

TransformPoint

(
    float Transform,
    const FVector2D & Point
)

Adapters for 2D uniform scale.

Public function

FVector

 

TransformPoint

(
    const FMatrix & Transform,
    const FVector & Point
)

TransformPoint overloads.

Public function

FVector

 

TransformPoint

(
    const FQuat & Transform,
    const FVector & Point
)

Specialization for FQuat as it's member function is called something slightly different.

Public function

FVector

 

TransformPoint

(
    const FRotator & Transform,
    const FVector & Point
)

Specialization for FRotator as it's member function is called something slightly different.

Public function

FVector

 

TransformPoint

(
    const FVector & Transform,
    const FVector & Point
)

Specialization for FVector Translation.

Public function

FVector

 

TransformPoint

(
    const FScale & Transform,
    const FVector & Point
)

Specialization for Scale.

Public function

FVector

 

TransformVector

(
    const FScale & Transform,
    const FVector & Vector
)

Specialization for Scale.

Public function

const FVecto ...

 

TransformVector

(
    const FVector & Transform,
    const FVector & Vector
)

Specialization for FVector Translation (does nothing).

Public function

FVector

 

TransformVector

(
    const FRotator & Transform,
    const FVector & Vector
)

Specialization for FRotator as it's member function is called something slightly different.

Public function

const FVecto ...

 

TransformVector

(
    const FVector2D & Transform,
    const FVector2D & Vector
)

Specialization for FVector2D Translation (does nothing).

Public function

FVector2D

 

TransformVector

(
    float Transform,
    const FVector2D & Vector
)

Specialization for uniform Scale.

Public function

FVector

 

TransformVector

(
    float Transform,
    const FVector & Vector
)

Specialization for uniform Scale.

Public function

FVector2D

 

TransformVector

(
    const TransformType& Transform,
    const FVector2D & Vector
)

Generic implementation of TransformVector for 2D vectors.

Public function

VectorType

 

TransformVector

(
    const TransformType& Transform,
    const VectorType& Vector
)

Generic implementation of TransformVector. Attempts to use a member function of the TransformType.

Public function

FVector

 

TransformVector

(
    const FQuat & Transform,
    const FVector & Vector
)

Specialization for FQuat as it's member function is called something slightly different.

Public function

[CORE_API](API\Runtime\Core\Misc\CORE_API_1) dou...

 

UnitConversion::TemperatureUnificationFactor

(
    EUnit From
)

Find the common quantization factor for the specified temperature unit. Quantizes to Kelvin.

Public function Static

float

 

UnrealPlatformMathSSE::InvSqrt

(
    float F
)

Public function Static

float

 

UnrealPlatformMathSSE::InvSqrtEst

(
    float F
)

Public function

VectorRegist ...

 

VectorAbs

(
    const VectorRegister & Vec
)

Returns the absolute value (component-wise).

Public function

VectorRegist ...

 

VectorAbs

(
    VectorRegister Vec
)

Returns the absolute value (component-wise).

Public function

VectorRegist ...

 

VectorAccumulateQuaternionShortestPath

(
    const VectorRegister & A,
    const VectorRegister & B
)

A and B are quaternions. The result is A + (|A.B| >= 0 ? 1 : -1) * B.

Public function

VectorRegist ...

 

VectorACos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorACos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorACos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorACos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorAdd

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Adds two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorAdd

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Adds two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorAdd

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Adds two vectors (component-wise) and returns the result.

Public function

uint32

 

VectorAllGreaterThan

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns non-zero if all elements in Vec1 are greater than the corresponding elements in Vec2, otherwise 0.

Public function

uint32

 

VectorAllLesserThan

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns non-zero if all elements in Vec1 are lesser than the corresponding elements in Vec2, otherwise 0.

Public function

uint32

 

VectorAnyGreaterThan

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Returns non-zero if any element in Vec1 is greater than the corresponding element in Vec2, otherwise 0.

Public function

uint32

 

VectorAnyGreaterThan

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Returns non-zero if any element in Vec1 is greater than the corresponding element in Vec2, otherwise 0.

Public function

int32

 

VectorAnyGreaterThan

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns non-zero if any element in Vec1 is greater than the corresponding element in Vec2, otherwise 0.

Public function

uint32

 

VectorAnyLesserThan

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns non-zero if any element in Vec1 is lesser than the corresponding element in Vec2, otherwise 0.

Public function

VectorRegist ...

 

VectorASin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorASin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorASin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorASin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan2

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan2

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan2

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorATan2

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorBiLerpQuat

(
    const VectorRegister & P00,
    const VectorRegister & P10,
    const VectorRegister & P01,
    const VectorRegister & P11,
    const VectorRegister & FracX,
    const VectorRegister & FracY
)

Bi-Linear Quaternion interpolation for quaternions stored in VectorRegisters.

Public function

VectorRegist ...

 

VectorBitwiseAnd

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise AND (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorBitwiseAnd

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise AND (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorBitwiseOr

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise OR (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorBitwiseOr

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise OR (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorBitwiseXor

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise XOR (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorBitwiseXor

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Combines two vectors using bitwise XOR (treating each vector as a 128 bit field)

Public function

VectorRegist ...

 

VectorCeil

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorCeil

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorCeil

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorCeil

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorCombineHigh

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two high components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineHigh

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two high components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineHigh

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two high components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineHigh

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two high components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineLow

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two low components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineLow

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two low components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineLow

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two low components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCombineLow

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a vector by combining two low components from each vector

The combined vector

Public function

VectorRegist ...

 

VectorCompareEQ

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise == compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareEQ

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise == compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareGE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise >= compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareGE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise >= compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareGT

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise > compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareGT

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise > compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareLE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise <= compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareLE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise <= compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareLT

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise < compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareLT

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise < compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareNE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise != compares of the input vectors

Public function

VectorRegist ...

 

VectorCompareNE

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Creates a four-part mask based on component-wise != compares of the input vectors

Public function

bool

 

VectorContainsNaNOrInfinite

(
    const VectorRegister & Vec
)

Returns true if the vector contains a component that is either NAN or +/-infinite.

Public function

bool

 

VectorContainsNaNOrInfinite

(
    const VectorRegister & Vec
)

Returns true if the vector contains a component that is either NAN or +/-infinite.

Public function

bool

 

VectorContainsNaNOrInfinite

(
    const VectorRegister & Vec
)

Returns true if the vector contains a component that is either NAN or +/-infinite.

Public function

bool

 

VectorContainsNaNOrInfinite

(
    const VectorRegister & Vec
)

Returns true if the vector contains a component that is either NAN or +/-infinite.

Public function

VectorRegist ...

 

VectorCos

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorCos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorCos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorCos

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorCross

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the cross product of two vectors (XYZ components).

Public function

VectorRegist ...

 

VectorCross

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the cross product of two vectors (XYZ components).

Public function

VectorRegist ...

 

VectorCross

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the cross product of two vectors (XYZ components).

Public function

VectorRegist ...

 

VectorDivide

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Divides two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorDivide

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Divides two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorDivide

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Divides two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorDot3

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the dot3 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorDot3

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the dot3 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorDot3

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the dot3 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorDot4

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the dot4 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorDot4

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Calculates the dot4 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorDot4

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Calculates the dot4 product of two vectors and returns a vector with the result in all 4 components.

Public function

VectorRegist ...

 

VectorExp

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorExp2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorFloatToInt

(
    const VectorRegister & A
)

Public function

VectorRegist ...

 

VectorFloor

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorFloor

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorFloor

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorFloor

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorFractional

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorFractional

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorFractional

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorFractional

(
    const VectorRegister & X
)

Public function

float

 

VectorGetComponent

(
    VectorRegister Vec,
    uint32 ComponentIndex
)

Returns an component from a vector.

The component as a float

Public function

float

 

VectorGetComponent

(
    VectorRegister Vec,
    uint32 ComponentIndex
)

Returns an component from a vector.

The component as a float

Public function

float

 

VectorGetComponent

(
    VectorRegister Vec,
    uint32 ComponentIndex
)

Returns a component from a vector.

The component as a float

Public function

float

 

VectorGetComponent

(
    VectorRegister Vec,
    uint32 ComponentIndex
)

Returns an component from a vector.

The component as a float

Public function

VectorRegist ...

 

VectorIntAbs

(
    const VectorRegisterInt & A
)

Public function

VectorRegist ...

 

VectorIntAbs

(
    const VectorRegisterInt & A
)

Public function

VectorRegist ...

 

VectorIntAbs

(
    const VectorRegisterInt & A
)

Public function

VectorRegist ...

 

VectorIntAdd

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Arithmetic.

Public function

VectorRegist ...

 

VectorIntAnd

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Integer ops.

Public function

VectorRegist ...

 

VectorIntAndNot

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

= (~a) & b to match _mm_andnot_si128

Public function

VectorRegist ...

 

VectorIntCompareEQ

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Comparison.

Public function

VectorRegist ...

 

VectorIntCompareGE

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntCompareGT

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntCompareLE

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntCompareLT

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntCompareNEQ

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntLoad

(
    const void* Ptr
)

Loads 4 int32s from unaligned memory.

Public function

VectorRegist ...

 

VectorIntLoad1

(
    const void* Ptr
)

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

Public function

VectorRegist ...

 

VectorIntLoadAligned

(
    const void* Ptr
)

Loads 4 int32s from aligned memory.

Public function

VectorRegist ...

 

VectorIntMax

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMax

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMax

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMin

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMin

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMin

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMultiply

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMultiply

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntMultiply

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntNegate

(
    const VectorRegisterInt & A
)

Public function

VectorRegist ...

 

VectorIntNot

(
    const VectorRegisterInt & A
)

= ~a

Public function

VectorRegist ...

 

VectorIntOr

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

= a | b

Public function

VectorRegist ...

 

VectorIntSelect

(
    const VectorRegisterInt & Mask,
    const VectorRegisterInt & Vec1,
    const VectorRegisterInt & Vec2
)

Public function

VectorRegist ...

 

VectorIntSelect

(
    const VectorRegisterInt & Mask,
    const VectorRegisterInt & Vec1,
    const VectorRegisterInt & Vec2
)

Public function

VectorRegist ...

 

VectorIntSelect

(
    const VectorRegisterInt & Mask,
    const VectorRegisterInt & Vec1,
    const VectorRegisterInt & Vec2
)

Public function

VectorRegist ...

 

VectorIntSelect

(
    const VectorRegisterInt & Mask,
    const VectorRegisterInt & Vec1,
    const VectorRegisterInt & Vec2
)

Public function

void

 

VectorIntStore

(
    const VectorRegisterInt & A,
    const void* Ptr
)

Loads and stores.

Public function

void

 

VectorIntStoreAligned

(
    const VectorRegisterInt & A,
    const void* Ptr
)

Stores a vector to memory (aligned).

Public function

VectorRegist ...

 

VectorIntSubtract

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

Public function

VectorRegist ...

 

VectorIntToFloat

(
    const VectorRegisterInt & A
)

Public function

VectorRegist ...

 

VectorIntXor

(
    const VectorRegisterInt & A,
    const VectorRegisterInt & B
)

= a ^ b

Public function

bool

 

VectorIsAligned

(
    const void* Ptr
)

Public function

VectorRegist ...

 

VectorLerpQuat

(
    const VectorRegister & A,
    const VectorRegister & B,
    const VectorRegister & Alpha
)

Fast Linear Quaternion Interpolation for quaternions stored in VectorRegisters.

Public function

VectorRegist ...

 

VectorLoad

(
    const void* Ptr
)

Loads 4 FLOATs from unaligned memory.

Public function

VectorRegist ...

 

VectorLoad

(
    const void* Ptr
)

Loads 4 floats from unaligned memory.

Public function

VectorRegist ...

 

VectorLoadAligned

(
    const void* Ptr
)

Loads 4 floats from aligned memory.

Public function

VectorRegist ...

 

VectorLoadByte4

(
    const void* Ptr
)

Loads 4 uint8s from unaligned memory and converts them into 4 floats.

Public function

VectorRegist ...

 

VectorLoadByte4Reverse

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadByte4Reverse

(
    const void* Ptr
)

Loads 4 uint8s from unaligned memory and converts them into 4 floats in reversed order.

Public function

VectorRegist ...

 

VectorLoadByte4Reverse

(
    const uint8 * Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadFloat1

(
    const void* Ptr
)

Loads 1 float from unaligned memory and replicates it to all 4 elements.

Public function

VectorRegist ...

 

VectorLoadSignedByte4

(
    const void* Ptr
)

Loads 4 signed BYTEs from unaligned memory and converts them into 4 FLOATs.

Public function

VectorRegist ...

 

VectorLoadSignedByte4

(
    const void* Ptr
)

Loads 4 int8s from unaligned memory and converts them into 4 floats.

Public function

VectorRegist ...

 

VectorLoadSRGBA16N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadSRGBA16N

(
    const void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadSRGBA16N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadURGB10A2N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadURGB10A2N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadURGB10A2N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadURGBA16N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLoadURGBA16N

(
    void* Ptr
)

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

Public function

VectorRegist ...

 

VectorLog

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorLog2

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

void

 

VectorMatrixInverse

(
    FMatrix * DstMatrix,
    const FMatrix * SrcMatrix
)

Calculate the inverse of an FMatrix .

Public function

void

 

VectorMatrixInverse

(
    void* DstMatrix,
    const void* SrcMatrix
)

Calculate the inverse of an FMatrix .

Public function

void

 

VectorMatrixInverse

(
    void* DstMatrix,
    const void* SrcMatrix
)

OPTIMIZE ME: stolen from UnMathFpu.h.

Public function

void

 

VectorMatrixInverse

(
    void* DstMatrix,
    const void* SrcMatrix
)

TODO: Vector version of this function that doesn't use D3DX.

Public function

void

 

VectorMatrixMultiply

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

Multiplies two 4x4 matrices.

Public function

void

 

VectorMatrixMultiply

(
    void* Result,
    const void* Matrix1,
    const void* Matrix2
)

Multiplies two 4x4 matrices.

Public function

void

 

VectorMatrixMultiply

(
    void* Result,
    const void* Matrix1,
    const void* Matrix2
)

Multiplies two 4x4 matrices.

Public function

void

 

VectorMatrixMultiply

(
    void* Result,
    const void* Matrix1,
    const void* Matrix2
)

Multiplies two 4x4 matrices.

Public function

VectorRegist ...

 

VectorMax

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Returns the maximum values of two vectors (component-wise).

Public function

VectorRegist ...

 

VectorMax

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns the maximum values of two vectors (component-wise).

Public function

VectorRegist ...

 

VectorMergeVecXYZ_VecW

(
    const VectorRegister & VecXYZ,
    const VectorRegister & VecW
)

Merges the XYZ components of one vector with the W component of another vector and returns the result.

Public function

VectorRegist ...

 

VectorMergeVecXYZ_VecW

(
    const VectorRegister & VecXYZ,
    const VectorRegister & VecW
)

Merges the XYZ components of one vector with the W component of another vector and returns the result.

Public function

VectorRegist ...

 

VectorMergeVecXYZ_VecW

(
    const VectorRegister & VecXYZ,
    const VectorRegister & VecW
)

Merges the XYZ components of one vector with the W component of another vector and returns the result.

Public function

VectorRegist ...

 

VectorMin

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Returns the minimum values of two vectors (component-wise).

Public function

VectorRegist ...

 

VectorMin

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Returns the minimum values of two vectors (component-wise).

Public function

VectorRegist ...

 

VectorMod

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorMod

(
    const VectorRegister & X,
    const VectorRegister & Y
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorMod

(
    const VectorRegister & X,
    const VectorRegister & Y
)

Public function

VectorRegist ...

 

VectorMod

(
    const VectorRegister & X,
    const VectorRegister & Y
)

Public function

VectorRegist ...

 

VectorMultiply

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Multiplies two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorMultiply

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Multiplies two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorMultiply

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Multiplies two vectors (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorMultiplyAdd

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

Multiplies two vectors (component-wise), adds in the third vector and returns the result.

Public function

VectorRegist ...

 

VectorMultiplyAdd

(
    VectorRegister Vec1,
    VectorRegister Vec2,
    VectorRegister Vec3
)

Multiplies two vectors (component-wise), adds in the third vector and returns the result.

Public function

VectorRegist ...

 

VectorNegate

(
    VectorRegister Vec
)

Returns the negated value (component-wise).

Public function

VectorRegist ...

 

VectorNormalize

(
    const VectorRegister & Vector
)

Normalize vector

Normalized VectorRegister

Public function

VectorRegist ...

 

VectorNormalize

(
    const VectorRegister & Vector
)

Normalize vector

Normalized VectorRegister

Public function

VectorRegist ...

 

VectorNormalize

(
    const VectorRegister & Vector
)

Normalize vector

Normalized VectorRegister

Public function

VectorRegist ...

 

VectorNormalizeAccurate

(
    const VectorRegister & Vector
)

Returns a normalized 4 vector = Vector / |Vector|.

Public function

VectorRegist ...

 

VectorNormalizeQuaternion

(
    const VectorRegister & Unnormalized...
)

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

Public function

VectorRegist ...

 

VectorNormalizeRotator

(
    const VectorRegister & Unnormalized...
)

Normalize Rotator.

Public function

VectorRegist ...

 

VectorNormalizeSafe

(
    const VectorRegister & Vector,
    const VectorRegister & DefaultValue
)

Returns ((Vector dot Vector) >= 1e-8) ? (Vector / |Vector|) : DefaultValue Uses accurate 1/sqrt, not the estimate

Public function

VectorRegist ...

 

VectorOne()

Returns a vector with all ones.

Public function

VectorRegist ...

 

VectorOne()

Returns a vector with all ones.

Public function

VectorRegist ...

 

VectorPow

(
    const VectorRegister & Base,
    const VectorRegister & Exponent
)

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

Public function

VectorRegist ...

 

VectorPow

(
    const VectorRegister & Base,
    const VectorRegister & Exponent
)

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

Public function

VectorRegist ...

 

VectorPow

(
    const VectorRegister & Base,
    const VectorRegister & Exponent
)

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

Public function

VectorRegist ...

 

VectorQuaternionInverse

(
    const VectorRegister & NormalizedQu...
)

Inverse quaternion ( -X, -Y, -Z, W)

Public function

VectorRegist ...

 

VectorQuaternionInverseRotateVector

(
    const VectorRegister & Quat,
    const VectorRegister & VectorW0
)

Rotate a vector using the inverse of a unit Quaternion (rotation in the opposite direction).

Public function

void

 

VectorQuaternionInverseRotateVectorPtr

(
    void*RESTRICT Result,
    const void*RESTRICT Quat,
    const void*RESTRICT VectorW0
)

Rotate a vector using the inverse of a unit Quaternion (rotation in the opposite direction).

Public function

void

 

VectorQuaternionMultiply

(
    void* Result,
    const void* Quat1,
    const void* Quat2
)

Multiplies two quaternions; the order matters.

Public function

void

 

VectorQuaternionMultiply

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

Multiplies two quaternions; the order matters.

Public function

void

 

VectorQuaternionMultiply

(
    void*RESTRICT Result,
    const void*RESTRICT Quat1,
    const void*RESTRICT Quat2
)

Multiplies two quaternions; the order matters.

Public function

void

 

VectorQuaternionMultiply

(
    void*RESTRICT Result,
    const void*RESTRICT Quat1,
    const void*RESTRICT Quat2
)

Multiplies two quaternions; the order matters.

Public function

void

 

VectorQuaternionMultiply

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

Multiplies two quaternions; the order matters.

Public function

VectorRegist ...

 

VectorQuaternionMultiply2

(
    const VectorRegister & Quat1,
    const VectorRegister & Quat2
)

Multiplies two quaternions; the order matters.

Public function

VectorRegist ...

 

VectorQuaternionMultiply2

(
    const VectorRegister & Quat1,
    const VectorRegister & Quat2
)

Multiplies two quaternions; the order matters.

Public function

VectorRegist ...

 

VectorQuaternionMultiply2

(
    const VectorRegister & Quat1,
    const VectorRegister & Quat2
)

Multiplies two quaternions; the order matters.

Public function

VectorRegist ...

 

VectorQuaternionMultiply2

(
    const VectorRegister & Quat1,
    const VectorRegister & Quat2
)

Multiplies two quaternions; the order matters.

Public function

VectorRegist ...

 

VectorQuaternionRotateVector

(
    const VectorRegister & Quat,
    const VectorRegister & VectorW0
)

Rotate a vector using a unit Quaternion.

Vector after rotation by Quat.

Public function

void

 

VectorQuaternionRotateVectorPtr

(
    void*RESTRICT Result,
    const void*RESTRICT Quat,
    const void*RESTRICT VectorW0
)

Rotate a vector using a pointer to a unit Quaternion.

Public function

void

 

VectorQuaternionVector3InverseRotate

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

Public function

void

 

VectorQuaternionVector3Rotate

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

Public function

VectorRegist ...

 

VectorReciprocal

(
    const VectorRegister & Vec
)

Computes an estimate of the reciprocal of a vector (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorReciprocalAccurate

(
    const VectorRegister & Vec
)

Computes the reciprocal of a vector (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorReciprocalAccurate

(
    const VectorRegister & Vec
)

Computes the reciprocal of a vector (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorReciprocalLen

(
    const VectorRegister & Vector
)

Return Reciprocal Length of the vector

Public function

VectorRegist ...

 

VectorReciprocalLen

(
    const VectorRegister & Vector
)

Return Reciprocal Length of the vector

Public function

VectorRegist ...

 

VectorReciprocalLen

(
    const VectorRegister & Vector
)

Return Reciprocal Length of the vector (estimate)

Public function

VectorRegist ...

 

VectorReciprocalSqrt

(
    const VectorRegister & Vec
)

Returns an estimate of 1/sqrt(c) for each component of the vector

Public function

VectorRegist ...

 

VectorReciprocalSqrtAccurate

(
    const VectorRegister & Vec
)

Return the reciprocal of the square root of each component

Public function

VectorRegist ...

 

VectorReciprocalSqrtAccurate

(
    const VectorRegister & Vec
)

Return the reciprocal of the square root of each component

Public function

VectorRegist ...

 

VectorSelect

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

Does a bitwise vector selection based on a mask (e.g., created from VectorCompareXX)

Public function

VectorRegist ...

 

VectorSelect

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

Does a bitwise vector selection based on a mask (e.g., created from VectorCompareXX)

Public function

VectorRegist ...

 

VectorSelect

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

Does a bitwise vector selection based on a mask (e.g., created from VectorCompareXX)

Public function

VectorRegist ...

 

VectorSet

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

Creates a vector out of four FLOATs.

Public function

VectorRegist ...

 

VectorSet

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

Creates a vector out of four floats.

Public function

VectorRegist ...

 

VectorSet_W1

(
    const VectorRegister & Vector
)

Loads XYZ and sets W=1

VectorRegister

Public function

VectorRegist ...

 

VectorSetFloat1

(
    float X
)

Creates a vector out of three floats and leaves W undefined.

Public function

VectorRegist ...

 

VectorSetFloat3

(
    float X,
    float Y,
    float Z
)

Creates a vector out of three floats and leaves W undefined.

Public function

VectorRegist ...

 

VectorSign

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSign

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSign

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSign

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorSin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSin

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorSin

(
    const VectorRegister & X
)

Public function

void

 

VectorSinCos

(
    VectorRegister *RESTRICT VSinAn...,
    VectorRegister *RESTRICT VCosAn...,
    const VectorRegister *RESTRICT ...
)

Computes the sine and cosine of each component of a Vector.

Public function

void

 

VectorSinCos

(
    VectorRegister *RESTRICT VSinAn...,
    VectorRegister *RESTRICT VCosAn...,
    const VectorRegister *RESTRICT ...
)

Computes the sine and cosine of each component of a Vector.

Public function

void

 

VectorSinCos

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

Computes the sine and cosine of each component of a Vector.

Public function

void

 

VectorSinCos

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

Computes the sine and cosine of each component of a Vector.

Public function

VectorRegist ...

 

VectorStep

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorStep

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorStep

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorStep

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

void

 

VectorStore

(
    VectorRegister Vec,
    void* Ptr
)

Stores a vector to memory (aligned or unaligned).

Public function

void

 

VectorStore

(
    const VectorRegister & Vec,
    void* Ptr
)

Stores a vector to memory (aligned or unaligned).

Public function

void

 

VectorStoreAligned

(
    VectorRegister Vec,
    void* Ptr
)

Stores a vector to aligned memory.

Public function

void

 

VectorStoreByte4

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreByte4

(
    VectorRegister Vec,
    void* Ptr
)

Converts the 4 floats in the vector to 4 uint8s, clamped to [0,255], and stores to unaligned memory.

Public function

void

 

VectorStoreByte4

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreFloat1

(
    VectorRegister Vec,
    void* Ptr
)

Stores the X component of a vector to unaligned memory.

Public function

void

 

VectorStoreFloat3

(
    const VectorRegister & Vec,
    void* Ptr
)

Stores the XYZ components of a vector to unaligned memory.

Public function

void

 

VectorStoreFloat3

(
    const VectorRegister & Vec,
    void* Ptr
)

Stores the XYZ components of a vector to unaligned memory.

Public function

void

 

VectorStoreHalf4

(
    VectorRegister Vec,
    void*RESTRICT Ptr
)

Converts the 4 floats in the vector to 4 fp16 and stores based off bool to [un]aligned memory.

Public function

void

 

VectorStoreSignedByte4

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreSignedByte4

(
    VectorRegister Vec,
    void* Ptr
)

Converts the 4 floats in the vector to 4 int8s, clamped to [-127, 127], and stores to unaligned memory.

Public function

void

 

VectorStoreSignedByte4

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreURGB10A2N

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreURGB10A2N

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreURGB10A2N

(
    const VectorRegister & Vec,
    void* Ptr
)

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

Public function

void

 

VectorStoreURGBA16N

(
    const VectorRegister & Vec,
    void* Ptr
)

Converts the 4 FLOATs in the vector RGBA16, clamped to [0, 65535], and stores to unaligned memory.

Public function

void

 

VectorStoreURGBA16N

(
    const VectorRegister & Vec,
    void* Ptr
)

Converts the 4 FLOATs in the vector RGBA16, clamped to [0, 65535], and stores to unaligned memory.

Public function

void

 

VectorStoreURGBA16N

(
    const VectorRegister & Vec,
    void* Ptr
)

Converts the 4 FLOATs in the vector RGBA16, clamped to [0, 65535], and stores to unaligned memory.

Public function

VectorRegist ...

 

VectorSubtract

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Subtracts a vector from another (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorSubtract

(
    VectorRegister Vec1,
    VectorRegister Vec2
)

Subtracts a vector from another (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorSubtract

(
    const VectorRegister & Vec1,
    const VectorRegister & Vec2
)

Subtracts a vector from another (component-wise) and returns the result.

Public function

VectorRegist ...

 

VectorTan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTan

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTransformVector

(
    const VectorRegister & VecP,
    const FMatrix * MatrixM
)

Calculate Homogeneous transform.

Public function

VectorRegist ...

 

VectorTransformVector

(
    const VectorRegister & VecP,
    const void* MatrixM
)

Calculate Homogeneous transform.

Public function

VectorRegist ...

 

VectorTransformVector

(
    const VectorRegister & VecP,
    const void* MatrixM
)

Calculate Homogeneous transform.

Public function

VectorRegist ...

 

VectorTransformVector

(
    const VectorRegister & VecP,
    const void* MatrixM
)

Calculate Homogeneous transform.

Public function

VectorRegist ...

 

VectorTruncate

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorTruncate

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTruncate

(
    const VectorRegister & X
)

TODO: Vectorize.

Public function

VectorRegist ...

 

VectorTruncate

(
    const VectorRegister & X
)

Public function

VectorRegist ...

 

VectorZero()

#define VectorPermute(Vec1, Vec2, Mask) my_perm(Vec1, Vec2, Mask)

Public function

VectorRegist ...

 

VectorZero()

============================================================================= Constants:

Variables

Name Description

Public variable

[CORE_API](API\Runtime\Core\Misc\CORE_API_1)int32 [9...

 

BasisL

Public variable

[CORE_API](API\Runtime\Core\Misc\CORE_API_1)int32 [9...

 

BasisM

Public variable

[CORE_API](API\Runtime\Core\Misc\CORE_API_1)FColorL ...

 

GColorList

Global instance of color list helper class.

Public variable

[CORE_API](API\Runtime\Core\Misc\CORE_API_1) float[...

 

NormalizationConstants

Constants.

Public variable

[CORE_API](API\Runtime\Core\Misc\CORE_API_1) const ...

 

VECTOR_INV_255

'Cross-platform' vector intrinsics (built on the platform-specific ones defined above)