shz::quat

C++ structure representing a quaternion.

A quaternion represents a rotation about an arbitrary axis in 3D space.

• Header: #include <sh4zam/shz_quat.hpp> (source)
• C type: shz_quat_t (layout-compatible; the C API accepts it directly)
• Bases: shz_quat_t

Static functions

identity

static quat identity() noexcept

Returns an identity quaternion.

Calls: shz_quat_identity()

from_angles_xyz

static quat from_angles_xyz(float x, float y, float z) noexcept

C++ convenience wrapper for shz_quat_from_angles_xyz().

Calls: shz_quat_from_angles_xyz()

from_rotation_xyz

static quat from_rotation_xyz(float x, float y, float z) noexcept

C++ convenience wrapper for shz_quat_from_rotation_xyz().

Calls: shz_quat_from_rotation_xyz()

from_rotation_zyx

static quat from_rotation_zyx(float z, float y, float x) noexcept

C++ convenience wrapper for shz_quat_from_rotation_zyx().

Calls: shz_quat_from_rotation_zyx()

from_rotation_zxy

static quat from_rotation_zxy(float z, float x, float y) noexcept

C++ convenience wrapper for shz_quat_from_rotation_zxy().

Calls: shz_quat_from_rotation_zxy()

from_rotation_yxz

static quat from_rotation_yxz(float y, float x, float z) noexcept

C++ convenience wrapper for shz_quat_from_rotation_yxz().

Calls: shz_quat_from_rotation_yxz()

from_rotation_xyz_u16

static quat from_rotation_xyz_u16(uint16_t x, uint16_t y, uint16_t z) noexcept

C++ convenience wrapper for shz_quat_from_rotation_xyz_u16().

Calls: shz_quat_from_rotation_xyz_u16()

from_rotation_zyx_u16

static quat from_rotation_zyx_u16(uint16_t z, uint16_t y, uint16_t x) noexcept

C++ convenience wrapper for shz_quat_from_rotation_zyx_u16().

Calls: shz_quat_from_rotation_zyx_u16()

from_rotation_zxy_u16

static quat from_rotation_zxy_u16(uint16_t z, uint16_t x, uint16_t y) noexcept

C++ convenience wrapper for shz_quat_from_rotation_zxy_u16().

Calls: shz_quat_from_rotation_zxy_u16()

from_rotation_yxz_u16

static quat from_rotation_yxz_u16(uint16_t y, uint16_t x, uint16_t z) noexcept

C++ convenience wrapper for shz_quat_from_rotation_yxz_u16().

Calls: shz_quat_from_rotation_yxz_u16()

from_axis_angle

static quat from_axis_angle(const vec3 &axis, float angle) noexcept

Initializes a quaternion which is a rotation in angle radians about the given axis.

Calls: shz_quat_from_axis_angle()

from_look_axis

static quat from_look_axis(const vec3 &forward, const vec3 &up) noexcept

Creates a quaternion looking in the given direction with the given reference direction.

Calls: shz_quat_from_look_axis()

from_rotated_axis

static quat from_rotated_axis(const vec3 &start, const vec3 &end) noexcept

Returns the quaternion representing the rotation from the start to the end axes.

Calls: shz_quat_from_rotated_axis()

lerp

static quat lerp(const quat &q, const quat &p, float t) noexcept

Returns the quaternion that is linearly interpolating q to p, by a t factor of 0.0f-1.0f.

Calls: shz_quat_lerp()

nlerp

static quat nlerp(const quat &q, const quat &p, float t) noexcept

Equivalent to lerp(), except that the resulting quaternion is normalized.

Calls: shz_quat_nlerp()

slerp

static quat slerp(const quat &q, const quat &p, float t) noexcept

Returns the quaternion that is spherically linearly interpolating q to p, by a t factor of 0.0f-1.0f.

Calls: shz_quat_slerp()

squad

static quat squad(const quat &q1, const quat &q2, const quat &s1, const quat &s2, float t) noexcept

Evaluates the smooth cubic spherical interpolation (SQUAD) at parameter t.

Calls: shz_quat_squad()

Members

quat

quat() noexcept=default
quat(const quat &other) noexcept=default
quat(float w, float x, float y, float z) noexcept
quat(const shz_quat_t &q) noexcept
quat(const volatile shz_quat_t &other) noexcept

Default constructor: does nothing.

angle

float angle() const noexcept

Returns the angle of rotation represented by the given quaternion.

Calls: shz_quat_angle()

axis

vec3 axis() const noexcept

Returns the axis of rotation represented by the given quaternion.

Calls: shz_quat_axis()

angle_x

float angle_x() const noexcept

Returns the angle of rotation about the X axis represented by the given quaternion.

Calls: shz_quat_angle_x()

angle_y

float angle_y() const noexcept

Returns the angle of rotation about the Y axis represented by the given quaternion.

Calls: shz_quat_angle_y()

angle_z

float angle_z() const noexcept

Returns the angle of rotation about the Z axis represented by the given quaternion.

Calls: shz_quat_angle_z()

magnitude_sqr

float magnitude_sqr() const noexcept

Returns the magnitude of the quaternion squared.

Calls: shz_quat_magnitude_sqr()

magnitude

float magnitude() const noexcept

Returns the magnitude of the quaternion.

Calls: shz_quat_magnitude()

magnitude_inv

float magnitude_inv() const noexcept

Returns the inverse of the magnitude of the quaternion.

Calls: shz_quat_magnitude_inv()

to_angles_xyz

vec3 to_angles_xyz() const noexcept

Returns the tait-bryan rotation angles about the X, Y, then Z axes which are represented by the given quaternion.

Calls: shz_quat_to_angles_xyz()

to_axis_angle

void to_axis_angle(shz_vec3_t *axis, float *angle) const noexcept
std::pair< vec3, float > to_axis_angle() const noexcept

Returns both the axis and angle of rotation through the pointer arguments.

Calls: shz_quat_to_axis_angle()

normalized

quat normalized() const noexcept

Returns the given quaternion as a unit quaternion.

Calls: shz_quat_normalize()

normalize

void normalize() noexcept

Normalizes the given quaternion.

normalized_safe

quat normalized_safe() const noexcept

Returns a safely normalized quaternion from the given quaternion, protecting against division-by-zero.

Calls: shz_quat_normalize_safe()

normalize_safe

void normalize_safe() noexcept

Safely normalizes the given quaternion by protecting against division-by-zero.

conjugated

quat conjugated() const noexcept

Returns a quaternion that is the conjugate of the given quaternion.

Calls: shz_quat_conjugate()

conjugate

void conjugate() noexcept

Conjugates the given quaternion.

inverse

quat inverse() const noexcept

Returns the inverse of the given quaternion.

Calls: shz_quat_inv()

invert

void invert() noexcept

Inverts the given quaternion.

negated

quat negated() const noexcept

Returns a new quaternion whose components are the negated values of the given quaternion.

Calls: shz_quat_neg()

negate

void negate() noexcept

Negates the components of the given quaternion.

add

quat add(const quat &rhs) const noexcept

Returns a new quaternion from adding the given quaterion to rhs.

Calls: shz_quat_add()

sub

quat sub(const quat &rhs) const noexcept

Returns a new quaternion from adding rhs from the given quaternion.

Calls: shz_quat_sub()

scaled

quat scaled(float s) const noexcept

Returns a new quaternion from scaling the given quaterion by s.

Calls: shz_quat_scale()

scale

void scale(float s) noexcept

Multiplies each component of the given quaternion by s.

dot

float dot(const quat &other) const noexcept
vec2 dot(const quat &q1, const quat &q2) const noexcept
vec3 dot(const quat &q1, const quat &q2, const quat &q3) const noexcept

Returns the dot product between the given quaternion and another.

Calls: shz_quat_dot(), shz_quat_dot2(), shz_quat_dot3()

mult

quat mult(const quat &rhs) const noexcept

Returns a new quaterion from multiplying the given quaternion by another.

Calls: shz_quat_mult()

div

quat div(const quat &rhs) const noexcept

Returns a new quaterion from dividing the given quaternion by another (or multiplying the given quaternion by the inverse of another).

Calls: shz_quat_div()

angle_between

float angle_between(const quat &p) const noexcept

Returns the angle in radians between the rotations represented by quaternions q and p.

Calls: shz_quat_angle_between()

rotate_towards

quat rotate_towards(const quat &to, float max_angle) const noexcept

Rotates quaternion from towards quaternion to by at most max_angle radians.

Calls: shz_quat_rotate_towards()

transform

vec3 transform(const vec3 &in) const noexcept

Returns a new shz::vec3 from transforming in by the given quaternion.

Calls: shz_quat_transform_vec3()

operator-

quat operator-() const noexcept

Overloaded unary negation operator, returns the negation of the given quaternion.

operator+=

quat operator+=(const quat &rhs) noexcept

Adds and accumulates rhs onto the given quaternion.

operator-=

quat operator-=(const quat &rhs) noexcept

Subtracts rhs from the given quaternion.

operator*=

quat operator*=(const quat &rhs) noexcept
quat operator*=(float rhs) noexcept

Multiplies and accumulates rhs into the given quaternion.

operator/=

quat operator/=(const quat &rhs) noexcept
quat operator/=(float rhs) noexcept

Divides the given quaternion by rhs.

Calls: shz_invf()

operator==

bool operator==(const quat &lhs, const quat &rhs) noexcept

Overloaded comparison operator, checks for quaternion equality.