Language:
Discover
By Skill Level
By Category

# FQuat

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.

Quaternion. The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Quat.h

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 FQuat & Q
)

Copy constructor.

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)

[CORE_API](API\Runtime\Core\Misc\CORE_API_1)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.

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

Euler()

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

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

Exp()

Exp should really only be used after Log.

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.

FastLerp

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

Fast Linear Quaternion Interpolation. Result is NOT normalized.

FindBetween

(
const FVector & Vector1,
const FVector & Vector2
)

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

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

FindBetweenNormals

(
const FVector & Normal1,
const FVector & Normal2
)

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

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

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

GetAxisX()

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

GetAxisY()

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

GetAxisZ()

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

GetForwardVector()

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

GetNormalized

(
float Tolerance
)

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

GetRightVector()

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

GetRotationAxis()

Get the axis of rotation of the Quaternion.

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 .

Inverse()

Inverse of this quaternion

bool

IsIdentity

(
float Tolerance
)

Checks whether this Quaternion is an Identity Quaternion.

bool

IsNormalized()

Return true if this quaternion is normalized.

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

Log()

Quaternion with W=0 and V=theta*v.

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

MakeFromEuler

(
const FVector & Euler
)

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

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

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.

RotateVector

(
FVector V
)

Rotate a vector by this quaternion.

vector after rotation

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

Rotator()

bool

Serialize

(
FArchive & Ar
)

float

Size()

Get the length of this quaternion.

The length of this quaternion.

float

SizeSquared()

Get the length squared of this quaternion.

The length of this quaternion.

Slerp

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

Spherical interpolation. Will correct alignment. Result is normalized.

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

Slerp_NotNormalized

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

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

SlerpFullPath

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

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

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

SlerpFullPath_NotNormalized

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

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

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

(
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.

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

(
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.

ToString()

Get a textual representation of the vector.

Text describing the vector.

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

ToSwingTwist

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

Get the swing and twist decomposition for a specified axis

UnrotateVector

(
FVector V
)

Rotate a vector by the inverse of this quaternion.

Vector()

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

Operators

Name Description

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.

operator*

(
const float Scale
)

Get the result of scaling this quaternion.

The result of scaling.

operator*

(
const FMatrix & M
)

Multiply this by a matrix.

operator*

(
const FVector & V
)

Rotate a vector by this quaternion.

vector after rotation

operator*

(
const FQuat & Q
)

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

operator*=

(
const float Scale
)

Multiply this quaternion by a scaling factor.

a reference to this after scaling.

operator*=

(
const FQuat & Q
)

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

operator/

(
const float Scale
)

Divide this quaternion by scale.

new Quaternion of this after division by scale.

operator/=

(
const float Scale
)

Divide this quaternion by scale.

a reference to this after scaling.

float

operator|

(
const FQuat & Q
)

Calculates dot product of two quaternions.

The dot product.

operator+

(
const FQuat & Q
)

Gets the result of adding a Quaternion to this.

operator+=

(
const FQuat & Q
)

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.

References