 # FQuat

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

Inheritance Hierarchy

FQuat TRotation< float, 3 >

References

Syntax

struct FQuat

Remarks

Floating point quaternion that can represent a rotation about an axis in 3-D space. The X, Y, Z, W components also double as the Axis/Angle format.

Order matters when composing quaternions: C = A * B will yield a quaternion C that logically first applies B then A to any subsequent transformation (right first, then left). Note that this is the opposite order of FTransform multiplication.

Example: LocalToWorld = (LocalToWorld * DeltaRotation) will change rotation in local space by DeltaRotation. Example: LocalToWorld = (DeltaRotation * LocalToWorld) will change rotation in world space by DeltaRotation.

Variables

Name Description

float

W

The quaternion's W-component.

float

X

The quaternion's X-component.

float

Y

The quaternion's Y-component.

float

Z

The quaternion's Z-component.

Constructors

Name Description

FQuat()

Default constructor (no initialization).

FQuat

Creates and initializes a new quaternion, with the W component either 0 or 1.

FQuat

(
const FMatrix& M
)

Creates and initializes a new quaternion from the given matrix.

FQuat

(
const FRotator& R
)

Creates and initializes a new quaternion from the given rotator.

FQuat

(
FVector Axis,
)

Creates and initializes a new quaternion from the a rotation around the given axis.

FQuat

(
float InX,
float InY,
float InZ,
float InW
)

Constructor.

Functions

Name Description

float

AngularDistance

(
const FQuat& Q
)

Find the angular distance between two rotation quaternions (in radians)

void

CalcTangents

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

Calculate tangents between given points

bool

ContainsNaN()

Utility to check if there are any non-finite values (NaN or Inf) in this Quat.

void

DiagnosticCheckNaN

(
const TCHAR* Message
)

void

DiagnosticCheckNaN()

void

EnforceShortestArcWith

(
const FQuat& OtherQuat
)

Enforce that the delta between this Quaternion and another one represents the shortest possible rotation angle

bool

Equals

(
const FQuat& Q,
float Tolerance
)

Checks whether another Quaternion is equal to this, within specified tolerance.

float

Error

(
const FQuat& Q1,
const FQuat& Q2
)

Error measure (angle) between two quaternions, ranged [0..1].

float

ErrorAutoNormalize

(
const FQuat& A,
const FQuat& B
)

FQuat::Error with auto-normalization.

FVector

Euler()

Convert a Quaternion into floating-point Euler angles (in degrees).

FQuat

Exp()

Exp should really only be used after Log.

FQuat

FastBilerp

(
const FQuat& P00,
const FQuat& P10,
const FQuat& P01,
const FQuat& P11,
float FracX,
float FracY
)

Bi-Linear Quaternion interpolation. Result is NOT normalized.

FQuat

FastLerp

(
const FQuat& A,
const FQuat& B,
const float Alpha
)

Fast Linear Quaternion Interpolation. Result is NOT normalized.

FQuat

FindBetween

(
const FVector& Vector1,
const FVector& Vector2
)

Generates the 'smallest' (geodesic) rotation between two vectors of arbitrary length.

FQuat

FindBetweenNormals

(
const FVector& Normal1,
const FVector& Normal2
)

Generates the 'smallest' (geodesic) rotation between two normals (assumed to be unit length).

FQuat

FindBetweenVectors

(
const FVector& Vector1,
const FVector& Vector2
)

Generates the 'smallest' (geodesic) rotation between two vectors of arbitrary length.

float

GetAngle()

Get the angle of this quaternion

FVector

GetAxisX()

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

FVector

GetAxisY()

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

FVector

GetAxisZ()

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

FVector

GetForwardVector()

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

FQuat

GetNormalized

(
float Tolerance
)

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

FVector

GetRightVector()

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

FVector

GetRotationAxis()

Get the axis of rotation of the Quaternion.

float

GetTwistAngle

(
const FVector& TwistAxis
)

Get the twist angle (in radians) for a specified axis

FVector

GetUpVector()

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

bool

InitFromString

(
const FString& InSourceString
)

Initialize this FQuat from a FString.

FQuat

Inverse()

bool

IsIdentity

(
float Tolerance
)

Checks whether this Quaternion is an Identity Quaternion. Assumes Quaternion tested is normalized.

bool

IsNormalized()

Return true if this quaternion is normalized.

FQuat

Log()

FQuat

MakeFromEuler

(
const FVector& Euler
)

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

bool

NetSerialize

(
FArchive& Ar,
UPackageMap* Map,
bool& bOutSuccess
)

Serializes the vector compressed for e.g. network transmission.

void

Normalize

(
float Tolerance
)

Normalize this quaternion if it is large enough.

FVector

RotateVector

(
FVector V
)

Rotate a vector by this quaternion.

FRotator

Rotator()

Get the FRotator representation of this Quaternion.

bool

Serialize

(
FArchive& Ar
)

float

Size()

Get the length of this quaternion.

float

SizeSquared()

Get the length squared of this quaternion.

FQuat

Slerp

(
const FQuat& Quat1,
const FQuat& Quat2,
float Slerp
)

Spherical interpolation. Will correct alignment. Result is normalized.

FQuat

Slerp_NotNormalized

(
const FQuat& Quat1,
const FQuat& Quat2,
float Slerp
)

Spherical interpolation. Will correct alignment. Result is NOT normalized.

FQuat

SlerpFullPath

(
const FQuat& quat1,
const FQuat& quat2,
float Alpha
)

Simpler Slerp that doesn't do any checks for 'shortest distance' etc.

FQuat

SlerpFullPath_NotNormalized

(
const FQuat& quat1,
const FQuat& quat2,
float Alpha
)

Simpler Slerp that doesn't do any checks for 'shortest distance' etc.

FQuat

(
const FQuat& quat1,
const FQuat& tang1,
const FQuat& quat2,
const FQuat& tang2,
float Alpha
)

Given start and end quaternions of quat1 and quat2, and tangents at those points tang1 and tang2, calculate the point at Alpha (between 0 and 1) between them.

FQuat

(
const FQuat& quat1,
const FQuat& tang1,
const FQuat& quat2,
const FQuat& tang2,
float Alpha
)

Simpler Squad that doesn't do any checks for 'shortest distance' etc.

void

ToAxisAndAngle

(
FVector& Axis,
float& Angle
)

Get the axis and angle of rotation of this quaternion

: assumes normalized quaternions.

FString

ToString()

Get a textual representation of the vector.

void

ToSwingTwist

(
const FVector& InTwistAxis,
FQuat& OutSwing,
FQuat& OutTwist
)

Get the swing and twist decomposition for a specified axis

FVector

UnrotateVector

(
FVector V
)

Rotate a vector by the inverse of this quaternion.

FVector

Vector()

Convert a rotation into a unit vector facing in its direction.

Operators

Name Description

FQuat

operator-

(
const FQuat& Q
)

Gets the result of subtracting a Quaternion to this.

bool

operator!=

(
const FQuat& Q
)

Checks whether two quaternions are not identical.

FQuat

operator*

(
const float Scale
)

Get the result of scaling this quaternion.

FMatrix

operator*

(
const FMatrix& M
)

Multiply this by a matrix.

FVector

operator*

(
const FVector& V
)

Rotate a vector by this quaternion.

FQuat

operator*

(
const FQuat& Q
)

Gets the result of multiplying this by another quaternion (this * Q).

FQuat

operator*=

(
const float Scale
)

Multiply this quaternion by a scaling factor.

FQuat

operator*=

(
const FQuat& Q
)

Multiply this by a quaternion (this = this * Q).

FQuat

operator/

(
const float Scale
)

Divide this quaternion by scale.

FQuat

operator/=

(
const float Scale
)

Divide this quaternion by scale.

float

operator|

(
const FQuat& Q
)

Calculates dot product of two quaternions.

FQuat

operator+

(
const FQuat& Q
)

Gets the result of adding a Quaternion to this.

FQuat

operator+=

(
const FQuat& Q
)

FQuat

operator-=

(
const FQuat& Q
)

Subtracts another quaternion from this.

bool

operator==

(
const FQuat& Q
)

Checks whether two quaternions are identical.

Constants

Name

Description

Identity

Identity quaternion.

Help shape the future of Unreal Engine documentation! Tell us how we're doing so we can serve you better.