```
#[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 select(mask: BVec2, if_true: IVec2, if_false: IVec2) -> IVec2

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

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]) -> IVec2

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

Creates a new vector from an array.

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

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

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

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

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

and `rhs`

.

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

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

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

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

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

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

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: IVec2) -> BVec2

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

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

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

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

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

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

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

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

.

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

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

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: IVec2) -> i32

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

Compute the squared euclidean distance between two points in space.

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

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

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

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

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: IVec2) -> i32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<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 for IVec2

### impl AddAssign for IVec2

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

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

`+=`

operation. Read more§### impl AsMutVectorParts<i32, 2> for IVec2

### impl AsMutVectorParts<i32, 2> for IVec2

#### fn as_mut_parts(&mut self) -> &mut [i32; 2]

§### impl AsRefVectorParts<i32, 2> for IVec2

### impl AsRefVectorParts<i32, 2> for IVec2

#### fn as_ref_parts(&self) -> &[i32; 2]

§### impl CreateFrom for IVec2

### impl CreateFrom for IVec2

#### fn create_from<B>(reader: &mut Reader<B>) -> IVec2where
B: BufferRef,

source§### impl<'de> Deserialize<'de> for IVec2

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

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

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

source§### 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 for IVec2

### impl DivAssign for IVec2

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

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

`/=`

operation. Read more§### impl FromReflect for IVec2

### impl FromReflect for IVec2

§#### fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<IVec2>

#### fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<IVec2>

`Self`

from a reflected value.§#### fn take_from_reflect(
reflect: Box<dyn Reflect>,
) -> Result<Self, Box<dyn Reflect>>

#### fn take_from_reflect( reflect: Box<dyn Reflect>, ) -> Result<Self, Box<dyn Reflect>>

`Self`

using,
constructing the value using `from_reflect`

if that fails. Read more§### impl FromVectorParts<i32, 2> for IVec2

### impl FromVectorParts<i32, 2> for IVec2

#### fn from_parts(parts: [i32; 2]) -> IVec2

§### impl GetTypeRegistration for IVec2

### impl GetTypeRegistration for IVec2

§#### fn get_type_registration() -> TypeRegistration

#### fn get_type_registration() -> TypeRegistration

`TypeRegistration`

for this type.§#### fn register_type_dependencies(registry: &mut TypeRegistry)

#### fn register_type_dependencies(registry: &mut TypeRegistry)

source§### 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 for IVec2

### impl MulAssign for IVec2

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

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

`*=`

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

### impl PartialEq for IVec2

§### impl Reflect for IVec2

### impl Reflect for IVec2

§#### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

#### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

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

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

`&mut dyn Any`

.§#### fn as_reflect(&self) -> &(dyn Reflect + 'static)

#### fn as_reflect(&self) -> &(dyn Reflect + 'static)

§#### fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

#### fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§#### fn clone_value(&self) -> Box<dyn Reflect>

#### fn clone_value(&self) -> Box<dyn Reflect>

`Reflect`

trait object. Read more§#### fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

#### fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§#### fn reflect_kind(&self) -> ReflectKind

#### fn reflect_kind(&self) -> ReflectKind

§#### fn reflect_ref(&self) -> ReflectRef<'_>

#### fn reflect_ref(&self) -> ReflectRef<'_>

§#### fn reflect_mut(&mut self) -> ReflectMut<'_>

#### fn reflect_mut(&mut self) -> ReflectMut<'_>

§#### fn reflect_owned(self: Box<IVec2>) -> ReflectOwned

#### fn reflect_owned(self: Box<IVec2>) -> ReflectOwned

§#### fn reflect_hash(&self) -> Option<u64>

#### fn reflect_hash(&self) -> Option<u64>

§#### fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

#### fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§#### fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

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

§#### fn apply(&mut self, value: &(dyn Reflect + 'static))

#### fn apply(&mut self, value: &(dyn Reflect + 'static))

§#### fn serializable(&self) -> Option<Serializable<'_>>

#### fn serializable(&self) -> Option<Serializable<'_>>

§#### fn is_dynamic(&self) -> bool

#### fn is_dynamic(&self) -> bool

*dynamic*type. Read more

source§### 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 for IVec2

### impl RemAssign for IVec2

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

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

`%=`

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

### impl Serialize for IVec2

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,

§### impl ShaderSize for IVec2where
i32: ShaderSize,

### impl ShaderSize for IVec2where
i32: ShaderSize,

§#### const SHADER_SIZE: NonZero<u64> = _

#### const SHADER_SIZE: NonZero<u64> = _

`ShaderType::min_size`

)§### impl ShaderType for IVec2where
i32: ShaderSize,

### impl ShaderType for IVec2where
i32: ShaderSize,

§#### fn assert_uniform_compat()

#### fn assert_uniform_compat()

`Self`

meets the requirements of the
uniform address space restrictions on stored values and the
uniform address space layout constraints Read more§### impl Struct for IVec2

### impl Struct for IVec2

§#### fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

#### fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

`name`

as a `&dyn Reflect`

.§#### fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

#### fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

`name`

as a
`&mut dyn Reflect`

.§#### fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

#### fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

`index`

as a
`&dyn Reflect`

.§#### fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

#### fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

`index`

as a `&mut dyn Reflect`

.§#### fn iter_fields(&self) -> FieldIter<'_> ⓘ

#### fn iter_fields(&self) -> FieldIter<'_> ⓘ

§#### fn clone_dynamic(&self) -> DynamicStruct

#### fn clone_dynamic(&self) -> DynamicStruct

`DynamicStruct`

.source§### 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 for IVec2

### impl SubAssign for IVec2

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

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

`-=`

operation. Read more§### impl TypePath for IVec2

### impl TypePath for IVec2

§#### fn short_type_path() -> &'static str

#### fn short_type_path() -> &'static str

§#### fn type_ident() -> Option<&'static str>

#### fn type_ident() -> Option<&'static str>

§#### fn crate_name() -> Option<&'static str>

#### fn crate_name() -> Option<&'static str>

source§### impl Vec2Swizzles for IVec2

### impl Vec2Swizzles for IVec2

#### type Vec3 = IVec3

#### type Vec4 = IVec4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### impl Copy for IVec2

### impl Eq for IVec2

### impl Pod for IVec2

### impl StructuralPartialEq for IVec2

## Auto Trait Implementations§

### impl Freeze for IVec2

### impl RefUnwindSafe for IVec2

### impl Send for IVec2

### impl Sync for IVec2

### impl Unpin for IVec2

### impl UnwindSafe for IVec2

## 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<T> DynamicTypePath for Twhere
T: TypePath,

### impl<T> DynamicTypePath for Twhere
T: TypePath,

§#### fn reflect_type_path(&self) -> &str

#### fn reflect_type_path(&self) -> &str

`TypePath::type_path`

.§#### fn reflect_short_type_path(&self) -> &str

#### fn reflect_short_type_path(&self) -> &str

§#### fn reflect_type_ident(&self) -> Option<&str>

#### fn reflect_type_ident(&self) -> Option<&str>

`TypePath::type_ident`

.§#### fn reflect_crate_name(&self) -> Option<&str>

#### fn reflect_crate_name(&self) -> Option<&str>

`TypePath::crate_name`

.§#### fn reflect_module_path(&self) -> Option<&str>

#### fn reflect_module_path(&self) -> Option<&str>

§### 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> GetPath for T

### impl<T> GetPath for T

§#### fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>

#### fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>

`path`

. Read more§#### fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>

#### fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>

`path`

. Read more§#### fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,

#### fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,

`path`

. Read more§#### fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,

#### fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,

`path`

. Read more§### 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()`

.