Struct leafwing_input_manager::orientation::Rotation

pub struct Rotation { /* private fields */ }

A discretized 2-dimensional rotation

Internally, these are stored in 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::{FRAC_PI_2, PI, TAU};

let east = Rotation::from_radians(0.0);
let north = Rotation::from_radians(FRAC_PI_2);
let west = Rotation::from_radians(PI);

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

(north + north).assert_approx_eq(west);
(west - east).assert_approx_eq(west);
(2.0 * north).assert_approx_eq(west);
(west / 2.0).assert_approx_eq(north);

north.assert_approx_eq(Rotation::NORTH);

Direction::from(west).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 = _

The direction that points straight up

pub const EAST: Rotation = _

The direction that points straight right

pub const SOUTH: Rotation = _

The direction that points straight down

pub const WEST: Rotation = _

The direction that points straight left

pub const NORTHEAST: Rotation = _

The direction that points halfway between up and right

pub const SOUTHEAST: Rotation = _

The direction that points halfway between down and right

pub const SOUTHWEST: Rotation = _

The direction that points halfway between down and left

pub const NORTHWEST: Rotation = _

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 counterclockwise from the positive x axis

pub fn into_radians(self) -> f32

Converts this direction into radians, measured counterclockwise from the positive x axis

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

Construct a Direction from degrees, measured counterclockwise from the positive x axis

pub fn into_degrees(self) -> f32

Converts this direction into degrees, measured counterclockwise from the positive x axis

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.

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

Performs copy-assignment from source.

impl Component for Rotationwhere
    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 GlobalTransform

fn from(rotation: Rotation) -> Self

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 Vec2

fn from(rotation: Rotation) -> Vec2

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 ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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.

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

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

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

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

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

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

const 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