`#[repr(transparent)]pub struct Quat(/* private fields */);`

## Expand description

A quaternion representing an orientation.

This quaternion is intended to be of unit length but may denormalize due to floating point “error creep” which can occur when successive quaternion operations are applied.

SIMD vector types are used for storage on supported platforms.

This type is 16 byte aligned.

## Implementations§

source§### impl Quat

### impl Quat

source#### pub const fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Quat

#### pub const fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Quat

Creates a new rotation quaternion.

This should generally not be called manually unless you know what you are doing.
Use one of the other constructors instead such as `identity`

or `from_axis_angle`

.

`from_xyzw`

is mostly used by unit tests and `serde`

deserialization.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

source#### pub const fn from_array(a: [f32; 4]) -> Quat

#### pub const fn from_array(a: [f32; 4]) -> Quat

Creates a rotation quaternion from an array.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

source#### pub fn from_vec4(v: Vec4) -> Quat

#### pub fn from_vec4(v: Vec4) -> Quat

Creates a new rotation quaternion from a 4D vector.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

source#### pub fn from_slice(slice: &[f32]) -> Quat

#### pub fn from_slice(slice: &[f32]) -> Quat

Creates a rotation quaternion from a slice.

##### Preconditions

##### Panics

Panics if `slice`

length is less than 4.

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

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

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

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

Create a quaternion for a normalized rotation `axis`

and `angle`

(in radians).

The axis must be a unit vector.

##### Panics

Will panic if `axis`

is not normalized when `glam_assert`

is enabled.

source#### pub fn from_scaled_axis(v: Vec3) -> Quat

#### pub fn from_scaled_axis(v: Vec3) -> Quat

Create a quaternion that rotates `v.length()`

radians around `v.normalize()`

.

`from_scaled_axis(Vec3::ZERO)`

results in the identity quaternion.

source#### pub fn from_rotation_x(angle: f32) -> Quat

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

Creates a quaternion from the `angle`

(in radians) around the x axis.

source#### pub fn from_rotation_y(angle: f32) -> Quat

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

Creates a quaternion from the `angle`

(in radians) around the y axis.

source#### pub fn from_rotation_z(angle: f32) -> Quat

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

Creates a quaternion from the `angle`

(in radians) around the z axis.

source#### pub fn from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Quat

#### pub fn from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Quat

Creates a quaternion from the given Euler rotation sequence and the angles (in radians).

source#### pub fn from_mat3a(mat: &Mat3A) -> Quat

#### pub fn from_mat3a(mat: &Mat3A) -> Quat

Creates a quaternion from a 3x3 SIMD aligned rotation matrix.

source#### pub fn from_mat4(mat: &Mat4) -> Quat

#### pub fn from_mat4(mat: &Mat4) -> Quat

Creates a quaternion from a 3x3 rotation matrix inside a homogeneous 4x4 matrix.

source#### pub fn from_rotation_arc(from: Vec3, to: Vec3) -> Quat

#### pub fn from_rotation_arc(from: Vec3, to: Vec3) -> Quat

Gets the minimal rotation for transforming `from`

to `to`

. The rotation is in the
plane spanned by the two vectors. Will rotate at most 180 degrees.

The inputs must be unit vectors.

`from_rotation_arc(from, to) * from ≈ to`

.

For near-singular cases (from≈to and from≈-to) the current implementation
is only accurate to about 0.001 (for `f32`

).

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_rotation_arc_colinear(from: Vec3, to: Vec3) -> Quat

#### pub fn from_rotation_arc_colinear(from: Vec3, to: Vec3) -> Quat

Gets the minimal rotation for transforming `from`

to either `to`

or `-to`

. This means
that the resulting quaternion will rotate `from`

so that it is colinear with `to`

.

The rotation is in the plane spanned by the two vectors. Will rotate at most 90 degrees.

The inputs must be unit vectors.

`to.dot(from_rotation_arc_colinear(from, to) * from).abs() ≈ 1`

.

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_rotation_arc_2d(from: Vec2, to: Vec2) -> Quat

#### pub fn from_rotation_arc_2d(from: Vec2, to: Vec2) -> Quat

Gets the minimal rotation for transforming `from`

to `to`

. The resulting rotation is
around the z axis. Will rotate at most 180 degrees.

The inputs must be unit vectors.

`from_rotation_arc_2d(from, to) * from ≈ to`

.

For near-singular cases (from≈to and from≈-to) the current implementation
is only accurate to about 0.001 (for `f32`

).

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn to_axis_angle(self) -> (Vec3, f32)

#### pub fn to_axis_angle(self) -> (Vec3, f32)

Returns the rotation axis (normalized) and angle (in radians) of `self`

.

source#### pub fn to_scaled_axis(self) -> Vec3

#### pub fn to_scaled_axis(self) -> Vec3

Returns the rotation axis scaled by the rotation in radians.

source#### pub fn to_euler(self, euler: EulerRot) -> (f32, f32, f32)

#### pub fn to_euler(self, euler: EulerRot) -> (f32, f32, f32)

Returns the rotation angles for the given euler rotation sequence.

source#### pub fn conjugate(self) -> Quat

#### pub fn conjugate(self) -> Quat

Returns the quaternion conjugate of `self`

. For a unit quaternion the
conjugate is also the inverse.

source#### pub fn inverse(self) -> Quat

#### pub fn inverse(self) -> Quat

Returns the inverse of a normalized quaternion.

Typically quaternion inverse returns the conjugate of a normalized quaternion.
Because `self`

is assumed to already be unit length this method *does not* normalize
before returning the conjugate.

##### Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

source#### pub fn dot(self, rhs: Quat) -> f32

#### pub fn dot(self, rhs: Quat) -> f32

Computes the dot product of `self`

and `rhs`

. The dot product is
equal to the cosine of the angle between two quaternion rotations.

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

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

Computes the squared length of `self`

.

This is generally faster than `length()`

as it avoids a square
root operation.

source#### pub fn length_recip(self) -> f32

#### pub fn length_recip(self) -> f32

Computes `1.0 / length()`

.

For valid results, `self`

must *not* be of length zero.

source#### pub fn normalize(self) -> Quat

#### pub fn normalize(self) -> Quat

Returns `self`

normalized to length 1.0.

For valid results, `self`

must *not* be of length zero.

Panics

Will panic if `self`

is zero length when `glam_assert`

is enabled.

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

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

.

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

source#### pub fn is_normalized(self) -> bool

#### pub fn is_normalized(self) -> bool

Returns whether `self`

of length `1.0`

or not.

Uses a precision threshold of `1e-6`

.

#### pub fn is_near_identity(self) -> bool

source#### pub fn angle_between(self, rhs: Quat) -> f32

#### pub fn angle_between(self, rhs: Quat) -> f32

Returns the angle (in radians) for the minimal rotation for transforming this quaternion into another.

Both quaternions must be normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

source#### pub fn abs_diff_eq(self, rhs: Quat, max_abs_diff: f32) -> bool

#### pub fn abs_diff_eq(self, rhs: Quat, 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 quaternions 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 lerp(self, end: Quat, s: f32) -> Quat

#### pub fn lerp(self, end: Quat, s: f32) -> Quat

Performs a linear interpolation between `self`

and `rhs`

based on
the value `s`

.

When `s`

is `0.0`

, the result will be equal to `self`

. When `s`

is `1.0`

, the result will be equal to `rhs`

.

##### Panics

Will panic if `self`

or `end`

are not normalized when `glam_assert`

is enabled.

source#### pub fn slerp(self, end: Quat, s: f32) -> Quat

#### pub fn slerp(self, end: Quat, s: f32) -> Quat

Performs a spherical linear interpolation between `self`

and `end`

based on the value `s`

.

When `s`

is `0.0`

, the result will be equal to `self`

. When `s`

is `1.0`

, the result will be equal to `end`

.

##### Panics

Will panic if `self`

or `end`

are not normalized when `glam_assert`

is enabled.

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

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

Multiplies a quaternion and a 3D vector, returning the rotated vector.

##### Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

source#### pub fn mul_quat(self, rhs: Quat) -> Quat

#### pub fn mul_quat(self, rhs: Quat) -> Quat

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_affine3(a: &Affine3A) -> Quat

#### pub fn from_affine3(a: &Affine3A) -> Quat

Creates a quaternion from a 3x3 rotation matrix inside a 3D affine transform.

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

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

Multiplies a quaternion and a 3D vector, returning the rotated vector.

#### pub fn as_f64(self) -> DQuat

## Trait Implementations§

source§### impl Add<Quat> for Quat

### impl Add<Quat> for Quat

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

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

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

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

§### impl FromReflect for Quatwhere
f32: FromReflect + TypePath,

### impl FromReflect for Quatwhere f32: FromReflect + TypePath,

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

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

`Self`

from a reflected value.§### impl GetTypeRegistration for Quatwhere
f32: FromReflect + TypePath,

### impl GetTypeRegistration for Quatwhere f32: FromReflect + TypePath,

source§### impl Mul<Quat> for Quat

### impl Mul<Quat> for Quat

source§#### fn mul(self, rhs: Quat) -> Quat

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

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

source§### impl MulAssign<Quat> for Quat

### impl MulAssign<Quat> for Quat

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

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

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

§### impl Reflect for Quatwhere
f32: FromReflect + TypePath,

### impl Reflect for Quatwhere f32: FromReflect + TypePath,

§#### 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 into_reflect(self: Box<Quat, Global>) -> Box<dyn Reflect, Global>

#### fn into_reflect(self: Box<Quat, Global>) -> Box<dyn Reflect, Global>

§#### 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, Global>

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

`Reflect`

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

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

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

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

§#### 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<Quat, Global>) -> ReflectOwned

#### fn reflect_owned(self: Box<Quat, Global>) -> ReflectOwned

§#### 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 reflect_hash(&self) -> Option<u64>

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

§#### 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 Serialize for Quat

### impl Serialize for Quat

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 Struct for Quatwhere
f32: FromReflect + TypePath,

### impl Struct for Quatwhere f32: FromReflect + TypePath,

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

.§### impl TypePath for Quatwhere
f32: FromReflect + TypePath,

### impl TypePath for Quatwhere f32: FromReflect + TypePath,

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

### impl Copy for Quat

### impl Pod for Quat

## Auto Trait Implementations§

### impl RefUnwindSafe for Quat

### impl Send for Quat

### impl Sync for Quat

### impl Unpin for Quat

### impl UnwindSafe for Quat

## Blanket Implementations§

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

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

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

#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> 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, Global>) -> Box<dyn Any, Global>

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

`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, Global>) -> Rc<dyn Any, Global>

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

`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> 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<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 Twhere
T: Reflect + ?Sized,

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

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

§### 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 Pwhere
R: Read + ReadEndian<P>,
P: Default,

### impl<R, P> ReadPrimitive<R> for Pwhere R: Read + ReadEndian<P>, P: Default,

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

.