Struct cgmath::Quaternion

pub struct Quaternion<S> {
    pub s: S,
    pub v: Vector3<S>,
}

A quaternion in scalar/vector form.

Fields

s: S

v: Vector3<S>

Implementations

impl<S: BaseFloat> Quaternion<S>

pub fn new(w: S, xi: S, yj: S, zk: S) -> Quaternion<S>

Construct a new quaternion from one scalar component and three imaginary components

pub fn from_sv(s: S, v: Vector3<S>) -> Quaternion<S>

Construct a new quaternion from a scalar and a vector

pub fn zero() -> Quaternion<S>

The additive identity, ie: q = 0 + 0i + 0j + 0i

pub fn one() -> Quaternion<S>

The multiplicative identity, ie: q = 1 + 0i + 0j + 0i

pub fn dot(self, q: Quaternion<S>) -> S

The dot product of the quaternion and q.

pub fn conjugate(self) -> Quaternion<S>

The conjugate of the quaternion.

pub fn magnitude2(self) -> S

The squared magnitude of the quaternion. This is useful for magnitude comparisons where the exact magnitude does not need to be calculated.

pub fn magnitude(&self) -> S

The magnitude of the quaternion

Performance notes

For instances where the exact magnitude of the quaternion does not need to be known, for example for quaternion-quaternion magnitude comparisons, it is advisable to use the magnitude2 method instead.

pub fn normalize(self) -> Quaternion<S>

Normalize this quaternion, returning the new quaternion.

pub fn nlerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>

Do a normalized linear interpolation with other, by amount.

impl<S: BaseFloat> Quaternion<S>

pub fn slerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>

Spherical Linear Intoperlation

Return the spherical linear interpolation between the quaternion and other. Both quaternions should be normalized first.

Performance notes

The acos operation used in slerp is an expensive operation, so unless your quarternions are far away from each other it’s generally more advisable to use nlerp when you know your rotations are going to be small.

• [Understanding Slerp, Then Not Using It] (http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/)
• [Arcsynthesis OpenGL tutorial] (http://www.arcsynthesis.org/gltut/Positioning/Tut08%20Interpolation.html)

pub fn to_euler(self) -> (Rad<S>, Rad<S>, Rad<S>)

Convert a Quaternion to Eular angles This is a polar singularity aware conversion

Based on:

• [Maths - Conversion Quaternion to Euler] (http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/)

Trait Implementations

impl<'a, 'b, S: BaseFloat> Add<&'b Quaternion<S>> for &'a Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the + operator.

fn add(self, other: &'b Quaternion<S>) -> Quaternion<S>

Performs the + operation.

impl<S: BaseFloat> ApproxEq for Quaternion<S>

type Epsilon = S

fn approx_eq_eps(&self, other: &Quaternion<S>, epsilon: &S) -> bool

fn approx_epsilon() -> Self::Epsilon

fn approx_eq(&self, other: &Self) -> bool

impl<S: BaseFloat> AsMut<[S; 4]> for Quaternion<S>

fn as_mut(&mut self) -> &mut [S; 4]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S: BaseFloat> AsMut<(S, S, S, S)> for Quaternion<S>

fn as_mut(&mut self) -> &mut (S, S, S, S)

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S: BaseFloat> AsRef<[S; 4]> for Quaternion<S>

fn as_ref(&self) -> &[S; 4]

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: BaseFloat> AsRef<(S, S, S, S)> for Quaternion<S>

fn as_ref(&self) -> &(S, S, S, S)

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Clone> Clone for Quaternion<S>

fn clone(&self) -> Quaternion<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: BaseFloat> Debug for Quaternion<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Decodable> Decodable for Quaternion<S>

fn decode<__D: Decoder>(d: &mut __D) -> Result<Quaternion<S>, __D::Error>

Deserialize a value using a Decoder.

impl<'a, S: BaseFloat> Div<S> for &'a Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the / operator.

fn div(self, value: S) -> Quaternion<S>

Performs the / operation.

impl<S: BaseFloat> Div<S> for Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the / operator.

fn div(self, value: S) -> Quaternion<S>

Performs the / operation.

impl<S: Encodable> Encodable for Quaternion<S>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl<'a, S: BaseFloat> From<&'a [S; 4]> for &'a Quaternion<S>

fn from(v: &'a [S; 4]) -> &'a Quaternion<S>

Converts to this type from the input type.

impl<'a, S: BaseFloat> From<&'a (S, S, S, S)> for &'a Quaternion<S>

fn from(v: &'a (S, S, S, S)) -> &'a Quaternion<S>

Converts to this type from the input type.

impl<'a, S: BaseFloat> From<&'a mut [S; 4]> for &'a mut Quaternion<S>

fn from(v: &'a mut [S; 4]) -> &'a mut Quaternion<S>

Converts to this type from the input type.

impl<'a, S: BaseFloat> From<&'a mut (S, S, S, S)> for &'a mut Quaternion<S>

fn from(v: &'a mut (S, S, S, S)) -> &'a mut Quaternion<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<[S; 4]> for Quaternion<S>

fn from(v: [S; 4]) -> Quaternion<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<(S, S, S, S)> for Quaternion<S>

fn from(v: (S, S, S, S)) -> Quaternion<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<Basis3<S>> for Quaternion<S>

fn from(b: Basis3<S>) -> Quaternion<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<Matrix3<S>> for Quaternion<S>

fn from(mat: Matrix3<S>) -> Quaternion<S>

Convert the matrix to a quaternion

impl<S: BaseFloat> From<Quaternion<S>> for Basis3<S>

fn from(quat: Quaternion<S>) -> Basis3<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<Quaternion<S>> for Matrix3<S>

fn from(quat: Quaternion<S>) -> Matrix3<S>

Convert the quaternion to a 3 x 3 rotation matrix

impl<S: BaseFloat> From<Quaternion<S>> for Matrix4<S>

fn from(quat: Quaternion<S>) -> Matrix4<S>

Convert the quaternion to a 4 x 4 rotation matrix

impl<S: BaseFloat> Index<Range<usize>> for Quaternion<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: Range<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S: BaseFloat> Index<RangeFrom<usize>> for Quaternion<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFrom<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S: BaseFloat> Index<RangeFull> for Quaternion<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFull) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S: BaseFloat> Index<RangeTo<usize>> for Quaternion<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeTo<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S: BaseFloat> Index<usize> for Quaternion<S>

type Output = S

The returned type after indexing.

fn index<'a>(&'a self, i: usize) -> &'a S

Performs the indexing (container[index]) operation.

impl<S: BaseFloat> IndexMut<Range<usize>> for Quaternion<S>

fn index_mut<'a>(&'a mut self, i: Range<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S: BaseFloat> IndexMut<RangeFrom<usize>> for Quaternion<S>

fn index_mut<'a>(&'a mut self, i: RangeFrom<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S: BaseFloat> IndexMut<RangeFull> for Quaternion<S>

fn index_mut<'a>(&'a mut self, i: RangeFull) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S: BaseFloat> IndexMut<RangeTo<usize>> for Quaternion<S>

fn index_mut<'a>(&'a mut self, i: RangeTo<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S: BaseFloat> IndexMut<usize> for Quaternion<S>

fn index_mut<'a>(&'a mut self, i: usize) -> &'a mut S

Performs the mutable indexing (container[index]) operation.

impl<S: BaseFloat> Into<[S; 4]> for Quaternion<S>

fn into(self) -> [S; 4]

Converts this type into the (usually inferred) input type.

impl<S: BaseFloat> Into<(S, S, S, S)> for Quaternion<S>

fn into(self) -> (S, S, S, S)

Converts this type into the (usually inferred) input type.

impl<'a, 'b, S: BaseFloat> Mul<&'b Quaternion<S>> for &'a Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: &'b Quaternion<S>) -> Quaternion<S>

Performs the * operation.

impl<'a, 'b, S: BaseFloat> Mul<&'b Vector3<S>> for &'a Quaternion<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, vec: &'b Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, S: BaseFloat> Mul<S> for &'a Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, value: S) -> Quaternion<S>

Performs the * operation.

impl<S: BaseFloat> Mul<S> for Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, value: S) -> Quaternion<S>

Performs the * operation.

impl<S: BaseFloat> Neg for Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn neg(self) -> Quaternion<S>

Performs the unary - operation.

impl<S: PartialEq> PartialEq<Quaternion<S>> for Quaternion<S>

fn eq(&self, other: &Quaternion<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: BaseFloat + Rand> Rand for Quaternion<S>

fn rand<R: Rng>(rng: &mut R) -> Quaternion<S>

Generates a random instance of this type using the specified source of randomness.

impl<S: BaseFloat> Rotation<Point3<S>> for Quaternion<S>

fn one() -> Quaternion<S>

Create the identity transform (causes no transformation).

fn look_at(dir: Vector3<S>, up: Vector3<S>) -> Quaternion<S>

Create a rotation to a given direction with an ‘up’ vector

fn between_vectors(a: Vector3<S>, b: Vector3<S>) -> Quaternion<S>

Create a shortest rotation to transform vector ‘a’ into ‘b’. Both given vectors are assumed to have unit length.

fn rotate_vector(&self, vec: Vector3<S>) -> Vector3<S>

Rotate a vector using this rotation.

fn concat(&self, other: &Quaternion<S>) -> Quaternion<S>

Create a new rotation which combines both this rotation, and another.

fn concat_self(&mut self, other: &Quaternion<S>)

Modify this rotation in-place by combining it with another.

fn invert(&self) -> Quaternion<S>

Create a new rotation which “un-does” this rotation. That is, r.concat(r.invert()) is the identity.

fn invert_self(&mut self)

Invert this rotation in-place.

fn rotate_point(&self, point: P) -> P

Rotate a point using this rotation, by converting it to its representation as a vector.

impl<S> Rotation3<S> for Quaternion<S>where S: 'static + BaseFloat,

fn from_euler(x: Rad<S>, y: Rad<S>, z: Rad<S>) -> Quaternion<S>

• [Maths - Conversion Euler to Quaternion] (http://www.euclideanspace.com/maths/geometry/rotations/conversions/eulerToQuaternion/index.htm)

fn from_axis_angle(axis: Vector3<S>, angle: Rad<S>) -> Quaternion<S>

Create a rotation using an angle around a given axis.

fn from_angle_x(theta: Rad<S>) -> Self

Create a rotation from an angle around the x axis (pitch).

fn from_angle_y(theta: Rad<S>) -> Self

Create a rotation from an angle around the y axis (yaw).

fn from_angle_z(theta: Rad<S>) -> Self

Create a rotation from an angle around the z axis (roll).

impl<'a, 'b, S: BaseFloat> Sub<&'b Quaternion<S>> for &'a Quaternion<S>

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn sub(self, other: &'b Quaternion<S>) -> Quaternion<S>

Performs the - operation.

impl<S: Copy> Copy for Quaternion<S>

impl<S> StructuralPartialEq for Quaternion<S>