Home | Download | Screen shots | Discussion | Documentation
--- | --- | --- | --- | ---

# openvrml::quatf Struct Reference

A POD-struct comprising a quaternion. More...

`#include <openvrml/basetypes.h>`

List of all members.

## Public Member Functions
quatf & | operator*= (const quatf &quat) throw ()
| Multiply by a quaternion.
quatf & | operator*= (float scalar) throw ()
| Multiply by a scalar.
quatf & | operator/= (float scalar) throw ()
| Divide by a scalar.
quatf & | operator+= (const quatf &quat) throw ()
| Add a quaternion.
quatf & | operator-= (const quatf &quat) throw ()
| Subtract a quaternion.
const float & | operator[] (std::size_t index) const throw ()
| Array element dereference operator (const version).
float & | operator[] (std::size_t index) throw ()
| Array element dereference operator (non-const version).
float | x () const throw ()
| Get the x component.
float | y () const throw ()
| Get the y component.
float | z () const throw ()
| Get the z component.
float | w () const throw ()
| Get the w component.
void | x (float value) throw ()
| Set the x component.
void | y (float value) throw ()
| Set the y component.
void | z (float value) throw ()
| Set the z component.
void | w (float value) throw ()
| Set the w component.
const quatf | conjugate () const throw ()
| Get the conjugate.
const quatf | inverse () const throw ()
| Get the inverse.
float | norm () const throw ()
| Get the norm.
const quatf | normalize () const throw ()
| Normalize the quaternion.
## Public Attributes
float | quat [4]
| An array comprising the quaternion components.
## Related Functions
(Note that these are not member functions.)
const openvrml::quatf | make_quatf () throw()
| Create a default `quatf`.
const openvrml::quatf | make_quatf (const float x, const float y, const float z, const float w) throw()
| Create a `quatf` from four values.
const openvrml::quatf | make_quatf (const float(&quat)[4]) throw()
| Create a `quatf` from an array of four values.
const openvrml::quatf | make_quatf (const mat4f &mat) throw()
| Create a `quatf` from a rotation matrix.
const openvrml::quatf | make_quatf (const rotation &rot) throw()
| Create a `quatf` from a `rotation`.
const openvrml::quatf | operator* (const quatf &lhs, const quatf &rhs) throw()
| Multiply two quaternions.
const openvrml::quatf | operator* (const quatf &quat, const float scalar) throw()
| Multiply a quaternion by a scalar.
const openvrml::quatf | operator* (const float scalar, const quatf &quat) throw()
| Multiply a scalar by a quaternion.
const openvrml::quatf | operator/ (const quatf &quat, const float scalar) throw()
| Divide a quaternion by a scalar.
const openvrml::quatf | operator+ (const quatf &lhs, const quatf &rhs) throw()
| Add two quaternions.
const openvrml::quatf | operator- (const quatf &lhs, const quatf &rhs) throw()
| Take the difference between two quaternions.
std::ostream & | operator<< (std::ostream &out, const quatf &quat)
| Stream output.
bool | operator== (const quatf &lhs, const quatf &rhs) throw()
| Compare for equality.
bool | operator!= (const quatf &lhs, const quatf &rhs) throw()
| Compare for inequality.

## Detailed Description

A POD-struct comprising a quaternion.

## Member Function Documentation

openvrml::quatf & openvrml::quatf::operator*= | ( | const quatf & | quat | ) | throw ()

Multiply by a quaternion.

Note:

Parameters:

  `[in]` | quat | the quaternion by which to multiply.

Returns:
  a reference to the object.

openvrml::quatf & openvrml::quatf::operator*= | ( | float | scalar | ) | throw ()

Multiply by a scalar.

Parameters:

  `[in]` | scalar | value by which to multiply.

Returns:
  a reference to the object.

openvrml::quatf & openvrml::quatf::operator/= | ( | float | scalar | ) | throw ()

Divide by a scalar.

Parameters:

  `[in]` | scalar | value by which to divide.

Returns:
  a reference to the object.

openvrml::quatf & openvrml::quatf::operator+= | ( | const quatf & | quat | ) | throw ()

Add a quaternion.

Parameters:

  `[in]` | quat | the quaternion to add.

Returns:
  a reference to the object.

openvrml::quatf & openvrml::quatf::operator-= | ( | const quatf & | quat | ) | throw ()

Subtract a quaternion.

Parameters:

  `[in]` | quat | the quaternion to subtract.

Returns:
  a reference to the object.

const float & openvrml::quatf::operator[] | ( | std::size_t | index | ) | const throw ()`[inline]`

Array element dereference operator (const version).

Parameters:

  `[in]` | index | an index from 0–3.

Precondition:
  `index` is not larger than 3.

float & openvrml::quatf::operator[] | ( | std::size_t | index | ) | throw ()`[inline]`

Array element dereference operator (non-const version).

Parameters:

  `[in]` | index | an index from 0–3.

Precondition:
  `index` is not larger than 3.

float openvrml::quatf::x | ( |  | ) | const throw ()`[inline]`

Get the x component.

Returns:
  the x component value.

float openvrml::quatf::y | ( |  | ) | const throw ()`[inline]`

Get the y component.

Returns:
  the y component value.

float openvrml::quatf::z | ( |  | ) | const throw ()`[inline]`

Get the z component.

Returns:
  the z component value.

float openvrml::quatf::w | ( |  | ) | const throw ()`[inline]`

Get the w component.

Returns:
  the w component value.

void openvrml::quatf::x | ( | float | value | ) | throw ()`[inline]`

Set the x component.

Parameters:

  `[in]` | value | x component value.

void openvrml::quatf::y | ( | float | value | ) | throw ()`[inline]`

Set the y component.

Parameters:

  `[in]` | value | y component value.

void openvrml::quatf::z | ( | float | value | ) | throw ()`[inline]`

Set the z component.

Parameters:

  `[in]` | value | z component value.

void openvrml::quatf::w | ( | float | value | ) | throw ()`[inline]`

Set the w component.

Parameters:

  `[in]` | value | w component value.

const openvrml::quatf openvrml::quatf::conjugate | ( |  | ) | const throw ()

Get the conjugate.

Note:

Returns:
  the conjugate of the quaternion.

const openvrml::quatf openvrml::quatf::inverse | ( |  | ) | const throw ()

Get the inverse.

Note:

Returns:
  the multiplicative inverse.

float openvrml::quatf::norm | ( |  | ) | const throw ()

Get the norm.

Note:

Returns:
  the norm.

const openvrml::quatf openvrml::quatf::normalize | ( |  | ) | const throw ()

Normalize the quaternion.

Returns:
  a unit quaternion derived from the quaternion.

## Friends And Related Function Documentation

const openvrml::quatf make_quatf | ( |  | ) | throw()`[related]`

Create a default `quatf`.

Returns:
  a `quatf` with the value [0.0, 0.0, 0.0, 1.0].

const openvrml::quatf make_quatf | ( | const float | x,
|  | const float | y,
|  | const float | z,
|  | const float | w |
| ) |  |  | throw()`[related]`

Create a `quatf` from four values.

Parameters:

  `[in]` | x | the x vector component.
  `[in]` | y | the y vector component.
  `[in]` | z | the z vector component.
  `[in]` | w | the scalar value w.

Returns:
  a `quatf` with the value [`x`, `y`, `z`, `w`].

const openvrml::quatf make_quatf | ( | const float(&) | quat[4] | ) | throw()`[related]`

Create a `quatf` from an array of four values.

Parameters:

  `[in]` | quat | the first three values in the array are used for the x, y, and z vector components, respectively. The fourth value in the array is used for the scalar part of the quaternion.

Returns:
  a `quatf` with the values in `quat`.

const openvrml::quatf make_quatf | ( | const mat4f & | mat | ) | throw()`[related]`

Create a `quatf` from a rotation matrix.

Parameters:

  `[in]` | mat | a rotation matrix.

Returns:
  a `quatf` corresponding to the rotation applied by `mat`.

const openvrml::quatf make_quatf | ( | const rotation & | rot | ) | throw()`[related]`

Create a `quatf` from a `rotation`.

Parameters:

  `[in]` | rot | a rotation.

Returns:
  a `quatf` corresponding to the rotation applied by `rot`.

const openvrml::quatf operator* | ( | const quatf & | lhs,
|  | const quatf & | rhs |
| ) |  |  | throw()`[related]`

Multiply two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the product of `lhs` and `rhs`.

const openvrml::quatf operator* | ( | const quatf & | quat,
|  | const float | scalar |
| ) |  |  | throw()`[related]`

Multiply a quaternion by a scalar.

Parameters:

  `[in]` | quat | quaternion.
  `[in]` | scalar | scalar.

Returns:
  the product of `quat` and `scalar`.

const openvrml::quatf operator* | ( | const float | scalar,
|  | const quatf & | quat |
| ) |  |  | throw()`[related]`

Multiply a scalar by a quaternion.

Parameters:

  `[in]` | scalar | scalar.
  `[in]` | quat | quaternion.

Returns:
  the product of `scalar` and `quat`.

const openvrml::quatf operator/ | ( | const quatf & | quat,
|  | const float | scalar |
| ) |  |  | throw()`[related]`

Divide a quaternion by a scalar.

Parameters:

  `[in]` | quat | quaternion.
  `[in]` | scalar | scalar.

Returns:
  the result of dividing `quat` by `scalar`.

const openvrml::quatf operator+ | ( | const quatf & | lhs,
|  | const quatf & | rhs |
| ) |  |  | throw()`[related]`

Add two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the sum of `lhs` and `rhs`.

const openvrml::quatf operator- | ( | const quatf & | lhs,
|  | const quatf & | rhs |
| ) |  |  | throw()`[related]`

Take the difference between two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the difference between `lhs` and `rhs`.

std::ostream & operator<< | ( | std::ostream & | out,
|  | const quatf & | quat |
| ) |  |  | `[related]`

Stream output.

Parameters:

  `[in,out]` | out | an output stream.
  `[in]` | quat | a quaternion.

Returns:
  `out`.

bool operator== | ( | const quatf & | lhs,
|  | const quatf & | rhs |
| ) |  |  | throw()`[related]`

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are equal; `false` otherwise.

bool operator!= | ( | const quatf & | lhs,
|  | const quatf & | rhs |
| ) |  |  | throw()`[related]`

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are not equal; `false` otherwise.

## Member Data Documentation

float openvrml::quatf::quat[4]

An array comprising the quaternion components.