Table of Contents

Class Quaternion

A unit quaternion used for representing 3D rotations.

Quaternion

Remarks

The Quaternion built-in Variant type is a 4D data structure that represents rotation in the form of a Hamilton convention quaternion. Compared to the Basis type which can store both rotation and scale, quaternions can only store rotation.

A Quaternion is composed by 4 floating-point components: w, x, y, and z. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as get_angle, get_axis, and Quaternion.slerp are faster than their Basis counterparts.

For a great introduction to quaternions, see this video by 3Blue1Brown. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include Quaternion.slerp and Quaternion.spherical_cubic_interpolate, as well as the * operator.

Note: Quaternions must be normalized before being used for rotation (see normalized).

Note: Similarly to Vector2 and Vector3, the components of a quaternion use 32-bit precision by default, unlike float which is always 64-bit. If double precision is needed, compile the engine with the option precision=double.

See Also

3Blue1Brown's video on Quaternions
Online Quaternion Visualization
Using 3D transforms
Third Person Shooter (TPS) Demo
Advanced Quaternion Visualization

Constructors

Quaternion

Constructs a Quaternion identical to IDENTITY.

Note: In C#, this constructs a Quaternion with all of its components set to 0.0.

Quaternion Quaternion

Quaternion(Quaternion)

Constructs a Quaternion as a copy of the given Quaternion.

Quaternion Quaternion(Quaternion from)

Parameters

from Quaternion

Quaternion(Vector3, Vector3)

Constructs a Quaternion representing the shortest arc between arc_from and arc_to. These can be imagined as two points intersecting a sphere's surface, with a radius of 1.0.

Quaternion Quaternion(Vector3 arc_from, Vector3 arc_to)

Parameters

arc_from Vector3
arc_to Vector3

Quaternion(Vector3, float)

Constructs a Quaternion representing rotation around the axis by the given angle, in radians. The axis must be a normalized vector.

Quaternion Quaternion(Vector3 axis, float angle)

Parameters

axis Vector3
angle float

Quaternion(Basis)

Constructs a Quaternion from the given rotation Basis.

This constructor is faster than get_rotation_quaternion, but the given basis must be orthonormalized (see orthonormalized). Otherwise, the constructor fails and returns IDENTITY.

Quaternion Quaternion(Basis from)

Parameters

from Basis

Quaternion(float, float, float, float)

Constructs a Quaternion defined by the given values.

Note: Only normalized quaternions represent rotation; if these values are not normalized, the new Quaternion will not be a valid rotation.

Quaternion Quaternion(float x, float y, float z, float w)

Parameters

x float
y float
z float
w float

Fields

IDENTITY

The identity quaternion, representing no rotation. This has the same rotation as IDENTITY.

If a Vector3 is rotated (multiplied) by this quaternion, it does not change.

Note: In GDScript, this constant is equivalent to creating a Quaternion without any arguments. It can be used to make your code clearer, and for consistency with C#.

const IDENTITY = Quaternion(0, 0, 0, 1)

Properties

w

W component of the quaternion. This is the "real" part.

Note: Quaternion components should usually not be manipulated directly.

var w : float = 1.0

Property Value

float

x

X component of the quaternion. This is the value along the "imaginary" i axis.

Note: Quaternion components should usually not be manipulated directly.

var x : float = 0.0

Property Value

float

y

Y component of the quaternion. This is the value along the "imaginary" j axis.

Note: Quaternion components should usually not be manipulated directly.

var y : float = 0.0

Property Value

float

z

Z component of the quaternion. This is the value along the "imaginary" k axis.

Note: Quaternion components should usually not be manipulated directly.

var z : float = 0.0

Property Value

float

Methods

angle_to(Quaternion)

Qualifiers: const

Returns the angle between this quaternion and to. This is the magnitude of the angle you would need to rotate by to get from one to the other.

Note: The magnitude of the floating-point error for this method is abnormally high, so methods such as is_zero_approx will not work reliably.

float angle_to(Quaternion to)

Parameters

to Quaternion

dot(Quaternion)

Qualifiers: const

Returns the dot product between this quaternion and with.

This is equivalent to (quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w).

float dot(Quaternion with)

Parameters

with Quaternion

exp

Qualifiers: const

Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.

Quaternion exp

from_euler(Vector3)

Qualifiers: static

Constructs a new Quaternion from the given Vector3 of Euler angles, in radians. This method always uses the YXZ convention (@GlobalScope.EULER_ORDER_YXZ).

Quaternion from_euler(Vector3 euler)

Parameters

euler Vector3

get_angle

Qualifiers: const

Returns the angle of the rotation represented by this quaternion.

Note: The quaternion must be normalized.

float get_angle

get_axis

Qualifiers: const

Returns the rotation axis of the rotation represented by this quaternion.

Vector3 get_axis

get_euler(int)

Qualifiers: const

Returns this quaternion's rotation as a Vector3 of Euler angles, in radians.

The order of each consecutive rotation can be changed with order (see EulerOrder constants). By default, the YXZ convention is used (@GlobalScope.EULER_ORDER_YXZ): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method Quaternion.from_euler, this order is reversed.

Vector3 get_euler(int order)

Parameters

order int

inverse

Qualifiers: const

Returns the inverse version of this quaternion, inverting the sign of every component except w.

Quaternion inverse

is_equal_approx(Quaternion)

Qualifiers: const

Returns true if this quaternion and to are approximately equal, by calling @GlobalScope.is_equal_approx on each component.

bool is_equal_approx(Quaternion to)

Parameters

to Quaternion

is_finite

Qualifiers: const

Returns true if this quaternion is finite, by calling @GlobalScope.is_finite on each component.

bool is_finite

is_normalized

Qualifiers: const

Returns true if this quaternion is normalized. See also normalized.

bool is_normalized

length

Qualifiers: const

Returns this quaternion's length, also called magnitude.

float length

length_squared

Qualifiers: const

Returns this quaternion's length, squared.

Note: This method is faster than length, so prefer it if you only need to compare quaternion lengths.

float length_squared

log

Qualifiers: const

Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part (x, y, and z). The returned quaternion's real part (w) is always 0.0.

Quaternion log

normalized

Qualifiers: const

Returns a copy of this quaternion, normalized so that its length is 1.0. See also is_normalized.

Quaternion normalized

slerp(Quaternion, float)

Qualifiers: const

Performs a spherical-linear interpolation with the to quaternion, given a weight and returns the result. Both this quaternion and to must be normalized.

Quaternion slerp(Quaternion to, float weight)

Parameters

to Quaternion
weight float

slerpni(Quaternion, float)

Qualifiers: const

Performs a spherical-linear interpolation with the to quaternion, given a weight and returns the result. Unlike Quaternion.slerp, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and to must be normalized.

Quaternion slerpni(Quaternion to, float weight)

Parameters

to Quaternion
weight float

spherical_cubic_interpolate(Quaternion, Quaternion, Quaternion, float)

Qualifiers: const

Performs a spherical cubic interpolation between quaternions pre_a, this vector, b, and post_b, by the given amount weight.

Quaternion spherical_cubic_interpolate(Quaternion b, Quaternion pre_a, Quaternion post_b, float weight)

Parameters

b Quaternion
pre_a Quaternion
post_b Quaternion
weight float

spherical_cubic_interpolate_in_time(Quaternion, Quaternion, Quaternion, float, float, float, float)

Qualifiers: const

Performs a spherical cubic interpolation between quaternions pre_a, this vector, b, and post_b, by the given amount weight.

It can perform smoother interpolation than Quaternion.spherical_cubic_interpolate by the time values.

Quaternion spherical_cubic_interpolate_in_time(Quaternion b, Quaternion pre_a, Quaternion post_b, float weight, float b_t, float pre_a_t, float post_b_t)

Parameters

b Quaternion
pre_a Quaternion
post_b Quaternion
weight float
b_t float
pre_a_t float
post_b_t float

Operators

!= (Quaternion)

Returns true if the components of both quaternions are not exactly equal.

Note: Due to floating-point precision errors, consider using Quaternion.is_equal_approx instead, which is more reliable.

bool != (Quaternion right)

Parameters

right Quaternion

* (Quaternion)

Composes (multiplies) two quaternions. This rotates the right quaternion (the child) by this quaternion (the parent).

Quaternion * (Quaternion right)

Parameters

right Quaternion

* (Vector3)

Rotates (multiplies) the right vector by this quaternion, returning a Vector3.

Vector3 * (Vector3 right)

Parameters

right Vector3

* (float)

Multiplies each component of the Quaternion by the right float value.

This operation is not meaningful on its own, but it can be used as a part of a larger expression.

Quaternion * (float right)

Parameters

right float

* (int)

Multiplies each component of the Quaternion by the right int value.

This operation is not meaningful on its own, but it can be used as a part of a larger expression.

Quaternion * (int right)

Parameters

right int

+ (Quaternion)

Adds each component of the left Quaternion to the right Quaternion.

This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.

Quaternion + (Quaternion right)

Parameters

right Quaternion

- (Quaternion)

Subtracts each component of the left Quaternion by the right Quaternion.

This operation is not meaningful on its own, but it can be used as a part of a larger expression.

Quaternion - (Quaternion right)

Parameters

right Quaternion

/ (float)

Divides each component of the Quaternion by the right float value.

This operation is not meaningful on its own, but it can be used as a part of a larger expression.

Quaternion / (float right)

Parameters

right float

/ (int)

Divides each component of the Quaternion by the right int value.

This operation is not meaningful on its own, but it can be used as a part of a larger expression.

Quaternion / (int right)

Parameters

right int

== (Quaternion)

Returns true if the components of both quaternions are exactly equal.

Note: Due to floating-point precision errors, consider using Quaternion.is_equal_approx instead, which is more reliable.

bool == (Quaternion right)

Parameters

right Quaternion

[] (int)

Accesses each component of this quaternion by their index.

Index 0 is the same as x, index 1 is the same as y, index 2 is the same as z, and index 3 is the same as w.

float [] (int index)

Parameters

index int

unary+

Returns the same value as if the + was not there. Unary + does nothing, but sometimes it can make your code more readable.

Quaternion unary+

unary-

Returns the negative value of the Quaternion. This is the same as multiplying all components by -1. This operation results in a quaternion that represents the same rotation.

Quaternion unary-