Replace FloatOrd with ordered_float crate

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -32,7 +32,7 @@ use bevy_render::{
     render_resource::CachedRenderPipelineId,
     Extract, RenderApp, RenderStage,
 };
-use bevy_utils::FloatOrd;
+use bevy_utils::OrderedFloat;
 use std::ops::Range;
 
 use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
@@ -104,7 +104,7 @@ impl Plugin for Core2dPlugin {
 }
 
 pub struct Transparent2d {
-    pub sort_key: FloatOrd,
+    pub sort_key: OrderedFloat<f32>,
     pub entity: Entity,
     pub pipeline: CachedRenderPipelineId,
     pub draw_function: DrawFunctionId,
@@ -113,7 +113,7 @@ pub struct Transparent2d {
 }
 
 impl PhaseItem for Transparent2d {
-    type SortKey = FloatOrd;
+    type SortKey = OrderedFloat<f32>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -41,7 +41,7 @@ use bevy_render::{
     view::ViewDepthTexture,
     Extract, RenderApp, RenderStage,
 };
-use bevy_utils::{FloatOrd, HashMap};
+use bevy_utils::{HashMap, OrderedFloat};
 
 use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
 
@@ -122,11 +122,11 @@ pub struct Opaque3d {
 
 impl PhaseItem for Opaque3d {
     // NOTE: Values increase towards the camera. Front-to-back ordering for opaque means we need a descending sort.
-    type SortKey = Reverse<FloatOrd>;
+    type SortKey = Reverse<OrderedFloat<f32>>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {
-        Reverse(FloatOrd(self.distance))
+        Reverse(OrderedFloat(self.distance))
     }
 
     #[inline]
@@ -164,11 +164,11 @@ pub struct AlphaMask3d {
 
 impl PhaseItem for AlphaMask3d {
     // NOTE: Values increase towards the camera. Front-to-back ordering for alpha mask means we need a descending sort.
-    type SortKey = Reverse<FloatOrd>;
+    type SortKey = Reverse<OrderedFloat<f32>>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {
-        Reverse(FloatOrd(self.distance))
+        Reverse(OrderedFloat(self.distance))
     }
 
     #[inline]
@@ -206,11 +206,11 @@ pub struct Transparent3d {
 
 impl PhaseItem for Transparent3d {
     // NOTE: Values increase towards the camera. Back-to-front ordering for transparent means we need an ascending sort.
-    type SortKey = FloatOrd;
+    type SortKey = OrderedFloat<f32>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {
-        FloatOrd(self.distance)
+        OrderedFloat(self.distance)
     }
 
     #[inline]

crates/bevy_pbr/src/render/light.rs

@@ -32,7 +32,7 @@ use bevy_render::{
     Extract,
 };
 use bevy_transform::{components::GlobalTransform, prelude::Transform};
-use bevy_utils::FloatOrd;
+use bevy_utils::OrderedFloat;
 use bevy_utils::{
     tracing::{error, warn},
     HashMap,
@@ -1697,11 +1697,11 @@ pub struct Shadow {
 }
 
 impl PhaseItem for Shadow {
-    type SortKey = FloatOrd;
+    type SortKey = OrderedFloat<f32>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {
-        FloatOrd(self.distance)
+        OrderedFloat(self.distance)
     }
 
     #[inline]

crates/bevy_sprite/src/mesh2d/material.rs

@@ -35,7 +35,7 @@ use bevy_render::{
     Extract, RenderApp, RenderStage,
 };
 use bevy_transform::components::{GlobalTransform, Transform};
-use bevy_utils::{FloatOrd, HashMap, HashSet};
+use bevy_utils::{HashMap, HashSet, OrderedFloat};
 use std::hash::Hash;
 use std::marker::PhantomData;
 
@@ -371,7 +371,7 @@ pub fn queue_material2d_meshes<M: Material2d>(
                             // lowest sort key and getting closer should increase. As we have
                             // -z in front of the camera, the largest distance is -far with values increasing toward the
                             // camera. As such we can just use mesh_z as the distance
-                            sort_key: FloatOrd(mesh_z),
+                            sort_key: OrderedFloat(mesh_z),
                             // This material is not batched
                             batch_range: None,
                         });

crates/bevy_sprite/src/render/mod.rs

@@ -31,8 +31,8 @@ use bevy_render::{
     Extract,
 };
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::FloatOrd;
 use bevy_utils::HashMap;
+use bevy_utils::OrderedFloat;
 use bytemuck::{Pod, Zeroable};
 use fixedbitset::FixedBitSet;
 
@@ -632,7 +632,7 @@ pub fn queue_sprites(
                 });
 
                 // These items will be sorted by depth with other phase items
-                let sort_key = FloatOrd(extracted_sprite.transform.translation().z);
+                let sort_key = OrderedFloat(extracted_sprite.transform.translation().z);
 
                 // Store the vertex data and add the item to the render phase
                 if current_batch.colored {

crates/bevy_text/src/font_atlas_set.rs

@@ -5,10 +5,10 @@ use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
-use bevy_utils::FloatOrd;
 use bevy_utils::HashMap;
+use bevy_utils::OrderedFloat;
 
-type FontSizeKey = FloatOrd;
+type FontSizeKey = OrderedFloat<f32>;
 
 #[derive(TypeUuid)]
 #[uuid = "73ba778b-b6b5-4f45-982d-d21b6b86ace2"]
@@ -41,7 +41,7 @@ impl FontAtlasSet {
 
     pub fn has_glyph(&self, glyph_id: GlyphId, glyph_position: Point, font_size: f32) -> bool {
         self.font_atlases
-            .get(&FloatOrd(font_size))
+            .get(&OrderedFloat(font_size))
             .map_or(false, |font_atlas| {
                 font_atlas
                     .iter()
@@ -61,7 +61,7 @@ impl FontAtlasSet {
         let font_size = glyph.scale.y;
         let font_atlases = self
             .font_atlases
-            .entry(FloatOrd(font_size))
+            .entry(OrderedFloat(font_size))
             .or_insert_with(|| {
                 vec![FontAtlas::new(
                     textures,
@@ -117,7 +117,7 @@ impl FontAtlasSet {
         position: Point,
     ) -> Option<GlyphAtlasInfo> {
         self.font_atlases
-            .get(&FloatOrd(font_size))
+            .get(&OrderedFloat(font_size))
             .and_then(|font_atlases| {
                 font_atlases
                     .iter()

crates/bevy_ui/src/render/mod.rs

@@ -27,8 +27,8 @@ use bevy_render::{
 use bevy_sprite::{SpriteAssetEvents, TextureAtlas};
 use bevy_text::{Text, TextLayoutInfo};
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::FloatOrd;
 use bevy_utils::HashMap;
+use bevy_utils::OrderedFloat;
 use bevy_window::{WindowId, Windows};
 use bytemuck::{Pod, Zeroable};
 use std::ops::Range;
@@ -620,7 +620,7 @@ pub fn queue_uinodes(
                     draw_function: draw_ui_function,
                     pipeline,
                     entity,
-                    sort_key: FloatOrd(batch.z),
+                    sort_key: OrderedFloat(batch.z),
                 });
             }
         }

crates/bevy_ui/src/render/render_pass.rs

@@ -11,7 +11,7 @@ use bevy_render::{
     renderer::*,
     view::*,
 };
-use bevy_utils::FloatOrd;
+use bevy_utils::OrderedFloat;
 
 pub struct UiPassNode {
     ui_view_query: QueryState<
@@ -102,14 +102,14 @@ impl Node for UiPassNode {
 }
 
 pub struct TransparentUi {
-    pub sort_key: FloatOrd,
+    pub sort_key: OrderedFloat<f32>,
     pub entity: Entity,
     pub pipeline: CachedRenderPipelineId,
     pub draw_function: DrawFunctionId,
 }
 
 impl PhaseItem for TransparentUi {
-    type SortKey = FloatOrd;
+    type SortKey = OrderedFloat<f32>;
 
     #[inline]
     fn sort_key(&self) -> Self::SortKey {

crates/bevy_utils/Cargo.toml

@@ -14,6 +14,7 @@ tracing = { version = "0.1", default-features = false, features = ["std"] }
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 uuid = { version = "1.1", features = ["v4", "serde"] }
 hashbrown = { version = "0.12", features = ["serde"] }
+ordered-float = "3.4.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = {version = "0.2.0", features = ["js"]}

crates/bevy_utils/src/lib.rs

@@ -9,13 +9,12 @@ pub use short_names::get_short_name;
 pub mod synccell;
 
 mod default;
-mod float_ord;
 
 pub use ahash::AHasher;
 pub use default::default;
-pub use float_ord::*;
 pub use hashbrown;
 pub use instant::{Duration, Instant};
+pub use ordered_float::*;
 pub use tracing;
 pub use uuid::Uuid;