Enum Dir2 

pub enum Dir2 {
    X,
    Y,
    NegX,
    NegY,
}

A 2d cardinal direction.

Variants

X

Y

NegX

NegY

Implementations

impl Dir2

pub const ALL: [Dir2; 4]

pub fn choose(rng: &mut impl RngExt) -> Dir2

pub fn from_vec2(vec: Vec2<i32>) -> Dir2

pub fn to_dir3(self) -> Dir3

pub fn opposite(self) -> Dir2

pub fn rotated_ccw(self) -> Dir2

Rotate the direction anti clock wise

pub fn rotated_cw(self) -> Dir2

Rotate the direction clock wise

pub fn orthogonal(self) -> Dir2

pub fn abs(self) -> Dir2

pub fn signum(self) -> i32

pub fn to_vec2(self) -> Vec2<i32>

pub fn diagonal(self) -> Vec2<i32>

The diagonal to the left of self, this is equal to this dir plus this dir rotated counter clockwise.

pub fn to_vec3(self) -> Vec3<i32>

pub fn vec2(self, x: i32, y: i32) -> Vec2<i32>

Create a vec2 where x is in the direction of self, and y is anti clockwise of self.

pub fn vec2_abs<T>(self, x: T, y: T) -> Vec2<T>

Create a vec2 where x is in the direction of self, and y is orthogonal version of self.

pub fn to_mat3(self) -> Mat3<i32>

Returns a 3x3 matrix that rotates Vec3(1, 0, 0) to the direction you get in to_vec3. Inteded to be used with Primitive::Rotate.

Example:

use vek::Vec3;
use veloren_common::util::Dir2;
let dir = Dir2::X;

assert_eq!(dir.to_mat3() * Vec3::new(1, 0, 0), dir.to_vec3());

let dir = Dir2::NegX;

assert_eq!(dir.to_mat3() * Vec3::new(1, 0, 0), dir.to_vec3());

let dir = Dir2::Y;

assert_eq!(dir.to_mat3() * Vec3::new(1, 0, 0), dir.to_vec3());

let dir = Dir2::NegY;

assert_eq!(dir.to_mat3() * Vec3::new(1, 0, 0), dir.to_vec3());

pub fn from_z_mat3(self) -> Mat3<i32>

Creates a matrix that tranforms an upwards facing vector to this direction.

pub fn relative_to(self, other: Dir2) -> Dir2

Translates this direction to worldspace as if it was relative to the other direction

pub fn is_x(self) -> bool

Is this direction parallel to x

pub fn is_y(self) -> bool

Is this direction parallel to y

pub fn is_positive(self) -> bool

pub fn is_negative(self) -> bool

pub fn select(self, vec: impl Into<Vec2<i32>>) -> i32

Returns the component that the direction is parallell to

pub fn select_with( self, vec: impl Into<Vec2<i32>>, other: impl Into<Vec2<i32>>, ) -> Vec2<i32>

Select one component the direction is parallel to from vec and select the other component from other

pub fn select_aabr<T>(self, aabr: Aabr<T>) -> T

Returns the side of an aabr that the direction is pointing to

pub fn select_aabr_with<T>( self, aabr: Aabr<T>, other: impl Into<Vec2<T>>, ) -> Vec2<T>

Select one component from the side the direction is pointing to from aabr and select the other component from other

pub fn sprite_ori(self) -> u8

The equivelant sprite direction of the direction

pub fn from_sprite_ori(ori: u8) -> Option<(Dir2, u8)>

Returns (Dir, rest)

Returns None if ori isn’t a valid sprite Ori.

pub fn sprite_ori_legacy(self) -> u8

Legacy version of sprite_ori, so prefer using that over this.

pub fn split_aabr_offset<T>(self, aabr: Aabr<T>, offset: T) -> [Aabr<T>; 2]

where T: Copy + PartialOrd + Add<T, Output = T> + Sub<T, Output = T>,

pub fn trim_aabr(self, aabr: Aabr<i32>, amount: i32) -> Aabr<i32>

pub fn extend_aabr(self, aabr: Aabr<i32>, amount: i32) -> Aabr<i32>

Trait Implementations

impl<O: Into<EnumSet<Dir2>>> BitAnd<O> for Dir2

type Output = EnumSet<Dir2>

The resulting type after applying the & operator.

fn bitand(self, other: O) -> Self::Output

Performs the & operation.

impl<O: Into<EnumSet<Dir2>>> BitOr<O> for Dir2

type Output = EnumSet<Dir2>

The resulting type after applying the | operator.

fn bitor(self, other: O) -> Self::Output

Performs the | operation.

impl<O: Into<EnumSet<Dir2>>> BitXor<O> for Dir2

type Output = EnumSet<Dir2>

The resulting type after applying the ^ operator.

fn bitxor(self, other: O) -> Self::Output

Performs the ^ operation.

impl Clone for Dir2

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dir2

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

Formats the value using the given formatter.

impl Enum for Dir2

const LENGTH: usize = 4usize

Length of the enum.

fn from_usize(value: usize) -> Self

Takes an usize, and returns an element matching into_usize function.

fn into_usize(self) -> usize

Returns an unique identifier for a value within range of 0..Array::LENGTH.

impl<V> EnumArray<V> for Dir2

type Array = [V; 4]

Representation of an enum map for type V.

impl EnumSetConstHelper for Dir2

const CONST_INIT_HELPER: __EnumSetInitHelper = __EnumSetInitHelper

The instance of the ConstInitHelper.

const CONST_OP_HELPER: __EnumSetOpHelper = __EnumSetOpHelper

The instance of the ConstOpHelper.

type ConstInitHelper = __EnumSetInitHelper

A helper type used to convert values to EnumSets at compile-time.

type ConstOpHelper = __EnumSetOpHelper

A helper type used to implement compile-time operations on enums.

impl EnumSetTypePrivate for Dir2

const ALL_BITS: Self::Repr = {transmute(0x0f): <util::cardinal_directions::Dir2 as enumset::__internal::EnumSetTypePrivate>::Repr}

A mask of bits that are valid in the bitset.

const BIT_WIDTH: u32 = 4u32

The largest bit used in the bitset.

const VARIANT_COUNT: u32 = 4u32

The number of variants in the bitset.

type Repr = u8

The underlying type used to store the bitset.

fn enum_into_u32(self) -> u32

Converts an enum of this type into its bit position.

unsafe fn enum_from_u32(val: u32) -> Self

Converts a bit position into an enum value.

unsafe fn enum_from_u32_checked(val: u32) -> Self

Converts a bit position into an enum value, with an debug_assert.

impl IntoEnumIterator for Dir2

type Iterator = Dir2Iter

fn iter() -> Dir2Iter

impl Neg for Dir2

type Output = Dir2

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Dir2

type Output = EnumSet<Dir2>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<EnumSet<Dir2>> for Dir2

fn eq(&self, other: &EnumSet<Dir2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Dir2

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<O: Into<EnumSet<Dir2>>> Sub<O> for Dir2

type Output = EnumSet<Dir2>

The resulting type after applying the - operator.

fn sub(self, other: O) -> Self::Output

Performs the - operation.

impl Copy for Dir2

impl EnumSetType for Dir2

impl Eq for Dir2