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

## Expand description

A 2-dimensional vector.

## Fields§

§`x: i16`

§`y: i16`

## Implementations§

source§### impl I16Vec2

### impl I16Vec2

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

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

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: [i16; 2]) -> I16Vec2

#### pub const fn from_array(a: [i16; 2]) -> I16Vec2

Creates a new vector from an array.

source#### pub const fn from_slice(slice: &[i16]) -> I16Vec2

#### pub const fn from_slice(slice: &[i16]) -> I16Vec2

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 [i16])

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

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: i16) -> I16Vec3

#### pub const fn extend(self, z: i16) -> I16Vec3

Creates a 3D vector from `self`

and the given `z`

value.

source#### pub fn with_x(self, x: i16) -> I16Vec2

#### pub fn with_x(self, x: i16) -> I16Vec2

Creates a 2D vector from `self`

with the given value of `x`

.

source#### pub fn with_y(self, y: i16) -> I16Vec2

#### pub fn with_y(self, y: i16) -> I16Vec2

Creates a 2D vector from `self`

with the given value of `y`

.

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

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

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

and `rhs`

.

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

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2, max: I16Vec2) -> I16Vec2

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

Component-wise clamping of values, similar to `i16::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) -> i16

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

Returns the horizontal minimum of `self`

.

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

.

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

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

Returns the horizontal maximum of `self`

.

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

.

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

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

Returns the sum of all elements of `self`

.

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

.

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

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

Returns the product of all elements of `self`

.

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

.

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

#### pub fn cmpeq(self, rhs: I16Vec2) -> 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: I16Vec2) -> BVec2

#### pub fn cmpne(self, rhs: I16Vec2) -> 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: I16Vec2) -> BVec2

#### pub fn cmpge(self, rhs: I16Vec2) -> 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: I16Vec2) -> BVec2

#### pub fn cmpgt(self, rhs: I16Vec2) -> 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: I16Vec2) -> BVec2

#### pub fn cmple(self, rhs: I16Vec2) -> 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: I16Vec2) -> BVec2

#### pub fn cmplt(self, rhs: I16Vec2) -> 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) -> I16Vec2

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

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

.

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

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

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) -> i16

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

Computes the squared length of `self`

.

source#### pub fn distance_squared(self, rhs: I16Vec2) -> i16

#### pub fn distance_squared(self, rhs: I16Vec2) -> i16

Compute the squared euclidean distance between two points in space.

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

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> i16

#### pub fn perp_dot(self, rhs: I16Vec2) -> i16

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: I16Vec2) -> I16Vec2

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

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_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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: I16Vec2) -> I16Vec2

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

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: U16Vec2) -> I16Vec2

#### pub const fn wrapping_add_unsigned(self, rhs: U16Vec2) -> I16Vec2

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: U16Vec2) -> I16Vec2

#### pub const fn wrapping_sub_unsigned(self, rhs: U16Vec2) -> I16Vec2

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: U16Vec2) -> I16Vec2

#### pub const fn saturating_add_unsigned(self, rhs: U16Vec2) -> I16Vec2

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: U16Vec2) -> I16Vec2

#### pub const fn saturating_sub_unsigned(self, rhs: U16Vec2) -> I16Vec2

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<i16> for I16Vec2

### impl AddAssign<i16> for I16Vec2

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

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

`+=`

operation. Read moresource§### impl AddAssign for I16Vec2

### impl AddAssign for I16Vec2

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

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

`+=`

operation. Read moresource§### impl<'de> Deserialize<'de> for I16Vec2

### impl<'de> Deserialize<'de> for I16Vec2

source§#### fn deserialize<D>(
deserializer: D,
) -> Result<I16Vec2, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

#### fn deserialize<D>(
deserializer: D,
) -> Result<I16Vec2, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

source§### impl DivAssign<i16> for I16Vec2

### impl DivAssign<i16> for I16Vec2

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

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

`/=`

operation. Read moresource§### impl DivAssign for I16Vec2

### impl DivAssign for I16Vec2

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

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

`/=`

operation. Read moresource§### impl MulAssign<i16> for I16Vec2

### impl MulAssign<i16> for I16Vec2

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

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

`*=`

operation. Read moresource§### impl MulAssign for I16Vec2

### impl MulAssign for I16Vec2

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

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

`*=`

operation. Read moresource§### impl PartialEq for I16Vec2

### impl PartialEq for I16Vec2

source§### impl RemAssign<i16> for I16Vec2

### impl RemAssign<i16> for I16Vec2

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

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

`%=`

operation. Read moresource§### impl RemAssign for I16Vec2

### impl RemAssign for I16Vec2

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

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

`%=`

operation. Read moresource§### impl Serialize for I16Vec2

### impl Serialize for I16Vec2

source§#### fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

#### fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl SubAssign<i16> for I16Vec2

### impl SubAssign<i16> for I16Vec2

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

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

`-=`

operation. Read moresource§### impl SubAssign for I16Vec2

### impl SubAssign for I16Vec2

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

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

`-=`

operation. Read moresource§### impl Vec2Swizzles for I16Vec2

### impl Vec2Swizzles for I16Vec2

#### type Vec3 = I16Vec3

#### type Vec4 = I16Vec4

#### fn xx(self) -> I16Vec2

#### fn xy(self) -> I16Vec2

#### fn yx(self) -> I16Vec2

#### fn yy(self) -> I16Vec2

#### fn xxx(self) -> I16Vec3

#### fn xxy(self) -> I16Vec3

#### fn xyx(self) -> I16Vec3

#### fn xyy(self) -> I16Vec3

#### fn yxx(self) -> I16Vec3

#### fn yxy(self) -> I16Vec3

#### fn yyx(self) -> I16Vec3

#### fn yyy(self) -> I16Vec3

#### fn xxxx(self) -> I16Vec4

#### fn xxxy(self) -> I16Vec4

#### fn xxyx(self) -> I16Vec4

#### fn xxyy(self) -> I16Vec4

#### fn xyxx(self) -> I16Vec4

#### fn xyxy(self) -> I16Vec4

#### fn xyyx(self) -> I16Vec4

#### fn xyyy(self) -> I16Vec4

#### fn yxxx(self) -> I16Vec4

#### fn yxxy(self) -> I16Vec4

#### fn yxyx(self) -> I16Vec4

#### fn yxyy(self) -> I16Vec4

#### fn yyxx(self) -> I16Vec4

#### fn yyxy(self) -> I16Vec4

#### fn yyyx(self) -> I16Vec4

#### fn yyyy(self) -> I16Vec4

### impl Copy for I16Vec2

### impl Eq for I16Vec2

### impl Pod for I16Vec2

### impl StructuralPartialEq for I16Vec2

## Auto Trait Implementations§

### impl Freeze for I16Vec2

### impl RefUnwindSafe for I16Vec2

### impl Send for I16Vec2

### impl Sync for I16Vec2

### impl Unpin for I16Vec2

### impl UnwindSafe for I16Vec2

## Blanket Implementations§

§### impl<T, U> AsBindGroupShaderType<U> for T

### impl<T, U> AsBindGroupShaderType<U> for T

§#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

`T`

`ShaderType`

for `self`

. When used in `AsBindGroup`

derives, it is safe to assume that all images in `self`

exist.source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

§### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

§#### type Bits = T

#### type Bits = T

`Self`

*must*have the same layout as the specified

`Bits`

except for
the possible invalid bit patterns being checked during
`is_valid_bit_pattern`

.§#### fn is_valid_bit_pattern(_bits: &T) -> bool

#### fn is_valid_bit_pattern(_bits: &T) -> bool

`bits`

as `&Self`

.§### impl<T> Downcast for Twhere
T: Any,

### impl<T> Downcast for Twhere
T: Any,

§#### fn into_any(self: Box<T>) -> Box<dyn Any>

#### fn into_any(self: Box<T>) -> Box<dyn Any>

`Box<dyn Trait>`

(where `Trait: Downcast`

) to `Box<dyn Any>`

. `Box<dyn Any>`

can
then be further `downcast`

into `Box<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

`Rc<Trait>`

(where `Trait: Downcast`

) to `Rc<Any>`

. `Rc<Any>`

can then be
further `downcast`

into `Rc<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn as_any(&self) -> &(dyn Any + 'static)

#### fn as_any(&self) -> &(dyn Any + 'static)

`&Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&Any`

’s vtable from `&Trait`

’s.§#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

`&mut Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&mut Any`

’s vtable from `&mut Trait`

’s.§### impl<T> DowncastSync for T

### impl<T> DowncastSync for T

§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.§### impl<S> FromSample<S> for S

### impl<S> FromSample<S> for S

#### fn from_sample_(s: S) -> S

§### impl<T> FromWorld for Twhere
T: Default,

### impl<T> FromWorld for Twhere
T: Default,

§#### fn from_world(_world: &mut World) -> T

#### fn from_world(_world: &mut World) -> T

`Self`

using data from the given `World`

.§### impl<T> Instrument for T

### impl<T> Instrument for T

§#### fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

#### fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

§#### fn in_current_span(self) -> Instrumented<Self> ⓘ

#### fn in_current_span(self) -> Instrumented<Self> ⓘ

source§### impl<T> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read more§### impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,

### impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,

#### fn into_sample(self) -> T

§### impl<T> NoneValue for Twhere
T: Default,

### impl<T> NoneValue for Twhere
T: Default,

#### type NoneType = T

§#### fn null_value() -> T

#### fn null_value() -> T

§### impl<T> Pointable for T

### impl<T> Pointable for T

source§### impl<R, P> ReadPrimitive<R> for P

### impl<R, P> ReadPrimitive<R> for P

source§#### fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

#### fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

`ReadEndian::read_from_little_endian()`

.