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+= (const quat &rhs) noexcept
quat	operator-= (const quat &rhs) noexcept
quat	operator*= (const quat &rhs) noexcept
quat	operator/= (const 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 (const quat &rhs) const noexcept
quat	sub (const quat &rhs) const noexcept
quat	scaled (float s) const noexcept
void	scale (float s) noexcept
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
quat	mult (const quat &rhs) const noexcept
quat	div (const quat &rhs) const noexcept
Miscellaneous
Other types of quaternion operations.
float	angle_between (const quat &p) const noexcept
quat	rotate_towards (const quat &to, float max_angle) const noexcept
Transformations
Routines for applying quaternion transforms.
vec3	transform (const vec3 &in) const noexcept

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

Initialization
Routines for creating and initializing quaternions.
	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
static quat	identity () noexcept
static quat	from_angles_xyz (float x, float y, float z) noexcept
static quat	from_axis_angle (const vec3 &axis, float angle) noexcept
static quat	from_look_axis (const vec3 &forward, const vec3 &up) noexcept
static quat	from_rotated_axis (const vec3 &start, const vec3 &end) noexcept
static quat	lerp (const quat &q, const quat &p, float t) noexcept
static quat	nlerp (const quat &q, const quat &p, float t) noexcept
static quat	slerp (const quat &q, const quat &p, float t) noexcept
static quat	squad (const quat &q1, const quat &q2, const quat &s1, const 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/5]

shz::quat::quat ( )

defaultnoexcept

Default constructor: does nothing.

quat() [2/5]

shz::quat::quat ( const quat & other )

defaultnoexcept

Default copy constructor.

quat() [3/5]

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 52 of file shz_quat.hpp.

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

quat() [4/5]

shz::quat::quat ( const shz_quat_t & q )

inlinenoexcept

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

Definition at line 56 of file shz_quat.hpp.

                                                           :
            shz_quat_t(q) {}

quat() [5/5]

shz::quat::quat ( const volatile shz_quat_t & other )

inlinenoexcept

Converting constructor from existing volatile C instance.

Definition at line 60 of file shz_quat.hpp.

                                                                        :
            shz_quat_t(const_cast<const shz_quat_t&>(other)) {}

Member Function Documentation

identity()

static quat shz::quat::identity ( )

inlinestaticnoexcept

Returns an identity quaternion.

Definition at line 64 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 69 of file shz_quat.hpp.

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

from_axis_angle()

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

inlinestaticnoexcept

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

Definition at line 74 of file shz_quat.hpp.

                                                                                             {
            return shz_quat_from_axis_angle(axis, angle);
        }

from_look_axis()

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

inlinestaticnoexcept

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

Definition at line 79 of file shz_quat.hpp.

                                                                                                  {
            return shz_quat_from_look_axis(forward, up);
        }

from_rotated_axis()

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

inlinestaticnoexcept

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

Definition at line 84 of file shz_quat.hpp.

                                                                                                    {
            return shz_quat_from_rotated_axis(start, end);
        }

lerp()

static quat shz::quat::lerp ( const quat & q, const 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 89 of file shz_quat.hpp.

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

nlerp()

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

inlinestaticnoexcept

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

Definition at line 94 of file shz_quat.hpp.

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

slerp()

static quat shz::quat::slerp ( const quat & q, const 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 99 of file shz_quat.hpp.

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

squad()

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

inlinestaticnoexcept

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

Definition at line 104 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 170 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 175 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 180 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 185 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 190 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 195 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 200 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 205 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 217 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 222 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 227 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 241 of file shz_quat.hpp.

                                                          {
            return shz_quat_normalize(*this);
        }

normalize()

void shz::quat::normalize ( )

inlinenoexcept

Normalizes the given quaternion.

Definition at line 246 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 251 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 256 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 261 of file shz_quat.hpp.

                                                          {
            return shz_quat_conjugate(*this);
        }

conjugate()

void shz::quat::conjugate ( )

inlinenoexcept

Conjugates the given quaternion.

Definition at line 266 of file shz_quat.hpp.

                                                   {
            *this = conjugated();
        }

inverse()

quat shz::quat::inverse ( ) const

inlinenoexcept

Returns the inverse of the given quaternion.

Definition at line 271 of file shz_quat.hpp.

                                                       {
            return shz_quat_inv(*this);
        }

invert()

void shz::quat::invert ( )

inlinenoexcept

Inverts the given quaternion.

Definition at line 276 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 281 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 286 of file shz_quat.hpp.

                                                {
            *this = negated();
        }

add()

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

inlinenoexcept

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

Definition at line 298 of file shz_quat.hpp.

                                                                  {
            return shz_quat_add(*this, rhs);
        }

sub()

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

inlinenoexcept

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

Definition at line 303 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 308 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 313 of file shz_quat.hpp.

                                                      {
            *this = scaled(s);
        }

dot() [1/3]

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

inlinenoexcept

Returns the dot product between the given quaternion and another.

Definition at line 318 of file shz_quat.hpp.

                                                                     {
            return shz_quat_dot(*this, other);
        }

dot() [2/3]

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

inlinenoexcept

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

Definition at line 323 of file shz_quat.hpp.

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

dot() [3/3]

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

inlinenoexcept

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

Definition at line 328 of file shz_quat.hpp.

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

mult()

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

inlinenoexcept

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

Definition at line 333 of file shz_quat.hpp.

                                                                   {
            return shz_quat_mult(*this, rhs);
        }

div()

quat shz::quat::div ( const 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 338 of file shz_quat.hpp.

                                                                  {
            return shz_quat_div(*this, rhs);
        }

angle_between()

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

inlinenoexcept

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

Definition at line 350 of file shz_quat.hpp.

                                                                           {
            return shz_quat_angle_between(*this, p);
        }

rotate_towards()

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

inlinenoexcept

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

Definition at line 355 of file shz_quat.hpp.

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

transform()

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

inlinenoexcept

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

Definition at line 367 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 374 of file shz_quat.hpp.

                                                         {
            return negated();
        }

operator+=()

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

inlinenoexcept

Adds and accumulates rhs onto the given quaternion.

Definition at line 379 of file shz_quat.hpp.

                                                                   {
            return *this = add(rhs);
        }

operator-=()

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

inlinenoexcept

Subtracts rhs from the given quaternion.

Definition at line 384 of file shz_quat.hpp.

                                                                   {
            return *this = sub(rhs);
        }

operator*=() [1/2]

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

inlinenoexcept

Multiplies and accumulates rhs into the given quaternion.

Definition at line 389 of file shz_quat.hpp.

                                                                   {
            return *this = mult(rhs);
        }

operator/=() [1/2]

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

inlinenoexcept

Divides the given quaternion by rhs.

Definition at line 394 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 399 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 405 of file shz_quat.hpp.

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

Friends And Related Symbol Documentation

operator==

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

friend

Overloaded comparison operator, checks for quaternion equality.

Definition at line 158 of file shz_quat.hpp.

                                                                          {
            return shz_quat_equal(lhs, rhs);
        }

---

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

• shz_quat.hpp