Struct Vec2

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

A vector in 2D cartesian space.

The Vec2 struct represents a two-dimensional vector with x and y components.

Fields

x: T

The cartesian x coordinate.

y: T

The cartesian y coordinate.

Implementations

impl<T> Vec2<T>

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

Construct a Vec2 from cartesian coordinates.

pub fn set_x(&mut self, x: T)

Sets the vector’s x component.

pub fn set_y(&mut self, y: T)

Sets the vector’s y component.

impl<T: Copy> Vec2<T>

pub const fn x(&self) -> T

Returns the x component of the vector.

pub const fn y(&self) -> T

Returns the y component of the vector.

impl<T: Float + Copy + Mul<Output = T>> Vec2<T>

pub fn from_polar(r: T, theta: T) -> Self

Construct a Vec2 from polar coordinates.

impl<T: Float + Copy> Vec2<T>

pub fn angle(&self) -> T

Returns this vector’s angle in radians relative to the origin (0, 0).

pub fn length(&self) -> T

Returns this vector’s distance (magnitude) from the origin (0, 0).

impl<T: Float + Copy + Sub<Output = T>> Vec2<T>

pub fn distance(&self, other: Vec2<T>) -> T

Returns the cartesian distance between one vector and another.

This operation is equivalent to (self - other).length().

impl<T: Float + Copy + Div<Output = T>> Vec2<T>

pub fn unit(&self) -> Self

Returns the unit (normalized) vector.

This function creates a Vec2 with a length of 1.0 while retaining the angle of its original input.

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

pub fn lerp(self, other: Vec2<T>, t: T) -> Vec2<T>

Linearly interpolates between two vectors.

pub fn rotated(&self, angle: T) -> Self

Creates a new vector with its coordinates rotated by a given angle in radians.

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

pub fn cross(&self, other: Vec2<T>) -> T

Computes the cross product between this vector and another Vec2.

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

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

Computes the dot product between this vector and another Vec2.

The dot product is the sum of the products of each vector’s components, and represents a measurement of how closely two vectors align with respect to angle.

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

pub fn projected(&self, onto: Vec2<T>) -> Self

Projects one Vec2 onto onto another.

Trait Implementations

impl<T: Add<Output = T>> Add for Vec2<T>

fn add(self, other: Vec2<T>) -> Self

Performs vector addition.

type Output = Vec2<T>

The resulting type after applying the + operator.

impl<T: AddAssign> AddAssign for Vec2<T>

fn add_assign(&mut self, other: Vec2<T>)

Performs vector add-assignment.

impl<T: Clone> Clone for Vec2<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vec2<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vec2<T>

fn default() -> Vec2<T>

Returns the “default value” for a type.

impl<T: Display> Display for Vec2<T>

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

Formats the value using the given formatter.

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

fn div(self, scalar: T) -> Self

Performs scalar division.

type Output = Vec2<T>

The resulting type after applying the / operator.

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

fn div_assign(&mut self, scalar: T)

Performs scalar div-assignment.

impl<T> From<(T, T)> for Vec2<T>

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

Converts to this type from the input type.

impl<T> From<Point2<T>> for Vec2<T>

fn from(value: Point2<T>) -> Self

Converts to this type from the input type.

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

fn mul(self, scalar: T) -> Self

Performs scalar multiplication.

type Output = Vec2<T>

The resulting type after applying the * operator.

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

fn mul_assign(&mut self, scalar: T)

Performs scalar mul-assignment.

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

fn neg(self) -> Self

Negates each component of the vector.

type Output = Vec2<T>

The resulting type after applying the - operator.

impl<T: PartialEq> PartialEq for Vec2<T>

fn eq(&self, other: &Vec2<T>) -> 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<Output = T>> Sub for Vec2<T>

fn sub(self, other: Vec2<T>) -> Self

Performs vector subtraction.

type Output = Vec2<T>

The resulting type after applying the - operator.

impl<T: SubAssign> SubAssign for Vec2<T>

fn sub_assign(&mut self, other: Vec2<T>)

Performs vector sub-assignment.

impl<T: Copy> Copy for Vec2<T>

impl<T: Eq> Eq for Vec2<T>

impl<T> StructuralPartialEq for Vec2<T>