Quaternion.hpp File Reference

Classes
class	mundy::AQuaternion< T, Accessor >
	AQuaternion class with floating point entries (an integer-valued quaternion doesn't make much sense). More...

Namespaces
namespace	mundy

Concepts
concept	mundy::ValidQuaternionType
	A temporary concept to check if a type is a valid AQuaternion type TODO(palmerb4): Extend this concept to contain all shared setters and getters for our quaternions.

Functions
Write to output stream
template<typename T, ValidAccessor< T > Accessor>
std::ostream &	mundy::operator<< (std::ostream &os, const AQuaternion< T, Accessor > &quat)
	Write the quaternion to an output stream.
Non-member comparison functions
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_close (const AQuaternion< U, Accessor1 > &quat1, const AQuaternion< T, Accessor2 > &quat2, const decltype(get_comparison_tolerance< T, U >())&tol=get_comparison_tolerance< T, U >())
	AQuaternion-quaternion equality (element-wise within a tolerance).
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr bool	mundy::is_approx_close (const AQuaternion< U, Accessor1 > &quat1, const AQuaternion< T, Accessor2 > &quat2, const decltype(get_relaxed_comparison_tolerance< T, U >())&tol=get_relaxed_comparison_tolerance< T, U >())
	AQuaternion-quaternion equality (element-wise within a relaxed tolerance).
Non-member multiplication and division operators
template<typename U, typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::operator* (const U &scalar, const AQuaternion< T, Accessor > &quat) -> AQuaternion< std::common_type_t< T, U > >
	Scalar-quaternion multiplication.
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::operator* (const AVector3< U, Accessor1 > &vec, const AQuaternion< T, Accessor2 > &quat) -> Vector3< std::common_type_t< T, U > >
	Vector-quaternion multiplication (same as v^T * R = transpose(R^T * v)).
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::operator* (const AMatrix3< U, Accessor1 > &mat, const AQuaternion< T, Accessor2 > &quat)
	Matrix-quaternion multiplication (same as R * M).
Special quaternion operations
template<ValidQuaternionType QuaternionType>
constexpr auto	mundy::copy (const QuaternionType &q)
	Get a deep copy of the given quaternion.
template<typename U, ValidQuaternionType QuaternionType>
constexpr auto	mundy::cast (const QuaternionType &q)
	Cast a quaternion to a different arithmetic type.
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::dot (const AQuaternion< U, Accessor1 > &q1, const AQuaternion< T, Accessor2 > &q2)
	Get the dot product of two quaternions.
template<typename T, ValidAccessor< T > Accessor>
constexpr AQuaternion< std::remove_const_t< T > >	mundy::conjugate (const AQuaternion< T, Accessor > &quat)
	Get the conjugate of a quaternion.
template<typename T, ValidAccessor< T > Accessor>
constexpr AQuaternion< std::remove_const_t< T > >	mundy::inverse (const AQuaternion< T, Accessor > &quat)
	Get the inverse of a quaternion.
template<typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::norm_squared (const AQuaternion< T, Accessor > &quat)
	Get the squared norm of a quaternion.
template<typename T, ValidAccessor< T > Accessor>
constexpr AQuaternion< std::remove_const_t< T > >	mundy::normalize (const AQuaternion< T, Accessor > &quat)
	Get the normalized quaternion.
template<typename U, typename T, typename V, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::slerp (const AQuaternion< U, Accessor1 > &q1, const AQuaternion< T, Accessor2 > &q2, const V t) -> AQuaternion< std::common_type_t< U, T, V > >
	Perform spherical linear interpolation between two quaternions.
template<ValidQuaternionType QuaternionType, ValidVectorType VectorType>
constexpr void	mundy::rotate_quaternion (QuaternionType &quat, const VectorType &omega, const typename QuaternionType::value_type &dt)
	Rotate a quaternion by an angular velocity omega dt.
Non-member constructors and converters
template<typename T, typename U, ValidAccessor< T > Accessor>
constexpr auto	mundy::axis_angle_to_quaternion (const AVector3< T, Accessor > &axis, const U &angle) -> AQuaternion< std::common_type_t< T, U > >
	Get the quaternion from an axis-angle representation.
template<typename T, ValidAccessor< T > Accessor>
constexpr AQuaternion< T >	mundy::rotation_matrix_to_quaternion (const AMatrix3< T, Accessor > &rot_mat)
	Get the quaternion from a rotation matrix.
template<typename T, ValidAccessor< T > Accessor>
constexpr Matrix3< std::remove_const_t< T > >	mundy::quaternion_to_rotation_matrix (const AQuaternion< T, Accessor > &quat)
	Get the rotation matrix from a quaternion.
template<typename T>
constexpr AQuaternion< std::remove_const_t< T > >	mundy::euler_to_quat (const T roll, const T pitch, const T yaw)
	Get the quaternion from Euler angles https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions#Euler_angles_%E2%86%94_quaternion.
template<typename U, typename T, ValidAccessor< U > Accessor1, ValidAccessor< T > Accessor2>
constexpr auto	mundy::quat_from_parallel_transport (const AVector3< U, Accessor1 > &v_from, const AVector3< T, Accessor2 > &v_to) -> AQuaternion< decltype(U() *T())>
	Get the quaternion that perform parallel transport from vector v1 to vector v2.
AQuaternion<T, Accessor> views
template<typename T, typename Accessor>
constexpr auto	mundy::get_quaternion_view (Accessor &&data)
	A helper function to create a AQuaternion<T, Accessor> based on a given accessor.
template<typename T, typename Accessor>
constexpr auto	mundy::get_owning_quaternion (Accessor &&data)

Variables
template<typename TypeToCheck>
constexpr bool	mundy::is_quaternion_v = is_quaternion<TypeToCheck>::value

Type specializations
Atomic v[i] += s (returns new v) Atomic v[i] -= s (returns new v) Atomic v[i] *= s (returns new v) Atomic v[i] /= s (returns new v) Atomic v1[i] += v2[i] (returns new v1) Atomic v1[i] -= v2[i] (returns new v1) Atomic v1[i] *= v2[i] (returns new v1) Atomic v1[i] /= v2[i] (returns new v1)
#define	MUNDY_MATH_QUATERNION_TYPE_SPECIALIZATION(alias, alias_lower, T)
	mundy::quaternionf
	mundy::MUNDY_MATH_QUATERNION_TYPE_SPECIALIZATION (Quaterniond, quaterniond, double) MUNDY_MATH_QUATERNION_TYPE_SPECIALIZATION(Quaternionf

Forward declare AQuaternion functions that also require AQuaternion to be defined
template<typename T>
using	mundy::Quaternion = AQuaternion<T, Array<T, 4>>
	Type alias for a quaternion with the default accessor.
template<typename T, ValidAccessor< T > Accessor>
constexpr auto	mundy::norm (const AQuaternion< T, Accessor > &quat)
	Get the norm of a quaternion.

Macro Definition Documentation

MUNDY_MATH_QUATERNION_TYPE_SPECIALIZATION

#define MUNDY_MATH_QUATERNION_TYPE_SPECIALIZATION	(		alias,
			alias_lower,
			T )

Value:

template <ValidAccessor<T> Accessor = Array<T, 4>>                                      \
using A##alias = AQuaternion<T, Accessor>;                                              \
using alias = A##alias<>;                                                               \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower##_impl : std::false_type {};                                    \
template <typename Accessor>                                                            \
struct is_##alias_lower##_impl<A##alias<Accessor>> : std::true_type {};                 \
template <typename TypeToCheck>                                                         \
struct is_##alias_lower : public is_##alias_lower##_impl<std::decay_t<TypeToCheck>> {}; \
template <typename TypeToCheck>                                                         \
constexpr bool is_##alias_lower##_v = is_##alias_lower<TypeToCheck>::value;