shz::quat Struct Reference

#include <shz_quat.hpp>

Inheritance diagram for shz::quat:

Collaboration diagram for shz::quat:

Public Member Functions
quat	operator- () const noexcept
quat	operator+= (quat rhs) noexcept
quat	operator-= (quat rhs) noexcept
quat	operator*= (quat rhs) noexcept
quat	operator/= (quat rhs) noexcept
quat	operator*= (float rhs) noexcept
quat	operator/= (float rhs) noexcept
Properties
Routines for accessing or extracting values.
float	angle () const noexcept
vec3	axis () const noexcept
float	angle_x () const noexcept
float	angle_y () const noexcept
float	angle_z () const noexcept
float	magnitude_sqr () const noexcept
float	magnitude () const noexcept
float	magnitude_inv () const noexcept
Conversions
Routines for converting to other types.
vec3	to_angles_xyz () const noexcept
void	to_axis_angle (shz_vec3_t *axis, float *angle) const noexcept
auto	to_axis_angle () const noexcept -> std::pair< vec3, float >
Modifiers
Routines for applying modifiers to an existing quaternion.
quat	normalized () const noexcept
void	normalize () noexcept
quat	normalized_safe () const noexcept
void	normalize_safe () noexcept
quat	conjugated () const noexcept
void	conjugate () noexcept
quat	inverse () const noexcept
void	invert () noexcept
quat	negated () const noexcept
void	negate () noexcept
Arithmetic
Routines performing calculations with quaternions.
quat	add (quat rhs) const noexcept
quat	sub (quat rhs) const noexcept
quat	scaled (float s) const noexcept
void	scale (float s) noexcept
float	dot (quat other) const noexcept
vec2	dot (quat q1, quat q2) const noexcept
vec3	dot (quat q1, quat q2, quat q3) const noexcept
quat	mult (quat rhs) const noexcept
quat	div (quat rhs) const noexcept
Miscellaneous
Other types of quaternion operations.
float	angle_between (quat p) const noexcept
quat	rotate_towards (shz_quat_t to, float max_angle) const noexcept
Transformations
Routines for applying quaternion transforms.
vec3	transform (vec3 in) const noexcept

Static Public Attributes
static constexpr float	slerp_phi_epsilon

Friends
bool	operator== (quat lhs, quat rhs) noexcept

Initialization
Routines for creating and initializing quaternions.
	quat () noexcept=default
	quat (float w, float x, float y, float z) noexcept
	quat (shz_quat_t q) noexcept
static quat	identity () noexcept
static quat	from_angles_xyz (float x, float y, float z) noexcept
static quat	from_axis_angle (vec3 axis, float angle) noexcept
static quat	from_look_axis (vec3 forward, vec3 up) noexcept
static quat	from_rotated_axis (vec3 start, vec3 end) noexcept
static quat	lerp (quat q, quat p, float t) noexcept
static quat	nlerp (quat q, quat p, float t) noexcept
static quat	slerp (quat q, quat p, float t) noexcept
static quat	squad (quat q1, quat q2, quat s1, quat s2, float t) noexcept

Additional Inherited Members
Data Fields inherited from shz_quat_t
union {
struct {
float   w
union {
struct {
float   x
float   y
float   z
}
shz_vec3_t   axis
}
}
float   e [4]
};

Detailed Description

C++ structure representing a quaternion.

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

Warning

The SH4ZAM internal quaternion representation puts the W or angle component first, followed by the X, Y, Z components for the axis!

Note

shz::quat is the C++ extension of shz_quat_t, which adds member functions, convenience operators, and still retains backwards compatibility with the C API.

See also

shz_quat_t, shz::mat4x4, shz::vec3

Definition at line 38 of file shz_quat.hpp.

Constructor & Destructor Documentation

quat() [1/3]

shz::quat::quat ( )

defaultnoexcept

Default constructor: does nothing.

quat() [2/3]

shz::quat::quat ( float w, float x, float y, float z )

inlinenoexcept

Value constructor: initializes a quaternion with the given values for each component.

Definition at line 51 of file shz_quat.hpp.

                                                                          :
            shz_quat_t({w, x, y, z}) {}

quat() [3/3]

shz::quat::quat ( shz_quat_t q )

inlinenoexcept

C Converting constructor: constructs a C++ shz::quat from a C shz_quat_t.

Definition at line 55 of file shz_quat.hpp.

                                                    :
            shz_quat_t(q) {}

Member Function Documentation

identity()

static quat shz::quat::identity ( )

inlinestaticnoexcept

Returns an identity quaternion.

Definition at line 59 of file shz_quat.hpp.

                                                         {
            return shz_quat_identity();
        }

from_angles_xyz()

static quat shz::quat::from_angles_xyz ( float x, float y, float z )

inlinestaticnoexcept

C++ convenience wrapper for shz_quat_from_angles_xyz().

Definition at line 64 of file shz_quat.hpp.

                                                                                         {
            return shz_quat_from_angles_xyz(x, y, z);
        }

from_axis_angle()

static quat shz::quat::from_axis_angle ( vec3 axis, float angle )

inlinestaticnoexcept

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

Definition at line 69 of file shz_quat.hpp.

                                                                                      {
            return shz_quat_from_axis_angle(axis, angle);
        }

from_look_axis()

static quat shz::quat::from_look_axis ( vec3 forward, vec3 up )

inlinestaticnoexcept

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

Definition at line 74 of file shz_quat.hpp.

                                                                                    {
            return shz_quat_from_look_axis(forward, up);
        }

from_rotated_axis()

static quat shz::quat::from_rotated_axis ( vec3 start, vec3 end )

inlinestaticnoexcept

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

Definition at line 79 of file shz_quat.hpp.

                                                                                      {
            return shz_quat_from_rotated_axis(start, end);
        }

lerp()

static quat shz::quat::lerp ( quat q, quat p, float t )

inlinestaticnoexcept

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

Definition at line 84 of file shz_quat.hpp.

                                                                            {
            return shz_quat_lerp(q, p, t);
        }

nlerp()

static quat shz::quat::nlerp ( quat q, quat p, float t )

inlinestaticnoexcept

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

Definition at line 89 of file shz_quat.hpp.

                                                                             {
            return shz_quat_nlerp(q, p, t);
        }

slerp()

static quat shz::quat::slerp ( quat q, quat p, float t )

inlinestaticnoexcept

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

Definition at line 94 of file shz_quat.hpp.

                                                                             {
            return shz_quat_slerp(q, p, t);
        }

squad()

static quat shz::quat::squad ( quat q1, quat q2, quat s1, quat s2, float t )

inlinestaticnoexcept

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

Definition at line 99 of file shz_quat.hpp.

                                                                                                 {
            return shz_quat_squad(q1, q2, s1, s2, t);
        }

angle()

float shz::quat::angle ( ) const

inlinenoexcept

Returns the angle of rotation represented by the given quaternion.

Definition at line 158 of file shz_quat.hpp.

                                                      {
            return shz_quat_angle(*this);
        }

axis()

vec3 shz::quat::axis ( ) const

inlinenoexcept

Returns the axis of rotation represented by the given quaternion.

Definition at line 163 of file shz_quat.hpp.

                                                    {
            return shz_quat_axis(*this);
        }

angle_x()

float shz::quat::angle_x ( ) const

inlinenoexcept

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

Definition at line 168 of file shz_quat.hpp.

                                                        {
            return shz_quat_angle_x(*this);
        }

angle_y()

float shz::quat::angle_y ( ) const

inlinenoexcept

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

Definition at line 173 of file shz_quat.hpp.

                                                        {
            return shz_quat_angle_y(*this);
        }

angle_z()

float shz::quat::angle_z ( ) const

inlinenoexcept

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

Definition at line 178 of file shz_quat.hpp.

                                                        {
            return shz_quat_angle_z(*this);
        }

magnitude_sqr()

float shz::quat::magnitude_sqr ( ) const

inlinenoexcept

Returns the magnitude of the quaternion squared.

Definition at line 183 of file shz_quat.hpp.

                                                              {
            return shz_quat_magnitude_sqr(*this);
        }

magnitude()

float shz::quat::magnitude ( ) const

inlinenoexcept

Returns the magnitude of the quaternion.

Definition at line 188 of file shz_quat.hpp.

                                                          {
            return shz_quat_magnitude(*this);
        }

magnitude_inv()

float shz::quat::magnitude_inv ( ) const

inlinenoexcept

Returns the inverse of the magnitude of the quaternion.

Definition at line 193 of file shz_quat.hpp.

                                                              {
            return shz_quat_magnitude_inv(*this);
        }

to_angles_xyz()

vec3 shz::quat::to_angles_xyz ( ) const

inlinenoexcept

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

Definition at line 205 of file shz_quat.hpp.

                                                             {
            return shz_quat_to_angles_xyz(*this);
        }

to_axis_angle() [1/2]

void shz::quat::to_axis_angle ( shz_vec3_t * axis, float * angle ) const

inlinenoexcept

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

Definition at line 210 of file shz_quat.hpp.

                                                                                           {
            shz_quat_to_axis_angle(*this, axis, angle);
        }

to_axis_angle() [2/2]

auto shz::quat::to_axis_angle ( ) const -> std::pair<vec3, float>

inlinenoexcept

Returns both the axis and angle of rotation as a std::pair.

Definition at line 215 of file shz_quat.hpp.

                                                                                     {
            std::pair<vec3, float> aa;
            shz_quat_to_axis_angle(*this, &std::get<0>(aa), &std::get<1>(aa));
            return aa;
        }

normalized()

quat shz::quat::normalized ( ) const

inlinenoexcept

Returns the given quaternion as a unit quaternion.

Definition at line 229 of file shz_quat.hpp.

                                                          {
            return shz_quat_normalize(*this);
        }

normalize()

void shz::quat::normalize ( )

inlinenoexcept

Normalizes the given quaternion.

Definition at line 234 of file shz_quat.hpp.

                                                   {
            *this = normalized();
        }

normalized_safe()

quat shz::quat::normalized_safe ( ) const

inlinenoexcept

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

Definition at line 239 of file shz_quat.hpp.

                                                               {
            return shz_quat_normalize_safe(*this);
        }

normalize_safe()

void shz::quat::normalize_safe ( )

inlinenoexcept

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

Definition at line 244 of file shz_quat.hpp.

                                                        {
            *this = normalized_safe();
        }

conjugated()

quat shz::quat::conjugated ( ) const

inlinenoexcept

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

Definition at line 249 of file shz_quat.hpp.

                                                          {
            return shz_quat_conjugate(*this);
        }

conjugate()

void shz::quat::conjugate ( )

inlinenoexcept

Conjugates the given quaternion.

Definition at line 254 of file shz_quat.hpp.

                                                   {
            *this = conjugated();
        }

inverse()

quat shz::quat::inverse ( ) const

inlinenoexcept

Returns the inverse of the given quaternion.

Definition at line 259 of file shz_quat.hpp.

                                                       {
            return shz_quat_inv(*this);
        }

invert()

void shz::quat::invert ( )

inlinenoexcept

Inverts the given quaternion.

Definition at line 264 of file shz_quat.hpp.

                                                {
            *this = inverse();
        }

negated()

quat shz::quat::negated ( ) const

inlinenoexcept

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

Definition at line 269 of file shz_quat.hpp.

                                                       {
            return shz_quat_neg(*this);
        }

negate()

void shz::quat::negate ( )

inlinenoexcept

Negates the components of the given quaternion.

Definition at line 274 of file shz_quat.hpp.

                                                {
            *this = negated();
        }

add()

quat shz::quat::add ( quat rhs ) const

inlinenoexcept

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

Definition at line 286 of file shz_quat.hpp.

                                                           {
            return shz_quat_add(*this, rhs);
        }

sub()

quat shz::quat::sub ( quat rhs ) const

inlinenoexcept

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

Definition at line 291 of file shz_quat.hpp.

                                                           {
            return shz_quat_sub(*this, rhs);
        }

scaled()

quat shz::quat::scaled ( float s ) const

inlinenoexcept

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

Definition at line 296 of file shz_quat.hpp.

                                                             {
            return shz_quat_scale(*this, s);
        }

scale()

void shz::quat::scale ( float s )

inlinenoexcept

Multiplies each component of the given quaternion by s.

Definition at line 301 of file shz_quat.hpp.

                                                      {
            *this = scaled(s);
        }

dot() [1/3]

float shz::quat::dot ( quat other ) const

inlinenoexcept

Returns the dot product between the given quaternion and another.

Definition at line 306 of file shz_quat.hpp.

                                                              {
            return shz_quat_dot(*this, other);
        }

dot() [2/3]

vec2 shz::quat::dot ( quat q1, quat q2 ) const

inlinenoexcept

Returns the dot product of the given quaternion against two others.

Definition at line 311 of file shz_quat.hpp.

                                                                   {
            return shz_quat_dot2(*this, q1, q2);
        }

dot() [3/3]

vec3 shz::quat::dot ( quat q1, quat q2, quat q3 ) const

inlinenoexcept

Returns the dot product of the given quaternion against three others.

Definition at line 316 of file shz_quat.hpp.

                                                                            {
            return shz_quat_dot3(*this, q1, q2, q3);
        }

mult()

quat shz::quat::mult ( quat rhs ) const

inlinenoexcept

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

Definition at line 321 of file shz_quat.hpp.

                                                            {
            return shz_quat_mult(*this, rhs);
        }

div()

quat shz::quat::div ( quat rhs ) const

inlinenoexcept

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

Definition at line 326 of file shz_quat.hpp.

                                                           {
            return shz_quat_div(*this, rhs);
        }

angle_between()

float shz::quat::angle_between ( quat p ) const

inlinenoexcept

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

Definition at line 338 of file shz_quat.hpp.

                                                                    {
            return shz_quat_angle_between(*this, p);
        }

rotate_towards()

quat shz::quat::rotate_towards ( shz_quat_t to, float max_angle ) const

inlinenoexcept

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

Definition at line 343 of file shz_quat.hpp.

                                                                                            {
            return shz_quat_rotate_towards(*this, to, max_angle);
        }

transform()

vec3 shz::quat::transform ( vec3 in ) const

inlinenoexcept

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

Definition at line 355 of file shz_quat.hpp.

                                                                {
            return shz_quat_transform_vec3(*this, in);
        }

operator-()

quat shz::quat::operator- ( ) const

inlinenoexcept

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

Definition at line 362 of file shz_quat.hpp.

                                                         {
            return negated();
        }

operator+=()

quat shz::quat::operator+= ( quat rhs )

inlinenoexcept

Adds and accumulates rhs onto the given quaternion.

Definition at line 367 of file shz_quat.hpp.

                                                            {
            return *this = add(rhs);
        }

operator-=()

quat shz::quat::operator-= ( quat rhs )

inlinenoexcept

Subtracts rhs from the given quaternion.

Definition at line 372 of file shz_quat.hpp.

                                                            {
            return *this = sub(rhs);
        }

operator*=() [1/2]

quat shz::quat::operator*= ( quat rhs )

inlinenoexcept

Multiplies and accumulates rhs into the given quaternion.

Definition at line 377 of file shz_quat.hpp.

                                                            {
            return *this = mult(rhs);
        }

operator/=() [1/2]

quat shz::quat::operator/= ( quat rhs )

inlinenoexcept

Divides the given quaternion by rhs.

Definition at line 382 of file shz_quat.hpp.

                                                            {
            return *this = div(rhs);
        }

operator*=() [2/2]

quat shz::quat::operator*= ( float rhs )

inlinenoexcept

Multiplies and accumulates each component of the given quaternion by rhs.

Definition at line 387 of file shz_quat.hpp.

                                                             {
            scale(rhs);
            return *this;
        }

operator/=() [2/2]

quat shz::quat::operator/= ( float rhs )

inlinenoexcept

Divides each component of the given quaternion by rhs.

Definition at line 393 of file shz_quat.hpp.

                                                             {
            scale(shz_invf(rhs));
            return *this;
        }

Friends And Related Symbol Documentation

operator==

bool operator== ( quat lhs, quat rhs )

friend

Overloaded comparison operator, checks for quaternion equality.

Definition at line 146 of file shz_quat.hpp.

                                                            {
            return shz_quat_equal(lhs, rhs);
        }

Field Documentation

slerp_phi_epsilon

float shz::quat::slerp_phi_epsilon

staticconstexpr

Minimum epsilon for bothering to interpolate in shz::quat::slerp().

Definition at line 40 of file shz_quat.hpp.

---

The documentation for this struct was generated from the following file:

• shz_quat.hpp