#include "HAL/UnrealMemory.h"
#include <cmath>
#include "Math/UnrealMathVectorConstants.h.inl"

Classes
struct	VectorRegisterConstInit

struct	VectorRegister4Float

struct	VectorRegister4Int

struct	VectorRegister2Double

struct	VectorRegister4Double

struct	VectorRegister4x4Float

struct	AlignedFloat4

struct	AlignedDouble4

Macros
#define	VectorZeroVectorRegister() VectorZeroDouble()

#define	VectorOneVectorRegister() VectorOneDouble()

#define	DECLARE_VECTOR_REGISTER(X, Y, Z, W) MakeVectorRegister(X, Y, Z, W)

#define	VectorGetComponent(Vec, ComponentIndex) VectorGetComponentImpl<ComponentIndex>(Vec)

#define	VectorReplicate(Vec, ElementIndex) MakeVectorRegister( (Vec).V[ElementIndex], (Vec).V[ElementIndex], (Vec).V[ElementIndex], (Vec).V[ElementIndex] )

#define	VectorSwizzle(Vec, X, Y, Z, W) MakeVectorRegister( (Vec).V[X], (Vec).V[Y], (Vec).V[Z], (Vec).V[W] )

#define	VectorShuffle(Vec1, Vec2, X, Y, Z, W) MakeVectorRegister( (Vec1).V[X], (Vec1).V[Y], (Vec2).V[Z], (Vec2).V[W] )

#define	USE_FAST_QUAT_MUL 1

#define	VectorLoadByte4(Ptr) MakeVectorRegisterFloat( float(((const uint8)(Ptr))[0]), float(((const uint8)(Ptr))[1]), float(((const uint8)(Ptr))[2]), float(((const uint8)(Ptr))[3]) )

#define	VectorLoadSignedByte4(Ptr) MakeVectorRegisterFloat( float(((const int8)(Ptr))[0]), float(((const int8)(Ptr))[1]), float(((const int8)(Ptr))[2]), float(((const int8)(Ptr))[3]) )

#define	VectorLoadByte4Reverse(Ptr) MakeVectorRegisterFloat( float(((const uint8)(Ptr))[3]), float(((const uint8)(Ptr))[2]), float(((const uint8)(Ptr))[1]), float(((const uint8)(Ptr))[0]) )

#define	VectorResetFloatRegisters()

#define	VectorGetControlRegister() 0

#define	VectorSetControlRegister(ControlStatus)

#define	VECTOR_ROUND_TOWARD_ZERO 0

#define	VECTOR_DENORMALS_FLUSH_TO_ZERO 0

#define	VectorIntSign(A) VectorIntSelect( VectorIntCompareGE(A, GlobalVectorConstants::IntZero), GlobalVectorConstants::IntOne, GlobalVectorConstants::IntMinusOne )

#define	VectorSetZero() MakeVectorRegisterFloat(0.f, 0.f, 0.f, 0.f)

#define	VectorSet1(F) VectorSetFloat1(F)

#define	VectorIntSet1(F) MakeVectorRegisterInt(F, F, F, F)

#define	VectorCastIntToFloat(Vec) VectorLoad((float*)(Vec.V))

#define	VectorCastFloatToInt(Vec) VectorIntLoad(Vec.V)

#define	VectorCastDoubleToInt(Vec) VectorInt64Load(Vec.V)

#define	VectorCastIntToDouble(Vec) VectorDoubleLoad(Vec.V)

#define	VectorShuffleImmediate(Vec, I0, I1, I2, I3) VectorShuffle(Vec, Vec, I3, I2, I1, I0)

#define	VectorShiftLeftImm(Vec, ImmAmt) static_assert(false, "Unimplemented")

#define	VectorShiftRightImmArithmetic(Vec, ImmAmt) static_assert(false, "Unimplemented")

#define	VectorShiftRightImmLogical(Vec, ImmAmt) static_assert(false, "Unimplemented")

#define	VectorIntExpandLow16To32(V0) static_assert(false, "Unimplemented")

Functions
VectorRegister4Float	VectorLoadAligned (const float *Ptr)

VectorRegister4Double	VectorLoadAligned (const double *Ptr)

void	VectorStoreAligned (const VectorRegister4Float &Vec, float *Ptr)

void	VectorStoreAligned (const VectorRegister4Double &Vec, double *Dst)

FORCEINLINE VectorRegister2Double	MakeVectorRegister2Double (double X, double Y)

FORCEINLINE VectorRegister4Float	MakeVectorRegisterFloat (uint32 X, uint32 Y, uint32 Z, uint32 W)

FORCEINLINE VectorRegister4Double	MakeVectorRegisterDouble (uint64 X, uint64 Y, uint64 Z, uint64 W)

FORCEINLINE VectorRegister4Float	MakeVectorRegister (uint32 X, uint32 Y, uint32 Z, uint32 W)

FORCEINLINE VectorRegister4Float	MakeVectorRegisterFloatMask (uint32 X, uint32 Y, uint32 Z, uint32 W)

FORCEINLINE VectorRegister4Double	MakeVectorRegisterDoubleMask (uint64 X, uint64 Y, uint64 Z, uint64 W)

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

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

FORCEINLINE VectorRegister4Double	MakeVectorRegisterDouble (const VectorRegister2Double &XY, const VectorRegister2Double &ZW)

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

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

FORCEINLINE VectorRegister4Double	MakeVectorRegisterDouble (const VectorRegister4Float &From)

FORCEINLINE VectorRegister4Float	MakeVectorRegisterFloatFromDouble (const VectorRegister4Double &Vec4d)

FORCEINLINE VectorRegister4Int	MakeVectorRegisterInt (int32 X, int32 Y, int32 Z, int32 W)

FORCEINLINE constexpr VectorRegister4Int	MakeVectorRegisterIntConstant (int32 X, int32 Y, int32 Z, int32 W)

FORCEINLINE constexpr VectorRegister4Float	MakeVectorRegisterFloatConstant (float X, float Y, float Z, float W)

FORCEINLINE constexpr VectorRegister2Double	MakeVectorRegister2DoubleConstant (double X, double Y)

FORCEINLINE VectorRegister4Int	MakeVectorRegisterInt64 (int64 X, int64 Y)

FORCEINLINE VectorRegister4Float	VectorZeroFloat (void)

FORCEINLINE VectorRegister4Double	VectorZeroDouble (void)

FORCEINLINE VectorRegister4Float	VectorOneFloat (void)

FORCEINLINE VectorRegister4Double	VectorOneDouble (void)

template<uint32 ComponentIndex>
FORCEINLINE float	VectorGetComponentImpl (const VectorRegister4Float &Vec)

FORCEINLINE float	VectorGetComponentDynamic (const VectorRegister4Float &Vec, uint32 ComponentIndex)

template<uint32 ComponentIndex>
FORCEINLINE double	VectorGetComponentImpl (const VectorRegister4Double &Vec)

FORCEINLINE double	VectorGetComponentDynamic (const VectorRegister4Double &Vec, uint32 ComponentIndex)

FORCEINLINE VectorRegister4Float	VectorLoad (const float *Ptr)

FORCEINLINE VectorRegister4Double	VectorLoad (const double *Ptr)

FORCEINLINE VectorRegister4x4Float	VectorLoad16 (const float *Ptr)

FORCEINLINE VectorRegister4Double	VectorLoadFloat3 (const double *Ptr)

FORCEINLINE VectorRegister4Double	VectorLoadFloat3_W1 (const double *Ptr)

FORCEINLINE VectorRegister4Float	VectorLoadFloat1 (const float *Ptr)

FORCEINLINE VectorRegister4Double	VectorLoadDouble1 (const double *Ptr)

FORCEINLINE VectorRegister4Float	VectorLoadFloat2 (const float *Ptr)

FORCEINLINE VectorRegister4Double	VectorLoadFloat2 (const double *Ptr)

FORCEINLINE VectorRegister4Float	VectorLoadTwoPairsFloat (const float Ptr1, const float Ptr2)

FORCEINLINE VectorRegister4Double	VectorLoadTwoPairsFloat (const double Ptr1, const double Ptr2)

FORCEINLINE VectorRegister4Float	VectorSetFloat1 (float F)

FORCEINLINE VectorRegister4Double	VectorSetFloat1 (double D)

FORCEINLINE void	VectorStoreAlignedStreamed (const VectorRegister4Float &Vec, float *Dst)

FORCEINLINE void	VectorStoreAlignedStreamed (const VectorRegister4Double &Vec, double *Dst)

FORCEINLINE void	VectorStore (const VectorRegister4Float &Vec, float *Dst)

FORCEINLINE void	VectorStore (const VectorRegister4Double &Vec, double *Dst)

FORCEINLINE void	VectorStore16 (const VectorRegister4x4Float &Vec, float *Dst)

FORCEINLINE void	VectorStoreFloat3 (const VectorRegister4Float &Vec, float *Dst)

FORCEINLINE void	VectorStoreFloat3 (const VectorRegister4Double &Vec, double *Dst)

FORCEINLINE void	VectorStoreFloat1 (const VectorRegister4Float &Vec, float *Dst)

FORCEINLINE void	VectorStoreFloat1 (const VectorRegister4Double &Vec, double *Dst)

FORCEINLINE VectorRegister4Float	VectorAbs (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorAbs (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorNegate (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorNegate (const VectorRegister4Double &Vec)

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

FORCEINLINE VectorRegister4Double	VectorAdd (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorSubtract (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorSubtract (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorMultiply (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorMultiply (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorMultiplyAdd (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2, const VectorRegister4Float &Vec3)

FORCEINLINE VectorRegister4Double	VectorMultiplyAdd (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2, const VectorRegister4Double &Vec3)

FORCEINLINE VectorRegister4Float	VectorNegateMultiplyAdd (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2, const VectorRegister4Float &Vec3)

FORCEINLINE VectorRegister4Double	VectorNegateMultiplyAdd (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2, const VectorRegister4Double &Vec3)

FORCEINLINE VectorRegister4Float	VectorDivide (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorDivide (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE float	VectorDot3Scalar (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE double	VectorDot3Scalar (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorDot3 (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorDot3 (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorDot4 (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorDot4 (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareEQ (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareEQ (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareNE (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareNE (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareGT (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareGT (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareGE (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareGE (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareLT (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareLT (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCompareLE (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCompareLE (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE int32	VectorMaskBits (const VectorRegister4Float &Vec1)

FORCEINLINE int32	VectorMaskBits (const VectorRegister4Double &Vec1)

FORCEINLINE VectorRegister4Float	VectorSelect (const VectorRegister4Float &Mask, const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorSelect (const VectorRegister4Double &Mask, const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorBitwiseOr (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorBitwiseOr (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorBitwiseAnd (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorBitwiseAnd (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorBitwiseXor (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorBitwiseXor (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCross (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCross (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

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

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

FORCEINLINE VectorRegister4Float	VectorSqrt (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorSqrt (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocalSqrt (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorReciprocalSqrt (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocalSqrtEstimate (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorReciprocalSqrtEstimate (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocal (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorReciprocal (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocalEstimate (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorReciprocalEstimate (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocalLen (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorReciprocalLen (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorReciprocalLenEstimate (const VectorRegister4Float &Vector)

FORCEINLINE VectorRegister4Double	VectorReciprocalLenEstimate (const VectorRegister4Double &Vector)

FORCEINLINE VectorRegister4Float	VectorSet_W0 (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorSet_W0 (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorSet_W1 (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorSet_W1 (const VectorRegister4Double &Vec)

FORCEINLINE void	VectorQuaternionMultiply (VectorRegister4Float RESTRICT Result, const VectorRegister4Float RESTRICT Quat1, const VectorRegister4Float *RESTRICT Quat2)

FORCEINLINE void	VectorQuaternionMultiply (VectorRegister4Double RESTRICT Result, const VectorRegister4Double RESTRICT Quat1, const VectorRegister4Double *RESTRICT Quat2)

FORCEINLINE VectorRegister4Float	VectorQuaternionMultiply2 (const VectorRegister4Float &Quat1, const VectorRegister4Float &Quat2)

FORCEINLINE VectorRegister4Double	VectorQuaternionMultiply2 (const VectorRegister4Double &Quat1, const VectorRegister4Double &Quat2)

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

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

FORCEINLINE bool	VectorMatrixInverse (FMatrix44d DstMatrix, const FMatrix44d SrcMatrix)

FORCEINLINE bool	VectorMatrixInverse (FMatrix44f DstMatrix, const FMatrix44f SrcMatrix)

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

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

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

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

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

FORCEINLINE VectorRegister4Double	VectorMin (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

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

FORCEINLINE VectorRegister4Double	VectorMax (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCombineHigh (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCombineHigh (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE VectorRegister4Float	VectorCombineLow (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE VectorRegister4Double	VectorCombineLow (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

FORCEINLINE void	VectorDeinterleave (VectorRegister4Float &RESTRICT OutEvens, VectorRegister4Float &RESTRICT OutOdds, const VectorRegister4Float &RESTRICT Lo, const VectorRegister4Float &RESTRICT Hi)

FORCEINLINE void	VectorDeinterleave (VectorRegister4Double &RESTRICT OutEvens, VectorRegister4Double &RESTRICT OutOdds, const VectorRegister4Double &RESTRICT Lo, const VectorRegister4Double &RESTRICT Hi)

FORCEINLINE VectorRegister4Float	VectorMergeVecXYZ_VecW (const VectorRegister4Float &VecXYZ, const VectorRegister4Float &VecW)

FORCEINLINE VectorRegister4Double	VectorMergeVecXYZ_VecW (const VectorRegister4Double &VecXYZ, const VectorRegister4Double &VecW)

FORCEINLINE void	VectorStoreByte4 (const VectorRegister4Float &Vec, void *Ptr)

FORCEINLINE void	VectorStoreSignedByte4 (const VectorRegister4Float &Vec, void *Ptr)

FORCEINLINE VectorRegister4Float	VectorLoadURGB10A2N (void *Ptr)

FORCEINLINE void	VectorStoreURGB10A2N (const VectorRegister4Float &Vec, void *Ptr)

FORCEINLINE uint32	VectorAnyGreaterThan (const VectorRegister4Float &Vec1, const VectorRegister4Float &Vec2)

FORCEINLINE uint32	VectorAnyGreaterThan (const VectorRegister4Double &Vec1, const VectorRegister4Double &Vec2)

bool	VectorContainsNaNOrInfinite (const VectorRegister4Float &Vec)

bool	VectorContainsNaNOrInfinite (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorExp (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorExp (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorExp2 (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorExp2 (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorLog (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorLog (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorLog2 (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorLog2 (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorSin (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorSin (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorCos (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorCos (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorTan (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorTan (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorASin (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorASin (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorACos (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorACos (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorATan (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorATan (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorATan2 (const VectorRegister4Float &Y, const VectorRegister4Float &X)

FORCEINLINE VectorRegister4Double	VectorATan2 (const VectorRegister4Double &Y, const VectorRegister4Double &X)

FORCEINLINE void	VectorSinCos (VectorRegister4Float RESTRICT VSinAngles, VectorRegister4Float RESTRICT VCosAngles, const VectorRegister4Float *RESTRICT VAngles)

FORCEINLINE void	VectorSinCos (VectorRegister4Double RESTRICT VSinAngles, VectorRegister4Double RESTRICT VCosAngles, const VectorRegister4Double *RESTRICT VAngles)

FORCEINLINE VectorRegister4Float	VectorCeil (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorCeil (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorFloor (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorFloor (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorTruncate (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorTruncate (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorRound (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorRound (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Int	VectorRoundToIntHalfToEven (const VectorRegister4Float &A)

FORCEINLINE VectorRegister4Float	VectorMod (const VectorRegister4Float &X, const VectorRegister4Float &Y)

FORCEINLINE VectorRegister4Double	VectorMod (const VectorRegister4Double &X, const VectorRegister4Double &Y)

FORCEINLINE VectorRegister4Float	VectorSign (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorSign (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorStep (const VectorRegister4Float &Vec)

FORCEINLINE VectorRegister4Double	VectorStep (const VectorRegister4Double &Vec)

FORCEINLINE VectorRegister4Float	VectorLoadURGBA16N (void *Ptr)

FORCEINLINE VectorRegister4Float	VectorLoadSRGBA16N (void *Ptr)

FORCEINLINE void	VectorStoreURGBA16N (const VectorRegister4Float &Vec, void *Ptr)

FORCEINLINE VectorRegister4Int	VectorIntAnd (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntOr (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntXor (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntAndNot (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntNot (const VectorRegister4Int &A)

FORCEINLINE VectorRegister4Int	VectorIntCompareEQ (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntCompareNEQ (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntCompareGT (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntCompareLT (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntCompareGE (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntCompareLE (const VectorRegister4Int &A, const VectorRegister4Int &B)

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

FORCEINLINE VectorRegister4Int	VectorIntAdd (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntSubtract (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntMultiply (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntNegate (const VectorRegister4Int &A)

FORCEINLINE VectorRegister4Int	VectorIntMin (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntMax (const VectorRegister4Int &A, const VectorRegister4Int &B)

FORCEINLINE VectorRegister4Int	VectorIntAbs (const VectorRegister4Int &A)

FORCEINLINE VectorRegister4Float	VectorIntToFloat (const VectorRegister4Int &A)

FORCEINLINE VectorRegister4Int	VectorFloatToInt (const VectorRegister4Float &A)

FORCEINLINE VectorRegister4Int	VectorFloatToInt (const VectorRegister4Double &A)

FORCEINLINE VectorRegister4Int	VectorDoubleToInt (const VectorRegister4Double &A)

FORCEINLINE VectorRegister4Int	VectorShuffleByte4 (const VectorRegister4Int &Vec, const VectorRegister4Int &Mask)

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

FORCEINLINE VectorRegister4Int	VectorIntLoad (const void *Ptr)

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

FORCEINLINE VectorRegister4Int	VectorIntLoadAligned (const void *Ptr)

FORCEINLINE VectorRegister4Int	VectorIntLoad1 (const void *Ptr)

FORCEINLINE VectorRegister4Int	VectorInt64Load (const void *Ptr)

FORCEINLINE VectorRegister2Double	VectorDoubleLoad (const void *Ptr)

Macro Definition Documentation

◆ DECLARE_VECTOR_REGISTER

#define DECLARE_VECTOR_REGISTER	(	X,
		Y,
		Z,
		W
	)	MakeVectorRegister(X, Y, Z, W)

◆ USE_FAST_QUAT_MUL

#define USE_FAST_QUAT_MUL 1

◆ VECTOR_DENORMALS_FLUSH_TO_ZERO

#define VECTOR_DENORMALS_FLUSH_TO_ZERO 0

Denormal operands and results will be flushed to zero

◆ VECTOR_ROUND_TOWARD_ZERO

#define VECTOR_ROUND_TOWARD_ZERO 0

Control status bit to round all floating point math results towards zero.

◆ VectorCastDoubleToInt

#define VectorCastDoubleToInt ( Vec ) VectorInt64Load(Vec.V)

◆ VectorCastFloatToInt

#define VectorCastFloatToInt ( Vec ) VectorIntLoad(Vec.V)

◆ VectorCastIntToDouble

#define VectorCastIntToDouble ( Vec ) VectorDoubleLoad(Vec.V)

◆ VectorCastIntToFloat

#define VectorCastIntToFloat ( Vec ) VectorLoad((float*)(Vec.V))

◆ VectorGetComponent

#define VectorGetComponent	(	Vec,
		ComponentIndex
	)	VectorGetComponentImpl<ComponentIndex>(Vec)

◆ VectorGetControlRegister

#define VectorGetControlRegister ( ) 0

Returns the control register.

Returns: The uint32 control register

◆ VectorIntExpandLow16To32

#define VectorIntExpandLow16To32 ( V0 ) static_assert(false, "Unimplemented")

◆ VectorIntSet1

#define VectorIntSet1 ( F ) MakeVectorRegisterInt(F, F, F, F)

◆ VectorIntSign

#define VectorIntSign ( A ) VectorIntSelect( VectorIntCompareGE(A, GlobalVectorConstants::IntZero), GlobalVectorConstants::IntOne, GlobalVectorConstants::IntMinusOne )

◆ VectorLoadByte4

#define VectorLoadByte4 ( Ptr ) MakeVectorRegisterFloat( float(((const uint8*)(Ptr))[0]), float(((const uint8*)(Ptr))[1]), float(((const uint8*)(Ptr))[2]), float(((const uint8*)(Ptr))[3]) )

Loads 4 BYTEs from unaligned memory and converts them into 4 FLOATs. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the 4 BYTEs.

Returns: VectorRegister( float(Ptr[0]), float(Ptr[1]), float(Ptr[2]), float(Ptr[3]) )

◆ VectorLoadByte4Reverse

#define VectorLoadByte4Reverse ( Ptr ) MakeVectorRegisterFloat( float(((const uint8*)(Ptr))[3]), float(((const uint8*)(Ptr))[2]), float(((const uint8*)(Ptr))[1]), float(((const uint8*)(Ptr))[0]) )

Loads 4 BYTEs from unaligned memory and converts them into 4 FLOATs in reversed order. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the 4 BYTEs.

Returns: VectorRegister( float(Ptr[3]), float(Ptr[2]), float(Ptr[1]), float(Ptr[0]) )

◆ VectorLoadSignedByte4

#define VectorLoadSignedByte4 ( Ptr ) MakeVectorRegisterFloat( float(((const int8*)(Ptr))[0]), float(((const int8*)(Ptr))[1]), float(((const int8*)(Ptr))[2]), float(((const int8*)(Ptr))[3]) )

Loads 4 signed BYTEs from unaligned memory and converts them into 4 FLOATs. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the 4 BYTEs.

Returns: VectorRegister( float(Ptr[0]), float(Ptr[1]), float(Ptr[2]), float(Ptr[3]) )

◆ VectorOneVectorRegister

#define VectorOneVectorRegister ( ) VectorOneDouble()

◆ VectorReplicate

#define VectorReplicate	(	Vec,
		ElementIndex
	)	MakeVectorRegister( (Vec).V[ElementIndex], (Vec).V[ElementIndex], (Vec).V[ElementIndex], (Vec).V[ElementIndex] )

Replicates one element into all four elements and returns the new vector.

Parameters

Vec	Source vector
ElementIndex	Index (0-3) of the element to replicate

Returns: VectorRegister( Vec[ElementIndex], Vec[ElementIndex], Vec[ElementIndex], Vec[ElementIndex] )

◆ VectorResetFloatRegisters

#define VectorResetFloatRegisters ( )

Resets the floating point registers so that they can be used again. Some intrinsics use these for MMX purposes (e.g. VectorLoadByte4 and VectorStoreByte4).

◆ VectorSet1

#define VectorSet1 ( F ) VectorSetFloat1(F)

◆ VectorSetControlRegister

#define VectorSetControlRegister ( ControlStatus )

Sets the control register.

Parameters

ControlStatus The uint32 control status value to set

◆ VectorSetZero

#define VectorSetZero ( ) MakeVectorRegisterFloat(0.f, 0.f, 0.f, 0.f)

◆ VectorShiftLeftImm

#define VectorShiftLeftImm	(	Vec,
		ImmAmt
	)	static_assert(false, "Unimplemented")

◆ VectorShiftRightImmArithmetic

#define VectorShiftRightImmArithmetic	(	Vec,
		ImmAmt
	)	static_assert(false, "Unimplemented")

◆ VectorShiftRightImmLogical

#define VectorShiftRightImmLogical	(	Vec,
		ImmAmt
	)	static_assert(false, "Unimplemented")

◆ VectorShuffle

#define VectorShuffle	(	Vec1,
		Vec2,
		X,
		Y,
		Z,
		W
	)	MakeVectorRegister( (Vec1).V[X], (Vec1).V[Y], (Vec2).V[Z], (Vec2).V[W] )

Creates a vector through selecting two components from each vector via a shuffle mask.

Parameters

Vec1	Source vector1
Vec2	Source vector2
X	Index for which component of Vector1 to use for X (literal 0-3)
Y	Index for which component to Vector1 to use for Y (literal 0-3)
Z	Index for which component to Vector2 to use for Z (literal 0-3)
W	Index for which component to Vector2 to use for W (literal 0-3)

Returns: The swizzled vector

◆ VectorShuffleImmediate

#define VectorShuffleImmediate	(	Vec,
		I0,
		I1,
		I2,
		I3
	)	VectorShuffle(Vec, Vec, I3, I2, I1, I0)

◆ VectorSwizzle

#define VectorSwizzle	(	Vec,
		X,
		Y,
		Z,
		W
	)	MakeVectorRegister( (Vec).V[X], (Vec).V[Y], (Vec).V[Z], (Vec).V[W] )

Swizzles the 4 components of a vector and returns the result.

Parameters

Vec	Source vector
X	Index for which component to use for X (literal 0-3)
Y	Index for which component to use for Y (literal 0-3)
Z	Index for which component to use for Z (literal 0-3)
W	Index for which component to use for W (literal 0-3)

Returns: The swizzled vector

◆ VectorZeroVectorRegister

#define VectorZeroVectorRegister ( ) VectorZeroDouble()

Typedef Documentation

◆ AlignedRegister4

typedef AlignedDouble4 AlignedRegister4

◆ VectorRegister

typedef VectorRegister4 VectorRegister

◆ VectorRegister2d

typedef VectorRegister2Double VectorRegister2d

◆ VectorRegister4

typedef VectorRegister4Double VectorRegister4

◆ VectorRegister4d

typedef VectorRegister4Double VectorRegister4d

◆ VectorRegister4f

typedef VectorRegister4Float VectorRegister4f

◆ VectorRegister4i

typedef VectorRegister4Int VectorRegister4i

◆ VectorRegisterInt

typedef VectorRegister4Int VectorRegisterInt

Function Documentation

◆ MakeVectorRegister() [1/3]

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

◆ MakeVectorRegister() [2/3]

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

◆ MakeVectorRegister() [3/3]

FORCEINLINE VectorRegister4Float MakeVectorRegister	(	uint32	X,
		uint32	Y,
		uint32	Z,
		uint32	W
	)

◆ MakeVectorRegister2Double()

FORCEINLINE VectorRegister2Double MakeVectorRegister2Double	(	double	X,
		double	Y
	)

◆ MakeVectorRegister2DoubleConstant()

FORCEINLINE constexpr VectorRegister2Double MakeVectorRegister2DoubleConstant	(	double	X,
		double	Y
	)

constexpr

◆ MakeVectorRegisterDouble() [1/4]

FORCEINLINE VectorRegister4Double MakeVectorRegisterDouble	(	const VectorRegister2Double &	XY,
		const VectorRegister2Double &	ZW
	)

◆ MakeVectorRegisterDouble() [2/4]

FORCEINLINE VectorRegister4Double MakeVectorRegisterDouble ( const VectorRegister4Float & From )

◆ MakeVectorRegisterDouble() [3/4]

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

◆ MakeVectorRegisterDouble() [4/4]

FORCEINLINE VectorRegister4Double MakeVectorRegisterDouble	(	uint64	X,
		uint64	Y,
		uint64	Z,
		uint64	W
	)

◆ MakeVectorRegisterDoubleMask()

FORCEINLINE VectorRegister4Double MakeVectorRegisterDoubleMask	(	uint64	X,
		uint64	Y,
		uint64	Z,
		uint64	W
	)

◆ MakeVectorRegisterFloat() [1/2]

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

Returns a vector based on 4 FLOATs.

Parameters

X	1st float component
Y	2nd float component
Z	3rd float component
W	4th float component

Returns: Vector of the 4 FLOATs

◆ MakeVectorRegisterFloat() [2/2]

FORCEINLINE VectorRegister4Float MakeVectorRegisterFloat	(	uint32	X,
		uint32	Y,
		uint32	Z,
		uint32	W
	)

Returns a bitwise equivalent vector based on 4 DWORDs.

Parameters

X	1st uint32 component
Y	2nd uint32 component
Z	3rd uint32 component
W	4th uint32 component

Returns: Bitwise equivalent vector with 4 floats

◆ MakeVectorRegisterFloatConstant()

FORCEINLINE constexpr VectorRegister4Float MakeVectorRegisterFloatConstant	(	float	X,
		float	Y,
		float	Z,
		float	W
	)

constexpr

◆ MakeVectorRegisterFloatFromDouble()

FORCEINLINE VectorRegister4Float MakeVectorRegisterFloatFromDouble ( const VectorRegister4Double & Vec4d )

◆ MakeVectorRegisterFloatMask()

FORCEINLINE VectorRegister4Float MakeVectorRegisterFloatMask	(	uint32	X,
		uint32	Y,
		uint32	Z,
		uint32	W
	)

◆ MakeVectorRegisterInt()

FORCEINLINE VectorRegister4Int MakeVectorRegisterInt	(	int32	X,
		int32	Y,
		int32	Z,
		int32	W
	)

Returns a vector based on 4 int32.

Parameters

X	1st int32 component
Y	2nd int32 component
Z	3rd int32 component
W	4th int32 component

Returns: Vector of the 4 int32

◆ MakeVectorRegisterInt64()

FORCEINLINE VectorRegister4Int MakeVectorRegisterInt64	(	int64	X,
		int64	Y
	)

◆ MakeVectorRegisterIntConstant()

FORCEINLINE constexpr VectorRegister4Int MakeVectorRegisterIntConstant	(	int32	X,
		int32	Y,
		int32	Z,
		int32	W
	)

constexpr

◆ VectorAbs() [1/2]

FORCEINLINE VectorRegister4Double VectorAbs ( const VectorRegister4Double & Vec )

◆ VectorAbs() [2/2]

FORCEINLINE VectorRegister4Float VectorAbs ( const VectorRegister4Float & Vec )

Returns the absolute value (component-wise).

Parameters

Vec	Source vector

Returns: VectorRegister( abs(Vec.x), abs(Vec.y), abs(Vec.z), abs(Vec.w) )

◆ VectorACos() [1/2]

FORCEINLINE VectorRegister4Double VectorACos ( const VectorRegister4Double & Vec )

◆ VectorACos() [2/2]

FORCEINLINE VectorRegister4Float VectorACos ( const VectorRegister4Float & Vec )

◆ VectorAdd() [1/2]

FORCEINLINE VectorRegister4Double VectorAdd	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorAdd() [2/2]

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

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x+Vec2.x, Vec1.y+Vec2.y, Vec1.z+Vec2.z, Vec1.w+Vec2.w )

◆ VectorAnyGreaterThan() [1/2]

FORCEINLINE uint32 VectorAnyGreaterThan	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorAnyGreaterThan() [2/2]

FORCEINLINE uint32 VectorAnyGreaterThan	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st source vector
Vec2	2nd source vector

Returns: Non-zero integer if (Vec1.x > Vec2.x) || (Vec1.y > Vec2.y) || (Vec1.z > Vec2.z) || (Vec1.w > Vec2.w)

◆ VectorASin() [1/2]

FORCEINLINE VectorRegister4Double VectorASin ( const VectorRegister4Double & Vec )

◆ VectorASin() [2/2]

FORCEINLINE VectorRegister4Float VectorASin ( const VectorRegister4Float & Vec )

◆ VectorATan() [1/2]

FORCEINLINE VectorRegister4Double VectorATan ( const VectorRegister4Double & Vec )

◆ VectorATan() [2/2]

FORCEINLINE VectorRegister4Float VectorATan ( const VectorRegister4Float & Vec )

◆ VectorATan2() [1/2]

FORCEINLINE VectorRegister4Double VectorATan2	(	const VectorRegister4Double &	Y,
		const VectorRegister4Double &	X
	)

◆ VectorATan2() [2/2]

FORCEINLINE VectorRegister4Float VectorATan2	(	const VectorRegister4Float &	Y,
		const VectorRegister4Float &	X
	)

◆ VectorBitwiseAnd() [1/2]

FORCEINLINE VectorRegister4Double VectorBitwiseAnd	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorBitwiseAnd() [2/2]

FORCEINLINE VectorRegister4Float VectorBitwiseAnd	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( for each bit i: Vec1[i] & Vec2[i] )

◆ VectorBitwiseOr() [1/2]

FORCEINLINE VectorRegister4Double VectorBitwiseOr	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorBitwiseOr() [2/2]

FORCEINLINE VectorRegister4Float VectorBitwiseOr	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( for each bit i: Vec1[i] | Vec2[i] )

◆ VectorBitwiseXor() [1/2]

FORCEINLINE VectorRegister4Double VectorBitwiseXor	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorBitwiseXor() [2/2]

FORCEINLINE VectorRegister4Float VectorBitwiseXor	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( for each bit i: Vec1[i] ^ Vec2[i] )

◆ VectorCeil() [1/2]

FORCEINLINE VectorRegister4Double VectorCeil ( const VectorRegister4Double & Vec )

◆ VectorCeil() [2/2]

FORCEINLINE VectorRegister4Float VectorCeil ( const VectorRegister4Float & Vec )

◆ VectorCombineHigh() [1/2]

FORCEINLINE VectorRegister4Double VectorCombineHigh	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCombineHigh() [2/2]

FORCEINLINE VectorRegister4Float VectorCombineHigh	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

Creates a vector by combining two high components from each vector

Parameters

Vec1	Source vector1
Vec2	Source vector2

Returns: The combined vector

◆ VectorCombineLow() [1/2]

FORCEINLINE VectorRegister4Double VectorCombineLow	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCombineLow() [2/2]

FORCEINLINE VectorRegister4Float VectorCombineLow	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

Creates a vector by combining two low components from each vector

Parameters

Vec1	Source vector1
Vec2	Source vector2

Returns: The combined vector

◆ VectorCompareEQ() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareEQ	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareEQ() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareEQ	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x == Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorCompareGE() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareGE	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareGE() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareGE	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x >= Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorCompareGT() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareGT	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareGT() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareGT	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x > Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorCompareLE() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareLE	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareLE() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareLE	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x <= Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorCompareLT() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareLT	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareLT() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareLT	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x < Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorCompareNE() [1/2]

FORCEINLINE VectorRegister4Double VectorCompareNE	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCompareNE() [2/2]

FORCEINLINE VectorRegister4Float VectorCompareNE	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x != Vec2.x ? 0xFFFFFFFF : 0, same for yzw )

◆ VectorContainsNaNOrInfinite() [1/2]

bool VectorContainsNaNOrInfinite ( const VectorRegister4Double & Vec )

inline

◆ VectorContainsNaNOrInfinite() [2/2]

bool VectorContainsNaNOrInfinite ( const VectorRegister4Float & Vec )

inline

◆ VectorCos() [1/2]

FORCEINLINE VectorRegister4Double VectorCos ( const VectorRegister4Double & Vec )

◆ VectorCos() [2/2]

FORCEINLINE VectorRegister4Float VectorCos ( const VectorRegister4Float & Vec )

◆ VectorCross() [1/2]

FORCEINLINE VectorRegister4Double VectorCross	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorCross() [2/2]

FORCEINLINE VectorRegister4Float VectorCross	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

Calculates the cross product of two vectors (XYZ components). W of the input should be 0, and will remain 0.

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: cross(Vec1.xyz, Vec2.xyz). W of the input should be 0, and will remain 0.

◆ VectorDeinterleave() [1/2]

FORCEINLINE void VectorDeinterleave	(	VectorRegister4Double &RESTRICT	OutEvens,
		VectorRegister4Double &RESTRICT	OutOdds,
		const VectorRegister4Double &RESTRICT	Lo,
		const VectorRegister4Double &RESTRICT	Hi
	)

◆ VectorDeinterleave() [2/2]

FORCEINLINE void VectorDeinterleave	(	VectorRegister4Float &RESTRICT	OutEvens,
		VectorRegister4Float &RESTRICT	OutOdds,
		const VectorRegister4Float &RESTRICT	Lo,
		const VectorRegister4Float &RESTRICT	Hi
	)

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

Parameters

Lo	[Even0, Odd0, Even1, Odd1]
Hi	[Even2, Odd2, Even3, Odd3]
OutEvens	[Even0, Even1, Even2, Even3]
OutOdds	[Odd0, Odd1, Odd2, Odd3]

◆ VectorDivide() [1/2]

FORCEINLINE VectorRegister4Double VectorDivide	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorDivide() [2/2]

FORCEINLINE VectorRegister4Float VectorDivide	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x/Vec2.x, Vec1.y/Vec2.y, Vec1.z/Vec2.z, Vec1.w/Vec2.w )

◆ VectorDot3() [1/2]

FORCEINLINE VectorRegister4Double VectorDot3	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorDot3() [2/2]

FORCEINLINE VectorRegister4Float VectorDot3	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: d = dot3(Vec1.xyz, Vec2.xyz), VectorRegister( d, d, d, d )

◆ VectorDot3Scalar() [1/2]

FORCEINLINE double VectorDot3Scalar	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorDot3Scalar() [2/2]

FORCEINLINE float VectorDot3Scalar	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

Calculates the dot3 product of two vectors and returns a scalar value.

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: d = dot3(Vec1.xyz, Vec2.xyz)

◆ VectorDot4() [1/2]

FORCEINLINE VectorRegister4Double VectorDot4	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorDot4() [2/2]

FORCEINLINE VectorRegister4Float VectorDot4	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: d = dot4(Vec1.xyzw, Vec2.xyzw), VectorRegister( d, d, d, d )

◆ VectorDoubleLoad()

FORCEINLINE VectorRegister2Double VectorDoubleLoad ( const void * Ptr )

Loads 2 doubles from unaligned memory.

Parameters

Ptr	Unaligned memory pointer to the 2 doubles

Returns: VectorRegister2Double(Ptr[0], Ptr[1])

◆ VectorDoubleToInt()

FORCEINLINE VectorRegister4Int VectorDoubleToInt ( const VectorRegister4Double & A )

◆ VectorExp() [1/2]

FORCEINLINE VectorRegister4Double VectorExp ( const VectorRegister4Double & Vec )

◆ VectorExp() [2/2]

FORCEINLINE VectorRegister4Float VectorExp ( const VectorRegister4Float & Vec )

◆ VectorExp2() [1/2]

FORCEINLINE VectorRegister4Double VectorExp2 ( const VectorRegister4Double & Vec )

◆ VectorExp2() [2/2]

FORCEINLINE VectorRegister4Float VectorExp2 ( const VectorRegister4Float & Vec )

◆ VectorFloatToInt() [1/2]

FORCEINLINE VectorRegister4Int VectorFloatToInt ( const VectorRegister4Double & A )

◆ VectorFloatToInt() [2/2]

FORCEINLINE VectorRegister4Int VectorFloatToInt ( const VectorRegister4Float & A )

◆ VectorFloor() [1/2]

FORCEINLINE VectorRegister4Double VectorFloor ( const VectorRegister4Double & Vec )

◆ VectorFloor() [2/2]

FORCEINLINE VectorRegister4Float VectorFloor ( const VectorRegister4Float & Vec )

◆ VectorGetComponentDynamic() [1/2]

FORCEINLINE double VectorGetComponentDynamic	(	const VectorRegister4Double &	Vec,
		uint32	ComponentIndex
	)

◆ VectorGetComponentDynamic() [2/2]

FORCEINLINE float VectorGetComponentDynamic	(	const VectorRegister4Float &	Vec,
		uint32	ComponentIndex
	)

◆ VectorGetComponentImpl() [1/2]

template<uint32 ComponentIndex>

FORCEINLINE double VectorGetComponentImpl ( const VectorRegister4Double & Vec )

◆ VectorGetComponentImpl() [2/2]

template<uint32 ComponentIndex>

FORCEINLINE float VectorGetComponentImpl ( const VectorRegister4Float & Vec )

Returns an component from a vector.

Parameters

Vec	Vector register
ComponentIndex	Which component to get, X=0, Y=1, Z=2, W=3

Returns: The component as a float

◆ VectorInt64Load()

FORCEINLINE VectorRegister4Int VectorInt64Load ( const void * Ptr )

Loads 2 int64s from unaligned memory.

Parameters

Ptr	Unaligned memory pointer to the 2 int64s

Returns: VectorRegister4Int(Ptr[0], Ptr[1])

◆ VectorIntAbs()

FORCEINLINE VectorRegister4Int VectorIntAbs ( const VectorRegister4Int & A )

◆ VectorIntAdd()

FORCEINLINE VectorRegister4Int VectorIntAdd	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntAnd()

FORCEINLINE VectorRegister4Int VectorIntAnd	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

= a & b

◆ VectorIntAndNot()

FORCEINLINE VectorRegister4Int VectorIntAndNot	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

= (~a) & b to match _mm_andnot_si128

◆ VectorIntCompareEQ()

FORCEINLINE VectorRegister4Int VectorIntCompareEQ	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntCompareGE()

FORCEINLINE VectorRegister4Int VectorIntCompareGE	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntCompareGT()

FORCEINLINE VectorRegister4Int VectorIntCompareGT	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntCompareLE()

FORCEINLINE VectorRegister4Int VectorIntCompareLE	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntCompareLT()

FORCEINLINE VectorRegister4Int VectorIntCompareLT	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntCompareNEQ()

FORCEINLINE VectorRegister4Int VectorIntCompareNEQ	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntLoad()

FORCEINLINE VectorRegister4Int VectorIntLoad ( const void * Ptr )

Loads 4 int32s from unaligned memory.

Parameters

Ptr	Unaligned memory pointer to the 4 int32s

Returns: VectorRegister4Int(Ptr[0], Ptr[1], Ptr[2], Ptr[3])

◆ VectorIntLoad1()

FORCEINLINE VectorRegister4Int VectorIntLoad1 ( const void * Ptr )

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

Parameters

Ptr	Unaligned memory pointer to the 4 int32s

Returns: VectorRegister4Int(*Ptr, *Ptr, *Ptr, *Ptr)

◆ VectorIntLoadAligned()

FORCEINLINE VectorRegister4Int VectorIntLoadAligned ( const void * Ptr )

Loads 4 int32s from aligned memory.

Parameters

Ptr	Aligned memory pointer to the 4 int32s

Returns: VectorRegister4Int(Ptr[0], Ptr[1], Ptr[2], Ptr[3])

◆ VectorIntMax()

FORCEINLINE VectorRegister4Int VectorIntMax	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntMin()

FORCEINLINE VectorRegister4Int VectorIntMin	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntMultiply()

FORCEINLINE VectorRegister4Int VectorIntMultiply	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntNegate()

FORCEINLINE VectorRegister4Int VectorIntNegate ( const VectorRegister4Int & A )

◆ VectorIntNot()

FORCEINLINE VectorRegister4Int VectorIntNot ( const VectorRegister4Int & A )

= ~a

◆ VectorIntOr()

FORCEINLINE VectorRegister4Int VectorIntOr	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

= a | b

◆ VectorIntSelect()

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

◆ VectorIntStore()

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

Stores a vector to memory (aligned or unaligned).

Parameters

Vec	Vector to store
Ptr	Memory pointer

◆ VectorIntStoreAligned()

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

Stores a vector to memory (aligned).

Parameters

Vec	Vector to store
Ptr	Aligned Memory pointer

◆ VectorIntSubtract()

FORCEINLINE VectorRegister4Int VectorIntSubtract	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

◆ VectorIntToFloat()

FORCEINLINE VectorRegister4Float VectorIntToFloat ( const VectorRegister4Int & A )

◆ VectorIntXor()

FORCEINLINE VectorRegister4Int VectorIntXor	(	const VectorRegister4Int &	A,
		const VectorRegister4Int &	B
	)

= a ^ b

◆ VectorLoad() [1/2]

FORCEINLINE VectorRegister4Double VectorLoad ( const double * Ptr )

◆ VectorLoad() [2/2]

FORCEINLINE VectorRegister4Float VectorLoad ( const float * Ptr )

Loads 4 FLOATs from unaligned memory.

Parameters

Ptr	Unaligned memory pointer to the 4 FLOATs

Returns: VectorRegister(Ptr[0], Ptr[1], Ptr[2], Ptr[3])

◆ VectorLoad16()

FORCEINLINE VectorRegister4x4Float VectorLoad16 ( const float * Ptr )

Loads 16 floats from unaligned memory into 4 vector registers.

Parameters

Ptr	Unaligned memory pointer to the 4 floats

Returns: VectorRegister4x4Float containing 16 floats

◆ VectorLoadAligned() [1/2]

FORCEINLINE VectorRegister4Double VectorLoadAligned ( const double * Ptr )

◆ VectorLoadAligned() [2/2]

FORCEINLINE VectorRegister4Float VectorLoadAligned ( const float * Ptr )

Loads 4 FLOATs from aligned memory.

Parameters

Ptr	Aligned memory pointer to the 4 FLOATs

Returns: VectorRegister4Float(Ptr[0], Ptr[1], Ptr[2], Ptr[3])

◆ VectorLoadDouble1()

FORCEINLINE VectorRegister4Double VectorLoadDouble1 ( const double * Ptr )

◆ VectorLoadFloat1()

FORCEINLINE VectorRegister4Float VectorLoadFloat1 ( const float * Ptr )

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

Parameters

Ptr	Unaligned memory pointer to the float

Returns: VectorRegister4Float(Ptr[0], Ptr[0], Ptr[0], Ptr[0])

◆ VectorLoadFloat2() [1/2]

FORCEINLINE VectorRegister4Double VectorLoadFloat2 ( const double * Ptr )

◆ VectorLoadFloat2() [2/2]

FORCEINLINE VectorRegister4Float VectorLoadFloat2 ( const float * Ptr )

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

Parameters

Ptr	Unaligned memory pointer to the floats

Returns: VectorRegister4Float(Ptr[0], Ptr[1], Ptr[0], Ptr[1])

◆ VectorLoadFloat3()

FORCEINLINE VectorRegister4Double VectorLoadFloat3 ( const double * Ptr )

Loads 3 FLOATs from unaligned memory and sets W=0.

Parameters

Ptr	Unaligned memory pointer to the 3 FLOATs

Returns: VectorRegister4Float(Ptr[0], Ptr[1], Ptr[2], 0)

◆ VectorLoadFloat3_W1()

FORCEINLINE VectorRegister4Double VectorLoadFloat3_W1 ( const double * Ptr )

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

Parameters

Ptr	Unaligned memory pointer to the 3 FLOATs

Returns: VectorRegister4Float(Ptr[0], Ptr[1], Ptr[2], 1.0f)

◆ VectorLoadSRGBA16N()

FORCEINLINE VectorRegister4Float VectorLoadSRGBA16N ( void * Ptr )

Loads packed signed RGBA16(4 bytes) from unaligned memory and converts them into 4 FLOATs. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the RGBA16(8 bytes).

Returns: VectorRegister with 4 FLOATs loaded from Ptr.

◆ VectorLoadTwoPairsFloat() [1/2]

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

◆ VectorLoadTwoPairsFloat() [2/2]

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

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

Parameters

Ptr1	Unaligned memory pointer to the first 2 floats
Ptr2	Unaligned memory pointer to the second 2 floats

Returns: VectorRegister(Ptr1[0], Ptr1[1], Ptr2[0], Ptr2[1])

◆ VectorLoadURGB10A2N()

FORCEINLINE VectorRegister4Float VectorLoadURGB10A2N ( void * Ptr )

Loads packed RGB10A2(4 bytes) from unaligned memory and converts them into 4 FLOATs. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the RGB10A2(4 bytes).

Returns: VectorRegister with 4 FLOATs loaded from Ptr.

◆ VectorLoadURGBA16N()

FORCEINLINE VectorRegister4Float VectorLoadURGBA16N ( void * Ptr )

Loads packed RGBA16(4 bytes) from unaligned memory and converts them into 4 FLOATs. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Ptr	Unaligned memory pointer to the RGBA16(8 bytes).

Returns: VectorRegister with 4 FLOATs loaded from Ptr.

◆ VectorLog() [1/2]

FORCEINLINE VectorRegister4Double VectorLog ( const VectorRegister4Double & Vec )

◆ VectorLog() [2/2]

FORCEINLINE VectorRegister4Float VectorLog ( const VectorRegister4Float & Vec )

◆ VectorLog2() [1/2]

FORCEINLINE VectorRegister4Double VectorLog2 ( const VectorRegister4Double & Vec )

◆ VectorLog2() [2/2]

FORCEINLINE VectorRegister4Float VectorLog2 ( const VectorRegister4Float & Vec )

◆ VectorMaskBits() [1/2]

FORCEINLINE int32 VectorMaskBits ( const VectorRegister4Double & Vec1 )

◆ VectorMaskBits() [2/2]

FORCEINLINE int32 VectorMaskBits ( const VectorRegister4Float & Vec1 )

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

Parameters

VecMask Vector

Returns: Bit 0 = sign(VecMask.x), Bit 1 = sign(VecMask.y), Bit 2 = sign(VecMask.z), Bit 3 = sign(VecMask.w)

◆ VectorMatrixInverse() [1/2]

FORCEINLINE bool VectorMatrixInverse	(	FMatrix44d *	DstMatrix,
		const FMatrix44d *	SrcMatrix
	)

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

Parameters

DstMatrix	FMatrix44 pointer to where the result should be stored
SrcMatrix	FMatrix44 pointer to the Matrix to be inversed

Returns: bool returns false if matrix is not invertable and stores identity

◆ VectorMatrixInverse() [2/2]

FORCEINLINE bool VectorMatrixInverse	(	FMatrix44f *	DstMatrix,
		const FMatrix44f *	SrcMatrix
	)

◆ VectorMatrixMultiply() [1/2]

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

Multiplies two 4x4 matrices.

Parameters

Result	Pointer to where the result should be stored
Matrix1	Pointer to the first matrix
Matrix2	Pointer to the second matrix

◆ VectorMatrixMultiply() [2/2]

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

◆ VectorMax() [1/2]

FORCEINLINE VectorRegister4Double VectorMax	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorMax() [2/2]

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

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( max(Vec1.x,Vec2.x), max(Vec1.y,Vec2.y), max(Vec1.z,Vec2.z), max(Vec1.w,Vec2.w) )

◆ VectorMergeVecXYZ_VecW() [1/2]

FORCEINLINE VectorRegister4Double VectorMergeVecXYZ_VecW	(	const VectorRegister4Double &	VecXYZ,
		const VectorRegister4Double &	VecW
	)

◆ VectorMergeVecXYZ_VecW() [2/2]

FORCEINLINE VectorRegister4Float VectorMergeVecXYZ_VecW	(	const VectorRegister4Float &	VecXYZ,
		const VectorRegister4Float &	VecW
	)

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

Parameters

VecXYZ	Source vector for XYZ_
VecW	Source register for ___W (note: the fourth component is used, not the first)

Returns: VectorRegister(VecXYZ.x, VecXYZ.y, VecXYZ.z, VecW.w)

◆ VectorMin() [1/2]

FORCEINLINE VectorRegister4Double VectorMin	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorMin() [2/2]

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

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( min(Vec1.x,Vec2.x), min(Vec1.y,Vec2.y), min(Vec1.z,Vec2.z), min(Vec1.w,Vec2.w) )

◆ VectorMod() [1/2]

FORCEINLINE VectorRegister4Double VectorMod	(	const VectorRegister4Double &	X,
		const VectorRegister4Double &	Y
	)

◆ VectorMod() [2/2]

FORCEINLINE VectorRegister4Float VectorMod	(	const VectorRegister4Float &	X,
		const VectorRegister4Float &	Y
	)

◆ VectorMultiply() [1/2]

FORCEINLINE VectorRegister4Double VectorMultiply	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorMultiply() [2/2]

FORCEINLINE VectorRegister4Float VectorMultiply	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x*Vec2.x, Vec1.y*Vec2.y, Vec1.z*Vec2.z, Vec1.w*Vec2.w )

◆ VectorMultiplyAdd() [1/2]

FORCEINLINE VectorRegister4Double VectorMultiplyAdd	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2,
		const VectorRegister4Double &	Vec3
	)

◆ VectorMultiplyAdd() [2/2]

FORCEINLINE VectorRegister4Float VectorMultiplyAdd	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2,
		const VectorRegister4Float &	Vec3
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector
Vec3	3rd vector

Returns: VectorRegister( Vec1.x*Vec2.x + Vec3.x, Vec1.y*Vec2.y + Vec3.y, Vec1.z*Vec2.z + Vec3.z, Vec1.w*Vec2.w + Vec3.w )

◆ VectorNegate() [1/2]

FORCEINLINE VectorRegister4Double VectorNegate ( const VectorRegister4Double & Vec )

◆ VectorNegate() [2/2]

FORCEINLINE VectorRegister4Float VectorNegate ( const VectorRegister4Float & Vec )

Returns the negated value (component-wise).

Parameters

Vec	Source vector

Returns: VectorRegister( -Vec.x, -Vec.y, -Vec.z, -Vec.w )

◆ VectorNegateMultiplyAdd() [1/2]

FORCEINLINE VectorRegister4Double VectorNegateMultiplyAdd	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2,
		const VectorRegister4Double &	Vec3
	)

◆ VectorNegateMultiplyAdd() [2/2]

FORCEINLINE VectorRegister4Float VectorNegateMultiplyAdd	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2,
		const VectorRegister4Float &	Vec3
	)

Multiplies two vectors (component-wise), negates the results and adds it to the third vector i.e. -AB + C = C - AB

Parameters

Vec1	1st vector
Vec2	2nd vector
Vec3	3rd vector

Returns: VectorRegister( Vec3.x - Vec1.x*Vec2.x, Vec3.y - Vec1.y*Vec2.y, Vec3.z - Vec1.z*Vec2.z, Vec3.w - Vec1.w*Vec2.w )

◆ VectorOneDouble()

FORCEINLINE VectorRegister4Double VectorOneDouble ( void )

◆ VectorOneFloat()

FORCEINLINE VectorRegister4Float VectorOneFloat ( void )

Returns a vector with all ones.

Returns: VectorRegister4Float(1.0f, 1.0f, 1.0f, 1.0f)

◆ VectorPow() [1/2]

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

◆ VectorPow() [2/2]

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

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

Parameters

Base	Base vector
Exponent	Exponent vector

Returns: VectorRegister( Base.x^Exponent.x, Base.y^Exponent.y, Base.z^Exponent.z, Base.w^Exponent.w )

◆ VectorQuaternionMultiply() [1/2]

FORCEINLINE void VectorQuaternionMultiply	(	VectorRegister4Double *RESTRICT	Result,
		const VectorRegister4Double *RESTRICT	Quat1,
		const VectorRegister4Double *RESTRICT	Quat2
	)

◆ VectorQuaternionMultiply() [2/2]

FORCEINLINE void VectorQuaternionMultiply	(	VectorRegister4Float *RESTRICT	Result,
		const VectorRegister4Float *RESTRICT	Quat1,
		const VectorRegister4Float *RESTRICT	Quat2
	)

Multiplies two quaternions; the order matters.

When composing quaternions: VectorQuaternionMultiply(C, A, B) will yield a quaternion C = A * B that logically first applies B then A to any subsequent transformation (right first, then left).

Parameters

Result	Pointer to where the result Quat1 * Quat2 should be stored
Quat1	Pointer to the first quaternion (must not be the destination)
Quat2	Pointer to the second quaternion (must not be the destination)

◆ VectorQuaternionMultiply2() [1/2]

FORCEINLINE VectorRegister4Double VectorQuaternionMultiply2	(	const VectorRegister4Double &	Quat1,
		const VectorRegister4Double &	Quat2
	)

◆ VectorQuaternionMultiply2() [2/2]

FORCEINLINE VectorRegister4Float VectorQuaternionMultiply2	(	const VectorRegister4Float &	Quat1,
		const VectorRegister4Float &	Quat2
	)

Multiplies two quaternions; the order matters.

Order matters when composing quaternions: C = VectorQuaternionMultiply2(A, B) will yield a quaternion C = A * B that logically first applies B then A to any subsequent transformation (right first, then left).

Parameters

Quat1	Pointer to the first quaternion
Quat2	Pointer to the second quaternion

Returns: Quat1 * Quat2

◆ VectorReciprocal() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocal ( const VectorRegister4Double & Vec )

◆ VectorReciprocal() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocal ( const VectorRegister4Float & Vec )

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

Parameters

Vec	1st vector

Returns: VectorRegister4Float( 1.0f / Vec.x, 1.0f / Vec.y, 1.0f / Vec.z, 1.0f / Vec.w )

◆ VectorReciprocalEstimate() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocalEstimate ( const VectorRegister4Double & Vec )

◆ VectorReciprocalEstimate() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocalEstimate ( const VectorRegister4Float & Vec )

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

Parameters

Vec	1st vector

Returns: VectorRegister( (Estimate) 1.0f / Vec.x, (Estimate) 1.0f / Vec.y, (Estimate) 1.0f / Vec.z, (Estimate) 1.0f / Vec.w )

◆ VectorReciprocalLen() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocalLen ( const VectorRegister4Double & Vec )

◆ VectorReciprocalLen() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocalLen ( const VectorRegister4Float & Vec )

Return Reciprocal Length of the vector

Parameters

Vec Vector

Returns: VectorRegister(rlen, rlen, rlen, rlen) when rlen = 1/sqrt(dot4(V))

◆ VectorReciprocalLenEstimate() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocalLenEstimate ( const VectorRegister4Double & Vector )

◆ VectorReciprocalLenEstimate() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocalLenEstimate ( const VectorRegister4Float & Vector )

Return Reciprocal Length of the vector (estimate)

Parameters

Vector Vector

Returns: VectorRegister4Float(rlen, rlen, rlen, rlen) when rlen = 1/sqrt(dot4(V))

◆ VectorReciprocalSqrt() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocalSqrt ( const VectorRegister4Double & Vec )

◆ VectorReciprocalSqrt() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocalSqrt ( const VectorRegister4Float & Vec )

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

Parameters

Vector Vector

Returns: VectorRegister(1/sqrt(t), 1/sqrt(t), 1/sqrt(t), 1/sqrt(t))

◆ VectorReciprocalSqrtEstimate() [1/2]

FORCEINLINE VectorRegister4Double VectorReciprocalSqrtEstimate ( const VectorRegister4Double & Vec )

◆ VectorReciprocalSqrtEstimate() [2/2]

FORCEINLINE VectorRegister4Float VectorReciprocalSqrtEstimate ( const VectorRegister4Float & Vec )

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

Parameters

Vector Vector

Returns: VectorRegister(1/sqrt(t), 1/sqrt(t), 1/sqrt(t), 1/sqrt(t))

◆ VectorRound() [1/2]

FORCEINLINE VectorRegister4Double VectorRound ( const VectorRegister4Double & Vec )

◆ VectorRound() [2/2]

FORCEINLINE VectorRegister4Float VectorRound ( const VectorRegister4Float & Vec )

◆ VectorRoundToIntHalfToEven()

FORCEINLINE VectorRegister4Int VectorRoundToIntHalfToEven ( const VectorRegister4Float & A )

◆ VectorSelect() [1/2]

FORCEINLINE VectorRegister4Double VectorSelect	(	const VectorRegister4Double &	Mask,
		const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorSelect() [2/2]

FORCEINLINE VectorRegister4Float VectorSelect	(	const VectorRegister4Float &	Mask,
		const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Mask	Mask (when 1: use the corresponding bit from Vec1 otherwise from Vec2)
Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( for each bit i: Mask[i] ? Vec1[i] : Vec2[i] )

◆ VectorSet_W0() [1/2]

FORCEINLINE VectorRegister4Double VectorSet_W0 ( const VectorRegister4Double & Vec )

◆ VectorSet_W0() [2/2]

FORCEINLINE VectorRegister4Float VectorSet_W0 ( const VectorRegister4Float & Vec )

Loads XYZ and sets W=0

Parameters

Vec	VectorRegister

Returns: VectorRegister(X, Y, Z, 0.0f)

◆ VectorSet_W1() [1/2]

FORCEINLINE VectorRegister4Double VectorSet_W1 ( const VectorRegister4Double & Vec )

◆ VectorSet_W1() [2/2]

FORCEINLINE VectorRegister4Float VectorSet_W1 ( const VectorRegister4Float & Vec )

Loads XYZ and sets W=1

Parameters

Vec	VectorRegister

Returns: VectorRegister(X, Y, Z, 1.0f)

◆ VectorSetFloat1() [1/2]

FORCEINLINE VectorRegister4Double VectorSetFloat1 ( double D )

◆ VectorSetFloat1() [2/2]

FORCEINLINE VectorRegister4Float VectorSetFloat1 ( float F )

Propagates passed in float to all registers

Parameters

F	Float to set

Returns: VectorRegister4Float(F,F,F,F)

◆ VectorShuffleByte4()

FORCEINLINE VectorRegister4Int VectorShuffleByte4	(	const VectorRegister4Int &	Vec,
		const VectorRegister4Int &	Mask
	)

◆ VectorSign() [1/2]

FORCEINLINE VectorRegister4Double VectorSign ( const VectorRegister4Double & Vec )

◆ VectorSign() [2/2]

FORCEINLINE VectorRegister4Float VectorSign ( const VectorRegister4Float & Vec )

◆ VectorSin() [1/2]

FORCEINLINE VectorRegister4Double VectorSin ( const VectorRegister4Double & Vec )

◆ VectorSin() [2/2]

FORCEINLINE VectorRegister4Float VectorSin ( const VectorRegister4Float & Vec )

◆ VectorSinCos() [1/2]

FORCEINLINE void VectorSinCos	(	VectorRegister4Double *RESTRICT	VSinAngles,
		VectorRegister4Double *RESTRICT	VCosAngles,
		const VectorRegister4Double *RESTRICT	VAngles
	)

◆ VectorSinCos() [2/2]

FORCEINLINE void VectorSinCos	(	VectorRegister4Float *RESTRICT	VSinAngles,
		VectorRegister4Float *RESTRICT	VCosAngles,
		const VectorRegister4Float *RESTRICT	VAngles
	)

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

Parameters

VSinAngles	VectorRegister Pointer to where the Sin result should be stored
VCosAngles	VectorRegister Pointer to where the Cos result should be stored
VAngles	VectorRegister Pointer to the input angles

◆ VectorSqrt() [1/2]

FORCEINLINE VectorRegister4Double VectorSqrt ( const VectorRegister4Double & Vec )

◆ VectorSqrt() [2/2]

FORCEINLINE VectorRegister4Float VectorSqrt ( const VectorRegister4Float & Vec )

◆ VectorStep() [1/2]

FORCEINLINE VectorRegister4Double VectorStep ( const VectorRegister4Double & Vec )

◆ VectorStep() [2/2]

FORCEINLINE VectorRegister4Float VectorStep ( const VectorRegister4Float & Vec )

◆ VectorStore() [1/2]

FORCEINLINE void VectorStore	(	const VectorRegister4Double &	Vec,
		double *	Dst
	)

◆ VectorStore() [2/2]

FORCEINLINE void VectorStore	(	const VectorRegister4Float &	Vec,
		float *	Dst
	)

Stores a vector to memory (aligned or unaligned).

Parameters

Vec	Vector to store
Ptr	Memory pointer

◆ VectorStore16()

FORCEINLINE void VectorStore16	(	const VectorRegister4x4Float &	Vec,
		float *	Dst
	)

Stores 4 vectors to memory (aligned or unaligned).

Parameters

Vec	Vector to store
Ptr	Memory pointer

◆ VectorStoreAligned() [1/2]

FORCEINLINE void VectorStoreAligned	(	const VectorRegister4Double &	Vec,
		double *	Dst
	)

◆ VectorStoreAligned() [2/2]

FORCEINLINE void VectorStoreAligned	(	const VectorRegister4Float &	Vec,
		float *	Dst
	)

Stores a vector to aligned memory.

Parameters

Vec	Vector to store
Ptr	Aligned memory pointer

◆ VectorStoreAlignedStreamed() [1/2]

FORCEINLINE void VectorStoreAlignedStreamed	(	const VectorRegister4Double &	Vec,
		double *	Dst
	)

◆ VectorStoreAlignedStreamed() [2/2]

FORCEINLINE void VectorStoreAlignedStreamed	(	const VectorRegister4Float &	Vec,
		float *	Dst
	)

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

Parameters

Vec	Vector to store
Ptr	Aligned memory pointer

◆ VectorStoreByte4()

FORCEINLINE void VectorStoreByte4	(	const VectorRegister4Float &	Vec,
		void *	Ptr
	)

Converts the 4 FLOATs in the vector to 4 BYTEs, clamped to [0,255], and stores to unaligned memory. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Vec	Vector containing 4 FLOATs
Ptr	Unaligned memory pointer to store the 4 BYTEs.

◆ VectorStoreFloat1() [1/2]

FORCEINLINE void VectorStoreFloat1	(	const VectorRegister4Double &	Vec,
		double *	Dst
	)

◆ VectorStoreFloat1() [2/2]

FORCEINLINE void VectorStoreFloat1	(	const VectorRegister4Float &	Vec,
		float *	Dst
	)

Stores the X component of a vector to unaligned memory.

Parameters

Vec	Vector to store X
Ptr	Unaligned memory pointer

◆ VectorStoreFloat3() [1/2]

FORCEINLINE void VectorStoreFloat3	(	const VectorRegister4Double &	Vec,
		double *	Dst
	)

◆ VectorStoreFloat3() [2/2]

FORCEINLINE void VectorStoreFloat3	(	const VectorRegister4Float &	Vec,
		float *	Dst
	)

Stores the XYZ components of a vector to unaligned memory.

Parameters

Vec	Vector to store XYZ
Ptr	Unaligned memory pointer

◆ VectorStoreSignedByte4()

FORCEINLINE void VectorStoreSignedByte4	(	const VectorRegister4Float &	Vec,
		void *	Ptr
	)

Converts the 4 FLOATs in the vector to 4 BYTEs, clamped to [-127,127], and stores to unaligned memory. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Vec	Vector containing 4 FLOATs
Ptr	Unaligned memory pointer to store the 4 BYTEs.

◆ VectorStoreURGB10A2N()

FORCEINLINE void VectorStoreURGB10A2N	(	const VectorRegister4Float &	Vec,
		void *	Ptr
	)

Converts the 4 FLOATs in the vector RGB10A2, clamped to [0, 1023] and [0, 3], and stores to unaligned memory. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Vec	Vector containing 4 FLOATs
Ptr	Unaligned memory pointer to store the packed RGB10A2(4 bytes).

◆ VectorStoreURGBA16N()

FORCEINLINE void VectorStoreURGBA16N	(	const VectorRegister4Float &	Vec,
		void *	Ptr
	)

Converts the 4 FLOATs in the vector RGBA16, clamped to [0, 65535], and stores to unaligned memory. IMPORTANT: You need to call VectorResetFloatRegisters() before using scalar FLOATs after you've used this intrinsic!

Parameters

Vec	Vector containing 4 FLOATs
Ptr	Unaligned memory pointer to store the packed RGBA16(8 bytes).

◆ VectorSubtract() [1/2]

FORCEINLINE VectorRegister4Double VectorSubtract	(	const VectorRegister4Double &	Vec1,
		const VectorRegister4Double &	Vec2
	)

◆ VectorSubtract() [2/2]

FORCEINLINE VectorRegister4Float VectorSubtract	(	const VectorRegister4Float &	Vec1,
		const VectorRegister4Float &	Vec2
	)

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

Parameters

Vec1	1st vector
Vec2	2nd vector

Returns: VectorRegister( Vec1.x-Vec2.x, Vec1.y-Vec2.y, Vec1.z-Vec2.z, Vec1.w-Vec2.w )

◆ VectorTan() [1/2]

FORCEINLINE VectorRegister4Double VectorTan ( const VectorRegister4Double & Vec )

◆ VectorTan() [2/2]

FORCEINLINE VectorRegister4Float VectorTan ( const VectorRegister4Float & Vec )

◆ VectorTransformVector() [1/4]

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

◆ VectorTransformVector() [2/4]

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

◆ VectorTransformVector() [3/4]

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

◆ VectorTransformVector() [4/4]

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

Calculate Homogeneous transform.

Parameters

VecP	VectorRegister
MatrixM	FMatrix44d pointer to the Matrix to apply transform

Returns: VectorRegister = VecP*MatrixM

◆ VectorTruncate() [1/2]

FORCEINLINE VectorRegister4Double VectorTruncate ( const VectorRegister4Double & Vec )

◆ VectorTruncate() [2/2]

FORCEINLINE VectorRegister4Float VectorTruncate ( const VectorRegister4Float & Vec )

◆ VectorZeroDouble()

FORCEINLINE VectorRegister4Double VectorZeroDouble ( void )

◆ VectorZeroFloat()

FORCEINLINE VectorRegister4Float VectorZeroFloat ( void )

Returns a vector with all zeros.

Returns: MakeVectorRegister(0.0f, 0.0f, 0.0f, 0.0f)

Typedefs
typedef VectorRegister4Int	VectorRegister4i

typedef VectorRegister4Float	VectorRegister4f

typedef VectorRegister4Double	VectorRegister4d

typedef VectorRegister2Double	VectorRegister2d

typedef VectorRegister4Double	VectorRegister4

typedef VectorRegister4	VectorRegister

typedef VectorRegister4Int	VectorRegisterInt

typedef AlignedDouble4	AlignedRegister4

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ DECLARE_VECTOR_REGISTER

◆ USE_FAST_QUAT_MUL

◆ VECTOR_DENORMALS_FLUSH_TO_ZERO

◆ VECTOR_ROUND_TOWARD_ZERO

◆ VectorCastDoubleToInt

◆ VectorCastFloatToInt

◆ VectorCastIntToDouble

◆ VectorCastIntToFloat

◆ VectorGetComponent

◆ VectorGetControlRegister

◆ VectorIntExpandLow16To32

◆ VectorIntSet1

◆ VectorIntSign

◆ VectorLoadByte4

◆ VectorLoadByte4Reverse

◆ VectorLoadSignedByte4

◆ VectorOneVectorRegister

◆ VectorReplicate

◆ VectorResetFloatRegisters

◆ VectorSet1

◆ VectorSetControlRegister

◆ VectorSetZero

◆ VectorShiftLeftImm

◆ VectorShiftRightImmArithmetic

◆ VectorShiftRightImmLogical

◆ VectorShuffle

◆ VectorShuffleImmediate

◆ VectorSwizzle

◆ VectorZeroVectorRegister

Typedef Documentation

◆ AlignedRegister4

◆ VectorRegister

◆ VectorRegister2d

◆ VectorRegister4

◆ VectorRegister4d

◆ VectorRegister4f

◆ VectorRegister4i

◆ VectorRegisterInt

Function Documentation

◆ MakeVectorRegister() [1/3]

◆ MakeVectorRegister() [2/3]

◆ MakeVectorRegister() [3/3]

◆ MakeVectorRegister2Double()

◆ MakeVectorRegister2DoubleConstant()

◆ MakeVectorRegisterDouble() [1/4]

◆ MakeVectorRegisterDouble() [2/4]

◆ MakeVectorRegisterDouble() [3/4]

◆ MakeVectorRegisterDouble() [4/4]

◆ MakeVectorRegisterDoubleMask()

◆ MakeVectorRegisterFloat() [1/2]

◆ MakeVectorRegisterFloat() [2/2]

◆ MakeVectorRegisterFloatConstant()

◆ MakeVectorRegisterFloatFromDouble()

◆ MakeVectorRegisterFloatMask()

◆ MakeVectorRegisterInt()

◆ MakeVectorRegisterInt64()

◆ MakeVectorRegisterIntConstant()

◆ VectorAbs() [1/2]

◆ VectorAbs() [2/2]

◆ VectorACos() [1/2]

◆ VectorACos() [2/2]

◆ VectorAdd() [1/2]

◆ VectorAdd() [2/2]

◆ VectorAnyGreaterThan() [1/2]

◆ VectorAnyGreaterThan() [2/2]

◆ VectorASin() [1/2]

◆ VectorASin() [2/2]

◆ VectorATan() [1/2]

◆ VectorATan() [2/2]

◆ VectorATan2() [1/2]

◆ VectorATan2() [2/2]

◆ VectorBitwiseAnd() [1/2]

◆ VectorBitwiseAnd() [2/2]

◆ VectorBitwiseOr() [1/2]

◆ VectorBitwiseOr() [2/2]