Struct DrawOrder 

pub struct DrawOrder(/* private fields */);

A struct representing the draw order of an entity Higher draw orders will be drawn on top of lower draw orders

Implementations

impl DrawOrder

pub fn new(order: f32) -> DrawOrder

Create a new DrawOrder

Methods from Deref<Target = f32>

pub const RADIX: u32 = 2

pub const BITS: u32 = 32

pub const MANTISSA_DIGITS: u32 = 24

pub const DIGITS: u32 = 6

pub const EPSILON: f32 = 1.19209290e-07_f32

pub const MIN: f32 = -3.40282347e+38_f32

pub const MIN_POSITIVE: f32 = 1.17549435e-38_f32

pub const MAX: f32 = 3.40282347e+38_f32

pub const MIN_EXP: i32 = -125

pub const MAX_EXP: i32 = 128

pub const MIN_10_EXP: i32 = -37

pub const MAX_10_EXP: i32 = 38

pub const NAN: f32

pub const INFINITY: f32

pub const NEG_INFINITY: f32

pub const MAX_EXACT_INTEGER: i32

pub const MIN_EXACT_INTEGER: i32

pub const SIGN_MASK: u32 = 0x8000_0000

pub const EXPONENT_MASK: u32 = 0x7f80_0000

pub const MANTISSA_MASK: u32 = 0x007f_ffff

pub fn total_cmp(&self, other: &f32) -> Ordering

Returns the ordering between self and other.

Unlike the standard partial comparison between floating point numbers, this comparison always produces an ordering in accordance to the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard. The values are ordered in the following sequence:

• negative quiet NaN
• negative signaling NaN
• negative infinity
• negative numbers
• negative subnormal numbers
• negative zero
• positive zero
• positive subnormal numbers
• positive numbers
• positive infinity
• positive signaling NaN
• positive quiet NaN.

The ordering established by this function does not always agree with the PartialOrd and PartialEq implementations of f32. For example, they consider negative and positive zero equal, while total_cmp doesn’t.

The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.

Example

struct GoodBoy {
    name: String,
    weight: f32,
}

let mut bois = vec![
    GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    GoodBoy { name: "Chonk".to_owned(), weight: f32::INFINITY },
    GoodBoy { name: "Abs. Unit".to_owned(), weight: f32::NAN },
    GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];

bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));

// `f32::NAN` could be positive or negative, which will affect the sort order.
if f32::NAN.is_sign_negative() {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([f32::NAN, -5.0, 0.1, 10.0, 99.0, f32::INFINITY].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([-5.0, 0.1, 10.0, 99.0, f32::INFINITY, f32::NAN].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
}

Trait Implementations

impl Add for DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: DrawOrder) -> <DrawOrder as Add>::Output

Performs the + operation.

impl Add<&DrawOrder> for DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: &DrawOrder) -> <DrawOrder as Add<&DrawOrder>>::Output

Performs the + operation.

impl Add<&DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: &DrawOrder) -> <&DrawOrder as Add<&DrawOrder>>::Output

Performs the + operation.

impl Add<&DrawOrder> for f32

type Output = f32

The resulting type after applying the + operator.

fn add(self, rhs: &DrawOrder) -> <f32 as Add<&DrawOrder>>::Output

Performs the + operation.

impl Add<DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: DrawOrder) -> <&DrawOrder as Add<DrawOrder>>::Output

Performs the + operation.

impl Add<DrawOrder> for f32

type Output = f32

The resulting type after applying the + operator.

fn add(self, rhs: DrawOrder) -> <f32 as Add<DrawOrder>>::Output

Performs the + operation.

impl Add<f32> for DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> <DrawOrder as Add<f32>>::Output

Performs the + operation.

impl Add<f32> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> <&DrawOrder as Add<f32>>::Output

Performs the + operation.

impl AddAssign for DrawOrder

fn add_assign(&mut self, rhs: DrawOrder)

Performs the += operation.

impl AddAssign<&DrawOrder> for DrawOrder

fn add_assign(&mut self, rhs: &DrawOrder)

Performs the += operation.

impl AddAssign<&DrawOrder> for f32

fn add_assign(&mut self, rhs: &DrawOrder)

Performs the += operation.

impl AddAssign<DrawOrder> for f32

fn add_assign(&mut self, rhs: DrawOrder)

Performs the += operation.

impl AddAssign<f32> for DrawOrder

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl Clone for DrawOrder

fn clone(&self) -> DrawOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for DrawOrder

where DrawOrder: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_component_hooks(_hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Copy for DrawOrder

impl Debug for DrawOrder

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

Formats the value using the given formatter.

impl Default for DrawOrder

fn default() -> DrawOrder

Returns the “default value” for a type.

impl Deref for DrawOrder

type Target = f32

The resulting type after dereferencing.

fn deref(&self) -> &<DrawOrder as Deref>::Target

Dereferences the value.

impl DerefMut for DrawOrder

fn deref_mut(&mut self) -> &mut <DrawOrder as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for DrawOrder

fn deserialize<__D>( __deserializer: __D, ) -> Result<DrawOrder, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div for DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

fn div(self, rhs: DrawOrder) -> <DrawOrder as Div>::Output

Performs the / operation.

impl Div<&DrawOrder> for DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

fn div(self, rhs: &DrawOrder) -> <DrawOrder as Div<&DrawOrder>>::Output

Performs the / operation.

impl Div<&DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

fn div(self, rhs: &DrawOrder) -> <&DrawOrder as Div<&DrawOrder>>::Output

Performs the / operation.

impl Div<&DrawOrder> for f32

type Output = f32

The resulting type after applying the / operator.

fn div(self, rhs: &DrawOrder) -> <f32 as Div<&DrawOrder>>::Output

Performs the / operation.

impl Div<DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

fn div(self, rhs: DrawOrder) -> <&DrawOrder as Div<DrawOrder>>::Output

Performs the / operation.

impl Div<DrawOrder> for f32

type Output = f32

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <&DrawOrder as Div<f32>>::Output

Performs the / operation.

impl DivAssign for DrawOrder

fn div_assign(&mut self, rhs: DrawOrder)

Performs the /= operation.

impl DivAssign<&DrawOrder> for DrawOrder

fn div_assign(&mut self, rhs: &DrawOrder)

Performs the /= operation.

impl DivAssign<&DrawOrder> for f32

fn div_assign(&mut self, rhs: &DrawOrder)

Performs the /= operation.

impl DivAssign<DrawOrder> for f32

fn div_assign(&mut self, rhs: DrawOrder)

Performs the /= operation.

impl DivAssign<f32> for DrawOrder

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl From<&DrawOrder> for f32

fn from(order: &DrawOrder) -> f32

Converts to this type from the input type.

impl From<DrawOrder> for f32

fn from(order: DrawOrder) -> f32

Converts to this type from the input type.

impl From<f32> for DrawOrder

fn from(order: f32) -> DrawOrder

Converts to this type from the input type.

impl FromReflect for DrawOrder

where DrawOrder: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

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.

impl GetTypeRegistration for DrawOrder

where DrawOrder: Any + Send + Sync, f32: 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.

impl Mul for DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&DrawOrder> for DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

fn mul(self, rhs: &DrawOrder) -> <DrawOrder as Mul<&DrawOrder>>::Output

Performs the * operation.

impl Mul<&DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

fn mul(self, rhs: &DrawOrder) -> <&DrawOrder as Mul<&DrawOrder>>::Output

Performs the * operation.

impl Mul<&DrawOrder> for f32

type Output = f32

The resulting type after applying the * operator.

fn mul(self, rhs: &DrawOrder) -> <f32 as Mul<&DrawOrder>>::Output

Performs the * operation.

impl Mul<DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

fn mul(self, rhs: DrawOrder) -> <&DrawOrder as Mul<DrawOrder>>::Output

Performs the * operation.

impl Mul<DrawOrder> for f32

type Output = f32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <&DrawOrder as Mul<f32>>::Output

Performs the * operation.

impl MulAssign for DrawOrder

fn mul_assign(&mut self, rhs: DrawOrder)

Performs the *= operation.

impl MulAssign<&DrawOrder> for DrawOrder

fn mul_assign(&mut self, rhs: &DrawOrder)

Performs the *= operation.

impl MulAssign<&DrawOrder> for f32

fn mul_assign(&mut self, rhs: &DrawOrder)

Performs the *= operation.

impl MulAssign<DrawOrder> for f32

fn mul_assign(&mut self, rhs: DrawOrder)

Performs the *= operation.

impl MulAssign<f32> for DrawOrder

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl Neg for DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl Neg for &DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn neg(self) -> <&DrawOrder as Neg>::Output

Performs the unary - operation.

impl PartialEq for DrawOrder

fn eq(&self, other: &DrawOrder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for DrawOrder

where DrawOrder: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<DrawOrder>) -> 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<DrawOrder>) -> 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.

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

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

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

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

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

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<DrawOrder>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Applies a reflected value to this value.

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

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

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

Debug formatter for the value.

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

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Rem for DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: DrawOrder) -> <DrawOrder as Rem>::Output

Performs the % operation.

impl Rem<&DrawOrder> for DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: &DrawOrder) -> <DrawOrder as Rem<&DrawOrder>>::Output

Performs the % operation.

impl Rem<&DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: &DrawOrder) -> <&DrawOrder as Rem<&DrawOrder>>::Output

Performs the % operation.

impl Rem<&DrawOrder> for f32

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: &DrawOrder) -> <f32 as Rem<&DrawOrder>>::Output

Performs the % operation.

impl Rem<DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: DrawOrder) -> <&DrawOrder as Rem<DrawOrder>>::Output

Performs the % operation.

impl Rem<DrawOrder> for f32

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: DrawOrder) -> <f32 as Rem<DrawOrder>>::Output

Performs the % operation.

impl Rem<f32> for DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> <DrawOrder as Rem<f32>>::Output

Performs the % operation.

impl Rem<f32> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> <&DrawOrder as Rem<f32>>::Output

Performs the % operation.

impl RemAssign for DrawOrder

fn rem_assign(&mut self, rhs: DrawOrder)

Performs the %= operation.

impl RemAssign<&DrawOrder> for DrawOrder

fn rem_assign(&mut self, rhs: &DrawOrder)

Performs the %= operation.

impl RemAssign<&DrawOrder> for f32

fn rem_assign(&mut self, rhs: &DrawOrder)

Performs the %= operation.

impl RemAssign<DrawOrder> for f32

fn rem_assign(&mut self, rhs: DrawOrder)

Performs the %= operation.

impl RemAssign<f32> for DrawOrder

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl Serialize for DrawOrder

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.

impl StructuralPartialEq for DrawOrder

impl Sub for DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&DrawOrder> for DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn sub(self, rhs: &DrawOrder) -> <DrawOrder as Sub<&DrawOrder>>::Output

Performs the - operation.

impl Sub<&DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn sub(self, rhs: &DrawOrder) -> <&DrawOrder as Sub<&DrawOrder>>::Output

Performs the - operation.

impl Sub<&DrawOrder> for f32

type Output = f32

The resulting type after applying the - operator.

fn sub(self, rhs: &DrawOrder) -> <f32 as Sub<&DrawOrder>>::Output

Performs the - operation.

impl Sub<DrawOrder> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn sub(self, rhs: DrawOrder) -> <&DrawOrder as Sub<DrawOrder>>::Output

Performs the - operation.

impl Sub<DrawOrder> for f32

type Output = f32

The resulting type after applying the - operator.

fn sub(self, rhs: DrawOrder) -> <f32 as Sub<DrawOrder>>::Output

Performs the - operation.

impl Sub<f32> for DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> <DrawOrder as Sub<f32>>::Output

Performs the - operation.

impl Sub<f32> for &DrawOrder

type Output = DrawOrder

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> <&DrawOrder as Sub<f32>>::Output

Performs the - operation.

impl SubAssign for DrawOrder

fn sub_assign(&mut self, rhs: DrawOrder)

Performs the -= operation.

impl SubAssign<&DrawOrder> for DrawOrder

fn sub_assign(&mut self, rhs: &DrawOrder)

Performs the -= operation.

impl SubAssign<&DrawOrder> for f32

fn sub_assign(&mut self, rhs: &DrawOrder)

Performs the -= operation.

impl SubAssign<DrawOrder> for f32

fn sub_assign(&mut self, rhs: DrawOrder)

Performs the -= operation.

impl SubAssign<f32> for DrawOrder

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl TupleStruct for DrawOrder

where DrawOrder: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

fn field(&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_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 field_len(&self) -> usize

Returns the number of fields in the tuple struct.

fn iter_fields(&self) -> TupleStructFieldIter<'_>

Returns an iterator over the values of the tuple struct’s fields.

fn clone_dynamic(&self) -> DynamicTupleStruct

Clones the struct into a DynamicTupleStruct.

impl TypePath for DrawOrder

where DrawOrder: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

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

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for DrawOrder

where DrawOrder: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.