Struct leafwing_input_manager::orientation::Rotation

pub struct Rotation { /* private fields */ }

A discretized 2-dimensional rotation

Internally, these are stored in normalized tenths of a degree, and so can be cleanly added and reversed without accumulating error.

Example

use leafwing_input_manager::orientation::{Rotation, Direction, Orientation};
use core::f32::consts::{PI, TAU};

let three_o_clock = Rotation::from_degrees(90.0);
let six_o_clock = Rotation::from_radians(PI);
let nine_o_clock = Rotation::from_degrees(-90.0);

Rotation::default().assert_approx_eq(Rotation::from_radians(0.0));
Rotation::default().assert_approx_eq(Rotation::from_radians(TAU));
Rotation::default().assert_approx_eq(500.0 * Rotation::from_radians(TAU));

(three_o_clock + six_o_clock).assert_approx_eq(nine_o_clock);
(nine_o_clock - three_o_clock).assert_approx_eq(six_o_clock);
(2.0 * nine_o_clock).assert_approx_eq(six_o_clock);
(six_o_clock / 2.0).assert_approx_eq(three_o_clock);

six_o_clock.assert_approx_eq(Rotation::SOUTH);

Direction::from(nine_o_clock).assert_approx_eq(Direction::WEST);

Implementations

impl Rotation

pub const fn new(deci_degrees: u16) -> Rotation

Creates a new Rotation from a whole number of tenths of a degree

Measured clockwise from midnight.

pub const fn deci_degrees(&self) -> u16

Returns the exact internal mesaurement, stored in tenths of a degree

Measured clockwise from midnight (x=0, y=1). 3600 make up a full circle.

impl Rotation

pub const FULL_CIRCLE: u16 = 3_600u16

The number of deci-degrees that make up a full circle

pub const NORTH: Rotation = Rotation { deci_degrees: 0 }

The direction that points straight up

pub const EAST: Rotation = Rotation { deci_degrees: 900 }

The direction that points straight right

pub const SOUTH: Rotation = Rotation { deci_degrees: 1800 }

The direction that points straight down

pub const WEST: Rotation = Rotation { deci_degrees: 2700 }

The direction that points straight left

pub const NORTHEAST: Rotation = Rotation { deci_degrees: 450 }

The direction that points halfway between up and right

pub const SOUTHEAST: Rotation = Rotation { deci_degrees: 1350 }

The direction that points halfway between down and right

pub const SOUTHWEST: Rotation = Rotation { deci_degrees: 2250 }

The direction that points halfway between down and left

pub const NORTHWEST: Rotation = Rotation { deci_degrees: 3150 }

The direction that points halfway between left and up

impl Rotation

pub fn from_xy(xy: Vec2) -> Result<Rotation, NearlySingularConversion>

Constructs a Rotation from an (x,y) Euclidean coordinate

If both x and y are nearly 0 (the magnitude is less than EPSILON), [Err(NearlySingularConversion)] will be returned instead.

Example

use bevy_math::Vec2;
use leafwing_input_manager::orientation::Rotation;

assert_eq!(Rotation::from_xy(Vec2::new(0.0, 1.0)), Ok(Rotation::NORTH));

pub fn into_xy(self) -> Vec2

Converts this direction into an (x, y) pair with magnitude 1

pub fn from_radians(radians: impl Into<f32>) -> Rotation

Construct a Direction from radians, measured clockwise from midnight

pub fn into_radians(self) -> f32

Converts this direction into radians, measured clockwise from midnight

pub fn from_degrees(degrees: impl Into<f32>) -> Rotation

Construct a Direction from degrees, measured clockwise from midnight

pub fn into_degrees(self) -> f32

Converts this direction into degrees, measured clockwise from midnight

Trait Implementations

impl Add<Rotation> for Rotation

type Output = Rotation

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Rotation> for Rotation

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Rotation

fn clone(&self) -> Rotation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Rotation where
    Self: Send + Sync + 'static, 

type Storage = TableStorage

impl Debug for Rotation

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

Formats the value using the given formatter.

impl Default for Rotation

fn default() -> Rotation

Returns the “default value” for a type.

impl Display for Rotation

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

Formats the value using the given formatter.

impl Div<Rotation> for f32

type Output = Rotation

The resulting type after applying the / operator.

fn div(self, rhs: Rotation) -> Rotation

Performs the / operation.

impl Div<f32> for Rotation

type Output = Rotation

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Rotation

Performs the / operation.

impl From<Direction> for Rotation

fn from(direction: Direction) -> Rotation

Converts to this type from the input type.

impl From<GlobalTransform> for Rotation

fn from(transform: GlobalTransform) -> Self

Converts to this type from the input type.

impl From<Quat> for Rotation

fn from(quaternion: Quat) -> Rotation

Converts to this type from the input type.

impl From<Rotation> for Direction

fn from(rotation: Rotation) -> Direction

Converts to this type from the input type.

impl From<Rotation> for Vec2

fn from(rotation: Rotation) -> Vec2

Converts to this type from the input type.

impl From<Rotation> for Quat

fn from(rotation: Rotation) -> Self

Converts to this type from the input type.

impl From<Rotation> for Transform

fn from(rotation: Rotation) -> Self

Converts to this type from the input type.

impl From<Rotation> for GlobalTransform

fn from(rotation: Rotation) -> Self

Converts to this type from the input type.

impl From<Transform> for Rotation

fn from(transform: Transform) -> Self

Converts to this type from the input type.

impl Hash for Rotation

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Mul<Rotation> for f32

type Output = Rotation

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Rotation

type Output = Rotation

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Rotation

type Output = Rotation

The resulting type after applying the - operator.

fn neg(self) -> Rotation

Performs the unary - operation.

impl Orientation for Rotation

fn distance(&self, other: Rotation) -> Rotation

Returns the absolute distance between self and other as a Rotation

fn assert_approx_eq(self, other: impl Orientation)

Asserts that self is approximately equal to other

fn rotation_direction(&self, target: Self) -> RotationDirection

Which RotationDirection is the shortest to rotate towards to reach target?

fn rotate_towards(
    &mut self,
    target_orientation: Self,
    max_rotation: Option<Rotation>
)

Rotates self towards target_orientation by up to max_rotation

impl PartialEq<Rotation> for Rotation

fn eq(&self, other: &Rotation) -> bool

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

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

This method tests for !=.

impl PartialOrd<Rotation> for Rotation

fn partial_cmp(&self, other: &Rotation) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Rotation> for Rotation

type Output = Rotation

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Rotation> for Rotation

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TryFrom<Vec2> for Rotation

type Error = NearlySingularConversion

The type returned in the event of a conversion error.

fn try_from(vec2: Vec2) -> Result<Rotation, NearlySingularConversion>

Performs the conversion.

impl Copy for Rotation

impl Eq for Rotation

impl StructuralEq for Rotation

impl StructuralPartialEq for Rotation