# Struct bevy::math::f32::Mat3

``````#[repr(C)]pub struct Mat3 {
pub x_axis: Vec3,
pub y_axis: Vec3,
pub z_axis: Vec3,
}``````
Expand description

A 3x3 column major matrix.

This 3x3 matrix type features convenience methods for creating and using linear and affine transformations. If you are primarily dealing with 2D affine transformations the `Affine2` type is much faster and more space efficient than using a 3x3 matrix.

Linear transformations including 3D rotation and scale can be created using methods such as `Self::from_diagonal()`, `Self::from_quat()`, `Self::from_axis_angle()`, `Self::from_rotation_x()`, `Self::from_rotation_y()`, or `Self::from_rotation_z()`.

The resulting matrices can be use to transform 3D vectors using regular vector multiplication.

Affine transformations including 2D translation, rotation and scale can be created using methods such as `Self::from_translation()`, `Self::from_angle()`, `Self::from_scale()` and `Self::from_scale_angle_translation()`.

The `Self::transform_point2()` and `Self::transform_vector2()` convenience methods are provided for performing affine transforms on 2D vectors and points. These multiply 2D inputs as 3D vectors with an implicit `z` value of `1` for points and `0` for vectors respectively. These methods assume that `Self` contains a valid affine transform.

## Fields§

§`x_axis: Vec3`§`y_axis: Vec3`§`z_axis: Vec3`

## Implementations§

source§

### impl Mat3

source

#### pub const ZERO: Mat3 = _

A 3x3 matrix with all elements set to `0.0`.

source

#### pub const IDENTITY: Mat3 = _

A 3x3 identity matrix, where all diagonal elements are `1`, and all off-diagonal elements are `0`.

source

All NAN:s.

source

#### pub const fn from_cols(x_axis: Vec3, y_axis: Vec3, z_axis: Vec3) -> Mat3

Creates a 3x3 matrix from three column vectors.

source

#### pub const fn from_cols_array(m: &[f32; 9]) -> Mat3

Creates a 3x3 matrix from a `[f32; 9]` array stored in column major order. If your data is stored in row major you will need to `transpose` the returned matrix.

source

#### pub const fn to_cols_array(&self) -> [f32; 9]

Creates a `[f32; 9]` array storing data in column major order. If you require data in row major order `transpose` the matrix first.

source

#### pub const fn from_cols_array_2d(m: &[[f32; 3]; 3]) -> Mat3

Creates a 3x3 matrix from a `[[f32; 3]; 3]` 3D array stored in column major order. If your data is in row major order you will need to `transpose` the returned matrix.

source

#### pub const fn to_cols_array_2d(&self) -> [[f32; 3]; 3]

Creates a `[[f32; 3]; 3]` 3D array storing data in column major order. If you require data in row major order `transpose` the matrix first.

source

#### pub const fn from_diagonal(diagonal: Vec3) -> Mat3

Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0.

source

#### pub fn from_mat4(m: Mat4) -> Mat3

Creates a 3x3 matrix from a 4x4 matrix, discarding the 4th row and column.

source

#### pub fn from_quat(rotation: Quat) -> Mat3

Creates a 3D rotation matrix from the given quaternion.

##### §Panics

Will panic if `rotation` is not normalized when `glam_assert` is enabled.

source

#### pub fn from_axis_angle(axis: Vec3, angle: f32) -> Mat3

Creates a 3D rotation matrix from a normalized rotation `axis` and `angle` (in radians).

##### §Panics

Will panic if `axis` is not normalized when `glam_assert` is enabled.

source

#### pub fn from_euler(order: EulerRot, a: f32, b: f32, c: f32) -> Mat3

Creates a 3D rotation matrix from the given euler rotation sequence and the angles (in radians).

source

#### pub fn from_rotation_x(angle: f32) -> Mat3

Creates a 3D rotation matrix from `angle` (in radians) around the x axis.

source

#### pub fn from_rotation_y(angle: f32) -> Mat3

Creates a 3D rotation matrix from `angle` (in radians) around the y axis.

##### Examples found in repository?
examples/3d/visibility_range.rs (line 249)
```216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
```
``````fn move_camera(
keyboard_input: Res<ButtonInput<KeyCode>>,
mut cameras: Query<&mut Transform, With<Camera3d>>,
) {
let (mut zoom_delta, mut theta_delta) = (0.0, 0.0);

// Process zoom in and out via the keyboard.
if keyboard_input.pressed(KeyCode::KeyW) || keyboard_input.pressed(KeyCode::ArrowUp) {
zoom_delta -= CAMERA_KEYBOARD_ZOOM_SPEED;
} else if keyboard_input.pressed(KeyCode::KeyS) || keyboard_input.pressed(KeyCode::ArrowDown) {
zoom_delta += CAMERA_KEYBOARD_ZOOM_SPEED;
}

// Process left and right pan via the keyboard.
if keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft) {
theta_delta -= CAMERA_KEYBOARD_PAN_SPEED;
} else if keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight) {
theta_delta += CAMERA_KEYBOARD_PAN_SPEED;
}

// Process zoom in and out via the mouse wheel.
zoom_delta -= event.y * CAMERA_MOUSE_MOVEMENT_SPEED;
}

// Update the camera transform.
for transform in cameras.iter_mut() {
let transform = transform.into_inner();

let direction = transform.translation.normalize_or_zero();
let magnitude = transform.translation.length();

let new_direction = Mat3::from_rotation_y(theta_delta) * direction;
let new_magnitude = (magnitude + zoom_delta).max(MIN_ZOOM_DISTANCE);

transform.translation = new_direction * new_magnitude;
transform.look_at(CAMERA_FOCAL_POINT, Vec3::Y);
}
}``````
source

#### pub fn from_rotation_z(angle: f32) -> Mat3

Creates a 3D rotation matrix from `angle` (in radians) around the z axis.

source

#### pub fn from_translation(translation: Vec2) -> Mat3

Creates an affine transformation matrix from the given 2D `translation`.

The resulting matrix can be used to transform 2D points and vectors. See `Self::transform_point2()` and `Self::transform_vector2()`.

source

#### pub fn from_angle(angle: f32) -> Mat3

Creates an affine transformation matrix from the given 2D rotation `angle` (in radians).

The resulting matrix can be used to transform 2D points and vectors. See `Self::transform_point2()` and `Self::transform_vector2()`.

##### Examples found in repository?
examples/math/render_primitives.rs (line 617)
```610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
```
``````fn rotate_primitive_2d_meshes(
mut primitives_2d: Query<
(&mut Transform, &ViewVisibility),
(With<PrimitiveData>, With<MeshDim2>),
>,
time: Res<Time>,
) {
let rotation_2d = Quat::from_mat3(&Mat3::from_angle(time.elapsed_seconds()));
primitives_2d
.iter_mut()
.filter(|(_, vis)| vis.get())
.for_each(|(mut transform, _)| {
transform.rotation = rotation_2d;
});
}``````
source

#### pub fn from_scale_angle_translation( scale: Vec2, angle: f32, translation: Vec2, ) -> Mat3

Creates an affine transformation matrix from the given 2D `scale`, rotation `angle` (in radians) and `translation`.

The resulting matrix can be used to transform 2D points and vectors. See `Self::transform_point2()` and `Self::transform_vector2()`.

source

#### pub fn from_scale(scale: Vec2) -> Mat3

Creates an affine transformation matrix from the given non-uniform 2D `scale`.

The resulting matrix can be used to transform 2D points and vectors. See `Self::transform_point2()` and `Self::transform_vector2()`.

##### §Panics

Will panic if all elements of `scale` are zero when `glam_assert` is enabled.

source

#### pub fn from_mat2(m: Mat2) -> Mat3

Creates an affine transformation matrix from the given 2x2 matrix.

The resulting matrix can be used to transform 2D points and vectors. See `Self::transform_point2()` and `Self::transform_vector2()`.

source

#### pub const fn from_cols_slice(slice: &[f32]) -> Mat3

Creates a 3x3 matrix from the first 9 values in `slice`.

##### §Panics

Panics if `slice` is less than 9 elements long.

source

#### pub fn write_cols_to_slice(self, slice: &mut [f32])

Writes the columns of `self` to the first 9 elements in `slice`.

##### §Panics

Panics if `slice` is less than 9 elements long.

source

#### pub fn col(&self, index: usize) -> Vec3

Returns the matrix column for the given `index`.

##### §Panics

Panics if `index` is greater than 2.

source

#### pub fn col_mut(&mut self, index: usize) -> &mut Vec3

Returns a mutable reference to the matrix column for the given `index`.

##### §Panics

Panics if `index` is greater than 2.

source

#### pub fn row(&self, index: usize) -> Vec3

Returns the matrix row for the given `index`.

##### §Panics

Panics if `index` is greater than 2.

source

#### pub fn is_finite(&self) -> bool

Returns `true` if, and only if, all elements are finite. If any element is either `NaN`, positive or negative infinity, this will return `false`.

source

#### pub fn is_nan(&self) -> bool

Returns `true` if any elements are `NaN`.

source

#### pub fn transpose(&self) -> Mat3

Returns the transpose of `self`.

source

#### pub fn determinant(&self) -> f32

Returns the determinant of `self`.

source

#### pub fn inverse(&self) -> Mat3

Returns the inverse of `self`.

If the matrix is not invertible the returned matrix will be invalid.

##### §Panics

Will panic if the determinant of `self` is zero when `glam_assert` is enabled.

source

#### pub fn transform_point2(&self, rhs: Vec2) -> Vec2

Transforms the given 2D vector as a point.

This is the equivalent of multiplying `rhs` as a 3D vector where `z` is `1`.

This method assumes that `self` contains a valid affine transform.

##### §Panics

Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled.

source

#### pub fn transform_vector2(&self, rhs: Vec2) -> Vec2

Rotates the given 2D vector.

This is the equivalent of multiplying `rhs` as a 3D vector where `z` is `0`.

This method assumes that `self` contains a valid affine transform.

##### §Panics

Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled.

source

#### pub fn mul_vec3(&self, rhs: Vec3) -> Vec3

Transforms a 3D vector.

source

#### pub fn mul_vec3a(&self, rhs: Vec3A) -> Vec3A

Transforms a `Vec3A`.

source

#### pub fn mul_mat3(&self, rhs: &Mat3) -> Mat3

Multiplies two 3x3 matrices.

source

source

#### pub fn sub_mat3(&self, rhs: &Mat3) -> Mat3

Subtracts two 3x3 matrices.

source

#### pub fn mul_scalar(&self, rhs: f32) -> Mat3

Multiplies a 3x3 matrix by a scalar.

source

#### pub fn div_scalar(&self, rhs: f32) -> Mat3

Divides a 3x3 matrix by a scalar.

source

#### pub fn abs_diff_eq(&self, rhs: Mat3, max_abs_diff: f32) -> bool

Returns true if the absolute difference of all elements between `self` and `rhs` is less than or equal to `max_abs_diff`.

This can be used to compare if two matrices contain similar elements. It works best when comparing with a known value. The `max_abs_diff` that should be used used depends on the values being compared against.

For more see comparing floating point numbers.

source

#### pub fn abs(&self) -> Mat3

Takes the absolute value of each element in `self`

source

## Trait Implementations§

source§

§

#### type Output = Mat3

The resulting type after applying the `+` operator.
source§

Performs the `+` operation. Read more
source§

source§

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

Performs the `+=` operation. Read more
source§

### impl AsMut<[f32; 9]> for Mat3

Available on non-`target_arch="spirv"` only.
source§

#### fn as_mut(&mut self) -> &mut [f32; 9]

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

§

source§

### impl AsRef<[f32; 9]> for Mat3

Available on non-`target_arch="spirv"` only.
source§

#### fn as_ref(&self) -> &[f32; 9]

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

§

source§

### impl Clone for Mat3

source§

#### fn clone(&self) -> Mat3

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
§

§

source§

### impl Debug for Mat3

Available on non-`target_arch="spirv"` only.
source§

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

Formats the value using the given formatter. Read more
source§

### impl Default for Mat3

source§

#### fn default() -> Mat3

Returns the “default value” for a type. Read more
source§

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

source§

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

Deserialize this value from the given Serde deserializer. Read more
source§

### impl Display for Mat3

Available on non-`target_arch="spirv"` only.
source§

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

Formats the value using the given formatter. Read more
source§

### impl Div<Mat3> for f32

§

#### type Output = Mat3

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Mat3) -> <f32 as Div<Mat3>>::Output

Performs the `/` operation. Read more
source§

### impl Div<f32> for Mat3

§

#### type Output = Mat3

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: f32) -> <Mat3 as Div<f32>>::Output

Performs the `/` operation. Read more
source§

### impl DivAssign<f32> for Mat3

source§

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

Performs the `/=` operation. Read more
source§

### impl From<Affine2> for Mat3

source§

#### fn from(m: Affine2) -> Mat3

Converts to this type from the input type.
source§

### impl From<Mat3> for Mat3A

source§

#### fn from(m: Mat3) -> Mat3A

Converts to this type from the input type.
source§

### impl From<Mat3A> for Mat3

source§

#### fn from(m: Mat3A) -> Mat3

Converts to this type from the input type.
§

§

§

### impl FromReflect for Mat3where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

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

Constructs a concrete instance of `Self` from a reflected value.
§

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

Attempts to downcast the given value to `Self` using, constructing the value using `from_reflect` if that fails. Read more
§

### impl GetTypeRegistration for Mat3where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

#### fn get_type_registration() -> TypeRegistration

Returns the default `TypeRegistration` for this type.
§

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

Registers other types needed by this type. Read more
source§

### impl Mul<Affine2> for Mat3

§

#### type Output = Mat3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Affine2) -> <Mat3 as Mul<Affine2>>::Output

Performs the `*` operation. Read more
source§

### impl Mul<Mat3> for Affine2

§

#### type Output = Mat3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Mat3) -> <Affine2 as Mul<Mat3>>::Output

Performs the `*` operation. Read more
source§

### impl Mul<Mat3> for f32

§

#### type Output = Mat3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Mat3) -> <f32 as Mul<Mat3>>::Output

Performs the `*` operation. Read more
source§

### impl Mul<Vec3> for Mat3

§

#### type Output = Vec3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Vec3) -> <Mat3 as Mul<Vec3>>::Output

Performs the `*` operation. Read more
source§

### impl Mul<Vec3A> for Mat3

§

#### type Output = Vec3A

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Vec3A) -> Vec3A

Performs the `*` operation. Read more
source§

### impl Mul<f32> for Mat3

§

#### type Output = Mat3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: f32) -> <Mat3 as Mul<f32>>::Output

Performs the `*` operation. Read more
source§

### impl Mul for Mat3

§

#### type Output = Mat3

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Mat3) -> <Mat3 as Mul>::Output

Performs the `*` operation. Read more
source§

### impl MulAssign<f32> for Mat3

source§

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

Performs the `*=` operation. Read more
source§

### impl MulAssign for Mat3

source§

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

Performs the `*=` operation. Read more
source§

### impl Neg for Mat3

§

#### type Output = Mat3

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> <Mat3 as Neg>::Output

Performs the unary `-` operation. Read more
source§

### impl PartialEq for Mat3

source§

#### fn eq(&self, rhs: &Mat3) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

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

### impl<'a> Product<&'a Mat3> for Mat3

source§

#### fn product<I>(iter: I) -> Mat3where I: Iterator<Item = &'a Mat3>,

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

### impl Product for Mat3

source§

#### fn product<I>(iter: I) -> Mat3where I: Iterator<Item = Mat3>,

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

§

§

### impl Reflect for Mat3where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

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

Returns the `TypeInfo` of the type represented by this value. Read more
§

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

Returns the value as a `Box<dyn Any>`.
§

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

Returns the value as a `&dyn Any`.
§

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

Returns the value as a `&mut dyn Any`.
§

#### fn into_reflect(self: Box<Mat3>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.
§

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

Casts this type to a reflected value.
§

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

Casts this type to a mutable reflected value.
§

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

Clones the value as a `Reflect` trait object. Read more
§

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

Performs a type-checked assignment of a reflected value to this value. Read more
§

#### fn try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

Tries to `apply` a reflected value to this value. Read more
§

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

Returns a zero-sized enumeration of “kinds” of type. Read more
§

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

Returns an immutable enumeration of “kinds” of type. Read more
§

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

Returns a mutable enumeration of “kinds” of type. Read more
§

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

Returns an owned enumeration of “kinds” of type. Read more
§

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

Returns a “partial equality” comparison result. Read more
§

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

Debug formatter for the value. Read more
§

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

Applies a reflected value to this value. Read more
§

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

Returns a hash of the value (which includes the type). Read more
§

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

Returns a serializable version of the value. Read more
§

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

Indicates whether or not this type is a dynamic type. Read more
source§

### impl Serialize for Mat3

source§

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

Serialize this value into the given Serde serializer. Read more
§

§

§

§

#### fn min_size() -> NonZero<u64>

Represents the minimum size of `Self` (equivalent to GPUBufferBindingLayout.minBindingSize) Read more
§

#### fn size(&self) -> NonZero<u64>

Returns the size of `Self` at runtime Read more
§

#### fn assert_uniform_compat()

Asserts that `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 Mat3where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

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

Returns a reference to the value of the field named `name` as a `&dyn Reflect`.
§

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

Returns a mutable reference to the value of the field named `name` as a `&mut dyn Reflect`.
§

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

Returns a reference to the value of the field with index `index` as a `&dyn Reflect`.
§

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

Returns a mutable reference to the value of the field with index `index` as a `&mut dyn Reflect`.
§

#### fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index `index`.
§

#### fn field_len(&self) -> usize

Returns the number of fields in the struct.
§

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

Returns an iterator over the values of the reflectable fields for this struct.
§

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

Clones the struct into a `DynamicStruct`.
source§

### impl Sub for Mat3

§

#### type Output = Mat3

The resulting type after applying the `-` operator.
source§

#### fn sub(self, rhs: Mat3) -> <Mat3 as Sub>::Output

Performs the `-` operation. Read more
source§

### impl SubAssign for Mat3

source§

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

Performs the `-=` operation. Read more
source§

### impl<'a> Sum<&'a Mat3> for Mat3

source§

#### fn sum<I>(iter: I) -> Mat3where I: Iterator<Item = &'a Mat3>,

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

### impl Sum for Mat3

source§

#### fn sum<I>(iter: I) -> Mat3where I: Iterator<Item = Mat3>,

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

### impl TypePath for Mat3where Mat3: Any + Send + Sync,

§

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

Returns the fully qualified path of the underlying type. Read more
§

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

Returns a short, pretty-print enabled path to the type. Read more
§

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

Returns the name of the type, or `None` if it is anonymous. Read more
§

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

Returns the name of the crate the type is in, or `None` if it is anonymous. Read more
§

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

Returns the path to the module the type is in, or `None` if it is anonymous. Read more
§

### impl Typed for Mat3where Mat3: Any + Send + Sync, Vec3: FromReflect + TypePath + RegisterForReflection,

§

#### fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
§

§

source§

§

source§

source§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,

§

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

Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist.
source§

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

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
§

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

§

#### 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

If this function returns true, then it must be valid to reinterpret `bits` as `&Self`.
source§

### impl<T> CloneToUninit for Twhere T: Clone,

source§

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dst`. Read more
source§

### impl<T> CloneToUninit for Twhere T: Copy,

source§

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dst`. Read more
§

§

§

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

§

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

Convert `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>

Convert `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)

Convert `&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)

Convert `&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 Twhere T: Any + Send + Sync,

§

#### fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`.
§

§

§

§

§

§

source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

§

§

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

§

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

Creates `Self` using data from the given `World`.
§

### impl<S> GetField for Swhere S: Struct,

§

#### fn get_field<T>(&self, name: &str) -> Option<&T>where T: Reflect,

Returns a reference to the value of the field named `name`, downcast to `T`.
§

#### fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>where T: Reflect,

Returns a mutable reference to the value of the field named `name`, downcast to `T`.
§

### impl<T> GetPath for Twhere T: Reflect + ?Sized,

§

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

Returns a reference to the value specified by `path`. Read more
§

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

Returns a mutable reference to the value specified by `path`. Read more
§

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

Returns a statically typed reference to the value specified by `path`. Read more
§

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

Returns a statically typed mutable reference to the value specified by `path`. Read more
§

### impl<T> Instrument for T

§

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

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

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

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> IntoEither for T

source§

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

Converts `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 more
source§

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

Converts `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<T> NoneValue for Twhere T: Default,

§

§

#### fn null_value() -> T

The none-equivalent value.
§

### impl<T> Pointable for T

§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_little_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_big_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_native_endian()`.
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

source§

source§

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

§

§

§

source§

### impl<T> ToString for Twhere T: Display + ?Sized,

source§

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

§

§

§

§

§

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

§

source§

§

§

§

§

§

§

§