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

#[repr(C)]pub struct DRotor2 {
    pub s: f64,
    pub bv: DBivec2,
}

Expand description

A Rotor in 2d space.

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

Fields

s: f64bv: DBivec2

Implementations

`impl DRotor2`[src]

`pub const fn new(scalar: f64, bivector: DBivec2) -> Self`[src]

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

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

Construct a Rotor that rotates one vector to another.

A rotation between antiparallel vectors is undefined!

`pub fn from_angle_plane(angle: f64, plane: DBivec2) -> 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_angle(angle: f64) -> Self`[src]

Construct a rotor given only an angle. This is possible in 2d since there is only one possible plane of rotation. However, there are two possible orientations. This function uses the common definition of positive angle in 2d as meaning the direction which brings the x unit vector towards the y unit vector.

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

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

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

#[must_use = "Did you mean to use `.normalize()` to normalize `self` in place?"] pub fn normalized(&self) -> Self [src]

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

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

`pub fn dot(&self, rhs: Self) -> f64`[src]

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

Rotates this rotor by another rotor in-place. 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 rotated_by(self, other: 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 DVec2)`[src]

Rotates a vector by this rotor.

self must be normalized!

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

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

Trait Implementations

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

`type Output = Self`

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

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

Performs the += operation. Read more

`impl Clone for DRotor2`[src]

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl Debug for DRotor2`[src]

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

Formats the value using the given formatter. Read more

`impl Default for DRotor2`[src]

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

Returns the “default value” for a type. Read more

`impl Div<f64> for DRotor2`[src]

`type Output = Self`

The resulting type after applying the / operator.

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

Performs the / operation. Read more

`impl DivAssign<f64> for DRotor2`[src]

`fn div_assign(&mut self, rhs: f64)`[src]

Performs the /= operation. Read more

`impl From<DRotor2> for DMat2`[src]

`fn from(rotor: DRotor2) -> DMat2`[src]

Performs the conversion.

`impl Lerp<f64> for DRotor2`[src]

`fn lerp(&self, end: Self, t: f64) -> Self`[src]

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.