Struct axgeom::Vec2

pub struct Vec2<N> {
    pub x: N,
    pub y: N,
}

A 2D vector.

Fields

x: N

y: N

Implementations

impl<S: Copy + Neg<Output = S> + PartialOrd + Zero> Vec2<S>

pub fn abs(&self) -> Vec2<S>

pub fn rotate_90deg_right(&self) -> Vec2<S>

pub fn rotate_90deg_left(&self) -> Vec2<S>

pub fn split_into_components(&self) -> [Vec2<S>; 2]

impl<S: Add<Output = S> + Sub<Output = S> + PartialOrd + Copy> Vec2<S>

pub fn manhattan_dis(&self, other: Vec2<S>) -> S

impl<T: Copy + PartialOrd + Sub<Output = T> + Mul<Output = T> + Add<Output = T>> Vec2<T>

pub fn distance_squared_to_point(&self, point: Vec2<T>) -> T

If the point is outside the rectangle, returns the squared distance from a point to a rectangle. If the point is inside the rectangle, it will return None.

impl<S: Mul<Output = S> + Div<Output = S> + Add<Output = S> + Copy> Vec2<S>

pub fn scale(&self, other: Vec2<S>) -> Vec2<S>

pub fn inv_scale(&self, other: Vec2<S>) -> Vec2<S>

pub fn magnitude2(&self) -> S

pub fn dot(&self, other: Vec2<S>) -> S

impl<S: FloatCore> Vec2<S>

pub fn is_nan(&self) -> bool

impl<S: Float> Vec2<S>

pub fn truncate_at(&self, mag: S) -> Vec2<S>

pub fn normalize_to(&self, mag: S) -> Vec2<S>

pub fn magnitude(&self) -> S

impl<T> Vec2<T>

pub fn inner_as<B: 'static + Copy>(self) -> Vec2<B>where T: AsPrimitive<B>,

impl<B> Vec2<B>

pub fn get_axis(&self, axis: impl Axis) -> &B

Get the range of one axis.

pub fn get_axis_mut(&mut self, axis: impl Axis) -> &mut B

Get the mutable range of one axis.

pub fn inner_into<A>(self) -> Vec2<A>where B: Into<A>,

pub fn inner_try_into<A>(self) -> Result<Vec2<A>, B::Error>where B: TryInto<A>,

Trait Implementations

impl<S: Add<Output = S> + Copy> Add<Vec2<S>> for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: AddAssign<S> + Copy> AddAssign<Vec2<S>> for Vec2<S>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<N> AsMut<[N; 2]> for Vec2<N>

fn as_mut(&mut self) -> &mut [N; 2]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<N> AsRef<[N; 2]> for Vec2<N>

fn as_ref(&self) -> &[N; 2]

Converts this type into a shared reference of the (usually inferred) input type.

impl<N: Clone> Clone for Vec2<N>

fn clone(&self) -> Vec2<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for Vec2<N>

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

Formats the value using the given formatter.

impl<N: Default> Default for Vec2<N>

fn default() -> Vec2<N>

Returns the “default value” for a type.

impl<'de, N> Deserialize<'de> for Vec2<N>where N: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Div<Output = S> + Copy> Div<S> for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Self

Performs the / operation.

impl<S: DivAssign<S> + Copy> DivAssign<S> for Vec2<S>

fn div_assign(&mut self, scalar: S)

Performs the /= operation.

impl<'a, B: Copy> From<&'a [B; 2]> for Vec2<B>

fn from(a: &'a [B; 2]) -> Self

Converts to this type from the input type.

impl<'a, B> From<&'a Vec2<B>> for &'a [B; 2]

fn from(a: &'a Vec2<B>) -> Self

Converts to this type from the input type.

impl<B> From<[B; 2]> for Vec2<B>

fn from(a: [B; 2]) -> Self

Converts to this type from the input type.

impl<B> From<Vec2<B>> for [B; 2]

fn from(a: Vec2<B>) -> Self

Converts to this type from the input type.

impl<N: Hash> Hash for Vec2<N>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: Mul<Output = S> + Copy> Mul<S> for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: MulAssign<S> + Copy> MulAssign<S> for Vec2<S>

fn mul_assign(&mut self, scalar: S)

Performs the *= operation.

impl<S: Neg<Output = S>> Neg for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the - operator.

fn neg(self) -> Vec2<S>

Performs the unary - operation.

impl<N: PartialEq> PartialEq<Vec2<N>> for Vec2<N>

fn eq(&self, other: &Vec2<N>) -> bool

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

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<N> Serialize for Vec2<N>where N: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Sub<Output = S> + Copy> Sub<Vec2<S>> for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: SubAssign<S> + Copy> SubAssign<Vec2<S>> for Vec2<S>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<S: Zero + Eq + Copy> Zero for Vec2<S>

fn zero() -> Vec2<S>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<N: Copy> Copy for Vec2<N>

impl<N: Eq> Eq for Vec2<N>

impl<N> StructuralEq for Vec2<N>

impl<N> StructuralPartialEq for Vec2<N>