Struct Vector2D

pub struct Vector2D<T, Kind> {
    pub x: T,
    pub y: T,
    /* private fields */
}

A generic vector with an X and Y component.

Fields

x: T

y: T

Implementations

impl<T> Vector2D<T, Point>

pub fn offset<P: ToPoint2D<T>>(self, point: P) -> Offset2D<T>

where T: Sub<Output = T>,

Returns the offset between self and point.

Order matters here, so if you are trying to get the offset needed for point A to get to point B, you would do a.offset(b).

Examples

let a = point!(10, 40);
let b = point!(5, 60);

assert_eq!(a.offset(b), offset!(-5, 20));

pub fn with_size<S: ToSize2D<T>>(self, size: S) -> Bounds2D<T>

where T: Num + Copy,

Returns a new Bounds2D using self as position, and size as the size.

Examples

let bounds = point!(20u32, 30).with_size(size!(50; 2));

assert_eq!(bounds, bounds!(20, 30, 50, 50));

impl<T, K> Vector2D<T, K>

pub fn new(x: T, y: T) -> Self

Returns a new Vector2D with x and y components.

In most cases you should not call this directly, but rather use the macros to get the specialized variants.

Examples

// Avoid doing this
let point: Vector2D<_, Point> = Vector2D::new(20, 40);

// This is better, but not great
let point: Point2D<_> = Vector2D::new(20, 40);

// This is acceptable, but...
let point = Point2D::new(20, 40);

// ...this is the preferred way
let point = point!(20, 40);

pub fn splat(value: T) -> Self

where T: Copy,

Returns a new Vector2D where both components are set to value.

Prefer using the splat syntax with the specialized macros instead of calling this directly.

Examples

// This is acceptable, but...
let offset = Offset2D::splat(5);

// ...this is the preferred way
let offset = offset!(5; 2);

assert_eq!(offset, offset!(5, 5));

pub fn cast<C>(self) -> Vector2D<C, K>

where C: Copy + 'static, T: AsPrimitive<C>,

Casts self into a new Vector2D where components are the (usually inferred) input type.

Trait Implementations

impl<T> Add<Vector2D<T, Offset>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the + operator.

fn add(self, rhs: Offset2D<T>) -> Self::Output

Performs the + operation.

impl<T: Clone, Kind: Clone> Clone for Vector2D<T, Kind>

fn clone(&self) -> Vector2D<T, Kind>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Kind: Debug> Debug for Vector2D<T, Kind>

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

Formats the value using the given formatter.

impl<T: Default, Kind: Default> Default for Vector2D<T, Kind>

fn default() -> Vector2D<T, Kind>

Returns the “default value” for a type.

impl<T, K> From<(T, T)> for Vector2D<T, K>

fn from(tuple: (T, T)) -> Self

Converts to this type from the input type.

impl<T, K> From<Vector2D<T, K>> for (T, T)

fn from(vector: Vector2D<T, K>) -> Self

Converts to this type from the input type.

impl<T: Hash, Kind: Hash> Hash for Vector2D<T, Kind>

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<T: PartialEq, Kind: PartialEq> PartialEq for Vector2D<T, Kind>

fn eq(&self, other: &Vector2D<T, Kind>) -> 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<T> Sub<Vector2D<T, Offset>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Offset2D<T>) -> Self::Output

Performs the - operation.

impl<T, K> ToVector2D<T, K> for Vector2D<T, K>

Makes it so that Vector2D itself can be used for interfaces expecting it.

fn to_vector(self) -> Vector2D<T, K>

Converts this type into a Vector2D.

impl<T, K, ToVector> Vector<T, ToVector> for Vector2D<T, K>

where ToVector: ToVector2D<T, K>,

fn dot(&self, rhs: ToVector) -> T

where T: Copy + Mul<Output = T> + Add<Output = T>,

Returns the dot product of self and rhs.

Examples

let a = offset!(5, 10);
let b = offset!(10, 5);

assert_eq!(a.dot(b), 100);

fn cross(&self, rhs: ToVector) -> T

where T: Copy + Mul<Output = T> + Sub<Output = T>,

Returns the normal of the cross product between self and rhs.

Examples

let a = offset!(0, 0);
let b = offset!(20, 20);

assert_eq!(a.cross(b), 0);

fn distance(&self, rhs: ToVector) -> T

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

Returns the absolute distance between self and rhs.

Examples

let a = offset!(10, 10);
let b = offset!(0, 0);

assert_eq!(a.distance(b), 20);

impl<T: Copy, Kind: Copy> Copy for Vector2D<T, Kind>

impl<T, Kind> StructuralPartialEq for Vector2D<T, Kind>