```
#[repr(C)]pub struct IVec2 {
pub x: i32,
pub y: i32,
}
```

## Expand description

A 2-dimensional vector.

## Fields§

§`x: i32`

§`y: i32`

## Implementations§

source§### impl IVec2

### impl IVec2

source#### pub fn map<F>(self, f: F) -> Selfwhere
F: Fn(i32) -> i32,

#### pub fn map<F>(self, f: F) -> Selfwhere F: Fn(i32) -> i32,

Returns a vector containing each element of `self`

modified by a mapping function `f`

.

source#### pub fn select(mask: BVec2, if_true: Self, if_false: Self) -> Self

#### pub fn select(mask: BVec2, if_true: Self, if_false: Self) -> Self

Creates a vector from the elements in `if_true`

and `if_false`

, selecting which to use
for each element of `self`

.

A true element in the mask uses the corresponding element from `if_true`

, and false
uses the element from `if_false`

.

source#### pub const fn from_array(a: [i32; 2]) -> Self

#### pub const fn from_array(a: [i32; 2]) -> Self

Creates a new vector from an array.

source#### pub const fn from_slice(slice: &[i32]) -> Self

#### pub const fn from_slice(slice: &[i32]) -> Self

Creates a vector from the first 2 values in `slice`

.

##### Panics

Panics if `slice`

is less than 2 elements long.

source#### pub fn write_to_slice(self, slice: &mut [i32])

#### pub fn write_to_slice(self, slice: &mut [i32])

Writes the elements of `self`

to the first 2 elements in `slice`

.

##### Panics

Panics if `slice`

is less than 2 elements long.

source#### pub const fn extend(self, z: i32) -> IVec3

#### pub const fn extend(self, z: i32) -> IVec3

Creates a 3D vector from `self`

and the given `z`

value.

source#### pub fn dot_into_vec(self, rhs: Self) -> Self

#### pub fn dot_into_vec(self, rhs: Self) -> Self

Returns a vector where every component is the dot product of `self`

and `rhs`

.

source#### pub fn min(self, rhs: Self) -> Self

#### pub fn min(self, rhs: Self) -> Self

Returns a vector containing the minimum values for each element of `self`

and `rhs`

.

In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`

.

source#### pub fn max(self, rhs: Self) -> Self

#### pub fn max(self, rhs: Self) -> Self

Returns a vector containing the maximum values for each element of `self`

and `rhs`

.

In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`

.

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

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

Component-wise clamping of values, similar to `i32::clamp`

.

Each element in `min`

must be less-or-equal to the corresponding element in `max`

.

##### Panics

Will panic if `min`

is greater than `max`

when `glam_assert`

is enabled.

source#### pub fn min_element(self) -> i32

#### pub fn min_element(self) -> i32

Returns the horizontal minimum of `self`

.

In other words this computes `min(x, y, ..)`

.

source#### pub fn max_element(self) -> i32

#### pub fn max_element(self) -> i32

Returns the horizontal maximum of `self`

.

In other words this computes `max(x, y, ..)`

.

source#### pub fn element_sum(self) -> i32

#### pub fn element_sum(self) -> i32

Returns the sum of all elements of `self`

.

In other words, this computes `self.x + self.y + ..`

.

source#### pub fn element_product(self) -> i32

#### pub fn element_product(self) -> i32

Returns the product of all elements of `self`

.

In other words, this computes `self.x * self.y * ..`

.

source#### pub fn cmpeq(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `==`

comparison for each element of
`self`

and `rhs`

.

In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]`

for all
elements.

source#### pub fn cmpne(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `!=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]`

for all
elements.

source#### pub fn cmpge(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `>=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]`

for all
elements.

source#### pub fn cmpgt(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `>`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]`

for all
elements.

source#### pub fn cmple(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `<=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]`

for all
elements.

source#### pub fn cmplt(self, rhs: Self) -> BVec2

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

Returns a vector mask containing the result of a `<`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]`

for all
elements.

source#### pub fn abs(self) -> Self

#### pub fn abs(self) -> Self

Returns a vector containing the absolute value of each element of `self`

.

source#### pub fn signum(self) -> Self

#### pub fn signum(self) -> Self

Returns a vector with elements representing the sign of `self`

.

`0`

if the number is zero`1`

if the number is positive`-1`

if the number is negative

source#### pub fn is_negative_bitmask(self) -> u32

#### pub fn is_negative_bitmask(self) -> u32

Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`

.

A negative element results in a `1`

bit and a positive element in a `0`

bit. Element `x`

goes
into the first lowest bit, element `y`

into the second, etc.

source#### pub fn length_squared(self) -> i32

#### pub fn length_squared(self) -> i32

Computes the squared length of `self`

.

source#### pub fn distance_squared(self, rhs: Self) -> i32

#### pub fn distance_squared(self, rhs: Self) -> i32

Compute the squared euclidean distance between two points in space.

source#### pub fn div_euclid(self, rhs: Self) -> Self

#### pub fn div_euclid(self, rhs: Self) -> Self

Returns the element-wise quotient of [Euclidean division] of `self`

by `rhs`

.

##### Panics

This function will panic if any `rhs`

element is 0 or the division results in overflow.

source#### pub fn rem_euclid(self, rhs: Self) -> Self

#### pub fn rem_euclid(self, rhs: Self) -> Self

Returns the element-wise remainder of Euclidean division of `self`

by `rhs`

.

##### Panics

This function will panic if any `rhs`

element is 0 or the division results in overflow.

source#### pub fn perp_dot(self, rhs: Self) -> i32

#### pub fn perp_dot(self, rhs: Self) -> i32

The perpendicular dot product of `self`

and `rhs`

.
Also known as the wedge product, 2D cross product, and determinant.

source#### pub fn rotate(self, rhs: Self) -> Self

#### pub fn rotate(self, rhs: Self) -> Self

Returns `rhs`

rotated by the angle of `self`

. If `self`

is normalized,
then this just rotation. This is what you usually want. Otherwise,
it will be like a rotation with a multiplication by `self`

’s length.

source#### pub fn as_i16vec2(&self) -> I16Vec2

#### pub fn as_i16vec2(&self) -> I16Vec2

Casts all elements of `self`

to `i16`

.

source#### pub fn as_u16vec2(&self) -> U16Vec2

#### pub fn as_u16vec2(&self) -> U16Vec2

Casts all elements of `self`

to `u16`

.

source#### pub fn as_i64vec2(&self) -> I64Vec2

#### pub fn as_i64vec2(&self) -> I64Vec2

Casts all elements of `self`

to `i64`

.

source#### pub fn as_u64vec2(&self) -> U64Vec2

#### pub fn as_u64vec2(&self) -> U64Vec2

Casts all elements of `self`

to `u64`

.

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

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

Returns a vector containing the wrapping addition of `self`

and `rhs`

.

In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`

.

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

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

Returns a vector containing the wrapping subtraction of `self`

and `rhs`

.

In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`

.

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

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

Returns a vector containing the wrapping multiplication of `self`

and `rhs`

.

In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`

.

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

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

Returns a vector containing the wrapping division of `self`

and `rhs`

.

In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`

.

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

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

Returns a vector containing the saturating addition of `self`

and `rhs`

.

In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`

.

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

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

Returns a vector containing the saturating subtraction of `self`

and `rhs`

.

In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`

.

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

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

Returns a vector containing the saturating multiplication of `self`

and `rhs`

.

In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`

.

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

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

Returns a vector containing the saturating division of `self`

and `rhs`

.

In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`

.

source#### pub const fn wrapping_add_unsigned(self, rhs: UVec2) -> Self

#### pub const fn wrapping_add_unsigned(self, rhs: UVec2) -> Self

Returns a vector containing the wrapping addition of `self`

and unsigned vector `rhs`

.

In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`

.

source#### pub const fn wrapping_sub_unsigned(self, rhs: UVec2) -> Self

#### pub const fn wrapping_sub_unsigned(self, rhs: UVec2) -> Self

Returns a vector containing the wrapping subtraction of `self`

and unsigned vector `rhs`

.

In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`

.

source#### pub const fn saturating_add_unsigned(self, rhs: UVec2) -> Self

#### pub const fn saturating_add_unsigned(self, rhs: UVec2) -> Self

In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`

.

source#### pub const fn saturating_sub_unsigned(self, rhs: UVec2) -> Self

#### pub const fn saturating_sub_unsigned(self, rhs: UVec2) -> Self

Returns a vector containing the saturating subtraction of `self`

and unsigned vector `rhs`

.

In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`

.

## Trait Implementations§

source§### impl AddAssign<&IVec2> for IVec2

### impl AddAssign<&IVec2> for IVec2

source§#### fn add_assign(&mut self, rhs: &Self)

#### fn add_assign(&mut self, rhs: &Self)

`+=`

operation. Read moresource§### impl AddAssign<&i32> for IVec2

### impl AddAssign<&i32> for IVec2

source§#### fn add_assign(&mut self, rhs: &i32)

#### fn add_assign(&mut self, rhs: &i32)

`+=`

operation. Read moresource§### impl AddAssign<IVec2> for IVec2

### impl AddAssign<IVec2> for IVec2

source§#### fn add_assign(&mut self, rhs: Self)

#### fn add_assign(&mut self, rhs: Self)

`+=`

operation. Read moresource§### impl AddAssign<i32> for IVec2

### impl AddAssign<i32> for IVec2

source§#### fn add_assign(&mut self, rhs: i32)

#### fn add_assign(&mut self, rhs: i32)

`+=`

operation. Read moresource§### impl DivAssign<&IVec2> for IVec2

### impl DivAssign<&IVec2> for IVec2

source§#### fn div_assign(&mut self, rhs: &Self)

#### fn div_assign(&mut self, rhs: &Self)

`/=`

operation. Read moresource§### impl DivAssign<&i32> for IVec2

### impl DivAssign<&i32> for IVec2

source§#### fn div_assign(&mut self, rhs: &i32)

#### fn div_assign(&mut self, rhs: &i32)

`/=`

operation. Read moresource§### impl DivAssign<IVec2> for IVec2

### impl DivAssign<IVec2> for IVec2

source§#### fn div_assign(&mut self, rhs: Self)

#### fn div_assign(&mut self, rhs: Self)

`/=`

operation. Read moresource§### impl DivAssign<i32> for IVec2

### impl DivAssign<i32> for IVec2

source§#### fn div_assign(&mut self, rhs: i32)

#### fn div_assign(&mut self, rhs: i32)

`/=`

operation. Read moresource§### impl MulAssign<&IVec2> for IVec2

### impl MulAssign<&IVec2> for IVec2

source§#### fn mul_assign(&mut self, rhs: &Self)

#### fn mul_assign(&mut self, rhs: &Self)

`*=`

operation. Read moresource§### impl MulAssign<&i32> for IVec2

### impl MulAssign<&i32> for IVec2

source§#### fn mul_assign(&mut self, rhs: &i32)

#### fn mul_assign(&mut self, rhs: &i32)

`*=`

operation. Read moresource§### impl MulAssign<IVec2> for IVec2

### impl MulAssign<IVec2> for IVec2

source§#### fn mul_assign(&mut self, rhs: Self)

#### fn mul_assign(&mut self, rhs: Self)

`*=`

operation. Read moresource§### impl MulAssign<i32> for IVec2

### impl MulAssign<i32> for IVec2

source§#### fn mul_assign(&mut self, rhs: i32)

#### fn mul_assign(&mut self, rhs: i32)

`*=`

operation. Read moresource§### impl PartialEq<IVec2> for IVec2

### impl PartialEq<IVec2> for IVec2

source§### impl RemAssign<&IVec2> for IVec2

### impl RemAssign<&IVec2> for IVec2

source§#### fn rem_assign(&mut self, rhs: &Self)

#### fn rem_assign(&mut self, rhs: &Self)

`%=`

operation. Read moresource§### impl RemAssign<&i32> for IVec2

### impl RemAssign<&i32> for IVec2

source§#### fn rem_assign(&mut self, rhs: &i32)

#### fn rem_assign(&mut self, rhs: &i32)

`%=`

operation. Read moresource§### impl RemAssign<IVec2> for IVec2

### impl RemAssign<IVec2> for IVec2

source§#### fn rem_assign(&mut self, rhs: Self)

#### fn rem_assign(&mut self, rhs: Self)

`%=`

operation. Read moresource§### impl RemAssign<i32> for IVec2

### impl RemAssign<i32> for IVec2

source§#### fn rem_assign(&mut self, rhs: i32)

#### fn rem_assign(&mut self, rhs: i32)

`%=`

operation. Read moresource§### impl SubAssign<&IVec2> for IVec2

### impl SubAssign<&IVec2> for IVec2

source§#### fn sub_assign(&mut self, rhs: &Self)

#### fn sub_assign(&mut self, rhs: &Self)

`-=`

operation. Read moresource§### impl SubAssign<&i32> for IVec2

### impl SubAssign<&i32> for IVec2

source§#### fn sub_assign(&mut self, rhs: &i32)

#### fn sub_assign(&mut self, rhs: &i32)

`-=`

operation. Read moresource§### impl SubAssign<IVec2> for IVec2

### impl SubAssign<IVec2> for IVec2

source§#### fn sub_assign(&mut self, rhs: IVec2)

#### fn sub_assign(&mut self, rhs: IVec2)

`-=`

operation. Read moresource§### impl SubAssign<i32> for IVec2

### impl SubAssign<i32> for IVec2

source§#### fn sub_assign(&mut self, rhs: i32)

#### fn sub_assign(&mut self, rhs: i32)

`-=`

operation. Read more