Struct glamour::Vector2

#[repr(C)]
pub struct Vector2<T: Unit = f32> {
    pub x: T::Scalar,
    pub y: T::Scalar,
}

2D vector.

Bitwise compatible with glam::Vec2 / glam::DVec2 / glam::IVec2

Alignment: Same as the scalar.

Fields

x: T::Scalar

X coordinate

y: T::Scalar

Y coordinate

Implementations

impl<T: Unit> Vector2<T>

pub const ZERO: Self = _

All zeroes.

pub const ONE: Self = _

All ones.

pub const X: Self = _

Unit vector in the direction of the X axis.

pub const Y: Self = _

Unit vector in the direction of the Y axis.

pub const AXES: [Self; 2] = _

The unit axes.

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

New vector.

pub fn from_array(array: [T::Scalar; 2]) -> Self

Instantiate from array. See glam::Vec2::from_array().

pub fn to_array(self) -> [T::Scalar; 2]

Convert to array. See glam::Vec2::to_array().

pub fn splat(scalar: T::Scalar) -> Self

Instance with all components set to scalar. See glam::Vec2::splat().

pub fn write_to_slice(self, slice: &mut [T::Scalar])

Write all components to slice.

pub fn cmpeq(self, other: Self) -> BVec2

Return a mask with the result of a component-wise equals comparison. See glam::Vec2::cmpeq().

pub fn cmpne(self, other: Self) -> BVec2

Return a mask with the result of a component-wise not-equal comparison. See glam::Vec2::cmpne().

pub fn cmpge(self, other: Self) -> BVec2

Return a mask with the result of a component-wise greater-than-or-equal comparison. See glam::Vec2::cmpge().

pub fn cmpgt(self, other: Self) -> BVec2

Return a mask with the result of a component-wise greater-than comparison. See glam::Vec2::cmpgt().

pub fn cmple(self, other: Self) -> BVec2

Return a mask with the result of a component-wise less-than-or-equal comparison. See glam::Vec2::cmple().

pub fn cmplt(self, other: Self) -> BVec2

Return a mask with the result of a component-wise less-than comparison. See glam::Vec2::cmplt().

pub fn min(self, other: Self) -> Self

Minimum by component. See glam::Vec2::min().

pub fn max(self, other: Self) -> Self

Maximum by component. See glam::Vec2::max().

pub fn min_element(self) -> T::Scalar

Horizontal minimum (smallest component). See glam::Vec2::min_element().

pub fn max_element(self) -> T::Scalar

Horizontal maximum (largest component). See glam::Vec2::max_element().

pub fn clamp(self, min: Self, max: Self) -> Self

Component-wise clamp. See glam::Vec2::clamp().

pub fn select(mask: BVec2, a: Self, b: Self) -> Self

Select components from two instances based on a mask. See glam::Vec2::select().

pub fn from_untyped(untyped: Vector2<T::Scalar>) -> Vector2<T>

Bitcast an untyped instance to self.

pub fn to_untyped(self) -> Vector2<T::Scalar>

Bitcast self to an untyped instance.

pub fn as_untyped(&self) -> &Vector2<T::Scalar>

Reinterpret cast self as the untyped variant.

pub fn as_untyped_mut(&mut self) -> &mut Vector2<T::Scalar>

Reinterpret cast self as the untyped variant.

pub fn cast<T2>(self) -> Vector2<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn cast_ref<T2>(&self) -> &Vector2<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn cast_mut<T2>(&mut self) -> &mut Vector2<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn try_cast<T2>(self) -> Option<Vector2<T2>>

where T2: Unit,

Cast to a different coordinate space with scalar type conversion. Returns None if any component could not be converted to the target scalar type.

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

Instantiate from tuple.

pub const fn to_tuple(self) -> (T::Scalar, T::Scalar)

Convert to tuple.

pub fn as_array(&self) -> &[T::Scalar; 2]

Reinterpret as array.

pub fn as_array_mut(&mut self) -> &mut [T::Scalar; 2]

Reinterpret as mutable array.

pub fn get(&self, index: usize) -> T::Scalar

Get component at index.

pub fn set(&mut self, index: usize, value: T::Scalar)

Set component at index.

pub fn const_get<const N: usize>(&self) -> T::Scalar

Get component at index N.

pub fn const_set<const N: usize>(&mut self, value: T::Scalar)

Set component at index N.

pub fn dot(self, other: Self) -> T::Scalar

Dot product See glam::Vec2::dot().

pub fn extend(self, z: T::Scalar) -> Vector3<T>

Extend with z-component to Vector3. See glam::Vec2::extend().

pub fn with_x(self, x: T::Scalar) -> Self

Replace the x-component with a new value. See glam::Vec2::with_x().

pub fn with_y(self, y: T::Scalar) -> Self

Replace the y-component with a new value. See glam::Vec2::with_y().

pub fn element_sum(self) -> T::Scalar

Returns the sum of all elements of self. See glam::Vec2::element_sum().

pub fn element_product(self) -> T::Scalar

Returns the product of all elements of self. See glam::Vec2::element_product().

pub fn swizzle<const X: usize, const Y: usize>(&self) -> Self

Select components of this vector and return a new vector containing those components.

pub fn from_point(point: Point2<T>) -> Self

Instantiate from point.

pub fn to_point(self) -> Point2<T>

Convert to point.

pub fn as_point(&self) -> &Point2<T>

Reinterpret as point.

pub fn as_point_mut(&mut self) -> &mut Point2<T>

Reinterpret as point.

pub fn from_size(size: Size2<T>) -> Self

Instantiate from size.

pub fn to_size(self) -> Size2<T>

Convert to size.

pub fn as_size(&self) -> &Size2<T>

Reinterpret as size.

pub fn as_size_mut(&mut self) -> &mut Size2<T>

Reinterpret as size.

impl<T> Vector2<T>

where T: Unit, T::Scalar: FloatScalar,

pub const NAN: Self = _

All NaN.

pub const INFINITY: Self = _

All positive infinity.

pub const NEG_INFINITY: Self = _

All negative infinity.

pub fn is_finite(&self) -> bool

True if all components are non-infinity and non-NaN. See glam::Vec2::is_finite().

pub fn is_nan(&self) -> bool

True if any component is NaN. See glam::Vec2::is_nan().

pub fn is_nan_mask(&self) -> BVec2

Return a mask where each bit is set if the corresponding component is NaN. See glam::Vec2::is_nan_mask().

pub fn ceil(self) -> Self

Round all components up. See glam::Vec2::ceil().

pub fn floor(self) -> Self

Round all components down. See glam::Vec2::floor().

pub fn round(self) -> Self

Round all components. See glam::Vec2::round().

pub fn fract(self) -> Self

See (e.g.) glam::Vec2::fract() See glam::Vec2::fract().

pub fn fract_gl(self) -> Self

See (e.g.) glam::Vec2::fract_gl() See glam::Vec2::fract_gl().

pub fn lerp(self, other: Self, t: T::Scalar) -> Self

Linear interpolation. See glam::Vec2::lerp().

pub fn normalize(self) -> Self

Normalize the vector. Undefined results in the vector’s length is (very close to) zero. See glam::Vec2::normalize().

pub fn normalize_or_zero(self) -> Self

Normalize the vector, returning zero if the length was already (very close to) zero. See glam::Vec2::normalize_or_zero().

pub fn normalize_or(self, fallback: Self) -> Self

Returns self normalized to length 1.0 if possible, else returns a fallback value. See glam::Vec2::normalize_or().

pub fn try_normalize(self) -> Option<Self>

Normalize the vector, returning None if the length was already (very close to) zero. See glam::Vec2::try_normalize().

pub fn is_normalized(self) -> bool

True if the vector is normalized. See glam::Vec2::is_normalized().

pub fn length(self) -> T::Scalar

Length of the vector See glam::Vec2::length().

pub fn length_squared(self) -> T::Scalar

Squared length of the vector See glam::Vec2::length_squared().

pub fn length_recip(self) -> T::Scalar

Reciprocal length of the vector See glam::Vec2::length_recip().

pub fn exp(self) -> Self

e^self by component See glam::Vec2::exp().

pub fn powf(self, n: T::Scalar) -> Self

self^n by component See glam::Vec2::powf().

pub fn recip(self) -> Self

1.0/self by component See glam::Vec2::recip().

pub fn mul_add(self, a: Self, b: Self) -> Self

self * a + b See glam::Vec2::mul_add().

pub fn clamp_length(self, min: T::Scalar, max: T::Scalar) -> Self

Clamp length See glam::Vec2::clamp_length().

pub fn clamp_length_min(self, min: T::Scalar) -> Self

Clamp length See glam::Vec2::clamp_length_min().

pub fn clamp_length_max(self, max: T::Scalar) -> Self

Clamp length See glam::Vec2::clamp_length_max().

pub fn project_onto(self, other: Self) -> Self

See (e.g.) glam::Vec2::project_onto() See glam::Vec2::project_onto().

pub fn reject_from(self, other: Self) -> Self

See (e.g.) glam::Vec2::reject_from() See glam::Vec2::reject_from().

pub fn project_onto_normalized(self, other: Self) -> Self

See (e.g.) glam::Vec2::project_onto_normalized() See glam::Vec2::project_onto_normalized().

pub fn reject_from_normalized(self, other: Self) -> Self

See (e.g.) glam::Vec2::reject_from_normalized() See glam::Vec2::reject_from_normalized().

pub fn from_angle(angle: Angle<T::Scalar>) -> Vector2<T::Scalar>

Return (sin(angle), cos(angle). See glam::Vec2::from_angle().

pub fn rotate(self, rotation: Vector2<T::Scalar>) -> Self

Rotate by a vector containing (sin(angle), cos(angle)) See glam::Vec2::rotate().

pub fn to_angle(self) -> Angle<T::Scalar>

Returns the angle (in radians) of this vector in the range [-π, +π]. See glam::Vec2::to_angle().

pub fn angle_between(self, other: Self) -> Angle<T::Scalar>

Angle between this and another vector. See glam::Vec2::angle_between().

impl<T> Vector2<T>

where T: Unit, T::Scalar: IntScalar,

pub fn saturating_add(self, rhs: Self) -> Self

Returns a vector containing the saturating addition of self and rhs. See glam::IVec2::saturating_add().

pub fn saturating_sub(self, rhs: Self) -> Self

Returns a vector containing the saturating subtraction of self and rhs. See glam::IVec2::saturating_sub().

pub fn saturating_mul(self, rhs: Self) -> Self

Returns a vector containing the saturating multiplication of self and rhs. See glam::IVec2::saturating_mul().

pub fn saturating_div(self, rhs: Self) -> Self

Returns a vector containing the saturating division of self and rhs. See glam::IVec2::saturating_div().

pub fn wrapping_add(self, rhs: Self) -> Self

Returns a vector containing the wrapping addition of self and rhs. See glam::IVec2::wrapping_add().

pub fn wrapping_sub(self, rhs: Self) -> Self

Returns a vector containing the wrapping subtraction of self and rhs. See glam::IVec2::wrapping_sub().

pub fn wrapping_mul(self, rhs: Self) -> Self

Returns a vector containing the wrapping multiplication of self and rhs. See glam::IVec2::wrapping_mul().

pub fn wrapping_div(self, rhs: Self) -> Self

Returns a vector containing the wrapping division of self and rhs. See glam::IVec2::wrapping_div().

impl<T> Vector2<T>

where T: Unit, T::Scalar: SignedScalar,

pub const NEG_ONE: Self = _

All negative one.

pub const NEG_X: Self = _

(-1, 0)

pub const NEG_Y: Self = _

(0, -1)

pub fn abs(self) -> Self

Turn all components positive. See glam::Vec2::abs().

pub fn signum(self) -> Self

Return a vector where each component is 1 or -1 depending on the sign of the input. See glam::Vec2::signum().

pub fn perp(self) -> Self

Get the perpendicular vector. See glam::Vec2::perp().

pub fn perp_dot(self, other: Self) -> T::Scalar

Perpendicular dot product See glam::Vec2::perp_dot().

Trait Implementations

impl<T: Unit> AbsDiffEq for Vector2<T>

type Epsilon = <<T as Unit>::Scalar as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Unit> Add<Vector2<T>> for Box2<T>

type Output = Box2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Unit> Add<Vector2<T>> for Point2<T>

type Output = Point2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Unit> Add for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Unit> AddAssign<Vector2<T>> for Box2<T>

fn add_assign(&mut self, rhs: Vector2<T>)

Performs the += operation.

impl<T: Unit> AddAssign<Vector2<T>> for Point2<T>

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

Performs the += operation.

impl<T: Unit<Scalar = f32>> AddAssign<f32> for Vector2<T>

fn add_assign(&mut self, other: f32)

Performs the += operation.

impl<T: Unit<Scalar = f64>> AddAssign<f64> for Vector2<T>

fn add_assign(&mut self, other: f64)

Performs the += operation.

impl<T: Unit<Scalar = i32>> AddAssign<i32> for Vector2<T>

fn add_assign(&mut self, other: i32)

Performs the += operation.

impl<T: Unit<Scalar = u32>> AddAssign<u32> for Vector2<T>

fn add_assign(&mut self, other: u32)

Performs the += operation.

impl<T: Unit> AddAssign for Vector2<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Unit> AsMut<[<T as Unit>::Scalar]> for Vector2<T>

fn as_mut(&mut self) -> &mut [T::Scalar]

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

impl<T: Unit> AsMut<[<T as Unit>::Scalar; 2]> for Vector2<T>

fn as_mut(&mut self) -> &mut [T::Scalar; 2]

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

impl<T> AsMut<DVec2> for Vector2<T>

where T: Unit<Scalar = f64>,

fn as_mut(&mut self) -> &mut DVec2

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

impl<T> AsMut<I64Vec2> for Vector2<T>

where T: Unit<Scalar = i64>,

fn as_mut(&mut self) -> &mut I64Vec2

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

impl<T> AsMut<IVec2> for Vector2<T>

where T: Unit<Scalar = i32>,

fn as_mut(&mut self) -> &mut IVec2

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

impl<T> AsMut<U64Vec2> for Vector2<T>

where T: Unit<Scalar = u64>,

fn as_mut(&mut self) -> &mut U64Vec2

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

impl<T> AsMut<UVec2> for Vector2<T>

where T: Unit<Scalar = u32>,

fn as_mut(&mut self) -> &mut UVec2

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

impl<T> AsMut<Vec2> for Vector2<T>

where T: Unit<Scalar = f32>,

fn as_mut(&mut self) -> &mut Vec2

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

impl<T: Unit> AsRaw for Vector2<T>

fn as_raw(&self) -> &Self::Raw

By-ref conversion to Self::Raw.

fn as_raw_mut(&mut self) -> &mut Self::Raw

By-ref mutable conversion to Self::Raw.

impl<T: Unit> AsRef<[<T as Unit>::Scalar]> for Vector2<T>

fn as_ref(&self) -> &[T::Scalar]

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

impl<T: Unit> AsRef<[<T as Unit>::Scalar; 2]> for Vector2<T>

fn as_ref(&self) -> &[T::Scalar; 2]

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

impl<T> AsRef<DVec2> for Vector2<T>

where T: Unit<Scalar = f64>,

fn as_ref(&self) -> &DVec2

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

impl<T> AsRef<I64Vec2> for Vector2<T>

where T: Unit<Scalar = i64>,

fn as_ref(&self) -> &I64Vec2

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

impl<T> AsRef<IVec2> for Vector2<T>

where T: Unit<Scalar = i32>,

fn as_ref(&self) -> &IVec2

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

impl<T> AsRef<U64Vec2> for Vector2<T>

where T: Unit<Scalar = u64>,

fn as_ref(&self) -> &U64Vec2

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

impl<T> AsRef<UVec2> for Vector2<T>

where T: Unit<Scalar = u32>,

fn as_ref(&self) -> &UVec2

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

impl<T> AsRef<Vec2> for Vector2<T>

where T: Unit<Scalar = f32>,

fn as_ref(&self) -> &Vec2

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

impl<T> Borrow<DVec2> for Vector2<T>

where T: Unit<Scalar = f64>,

fn borrow(&self) -> &DVec2

Immutably borrows from an owned value.

impl<T> Borrow<I64Vec2> for Vector2<T>

where T: Unit<Scalar = i64>,

fn borrow(&self) -> &I64Vec2

Immutably borrows from an owned value.

impl<T> Borrow<IVec2> for Vector2<T>

where T: Unit<Scalar = i32>,

fn borrow(&self) -> &IVec2

Immutably borrows from an owned value.

impl<T> Borrow<U64Vec2> for Vector2<T>

where T: Unit<Scalar = u64>,

fn borrow(&self) -> &U64Vec2

Immutably borrows from an owned value.

impl<T> Borrow<UVec2> for Vector2<T>

where T: Unit<Scalar = u32>,

fn borrow(&self) -> &UVec2

Immutably borrows from an owned value.

impl<T> Borrow<Vec2> for Vector2<T>

where T: Unit<Scalar = f32>,

fn borrow(&self) -> &Vec2

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for DVec2

where T: Unit<Scalar = f64>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for I64Vec2

where T: Unit<Scalar = i64>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for IVec2

where T: Unit<Scalar = i32>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for U64Vec2

where T: Unit<Scalar = u64>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for UVec2

where T: Unit<Scalar = u32>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> Borrow<Vector2<T>> for Vec2

where T: Unit<Scalar = f32>,

fn borrow(&self) -> &Vector2<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<DVec2> for Vector2<T>

where T: Unit<Scalar = f64>,

fn borrow_mut(&mut self) -> &mut DVec2

Mutably borrows from an owned value.

impl<T> BorrowMut<I64Vec2> for Vector2<T>

where T: Unit<Scalar = i64>,

fn borrow_mut(&mut self) -> &mut I64Vec2

Mutably borrows from an owned value.

impl<T> BorrowMut<IVec2> for Vector2<T>

where T: Unit<Scalar = i32>,

fn borrow_mut(&mut self) -> &mut IVec2

Mutably borrows from an owned value.

impl<T> BorrowMut<U64Vec2> for Vector2<T>

where T: Unit<Scalar = u64>,

fn borrow_mut(&mut self) -> &mut U64Vec2

Mutably borrows from an owned value.

impl<T> BorrowMut<UVec2> for Vector2<T>

where T: Unit<Scalar = u32>,

fn borrow_mut(&mut self) -> &mut UVec2

Mutably borrows from an owned value.

impl<T> BorrowMut<Vec2> for Vector2<T>

where T: Unit<Scalar = f32>,

fn borrow_mut(&mut self) -> &mut Vec2

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for DVec2

where T: Unit<Scalar = f64>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for I64Vec2

where T: Unit<Scalar = i64>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for IVec2

where T: Unit<Scalar = i32>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for U64Vec2

where T: Unit<Scalar = u64>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for UVec2

where T: Unit<Scalar = u32>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<Vector2<T>> for Vec2

where T: Unit<Scalar = f32>,

fn borrow_mut(&mut self) -> &mut Vector2<T>

Mutably borrows from an owned value.

impl<T: Unit> Clone for Vector2<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Unit> Debug for Vector2<T>

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

Formats the value using the given formatter.

impl<T: Unit> Default for Vector2<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Unit<Scalar = f32>> Div<f32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

fn div(self, other: f32) -> Self

Performs the / operation.

impl<T: Unit<Scalar = f64>> Div<f64> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self

Performs the / operation.

impl<T: Unit<Scalar = i32>> Div<i32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Self

Performs the / operation.

impl<T: Unit<Scalar = u32>> Div<u32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Self

Performs the / operation.

impl<T: Unit> Div for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<T: Unit<Scalar = f32>> DivAssign<f32> for Vector2<T>

fn div_assign(&mut self, other: f32)

Performs the /= operation.

impl<T: Unit<Scalar = f64>> DivAssign<f64> for Vector2<T>

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl<T: Unit<Scalar = i32>> DivAssign<i32> for Vector2<T>

fn div_assign(&mut self, other: i32)

Performs the /= operation.

impl<T: Unit<Scalar = u32>> DivAssign<u32> for Vector2<T>

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<T: Unit> DivAssign for Vector2<T>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: Unit> From<[<T as Unit>::Scalar; 2]> for Vector2<T>

fn from(arr: [T::Scalar; 2]) -> Self

Converts to this type from the input type.

impl<T: Unit> From<(<T as Unit>::Scalar, <T as Unit>::Scalar)> for Vector2<T>

fn from(tuple: (T::Scalar, T::Scalar)) -> Vector2<T>

Converts to this type from the input type.

impl<T: Unit> From<BVec2> for Vector2<T>

fn from(v: BVec2) -> Self

Converts to this type from the input type.

impl<T> From<DVec2> for Vector2<T>

where T: Unit<Scalar = f64>,

fn from(vec: DVec2) -> Vector2<T>

Converts to this type from the input type.

impl<T> From<I64Vec2> for Vector2<T>

where T: Unit<Scalar = i64>,

fn from(vec: I64Vec2) -> Vector2<T>

Converts to this type from the input type.

impl<T> From<IVec2> for Vector2<T>

where T: Unit<Scalar = i32>,

fn from(vec: IVec2) -> Vector2<T>

Converts to this type from the input type.

impl<T: Unit> From<Point2<T>> for Vector2<T>

fn from(point: Point2<T>) -> Vector2<T>

Converts to this type from the input type.

impl<T: Unit> From<Size2<T>> for Vector2<T>

fn from(point: Size2<T>) -> Self

Converts to this type from the input type.

impl<T> From<U64Vec2> for Vector2<T>

where T: Unit<Scalar = u64>,

fn from(vec: U64Vec2) -> Vector2<T>

Converts to this type from the input type.

impl<T> From<UVec2> for Vector2<T>

where T: Unit<Scalar = u32>,

fn from(vec: UVec2) -> Vector2<T>

Converts to this type from the input type.

impl<T> From<Vec2> for Vector2<T>

where T: Unit<Scalar = f32>,

fn from(vec: Vec2) -> Vector2<T>

Converts to this type from the input type.

impl<T: Unit> From<Vector2<T>> for [T::Scalar; 2]

fn from(v: Vector2<T>) -> Self

Converts to this type from the input type.

impl<T: Unit> From<Vector2<T>> for (T::Scalar, T::Scalar)

fn from(value: Vector2<T>) -> (T::Scalar, T::Scalar)

Converts to this type from the input type.

impl<T> From<Vector2<T>> for DVec2

where T: Unit<Scalar = f64>,

fn from(vec: Vector2<T>) -> DVec2

Converts to this type from the input type.

impl<T> From<Vector2<T>> for I64Vec2

where T: Unit<Scalar = i64>,

fn from(vec: Vector2<T>) -> I64Vec2

Converts to this type from the input type.

impl<T> From<Vector2<T>> for IVec2

where T: Unit<Scalar = i32>,

fn from(vec: Vector2<T>) -> IVec2

Converts to this type from the input type.

impl<T: Unit> From<Vector2<T>> for Point2<T>

fn from(vec: Vector2<T>) -> Point2<T>

Converts to this type from the input type.

impl<T: Unit> From<Vector2<T>> for Size2<T>

fn from(vec: Vector2<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vector2<T>> for U64Vec2

where T: Unit<Scalar = u64>,

fn from(vec: Vector2<T>) -> U64Vec2

Converts to this type from the input type.

impl<T> From<Vector2<T>> for UVec2

where T: Unit<Scalar = u32>,

fn from(vec: Vector2<T>) -> UVec2

Converts to this type from the input type.

impl<T> From<Vector2<T>> for Vec2

where T: Unit<Scalar = f32>,

fn from(vec: Vector2<T>) -> Vec2

Converts to this type from the input type.

impl<T: Unit> FromRaw for Vector2<T>

fn from_raw(raw: Self::Raw) -> Self

By-value conversion from Self::Raw.

impl<T> Hash for Vector2<T>

where T: Unit, T::Scalar: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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: Unit> Index<usize> for Vector2<T>

type Output = <T as Unit>::Scalar

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Unit> IndexMut<usize> for Vector2<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Unit> IntoIterator for Vector2<T>

type Item = <T as Unit>::Scalar

The type of the elements being iterated over.

type IntoIter = <[<T as Unit>::Scalar; 2] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Mul<Vector2<T>> for Matrix2<T::Scalar>

where T: FloatScalar,

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector2<T>) -> Vector2<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<f32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> Self

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<f64> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<i32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Self

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<u32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Self

Performs the * operation.

impl<T: Unit> Mul for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<T: Unit<Scalar = f32>> MulAssign<f32> for Vector2<T>

fn mul_assign(&mut self, other: f32)

Performs the *= operation.

impl<T: Unit<Scalar = f64>> MulAssign<f64> for Vector2<T>

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl<T: Unit<Scalar = i32>> MulAssign<i32> for Vector2<T>

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

impl<T: Unit<Scalar = u32>> MulAssign<u32> for Vector2<T>

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<T: Unit> MulAssign for Vector2<T>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T> Neg for Vector2<T>

where T: Unit, T::Scalar: SignedScalar,

type Output = Vector2<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Unit> PartialEq<[<T as Unit>::Scalar; 2]> for Vector2<T>

fn eq(&self, other: &[T::Scalar; 2]) -> 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<T: Unit> PartialEq<(<T as Unit>::Scalar, <T as Unit>::Scalar)> for Vector2<T>

fn eq(&self, (x, y): &(T::Scalar, T::Scalar)) -> 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<T: Unit> PartialEq for Vector2<T>

fn eq(&self, other: &Self) -> 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<'a, T: Unit> Product<&'a Vector2<T>> for Vector2<T>

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T: Unit> RelativeEq for Vector2<T>

where T::Scalar: RelativeEq,

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: Unit<Scalar = f32>> Rem<f32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: f32) -> Self

Performs the % operation.

impl<T: Unit<Scalar = f64>> Rem<f64> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: f64) -> Self

Performs the % operation.

impl<T: Unit<Scalar = i32>> Rem<i32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Self

Performs the % operation.

impl<T: Unit<Scalar = u32>> Rem<u32> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Self

Performs the % operation.

impl<T: Unit> Rem for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self

Performs the % operation.

impl<T: Unit<Scalar = f32>> RemAssign<f32> for Vector2<T>

fn rem_assign(&mut self, other: f32)

Performs the %= operation.

impl<T: Unit<Scalar = f64>> RemAssign<f64> for Vector2<T>

fn rem_assign(&mut self, other: f64)

Performs the %= operation.

impl<T: Unit<Scalar = i32>> RemAssign<i32> for Vector2<T>

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

impl<T: Unit<Scalar = u32>> RemAssign<u32> for Vector2<T>

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<T: Unit> RemAssign for Vector2<T>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T: Unit> Sub<Vector2<T>> for Box2<T>

type Output = Box2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Unit> Sub<Vector2<T>> for Point2<T>

type Output = Point2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Unit> Sub for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Unit> SubAssign<Vector2<T>> for Box2<T>

fn sub_assign(&mut self, rhs: Vector2<T>)

Performs the -= operation.

impl<T: Unit> SubAssign<Vector2<T>> for Point2<T>

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

Performs the -= operation.

impl<T: Unit<Scalar = f32>> SubAssign<f32> for Vector2<T>

fn sub_assign(&mut self, other: f32)

Performs the -= operation.

impl<T: Unit<Scalar = f64>> SubAssign<f64> for Vector2<T>

fn sub_assign(&mut self, other: f64)

Performs the -= operation.

impl<T: Unit<Scalar = i32>> SubAssign<i32> for Vector2<T>

fn sub_assign(&mut self, other: i32)

Performs the -= operation.

impl<T: Unit<Scalar = u32>> SubAssign<u32> for Vector2<T>

fn sub_assign(&mut self, other: u32)

Performs the -= operation.

impl<T: Unit> SubAssign for Vector2<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<'a, T: Unit> Sum<&'a Vector2<T>> for Vector2<T>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Unit> Swizzle<T> for Vector2<T>

fn swizzle2<const X: usize, const Y: usize>(&self) -> Vector2<T>

Select two components from this vector and return a 2D vector made from those components.

fn swizzle3<const X: usize, const Y: usize, const Z: usize>(&self) -> Vector3<T>

Select three components from this vector and return a 3D vector made from those components.

fn swizzle4<const X: usize, const Y: usize, const Z: usize, const W: usize>( &self ) -> Vector4<T>

Select four components from this vector and return a 4D vector made from those components.

impl<T: Unit> ToRaw for Vector2<T>

type Raw = <<T as Unit>::Scalar as Scalar>::Vec2

The underlying glam type.

fn to_raw(self) -> Self::Raw

By-value conversion to Self::Raw.

impl<Src, Dst> TransformMap<Vector2<Src>> for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

type Output = Vector2<Dst>

Result type of the transformation.

fn map(&self, value: Vector2<Src>) -> Self::Output

Map T to Self::Output.

impl<T: Unit> TransparentWrapper<<<T as Unit>::Scalar as Scalar>::Vec2> for Vector2<T>

SAFETY: These are guaranteed to have the same representation.

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<T: Unit> UlpsEq for Vector2<T>

where T::Scalar: UlpsEq,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T: Unit> Zeroable for Vector2<T>

SAFETY: T::Scalar is Zeroable, and Vector2 is #[repr(C)].

fn zeroed() -> Self

Calls zeroed.

impl<T: Unit> Copy for Vector2<T>

impl<T> Eq for Vector2<T>

where T: Unit, T::Scalar: Eq,

impl<T: Unit> Pod for Vector2<T>

SAFETY: T::Scalar is Pod.