Struct ultraviolet::rotor::Rotor3

#[repr(C)]
pub struct Rotor3 {
    pub s: f32,
    pub bv: Bivec3,
}

A Rotor in 3d space.

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

Fields

s: f32

bv: Bivec3

Methods

impl Rotor3

pub fn new(scalar: f32, bivector: Bivec3) -> Self

pub fn identity() -> Self

pub fn from_rotation_between(from: Vec3, to: Vec3) -> Self

Construct a Rotor that rotates one vector to another.

pub fn from_angle_plane(angle: f32, plane: Bivec3) -> Self

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: f32) -> Self

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

pub fn from_rotation_xz(angle: f32) -> Self

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

pub fn from_rotation_yz(angle: f32) -> Self

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

pub fn from_euler_angles(roll: f32, pitch: f32, yaw: f32) -> Self

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) -> f32

pub fn mag(&self) -> f32

pub fn normalize(&mut self)

pub fn normalized(&self) -> Self

pub fn reverse(&mut self)

pub fn reversed(&self) -> Self

pub fn rotate_by(&mut self, rhs: Self)

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

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 Vec3)

Rotates a vector by this rotor.

self must be normalized!

pub fn into_matrix(self) -> Mat3

pub fn layout() -> Layout

Trait Implementations

impl Lerp<f32> for Rotor3

fn lerp(&self, end: Self, t: f32) -> Self

impl From<Rotor3> for Mat3

fn from(rotor: Rotor3) -> Mat3

Performs the conversion.

impl Clone for Rotor3

fn clone(&self) -> Rotor3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Rotor3

impl Default for Rotor3

fn default() -> Rotor3

Returns the "default value" for a type.

impl Debug for Rotor3

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

Formats the value using the given formatter.

impl Sub<Rotor3> for Rotor3

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl Add<Rotor3> for Rotor3

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Mul<Rotor3> for Rotor3

The composition of self with q, i.e. self * q gives the rotation as though you first perform q and then self.

type Output = Self

The resulting type after applying the * operator.

fn mul(self, q: Self) -> Self

Performs the * operation.

impl Mul<Vec3> for Rotor3

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, rhs: Vec3) -> Vec3

Performs the * operation.

impl Mul<f32> for Rotor3

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self

Performs the * operation.

impl Mul<Rotor3> for f32

type Output = Rotor3

The resulting type after applying the * operator.

fn mul(self, rotor: Rotor3) -> Rotor3

Performs the * operation.

impl AddAssign<Rotor3> for Rotor3

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl SubAssign<Rotor3> for Rotor3

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl MulAssign<f32> for Rotor3

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.