[−][src]Struct ultraviolet::rotor::WRotor3

#[repr(C)]
pub struct WRotor3 {
    pub s: f32x4,
    pub bv: WBivec3,
}

A Rotor in 3d space.

Please see the module level documentation for more information on rotors!

Fields

s: f32x4bv: WBivec3

Methods

`impl WRotor3`[src]

`pub fn new(scalar: f32x4, bivector: WBivec3) -> Self`[src]

`pub fn identity() -> Self`[src]

`pub fn from_rotation_between(from: Wec3, to: Wec3) -> Self`[src]

Construct a Rotor that rotates one vector to another.

`pub fn from_angle_plane(angle: f32x4, plane: WBivec3) -> Self`[src]

Construct a rotor given a bivector which defines a plane and rotation orientation, and a rotation angle.

plane must be normalized!

This is the equivalent of an axis-angle rotation.

`pub fn from_rotation_xy(angle: f32x4) -> Self`[src]

Create new Rotor from a rotation in the xy plane (also known as "around the z axis").

`pub fn from_rotation_xz(angle: f32x4) -> Self`[src]

Create new Rotor from a rotation in the xz plane (also known as "around the y axis").

`pub fn from_rotation_yz(angle: f32x4) -> Self`[src]

Create new Rotor from a rotation in the yz plane (also known as "around the x axis").

`pub fn from_euler_angles(roll: f32x4, pitch: f32x4, yaw: f32x4) -> Self`[src]

Angles are applied in the order roll -> pitch -> yaw

Roll is rotation inside the xy plane ("around the z axis")
Pitch is rotation inside the yz plane ("around the x axis")
Yaw is rotation inside the xz plane ("around the y axis")

`pub fn mag_sq(&self) -> f32x4`[src]

`pub fn mag(&self) -> f32x4`[src]

`pub fn normalize(&mut self)`[src]

`pub fn normalized(&self) -> Self`[src]

`pub fn reverse(&mut self)`[src]

`pub fn reversed(&self) -> Self`[src]

`pub fn rotate_by(&mut self, rhs: Self)`[src]

Rotates this rotor by another rotor in-place. Note that if you are looking to compose rotations (you probably are), you should NOT use this operation. Rather, just use regular left-multiplication as in matrix composition.

`pub fn rotated_by(self, rhs: Self) -> Self`[src]

Rotates this rotor by another rotor and returns the result. Note that if you are looking to compose rotations, you should NOT use this operation and rather just use regular left-multiplication like for matrix composition.

`pub fn rotate_vec(self, vec: &mut Wec3)`[src]

Rotates a vector by this rotor.

self must be normalized!

`pub fn into_matrix(self) -> Wat3`[src]

`pub fn layout() -> Layout`[src]

Trait Implementations

`impl Add<WRotor3> for WRotor3`[src]

`type Output = Self`

The resulting type after applying the + operator.

`fn add(self, rhs: Self) -> Self`[src]

`impl AddAssign<WRotor3> for WRotor3`[src]

`fn add_assign(&mut self, rhs: Self)`[src]

`impl Clone for WRotor3`[src]

`fn clone(&self) -> WRotor3`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Copy for WRotor3`[src]

`impl Debug for WRotor3`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl Default for WRotor3`[src]

`fn default() -> Self`[src]

`impl From<WRotor3> for Wat3`[src]

`fn from(rotor: WRotor3) -> Wat3`[src]