From 3a09af915c7d37d7cf667bcddf8bc83273029e9d Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 17 Feb 2023 19:49:53 +0000
Subject: [PATCH 01/38] changes: * Added a new trait `MeasureNode`. * Added new
 structs `ImageMeasure` and `BasicMeasure` that implement `MeasureNode`. * Add
 a field to `CalculatedSize` called `measure` that takes a boxed
 `MeasureNode`. * `upsert_leaf` uses the `measure` of `CalculatedSize` to
 create a `MeasureFunc` for the node.

---
 crates/bevy_ui/src/flex/mod.rs     | 45 +++++++++++++-----------------
 crates/bevy_ui/src/lib.rs          |  5 ++--
 crates/bevy_ui/src/measurement.rs  | 29 +++++++++++++++++++
 crates/bevy_ui/src/node_bundles.rs |  4 +--
 crates/bevy_ui/src/ui_node.rs      | 22 +++++++--------
 crates/bevy_ui/src/widget/image.rs | 38 +++++++++++++++++++++++--
 crates/bevy_ui/src/widget/text.rs  |  5 +++-
 7 files changed, 104 insertions(+), 44 deletions(-)
 create mode 100644 crates/bevy_ui/src/measurement.rs

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index d48d6a0f3b5b9..341b58220edf9 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -79,37 +79,30 @@ impl FlexSurface {
         &mut self,
         entity: Entity,
         style: &Style,
-        calculated_size: CalculatedSize,
+        calculated_size: &CalculatedSize,
         scale_factor: f64,
     ) {
         let taffy = &mut self.taffy;
         let taffy_style = convert::from_style(scale_factor, style);
+        let  m = calculated_size.measure.box_clone();
         let measure = taffy::node::MeasureFunc::Boxed(Box::new(
-            move |constraints: Size<Option<f32>>, _available: Size<AvailableSpace>| {
-                let mut size = Size {
-                    width: (scale_factor * calculated_size.size.x as f64) as f32,
-                    height: (scale_factor * calculated_size.size.y as f64) as f32,
-                };
-                match (constraints.width, constraints.height) {
-                    (None, None) => {}
-                    (Some(width), None) => {
-                        if calculated_size.preserve_aspect_ratio {
-                            size.height = width * size.height / size.width;
-                        }
-                        size.width = width;
-                    }
-                    (None, Some(height)) => {
-                        if calculated_size.preserve_aspect_ratio {
-                            size.width = height * size.width / size.height;
-                        }
-                        size.height = height;
-                    }
-                    (Some(width), Some(height)) => {
-                        size.width = width;
-                        size.height = height;
+            move |constraints: Size<Option<f32>>, available_space: Size<AvailableSpace>| {
+                let size = m.measure(
+                    constraints.width.map(|w| (w as f64 / scale_factor) as f32),
+                    constraints.height.map(|h| (h as f64 / scale_factor) as f32),
+                    match available_space.width {
+                        AvailableSpace::Definite(w) => AvailableSpace::Definite((w as f64 / scale_factor as f64) as f32),
+                        s => s,
+                    },
+                    match available_space.height {
+                        AvailableSpace::Definite(h) => AvailableSpace::Definite((h as f64 / scale_factor as f64) as f32),
+                        s => s,
                     }
+                );
+                taffy::geometry::Size {
+                    width: (size.x as f64 * scale_factor) as f32,
+                    height: (size.y as f64 * scale_factor) as f32,
                 }
-                size
             },
         ));
         if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
@@ -266,7 +259,7 @@ pub fn flex_node_system(
         for (entity, style, calculated_size) in &query {
             // TODO: remove node from old hierarchy if its root has changed
             if let Some(calculated_size) = calculated_size {
-                flex_surface.upsert_leaf(entity, style, *calculated_size, scaling_factor);
+                flex_surface.upsert_leaf(entity, style, calculated_size, scaling_factor);
             } else {
                 flex_surface.upsert_node(entity, style, scaling_factor);
             }
@@ -281,7 +274,7 @@ pub fn flex_node_system(
     }
 
     for (entity, style, calculated_size) in &changed_size_query {
-        flex_surface.upsert_leaf(entity, style, *calculated_size, scale_factor);
+        flex_surface.upsert_leaf(entity, style, calculated_size, scale_factor);
     }
 
     // clean up removed nodes
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 8ea3b454108d8..e0aee0c79d39c 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -13,6 +13,7 @@ pub mod camera_config;
 pub mod node_bundles;
 pub mod update;
 pub mod widget;
+pub mod measurement;
 
 use bevy_render::{camera::CameraUpdateSystem, extract_component::ExtractComponentPlugin};
 pub use flex::*;
@@ -20,13 +21,14 @@ pub use focus::*;
 pub use geometry::*;
 pub use render::*;
 pub use ui_node::*;
+pub use measurement::*;
 
 #[doc(hidden)]
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, Interaction,
-        UiScale,
+        UiScale, measurement::*
     };
 }
 
@@ -80,7 +82,6 @@ impl Plugin for UiPlugin {
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
-            .register_type::<CalculatedSize>()
             .register_type::<Direction>()
             .register_type::<Display>()
             .register_type::<FlexDirection>()
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
new file mode 100644
index 0000000000000..b45ed7a6de647
--- /dev/null
+++ b/crates/bevy_ui/src/measurement.rs
@@ -0,0 +1,29 @@
+use bevy_math::Vec2;
+pub use taffy::layout::AvailableSpace;
+
+pub trait MeasureNode: Send + Sync + 'static {
+    /// Calculate the size of the node given the constraints.
+    fn measure(&self, max_width: Option<f32>, max_height: Option<f32>, available_width: AvailableSpace, available_height: AvailableSpace) -> Vec2;
+    /// Clone and box self.
+    fn box_clone(&self) -> Box<dyn MeasureNode>;
+}
+
+#[derive(Clone)]
+pub struct BasicMeasure {
+    /// Prefered size
+    pub size: Vec2,
+}
+
+impl MeasureNode for BasicMeasure {
+    fn measure(&self, width: Option<f32>, height: Option<f32>, _: AvailableSpace, _: AvailableSpace) -> Vec2 {
+        match (width, height) {
+            (Some(width), Some(height)) => Vec2::new(width, height),
+            (Some(width), None) => Vec2::new(width, self.size.y),
+            (None, Some(height)) => Vec2::new(self.size.x, height),
+            (None, None) => self.size,
+        }
+    }
+    fn box_clone(&self) -> Box<dyn MeasureNode> {
+        Box::new(self.clone())
+    }
+}
\ No newline at end of file
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 8369b33bfe0b0..4e00fc07b2dd8 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -61,7 +61,7 @@ impl Default for NodeBundle {
 }
 
 /// A UI node that is an image
-#[derive(Bundle, Clone, Debug, Default)]
+#[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Describes the size of the node
     pub node: Node,
@@ -96,7 +96,7 @@ pub struct ImageBundle {
 }
 
 /// A UI node that is text
-#[derive(Bundle, Clone, Debug, Default)]
+#[derive(Bundle, Debug, Default)]
 pub struct TextBundle {
     /// Describes the size of the node
     pub node: Node,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 588cb141d3f38..23c1f5c9b8d7d 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,4 +1,4 @@
-use crate::{Size, UiRect};
+use crate::{Size, UiRect, MeasureNode, BasicMeasure};
 use bevy_asset::Handle;
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
@@ -562,25 +562,25 @@ impl Default for FlexWrap {
 }
 
 /// The calculated size of the node
-#[derive(Component, Copy, Clone, Debug, Reflect)]
-#[reflect(Component)]
+#[derive(Component)]
 pub struct CalculatedSize {
     /// The size of the node in logical pixels
     pub size: Vec2,
-    /// Whether to attempt to preserve the aspect ratio when determining the layout for this item
-    pub preserve_aspect_ratio: bool,
+    /// The measure function used to calculate the size
+    pub measure: Box<dyn MeasureNode + 'static + Send + Sync>
+
 }
 
-impl CalculatedSize {
-    const DEFAULT: Self = Self {
-        size: Vec2::ZERO,
-        preserve_aspect_ratio: false,
-    };
+impl std::fmt::Debug for CalculatedSize {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CalculatedSize")
+            .finish()
+    }
 }
 
 impl Default for CalculatedSize {
     fn default() -> Self {
-        Self::DEFAULT
+        Self { size: Default::default(), measure: Box::new(BasicMeasure { size: Default::default() }) }
     }
 }
 
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 232be96eb4047..f59adaa7875be 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, UiImage};
+use crate::{CalculatedSize, UiImage, MeasureNode};
 use bevy_asset::Assets;
 use bevy_ecs::{
     query::Without,
@@ -7,6 +7,40 @@ use bevy_ecs::{
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
 use bevy_text::Text;
+use taffy::prelude::AvailableSpace;
+
+#[derive(Clone)] 
+pub struct ImageMeasure {
+    size: Vec2,
+}
+
+impl MeasureNode for ImageMeasure {
+    fn measure(&self, width: Option<f32>, height: Option<f32>, _: AvailableSpace, _: AvailableSpace) -> Vec2 {
+        let mut size = self.size;
+        match (width, height) {
+            (None, None) => {}
+            (Some(width), None) => {          
+                size.y = width * size.y / size.x;
+                size.x = width;  
+
+            }
+            (None, Some(height)) => {
+                size.x = height * size.x / size.y;
+                size.y = height;
+            }
+            (Some(width), Some(height)) => {
+                size.x = width;
+                size.y = height;
+            }
+        }
+        size
+    }
+
+    fn box_clone(&self) -> Box<dyn MeasureNode> {
+        Box::new(self.clone())
+    }
+}
+
 
 /// Updates calculated size of the node based on the image provided
 pub fn update_image_calculated_size_system(
@@ -22,7 +56,7 @@ pub fn update_image_calculated_size_system(
             // Update only if size has changed to avoid needless layout calculations
             if size != calculated_size.size {
                 calculated_size.size = size;
-                calculated_size.preserve_aspect_ratio = true;
+                calculated_size.measure = Box::new(ImageMeasure { size });
             }
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index a4464701fdcee..ad9bcbedd547a 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Node, Style, UiScale, Val};
+use crate::{CalculatedSize, Node, Style, UiScale, Val, MeasureNode, BasicMeasure};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
@@ -139,6 +139,9 @@ pub fn text_system(
                         scale_value(info.size.x, inv_scale_factor),
                         scale_value(info.size.y, inv_scale_factor),
                     );
+                    calculated_size.measure = Box::new(BasicMeasure {
+                        size: calculated_size.size,
+                    });
                     match text_layout_info {
                         Some(mut t) => *t = info,
                         None => {

From b1712b8a9629044ab39719364f88a1bddd0b6426 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 17 Feb 2023 20:08:14 +0000
Subject: [PATCH 02/38] cargo fmt

---
 crates/bevy_ui/src/flex/mod.rs     | 12 ++++++++----
 crates/bevy_ui/src/lib.rs          |  8 ++++----
 crates/bevy_ui/src/measurement.rs  | 19 ++++++++++++++++---
 crates/bevy_ui/src/ui_node.rs      | 15 +++++++++------
 crates/bevy_ui/src/widget/image.rs | 18 +++++++++++-------
 crates/bevy_ui/src/widget/text.rs  |  2 +-
 6 files changed, 49 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 341b58220edf9..c4810de62adc0 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -84,20 +84,24 @@ impl FlexSurface {
     ) {
         let taffy = &mut self.taffy;
         let taffy_style = convert::from_style(scale_factor, style);
-        let  m = calculated_size.measure.box_clone();
+        let m = calculated_size.measure.box_clone();
         let measure = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, available_space: Size<AvailableSpace>| {
                 let size = m.measure(
                     constraints.width.map(|w| (w as f64 / scale_factor) as f32),
                     constraints.height.map(|h| (h as f64 / scale_factor) as f32),
                     match available_space.width {
-                        AvailableSpace::Definite(w) => AvailableSpace::Definite((w as f64 / scale_factor as f64) as f32),
+                        AvailableSpace::Definite(w) => {
+                            AvailableSpace::Definite((w as f64 / scale_factor as f64) as f32)
+                        }
                         s => s,
                     },
                     match available_space.height {
-                        AvailableSpace::Definite(h) => AvailableSpace::Definite((h as f64 / scale_factor as f64) as f32),
+                        AvailableSpace::Definite(h) => {
+                            AvailableSpace::Definite((h as f64 / scale_factor as f64) as f32)
+                        }
                         s => s,
-                    }
+                    },
                 );
                 taffy::geometry::Size {
                     width: (size.x as f64 * scale_factor) as f32,
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index e0aee0c79d39c..1be2bdf49e14a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -10,25 +10,25 @@ mod stack;
 mod ui_node;
 
 pub mod camera_config;
+pub mod measurement;
 pub mod node_bundles;
 pub mod update;
 pub mod widget;
-pub mod measurement;
 
 use bevy_render::{camera::CameraUpdateSystem, extract_component::ExtractComponentPlugin};
 pub use flex::*;
 pub use focus::*;
 pub use geometry::*;
+pub use measurement::*;
 pub use render::*;
 pub use ui_node::*;
-pub use measurement::*;
 
 #[doc(hidden)]
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, Interaction,
-        UiScale, measurement::*
+        camera_config::*, geometry::*, measurement::*, node_bundles::*, ui_node::*, widget::Button,
+        Interaction, UiScale,
     };
 }
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index b45ed7a6de647..e93602d064197 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -3,7 +3,13 @@ pub use taffy::layout::AvailableSpace;
 
 pub trait MeasureNode: Send + Sync + 'static {
     /// Calculate the size of the node given the constraints.
-    fn measure(&self, max_width: Option<f32>, max_height: Option<f32>, available_width: AvailableSpace, available_height: AvailableSpace) -> Vec2;
+    fn measure(
+        &self,
+        max_width: Option<f32>,
+        max_height: Option<f32>,
+        available_width: AvailableSpace,
+        available_height: AvailableSpace,
+    ) -> Vec2;
     /// Clone and box self.
     fn box_clone(&self) -> Box<dyn MeasureNode>;
 }
@@ -15,7 +21,13 @@ pub struct BasicMeasure {
 }
 
 impl MeasureNode for BasicMeasure {
-    fn measure(&self, width: Option<f32>, height: Option<f32>, _: AvailableSpace, _: AvailableSpace) -> Vec2 {
+    fn measure(
+        &self,
+        width: Option<f32>,
+        height: Option<f32>,
+        _: AvailableSpace,
+        _: AvailableSpace,
+    ) -> Vec2 {
         match (width, height) {
             (Some(width), Some(height)) => Vec2::new(width, height),
             (Some(width), None) => Vec2::new(width, self.size.y),
@@ -23,7 +35,8 @@ impl MeasureNode for BasicMeasure {
             (None, None) => self.size,
         }
     }
+
     fn box_clone(&self) -> Box<dyn MeasureNode> {
         Box::new(self.clone())
     }
-}
\ No newline at end of file
+}
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 23c1f5c9b8d7d..43dd1568f5a88 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,4 +1,4 @@
-use crate::{Size, UiRect, MeasureNode, BasicMeasure};
+use crate::{BasicMeasure, MeasureNode, Size, UiRect};
 use bevy_asset::Handle;
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
@@ -567,20 +567,23 @@ pub struct CalculatedSize {
     /// The size of the node in logical pixels
     pub size: Vec2,
     /// The measure function used to calculate the size
-    pub measure: Box<dyn MeasureNode + 'static + Send + Sync>
-
+    pub measure: Box<dyn MeasureNode + 'static + Send + Sync>,
 }
 
 impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CalculatedSize")
-            .finish()
+        f.debug_struct("CalculatedSize").finish()
     }
 }
 
 impl Default for CalculatedSize {
     fn default() -> Self {
-        Self { size: Default::default(), measure: Box::new(BasicMeasure { size: Default::default() }) }
+        Self {
+            size: Default::default(),
+            measure: Box::new(BasicMeasure {
+                size: Default::default(),
+            }),
+        }
     }
 }
 
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index f59adaa7875be..f3f1b6a68732e 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, UiImage, MeasureNode};
+use crate::{CalculatedSize, MeasureNode, UiImage};
 use bevy_asset::Assets;
 use bevy_ecs::{
     query::Without,
@@ -9,20 +9,25 @@ use bevy_render::texture::Image;
 use bevy_text::Text;
 use taffy::prelude::AvailableSpace;
 
-#[derive(Clone)] 
+#[derive(Clone)]
 pub struct ImageMeasure {
     size: Vec2,
 }
 
 impl MeasureNode for ImageMeasure {
-    fn measure(&self, width: Option<f32>, height: Option<f32>, _: AvailableSpace, _: AvailableSpace) -> Vec2 {
+    fn measure(
+        &self,
+        width: Option<f32>,
+        height: Option<f32>,
+        _: AvailableSpace,
+        _: AvailableSpace,
+    ) -> Vec2 {
         let mut size = self.size;
         match (width, height) {
             (None, None) => {}
-            (Some(width), None) => {          
+            (Some(width), None) => {
                 size.y = width * size.y / size.x;
-                size.x = width;  
-
+                size.x = width;
             }
             (None, Some(height)) => {
                 size.x = height * size.x / size.y;
@@ -41,7 +46,6 @@ impl MeasureNode for ImageMeasure {
     }
 }
 
-
 /// Updates calculated size of the node based on the image provided
 pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index ad9bcbedd547a..7926773636672 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Node, Style, UiScale, Val, MeasureNode, BasicMeasure};
+use crate::{BasicMeasure, CalculatedSize, MeasureNode, Node, Style, UiScale, Val};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,

From 080aae75a20e9b94332c51f1f3c1df7c9162b249 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 17 Feb 2023 22:18:00 +0000
Subject: [PATCH 03/38] fix lints

---
 crates/bevy_ui/src/flex/mod.rs    | 4 ++--
 crates/bevy_ui/src/measurement.rs | 1 +
 crates/bevy_ui/src/widget/text.rs | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index c4810de62adc0..50726fa87f413 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -92,13 +92,13 @@ impl FlexSurface {
                     constraints.height.map(|h| (h as f64 / scale_factor) as f32),
                     match available_space.width {
                         AvailableSpace::Definite(w) => {
-                            AvailableSpace::Definite((w as f64 / scale_factor as f64) as f32)
+                            AvailableSpace::Definite((w as f64 / scale_factor) as f32)
                         }
                         s => s,
                     },
                     match available_space.height {
                         AvailableSpace::Definite(h) => {
-                            AvailableSpace::Definite((h as f64 / scale_factor as f64) as f32)
+                            AvailableSpace::Definite((h as f64 / scale_factor) as f32)
                         }
                         s => s,
                     },
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index e93602d064197..ef397ab5f9295 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -14,6 +14,7 @@ pub trait MeasureNode: Send + Sync + 'static {
     fn box_clone(&self) -> Box<dyn MeasureNode>;
 }
 
+
 #[derive(Clone)]
 pub struct BasicMeasure {
     /// Prefered size
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 7926773636672..de77506d504d4 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{BasicMeasure, CalculatedSize, MeasureNode, Node, Style, UiScale, Val};
+use crate::{BasicMeasure, CalculatedSize, Node, Style, UiScale, Val};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,

From 9c4c01d00b3181d9c056e9743006362c15aba948 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 17 Feb 2023 23:08:43 +0000
Subject: [PATCH 04/38] cargo fmt

---
 crates/bevy_ui/src/measurement.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index ef397ab5f9295..e93602d064197 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -14,7 +14,6 @@ pub trait MeasureNode: Send + Sync + 'static {
     fn box_clone(&self) -> Box<dyn MeasureNode>;
 }
 
-
 #[derive(Clone)]
 pub struct BasicMeasure {
     /// Prefered size

From 8934a6f71fb7fddc7312ee3bca17da635534785d Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 18 Feb 2023 10:00:18 +0000
Subject: [PATCH 05/38] impl Measure for Fn

---
 crates/bevy_ui/src/flex/mod.rs     |  2 +-
 crates/bevy_ui/src/measurement.rs  | 61 ++++++++++++++++++++++++++++--
 crates/bevy_ui/src/ui_node.rs      | 28 +-------------
 crates/bevy_ui/src/widget/image.rs |  6 +--
 crates/bevy_ui/src/widget/text.rs  |  9 ++---
 5 files changed, 66 insertions(+), 40 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 50726fa87f413..6ed4e0bc6d5f4 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -84,7 +84,7 @@ impl FlexSurface {
     ) {
         let taffy = &mut self.taffy;
         let taffy_style = convert::from_style(scale_factor, style);
-        let m = calculated_size.measure.box_clone();
+        let m = calculated_size.measure.dyn_clone();
         let measure = taffy::node::MeasureFunc::Boxed(Box::new(
             move |constraints: Size<Option<f32>>, available_space: Size<AvailableSpace>| {
                 let size = m.measure(
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index e93602d064197..a9430cac0a855 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,7 +1,36 @@
+use bevy_ecs::prelude::Component;
 use bevy_math::Vec2;
+use std::fmt::Formatter;
 pub use taffy::layout::AvailableSpace;
 
-pub trait MeasureNode: Send + Sync + 'static {
+/// The calculated size of the node
+#[derive(Component)]
+pub struct CalculatedSize {
+    pub size: Vec2,
+    /// The measure function used to calculate the size
+    pub measure: Box<dyn Measure>,
+}
+
+impl Default for CalculatedSize {
+    fn default() -> Self {
+        Self {
+            size: Default::default(),
+            measure: Box::new(|w: Option<f32>, h: Option<f32>, _, _| {
+                Vec2::new(w.unwrap_or(0.), h.unwrap_or(0.))
+            }),
+        }
+    }
+}
+
+impl std::fmt::Debug for CalculatedSize {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CalculatedSize")
+            .field("size", &self.size)
+            .finish()
+    }
+}
+
+pub trait Measure: Send + Sync + 'static {
     /// Calculate the size of the node given the constraints.
     fn measure(
         &self,
@@ -10,8 +39,9 @@ pub trait MeasureNode: Send + Sync + 'static {
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2;
+
     /// Clone and box self.
-    fn box_clone(&self) -> Box<dyn MeasureNode>;
+    fn dyn_clone(&self) -> Box<dyn Measure>;
 }
 
 #[derive(Clone)]
@@ -20,7 +50,7 @@ pub struct BasicMeasure {
     pub size: Vec2,
 }
 
-impl MeasureNode for BasicMeasure {
+impl Measure for BasicMeasure {
     fn measure(
         &self,
         width: Option<f32>,
@@ -36,7 +66,30 @@ impl MeasureNode for BasicMeasure {
         }
     }
 
-    fn box_clone(&self) -> Box<dyn MeasureNode> {
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
+}
+
+impl<F> Measure for F
+where
+    F: Fn(Option<f32>, Option<f32>, AvailableSpace, AvailableSpace) -> Vec2
+        + Send
+        + Sync
+        + 'static
+        + Clone,
+{
+    fn measure(
+        &self,
+        max_width: Option<f32>,
+        max_height: Option<f32>,
+        available_width: AvailableSpace,
+        available_height: AvailableSpace,
+    ) -> Vec2 {
+        self(max_width, max_height, available_width, available_height)
+    }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
         Box::new(self.clone())
     }
 }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 43dd1568f5a88..0fb5f34413035 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,4 +1,4 @@
-use crate::{BasicMeasure, MeasureNode, Size, UiRect};
+use crate::{Size, UiRect};
 use bevy_asset::Handle;
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
@@ -561,32 +561,6 @@ impl Default for FlexWrap {
     }
 }
 
-/// The calculated size of the node
-#[derive(Component)]
-pub struct CalculatedSize {
-    /// The size of the node in logical pixels
-    pub size: Vec2,
-    /// The measure function used to calculate the size
-    pub measure: Box<dyn MeasureNode + 'static + Send + Sync>,
-}
-
-impl std::fmt::Debug for CalculatedSize {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CalculatedSize").finish()
-    }
-}
-
-impl Default for CalculatedSize {
-    fn default() -> Self {
-        Self {
-            size: Default::default(),
-            measure: Box::new(BasicMeasure {
-                size: Default::default(),
-            }),
-        }
-    }
-}
-
 /// The background color of the node
 ///
 /// This serves as the "fill" color.
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index f3f1b6a68732e..875b1d3e915c1 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, MeasureNode, UiImage};
+use crate::{CalculatedSize, Measure, UiImage};
 use bevy_asset::Assets;
 use bevy_ecs::{
     query::Without,
@@ -14,7 +14,7 @@ pub struct ImageMeasure {
     size: Vec2,
 }
 
-impl MeasureNode for ImageMeasure {
+impl Measure for ImageMeasure {
     fn measure(
         &self,
         width: Option<f32>,
@@ -41,7 +41,7 @@ impl MeasureNode for ImageMeasure {
         size
     }
 
-    fn box_clone(&self) -> Box<dyn MeasureNode> {
+    fn dyn_clone(&self) -> Box<dyn Measure> {
         Box::new(self.clone())
     }
 }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index de77506d504d4..b66ea1f0e2cf0 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -135,12 +135,11 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    calculated_size.size = Vec2::new(
-                        scale_value(info.size.x, inv_scale_factor),
-                        scale_value(info.size.y, inv_scale_factor),
-                    );
                     calculated_size.measure = Box::new(BasicMeasure {
-                        size: calculated_size.size,
+                        size: Vec2::new(
+                            scale_value(info.size.x, inv_scale_factor),
+                            scale_value(info.size.y, inv_scale_factor),
+                        ),
                     });
                     match text_layout_info {
                         Some(mut t) => *t = info,

From fc9b2d9afa90d0f2fe29ed495af8c6ab7cf5e578 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Sun, 19 Feb 2023 21:43:55 +0000
Subject: [PATCH 06/38] Changes:     * Added the `TextLayoutInfo` component to
 `TextBundle`.     * Added the `TextLayoutInfo` component to `Text2dBundle`.  
   * Changed `TextLayoutInfo` queries to be non-optional.

---
 crates/bevy_text/src/text2d.rs     | 15 +++++----------
 crates/bevy_ui/src/node_bundles.rs |  4 +++-
 crates/bevy_ui/src/widget/text.rs  | 14 ++++----------
 3 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_text/src/text2d.rs b/crates/bevy_text/src/text2d.rs
index 56da32ade4e8b..e4907c24df8c7 100644
--- a/crates/bevy_text/src/text2d.rs
+++ b/crates/bevy_text/src/text2d.rs
@@ -7,7 +7,7 @@ use bevy_ecs::{
     event::EventReader,
     prelude::With,
     reflect::ReflectComponent,
-    system::{Commands, Local, Query, Res, ResMut},
+    system::{Local, Query, Res, ResMut},
 };
 use bevy_math::{Vec2, Vec3};
 use bevy_reflect::Reflect;
@@ -65,6 +65,7 @@ pub struct Text2dBundle {
     pub text_2d_bounds: Text2dBounds,
     pub visibility: Visibility,
     pub computed_visibility: ComputedVisibility,
+    pub text_layout_info: TextLayoutInfo,
 }
 
 pub fn extract_text2d_sprite(
@@ -146,7 +147,6 @@ pub fn extract_text2d_sprite(
 /// It does not modify or observe existing ones.
 #[allow(clippy::too_many_arguments)]
 pub fn update_text2d_layout(
-    mut commands: Commands,
     // Text items which should be reprocessed again, generally when the font hasn't loaded yet.
     mut queue: Local<HashSet<Entity>>,
     mut textures: ResMut<Assets<Image>>,
@@ -162,7 +162,7 @@ pub fn update_text2d_layout(
         Entity,
         Ref<Text>,
         &Text2dBounds,
-        Option<&mut TextLayoutInfo>,
+        &mut TextLayoutInfo,
     )>,
 ) {
     // We need to consume the entire iterator, hence `last`
@@ -174,7 +174,7 @@ pub fn update_text2d_layout(
         .map(|window| window.resolution.scale_factor())
         .unwrap_or(1.0);
 
-    for (entity, text, bounds, text_layout_info) in &mut text_query {
+    for (entity, text, bounds, mut text_layout_info) in &mut text_query {
         if factor_changed || text.is_changed() || queue.remove(&entity) {
             let text_bounds = Vec2::new(
                 scale_value(bounds.size.x, scale_factor),
@@ -203,12 +203,7 @@ pub fn update_text2d_layout(
                 Err(e @ TextError::FailedToAddGlyph(_)) => {
                     panic!("Fatal error when processing text: {e}.");
                 }
-                Ok(info) => match text_layout_info {
-                    Some(mut t) => *t = info,
-                    None => {
-                        commands.entity(entity).insert(info);
-                    }
-                },
+                Ok(info) => *text_layout_info = info,
             }
         }
     }
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 8369b33bfe0b0..bd0dac6cc1c25 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -9,7 +9,7 @@ use bevy_render::{
     prelude::{Color, ComputedVisibility},
     view::Visibility,
 };
-use bevy_text::{Text, TextAlignment, TextSection, TextStyle};
+use bevy_text::{Text, TextAlignment, TextSection, TextStyle, TextLayoutInfo};
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
 /// The basic UI node
@@ -104,6 +104,8 @@ pub struct TextBundle {
     pub style: Style,
     /// Contains the text of the node
     pub text: Text,
+    /// Text layout information
+    pub text_layout_info: TextLayoutInfo,
     /// The calculated size based on the given image
     pub calculated_size: CalculatedSize,
     /// Whether this node should block interaction with lower nodes
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index a4464701fdcee..7ca24fff631c2 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -3,7 +3,7 @@ use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
     query::{Changed, Or, With},
-    system::{Commands, Local, ParamSet, Query, Res, ResMut},
+    system::{Local, ParamSet, Query, Res, ResMut},
 };
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
@@ -41,7 +41,6 @@ pub fn text_constraint(min_size: Val, size: Val, max_size: Val, scale_factor: f6
 /// It does not modify or observe existing ones.
 #[allow(clippy::too_many_arguments)]
 pub fn text_system(
-    mut commands: Commands,
     mut queued_text_ids: Local<Vec<Entity>>,
     mut last_scale_factor: Local<f64>,
     mut textures: ResMut<Assets<Image>>,
@@ -60,7 +59,7 @@ pub fn text_system(
             &Text,
             &Style,
             &mut CalculatedSize,
-            Option<&mut TextLayoutInfo>,
+            &mut TextLayoutInfo,
         )>,
     )>,
 ) {
@@ -96,7 +95,7 @@ pub fn text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text_ids.drain(..) {
-        if let Ok((text, style, mut calculated_size, text_layout_info)) = query.get_mut(entity) {
+        if let Ok((text, style, mut calculated_size, mut text_layout_info)) = query.get_mut(entity) {
             let node_size = Vec2::new(
                 text_constraint(
                     style.min_size.width,
@@ -139,12 +138,7 @@ pub fn text_system(
                         scale_value(info.size.x, inv_scale_factor),
                         scale_value(info.size.y, inv_scale_factor),
                     );
-                    match text_layout_info {
-                        Some(mut t) => *t = info,
-                        None => {
-                            commands.entity(entity).insert(info);
-                        }
-                    }
+                    *text_layout_info = info;
                 }
             }
         }

From f7d20ea6ba7a0fb162267ea23d0bf505066f98f7 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Sun, 19 Feb 2023 22:17:20 +0000
Subject: [PATCH 07/38] cargo fmt --all

---
 crates/bevy_text/src/text2d.rs     |  7 +------
 crates/bevy_ui/src/node_bundles.rs |  2 +-
 crates/bevy_ui/src/widget/text.rs  | 10 +++-------
 3 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_text/src/text2d.rs b/crates/bevy_text/src/text2d.rs
index e4907c24df8c7..e79ac4f5b219f 100644
--- a/crates/bevy_text/src/text2d.rs
+++ b/crates/bevy_text/src/text2d.rs
@@ -158,12 +158,7 @@ pub fn update_text2d_layout(
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(
-        Entity,
-        Ref<Text>,
-        &Text2dBounds,
-        &mut TextLayoutInfo,
-    )>,
+    mut text_query: Query<(Entity, Ref<Text>, &Text2dBounds, &mut TextLayoutInfo)>,
 ) {
     // We need to consume the entire iterator, hence `last`
     let factor_changed = scale_factor_changed.iter().last().is_some();
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index bd0dac6cc1c25..d5b7ca41dd109 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -9,7 +9,7 @@ use bevy_render::{
     prelude::{Color, ComputedVisibility},
     view::Visibility,
 };
-use bevy_text::{Text, TextAlignment, TextSection, TextStyle, TextLayoutInfo};
+use bevy_text::{Text, TextAlignment, TextLayoutInfo, TextSection, TextStyle};
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
 /// The basic UI node
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 7ca24fff631c2..80590fb7f5c9b 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -55,12 +55,7 @@ pub fn text_system(
     mut text_queries: ParamSet<(
         Query<Entity, Or<(Changed<Text>, Changed<Node>, Changed<Style>)>>,
         Query<Entity, (With<Text>, With<Style>)>,
-        Query<(
-            &Text,
-            &Style,
-            &mut CalculatedSize,
-            &mut TextLayoutInfo,
-        )>,
+        Query<(&Text, &Style, &mut CalculatedSize, &mut TextLayoutInfo)>,
     )>,
 ) {
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -95,7 +90,8 @@ pub fn text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text_ids.drain(..) {
-        if let Ok((text, style, mut calculated_size, mut text_layout_info)) = query.get_mut(entity) {
+        if let Ok((text, style, mut calculated_size, mut text_layout_info)) = query.get_mut(entity)
+        {
             let node_size = Vec2::new(
                 text_constraint(
                     style.min_size.width,

From 13091a322ea0d299ffc6289e56b2791922e9a1a0 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 08:35:57 +0000
Subject: [PATCH 08/38] remove `text_constraint` function

---
 crates/bevy_ui/src/widget/text.rs | 36 ++++++-------------------------
 1 file changed, 7 insertions(+), 29 deletions(-)

diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index a4464701fdcee..a37b2828f6420 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -18,19 +18,7 @@ fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32
 }
 
-/// Defines how `min_size`, `size`, and `max_size` affects the bounds of a text
-/// block.
-pub fn text_constraint(min_size: Val, size: Val, max_size: Val, scale_factor: f64) -> f32 {
-    // Needs support for percentages
-    match (min_size, size, max_size) {
-        (_, _, Val::Px(max)) => scale_value(max, scale_factor),
-        (Val::Px(min), _, _) => scale_value(min, scale_factor),
-        (Val::Undefined, Val::Px(size), Val::Undefined) | (Val::Auto, Val::Px(size), Val::Auto) => {
-            scale_value(size, scale_factor)
-        }
-        _ => f32::MAX,
-    }
-}
+
 
 /// Updates the layout and size information whenever the text or style is changed.
 /// This information is computed by the `TextPipeline` on insertion, then stored.
@@ -54,9 +42,10 @@ pub fn text_system(
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
     mut text_pipeline: ResMut<TextPipeline>,
     mut text_queries: ParamSet<(
-        Query<Entity, Or<(Changed<Text>, Changed<Node>, Changed<Style>)>>,
-        Query<Entity, (With<Text>, With<Style>)>,
+        Query<Entity, Or<(Changed<Text>, Changed<Node>)>>,
+        Query<Entity, (With<Text>, With<Node>)>,
         Query<(
+            &Node,
             &Text,
             &Style,
             &mut CalculatedSize,
@@ -96,22 +85,11 @@ pub fn text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text_ids.drain(..) {
-        if let Ok((text, style, mut calculated_size, text_layout_info)) = query.get_mut(entity) {
+        if let Ok((node, text, style, mut calculated_size, text_layout_info)) = query.get_mut(entity) {
             let node_size = Vec2::new(
-                text_constraint(
-                    style.min_size.width,
-                    style.size.width,
-                    style.max_size.width,
-                    scale_factor,
-                ),
-                text_constraint(
-                    style.min_size.height,
-                    style.size.height,
-                    style.max_size.height,
-                    scale_factor,
-                ),
+                scale_value(node.size().x, scale_factor),
+                scale_value(node.size().y, scale_factor),
             );
-
             match text_pipeline.queue_text(
                 &fonts,
                 &text.sections,

From 3981c7f962923a017e024d350987ab5bf998c256 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 08:45:23 +0000
Subject: [PATCH 09/38] add TextLayoutInfo to default TextBundle

---
 crates/bevy_ui/src/node_bundles.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 28beaad6b12f2..9060b4868795e 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -134,6 +134,7 @@ impl Default for TextBundle {
     fn default() -> Self {
         Self {
             text: Default::default(),
+            text_layout_info: Default::default(),
             calculated_size: Default::default(),
             // Transparent background
             background_color: BackgroundColor(Color::NONE),

From af7b6f2ed70d467da9f441524cc1f32b0921a9af Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 10:27:37 +0000
Subject: [PATCH 10/38] changes: * Added the system (dummy atm)
 `measure_text_system` * Changed the system execution order so that
 `measure_text_system` replaces `text_system` in the order. `text_system` now
 runs after `UiSystem::Flex`.

Previously the `text_system` ran before the layout was calculated and the size of the text node was determined,
so it couldn't shape the text correctly to fit the layout, and had no way of determining if the text needed to be wrapped.
There was a hack, the system `text_constraint` that tried to determine the size of the node from the local size constraints of the node in its `Style` component.
This could not work correctly, `Val::Percent` constraints just had to be ignored as they are calcualted from size of the parent node and the `Val::Px` constraints are just a guess,
without computing the rest of the layout.
Also because the `text_system` queried for changes to the `Style` component, and not the `Node` component, it couldn't react to changes in the layout correctly.
The layout system then wouldn't recieve all the information it would need to fit the text node correctly, such as the `max-content` and `min-content` sizes.
---
 crates/bevy_ui/src/lib.rs         | 8 ++++++--
 crates/bevy_ui/src/widget/text.rs | 5 +++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 9a6e46106e4de..d820ee6a7af18 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -108,7 +108,7 @@ impl Plugin for UiPlugin {
             .add_system(ui_focus_system.in_set(UiSystem::Focus).after(InputSystem))
             // add these systems to front because these must run before transform update systems
             .add_system(
-                widget::text_system
+                widget::measure_text_system
                     .in_base_set(CoreSet::PostUpdate)
                     .before(UiSystem::Flex)
                     // Potential conflict: `Assets<Image>`
@@ -142,8 +142,12 @@ impl Plugin for UiPlugin {
                 update_clipping_system
                     .after(TransformSystem::TransformPropagate)
                     .in_base_set(CoreSet::PostUpdate),
+            )
+            .add_system(
+                widget::text_system
+                    .in_base_set(CoreSet::PostUpdate)
+                    .after(UiSystem::Flex),
             );
-
         crate::render::build_ui_render(app);
     }
 }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 3659b840ed837..6dac08df41959 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -18,6 +18,11 @@ fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32
 }
 
+/// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space 
+/// to provide for the text given the fonts, the text itself and the constraints of the layout.
+pub fn measure_text_system() {
+}
+
 /// Updates the layout and size information whenever the text or style is changed.
 /// This information is computed by the `TextPipeline` on insertion, then stored.
 ///

From 2280bb062c3ec68bcfea43689929b6f958271bc8 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 12:55:28 +0000
Subject: [PATCH 11/38] changes: * implemented the `measure_text_system`
 function. * Added the `TextMeasure` type that implements measure. * Added the
 `TextQueue` resource struct. * Added methods to the `TextPipeline` to get min
 and max content sizes for the text.

---
 crates/bevy_text/src/pipeline.rs  |  77 +++++++++++++++
 crates/bevy_ui/src/lib.rs         |   2 +
 crates/bevy_ui/src/widget/text.rs | 159 ++++++++++++++++++++++++------
 3 files changed, 208 insertions(+), 30 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index ac29c6b7c9f87..ed994362f8761 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -114,4 +114,81 @@ impl TextPipeline {
 
         Ok(TextLayoutInfo { glyphs, size })
     }
+
+
+    // Past here is just terrible hacks to get what I want
+
+    pub fn compute_sections<'a>(
+        &mut self,
+        fonts: &Assets<Font>,
+        sections: &'a [TextSection],
+        scale_factor: f64,
+    ) -> Result<(Vec<SectionText<'a>>, Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>), TextError> {
+        let mut scaled_fonts = Vec::new();
+        let sections = sections
+            .iter()
+            .map(|section| {
+                let font = fonts
+                    .get(&section.style.font)
+                    .ok_or(TextError::NoSuchFont)?;
+                let font_id = self.get_or_insert_font_id(&section.style.font, font);
+                let font_size = scale_value(section.style.font_size, scale_factor);
+
+                let px_scale_font = ab_glyph::Font::into_scaled(font.font.clone(), font_size);
+                scaled_fonts.push(px_scale_font);
+
+                let section = SectionText {
+                    font_id,
+                    scale: PxScale::from(font_size),
+                    text: &section.value,
+                };
+
+                Ok(section)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok((sections, scaled_fonts))
+    }
+
+    pub fn compute_section_glyphs(
+        &self,
+        sections: &Vec<SectionText>,
+        text_alignment: TextAlignment,
+        linebreak_behaviour: BreakLineOn,
+        bounds: Vec2,
+    ) -> Result<Vec<glyph_brush_layout::SectionGlyph>, TextError> {
+        self.brush
+            .compute_glyphs(&sections, bounds, text_alignment, linebreak_behaviour)
+    }
+
+    pub fn compute_size(
+        &self,
+        sections: &Vec<SectionText>,
+        scaled_fonts: &Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
+        text_alignment: TextAlignment,
+        linebreak_behaviour: BreakLineOn,
+        bounds: Vec2,
+    ) -> Vec2 {
+        if let Ok(section_glyphs) =
+            self.brush
+                .compute_glyphs(sections, bounds, text_alignment, linebreak_behaviour)
+        {
+            let mut min_x: f32 = std::f32::MAX;
+            let mut min_y: f32 = std::f32::MAX;
+            let mut max_x: f32 = std::f32::MIN;
+            let mut max_y: f32 = std::f32::MIN;
+
+            for sg in section_glyphs {
+                let scaled_font = &scaled_fonts[sg.section_index];
+                let glyph = &sg.glyph;
+                min_x = min_x.min(glyph.position.x);
+                min_y = min_y.min(glyph.position.y - scaled_font.ascent());
+                max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
+                max_y = max_y.max(glyph.position.y - scaled_font.descent());
+            }
+
+            Vec2::new(max_x - min_x, max_y - min_y)
+        } else {
+            Vec2::ZERO
+        }
+    }
 }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index d820ee6a7af18..b9736729ae85a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -39,6 +39,7 @@ use bevy_transform::TransformSystem;
 use stack::ui_stack_system;
 pub use stack::UiStack;
 use update::update_clipping_system;
+use widget::TextQueue;
 
 use crate::prelude::UiCameraConfig;
 
@@ -79,6 +80,7 @@ impl Plugin for UiPlugin {
             .init_resource::<FlexSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
+            .init_resource::<TextQueue>()
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 6dac08df41959..2741d559d5acb 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,9 +1,9 @@
-use crate::{IntrinsicSize, Node, UiScale};
+use crate::{IntrinsicSize, Node, UiScale, Measure};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
     query::{Changed, Or, With},
-    system::{Local, ParamSet, Query, Res, ResMut},
+    system::{Local, ParamSet, Query, Res, ResMut, Resource},
 };
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
@@ -13,14 +13,133 @@ use bevy_text::{
     TextSettings, YAxisOrientation,
 };
 use bevy_window::{PrimaryWindow, Window};
+use crate::measurement::AvailableSpace;
 
 fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32
 }
 
+#[derive(Clone)]
+pub struct TextMeasure {
+    pub min_content: Vec2,
+    pub max_content: Vec2,
+}
+
+impl Measure for TextMeasure {
+    fn measure(
+        &self,
+        max_width: Option<f32>,
+        max_height: Option<f32>,
+        _: AvailableSpace,
+        _: AvailableSpace,
+    ) -> Vec2 {
+        Vec2::new(
+            match max_width {
+                Some(width) => width,
+                None => self.max_content.x,
+            },
+            match max_height {
+                Some(height) => height,
+                None => self.min_content.y,
+            }
+        )
+        // taffy rounds the size down to the nearest pixel, which can cause the text to be cut off
+        .ceil()
+    }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
+}
+
+#[derive(Resource, Default)]
+pub struct TextQueue {
+    pub ids: Vec<Entity>,
+}
+
 /// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space 
 /// to provide for the text given the fonts, the text itself and the constraints of the layout.
-pub fn measure_text_system() {
+pub fn measure_text_system(
+    mut text_queue: ResMut<TextQueue>,
+    mut queued_text_ids: Local<Vec<Entity>>,
+    mut last_scale_factor: Local<f64>,
+    fonts: Res<Assets<Font>>,
+    windows: Query<&Window, With<PrimaryWindow>>,
+    ui_scale: Res<UiScale>,
+    mut text_pipeline: ResMut<TextPipeline>,
+    mut text_queries: ParamSet<(
+        Query<Entity, Changed<Text>>,
+        Query<Entity, With<Text>>,
+        Query<(&Text, &mut IntrinsicSize)>,
+    )>,
+) {
+    let window_scale_factor = windows
+    .get_single()
+    .map(|window| window.resolution.scale_factor())
+    .unwrap_or(1.);
+
+    let scale_factor = ui_scale.scale * window_scale_factor;
+
+    #[allow(clippy::float_cmp)]
+    if *last_scale_factor == scale_factor {
+        // Adds all entities where the text or the style has changed to the local queue
+        for entity in text_queries.p0().iter() {
+            queued_text_ids.push(entity);
+        }
+    } else {
+        // If the scale factor has changed, queue all text
+        for entity in text_queries.p1().iter() {
+            queued_text_ids.push(entity);
+        }
+        *last_scale_factor = scale_factor;
+    }
+
+    if queued_text_ids.is_empty() {
+        return;
+    }
+
+    let mut new_queue = Vec::new();
+    let mut query = text_queries.p2();
+    for entity in queued_text_ids.drain(..) {
+        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
+            match text_pipeline.compute_sections(&fonts, &text.sections, scale_factor) {
+                Ok((sections, scaled_fonts)) => {
+                    // computes the size of the text with the text wrapped after every word
+                    let min = text_pipeline.compute_size(
+                        &sections,
+                        &scaled_fonts,
+                        text.alignment,
+                        text.linebreak_behaviour,
+                        Vec2::new(0., f32::INFINITY),
+                    );
+
+                    // computes the size of the text with no width constraint
+                    let max = text_pipeline.compute_size(
+                        &sections,
+                        &scaled_fonts,
+                        text.alignment,
+                        text.linebreak_behaviour,
+                        Vec2::splat(f32::INFINITY),
+                    );
+
+                    let measure = TextMeasure {
+                        min_content: min,
+                        max_content: max,
+                    };
+                    calculated_size.measure = Box::new(measure);
+                    text_queue.ids.push(entity);
+                }
+                Err(TextError::NoSuchFont) => {
+                    new_queue.push(entity);
+                }
+                Err(e @ TextError::FailedToAddGlyph(_)) => {
+                    panic!("Fatal error when processing text: {e}.");
+                }
+            };
+        }
+    }
+    *queued_text_ids = new_queue;
+
 }
 
 /// Updates the layout and size information whenever the text or style is changed.
@@ -32,8 +151,7 @@ pub fn measure_text_system() {
 /// It does not modify or observe existing ones.
 #[allow(clippy::too_many_arguments)]
 pub fn text_system(
-    mut queued_text_ids: Local<Vec<Entity>>,
-    mut last_scale_factor: Local<f64>,
+    mut queued_text: ResMut<TextQueue>,
     mut textures: ResMut<Assets<Image>>,
     fonts: Res<Assets<Font>>,
     windows: Query<&Window, With<PrimaryWindow>>,
@@ -56,31 +174,12 @@ pub fn text_system(
         .unwrap_or(1.);
 
     let scale_factor = ui_scale.scale * window_scale_factor;
-
     let inv_scale_factor = 1. / scale_factor;
 
-    #[allow(clippy::float_cmp)]
-    if *last_scale_factor == scale_factor {
-        // Adds all entities where the text or the style has changed to the local queue
-        for entity in text_queries.p0().iter() {
-            queued_text_ids.push(entity);
-        }
-    } else {
-        // If the scale factor has changed, queue all text
-        for entity in text_queries.p1().iter() {
-            queued_text_ids.push(entity);
-        }
-        *last_scale_factor = scale_factor;
-    }
-
-    if queued_text_ids.is_empty() {
-        return;
-    }
-
     // Computes all text in the local queue
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
-    for entity in queued_text_ids.drain(..) {
+    for entity in queued_text.ids.drain(..) {
         if let Ok((node, text, mut calculated_size, mut text_layout_info)) = query.get_mut(entity) {
             let node_size = Vec2::new(
                 scale_value(node.size().x, scale_factor),
@@ -109,15 +208,15 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    calculated_size.size = Vec2::new(
-                        scale_value(info.size.x, inv_scale_factor),
-                        scale_value(info.size.y, inv_scale_factor),
-                    );
+                    // calculated_size.size = Vec2::new(
+                    //     scale_value(info.size.x, inv_scale_factor),
+                    //     scale_value(info.size.y, inv_scale_factor),
+                    // );
                     *text_layout_info = info;
                 }
             }
         }
     }
 
-    *queued_text_ids = new_queue;
+    queued_text.ids = new_queue;
 }

From f5108992e495d050ae6f115f8d3f71f9d0ab3988 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 15:32:13 +0000
Subject: [PATCH 12/38] Clean up and bug fixes.

changes:
* Removed `TextQueue`
* Added `min_content`, `max_content` and `ideal` fields to IntrinsicSize.
* Added `ideal_height` field to `TextMeasure`.
* Fixed text system queueing and change detection issues. `measure_text_system` only queries for modified `Text`,
`text_system` queuries for `Text` or `Node` changes.
---
 crates/bevy_text/src/pipeline.rs  |  22 ++----
 crates/bevy_ui/src/lib.rs         |   5 +-
 crates/bevy_ui/src/measurement.rs |   9 +++
 crates/bevy_ui/src/widget/text.rs | 125 +++++++++++++++++++-----------
 4 files changed, 96 insertions(+), 65 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index ed994362f8761..39d8888aa4a15 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -115,15 +115,20 @@ impl TextPipeline {
         Ok(TextLayoutInfo { glyphs, size })
     }
 
-
-    // Past here is just terrible hacks to get what I want
+    //  Some hacks to find the size constraints for the text, needs a better solution
 
     pub fn compute_sections<'a>(
         &mut self,
         fonts: &Assets<Font>,
         sections: &'a [TextSection],
         scale_factor: f64,
-    ) -> Result<(Vec<SectionText<'a>>, Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>), TextError> {
+    ) -> Result<
+        (
+            Vec<SectionText<'a>>,
+            Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
+        ),
+        TextError,
+    > {
         let mut scaled_fonts = Vec::new();
         let sections = sections
             .iter()
@@ -149,17 +154,6 @@ impl TextPipeline {
         Ok((sections, scaled_fonts))
     }
 
-    pub fn compute_section_glyphs(
-        &self,
-        sections: &Vec<SectionText>,
-        text_alignment: TextAlignment,
-        linebreak_behaviour: BreakLineOn,
-        bounds: Vec2,
-    ) -> Result<Vec<glyph_brush_layout::SectionGlyph>, TextError> {
-        self.brush
-            .compute_glyphs(&sections, bounds, text_alignment, linebreak_behaviour)
-    }
-
     pub fn compute_size(
         &self,
         sections: &Vec<SectionText>,
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index b9736729ae85a..3bef9fe3cec99 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -32,6 +32,7 @@ pub mod prelude {
     };
 }
 
+use crate::prelude::UiCameraConfig;
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_input::InputSystem;
@@ -39,9 +40,6 @@ use bevy_transform::TransformSystem;
 use stack::ui_stack_system;
 pub use stack::UiStack;
 use update::update_clipping_system;
-use widget::TextQueue;
-
-use crate::prelude::UiCameraConfig;
 
 /// The basic plugin for Bevy UI
 #[derive(Default)]
@@ -80,7 +78,6 @@ impl Plugin for UiPlugin {
             .init_resource::<FlexSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
-            .init_resource::<TextQueue>()
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 85a68e1ad8359..08f1dd84433c2 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -57,6 +57,9 @@ impl Measure for FixedMeasure {
 pub struct IntrinsicSize {
     /// Used to track changes
     pub size: Vec2,
+    pub min_content: Vec2,
+    pub max_content: Vec2,
+    pub ideal: Vec2,
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
     pub measure: Box<dyn Measure>,
@@ -66,6 +69,9 @@ impl Default for IntrinsicSize {
     fn default() -> Self {
         Self {
             size: Default::default(),
+            min_content: Default::default(),
+            max_content: Default::default(),
+            ideal: Default::default(),
             // Default `FixedMeasure` always returns zero size.
             measure: Box::<FixedMeasure>::default(),
         }
@@ -76,6 +82,9 @@ impl Clone for IntrinsicSize {
     fn clone(&self) -> Self {
         Self {
             size: self.size,
+            min_content: Default::default(),
+            max_content: Default::default(),
+            ideal: Default::default(),
             measure: self.measure.dyn_clone(),
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 2741d559d5acb..276062251b7e4 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,9 +1,10 @@
-use crate::{IntrinsicSize, Node, UiScale, Measure};
+use crate::measurement::AvailableSpace;
+use crate::{IntrinsicSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
     query::{Changed, Or, With},
-    system::{Local, ParamSet, Query, Res, ResMut, Resource},
+    system::{Local, ParamSet, Query, Res, ResMut},
 };
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
@@ -13,7 +14,6 @@ use bevy_text::{
     TextSettings, YAxisOrientation,
 };
 use bevy_window::{PrimaryWindow, Window};
-use crate::measurement::AvailableSpace;
 
 fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32
@@ -23,6 +23,7 @@ fn scale_value(value: f32, factor: f64) -> f32 {
 pub struct TextMeasure {
     pub min_content: Vec2,
     pub max_content: Vec2,
+    pub ideal_height: f32,
 }
 
 impl Measure for TextMeasure {
@@ -33,18 +34,29 @@ impl Measure for TextMeasure {
         _: AvailableSpace,
         _: AvailableSpace,
     ) -> Vec2 {
-        Vec2::new(
-            match max_width {
-                Some(width) => width,
-                None => self.max_content.x,
-            },
-            match max_height {
-                Some(height) => height,
-                None => self.min_content.y,
+        let mut size = Vec2::ZERO;
+        match (max_width, max_height) {
+            (None, None) => {
+                // with no constraints
+                // ask for maximum width space for text with no wrapping
+                size = self.max_content;
+            }
+            (Some(width), None) => {
+                size.x = width;
+                size.y = self.ideal_height;
+            }
+            (None, Some(height)) => {
+                size.y = height;
+                size.x = self.max_content.x;
             }
-        )
-        // taffy rounds the size down to the nearest pixel, which can cause the text to be cut off
-        .ceil()
+            (Some(width), Some(height)) => {
+                size.x = width;
+                size.y = height;
+            }
+        }
+        size.x = size.x.ceil();
+        size.y = size.y.ceil();
+        size
     }
 
     fn dyn_clone(&self) -> Box<dyn Measure> {
@@ -52,16 +64,10 @@ impl Measure for TextMeasure {
     }
 }
 
-#[derive(Resource, Default)]
-pub struct TextQueue {
-    pub ids: Vec<Entity>,
-}
-
-/// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space 
+/// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space
 /// to provide for the text given the fonts, the text itself and the constraints of the layout.
 pub fn measure_text_system(
-    mut text_queue: ResMut<TextQueue>,
-    mut queued_text_ids: Local<Vec<Entity>>,
+    mut queued_text: Local<Vec<Entity>>,
     mut last_scale_factor: Local<f64>,
     fonts: Res<Assets<Font>>,
     windows: Query<&Window, With<PrimaryWindow>>,
@@ -69,14 +75,14 @@ pub fn measure_text_system(
     mut text_pipeline: ResMut<TextPipeline>,
     mut text_queries: ParamSet<(
         Query<Entity, Changed<Text>>,
-        Query<Entity, With<Text>>,
+        Query<Entity, (With<Text>, With<Node>)>,
         Query<(&Text, &mut IntrinsicSize)>,
     )>,
 ) {
     let window_scale_factor = windows
-    .get_single()
-    .map(|window| window.resolution.scale_factor())
-    .unwrap_or(1.);
+        .get_single()
+        .map(|window| window.resolution.scale_factor())
+        .unwrap_or(1.);
 
     let scale_factor = ui_scale.scale * window_scale_factor;
 
@@ -84,24 +90,26 @@ pub fn measure_text_system(
     if *last_scale_factor == scale_factor {
         // Adds all entities where the text or the style has changed to the local queue
         for entity in text_queries.p0().iter() {
-            queued_text_ids.push(entity);
+            if !queued_text.contains(&entity) {
+                queued_text.push(entity);
+            }
         }
     } else {
         // If the scale factor has changed, queue all text
         for entity in text_queries.p1().iter() {
-            queued_text_ids.push(entity);
+            queued_text.push(entity);
         }
         *last_scale_factor = scale_factor;
     }
 
-    if queued_text_ids.is_empty() {
+    if queued_text.is_empty() {
         return;
     }
 
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
-    for entity in queued_text_ids.drain(..) {
-        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
+    for entity in queued_text.drain(..) {
+        if let Ok((text, mut intrinsic_size)) = query.get_mut(entity) {
             match text_pipeline.compute_sections(&fonts, &text.sections, scale_factor) {
                 Ok((sections, scaled_fonts)) => {
                     // computes the size of the text with the text wrapped after every word
@@ -125,9 +133,12 @@ pub fn measure_text_system(
                     let measure = TextMeasure {
                         min_content: min,
                         max_content: max,
+                        ideal_height: min.y,
                     };
-                    calculated_size.measure = Box::new(measure);
-                    text_queue.ids.push(entity);
+                    intrinsic_size.min_content = min;
+                    intrinsic_size.max_content = max;
+                    intrinsic_size.ideal.y = min.y;
+                    intrinsic_size.measure = Box::new(measure);
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);
@@ -138,8 +149,7 @@ pub fn measure_text_system(
             };
         }
     }
-    *queued_text_ids = new_queue;
-
+    *queued_text = new_queue;
 }
 
 /// Updates the layout and size information whenever the text or style is changed.
@@ -151,8 +161,9 @@ pub fn measure_text_system(
 /// It does not modify or observe existing ones.
 #[allow(clippy::too_many_arguments)]
 pub fn text_system(
-    mut queued_text: ResMut<TextQueue>,
+    mut queued_text: Local<Vec<Entity>>,
     mut textures: ResMut<Assets<Image>>,
+    mut last_scale_factor: Local<f64>,
     fonts: Res<Assets<Font>>,
     windows: Query<&Window, With<PrimaryWindow>>,
     text_settings: Res<TextSettings>,
@@ -174,13 +185,29 @@ pub fn text_system(
         .unwrap_or(1.);
 
     let scale_factor = ui_scale.scale * window_scale_factor;
-    let inv_scale_factor = 1. / scale_factor;
 
-    // Computes all text in the local queue
+    #[allow(clippy::float_cmp)]
+    if *last_scale_factor == scale_factor {
+        // Adds all entities where the text or the style has changed to the local queue
+        for entity in text_queries.p0().iter() {
+            if !queued_text.contains(&entity) {
+                queued_text.push(entity);
+            }
+        }
+    } else {
+        // If the scale factor has changed, queue all text
+        for entity in text_queries.p1().iter() {
+            queued_text.push(entity);
+        }
+        *last_scale_factor = scale_factor;
+    }
+
     let mut new_queue = Vec::new();
-    let mut query = text_queries.p2();
-    for entity in queued_text.ids.drain(..) {
-        if let Ok((node, text, mut calculated_size, mut text_layout_info)) = query.get_mut(entity) {
+    let mut text_query = text_queries.p2();
+    for entity in queued_text.drain(..) {
+        if let Ok((node, text, mut intrinsic_size, mut text_layout_info)) =
+            text_query.get_mut(entity)
+        {
             let node_size = Vec2::new(
                 scale_value(node.size().x, scale_factor),
                 scale_value(node.size().y, scale_factor),
@@ -208,15 +235,19 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    // calculated_size.size = Vec2::new(
-                    //     scale_value(info.size.x, inv_scale_factor),
-                    //     scale_value(info.size.y, inv_scale_factor),
-                    // );
+                    if info.size.y != intrinsic_size.ideal.y {
+                        let measure = TextMeasure {
+                            min_content: intrinsic_size.min_content,
+                            max_content: intrinsic_size.max_content,
+                            ideal_height: info.size.y,
+                        };
+                        intrinsic_size.ideal = info.size;
+                        intrinsic_size.measure = Box::new(measure);
+                    }
                     *text_layout_info = info;
                 }
             }
         }
     }
-
-    queued_text.ids = new_queue;
+    *queued_text = new_queue;
 }

From 95d7c9668a35efe5bca060d2c0eb938656cb8907 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 16:09:36 +0000
Subject: [PATCH 13/38] simplified text size code

---
 crates/bevy_text/src/pipeline.rs  | 76 ++++++++++++++-----------------
 crates/bevy_ui/src/widget/text.rs | 28 ++++--------
 2 files changed, 42 insertions(+), 62 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 39d8888aa4a15..e416fe93c4776 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -115,20 +115,15 @@ impl TextPipeline {
         Ok(TextLayoutInfo { glyphs, size })
     }
 
-    //  Some hacks to find the size constraints for the text, needs a better solution
-
-    pub fn compute_sections<'a>(
+    // hacked up `queue_text` that returns the text size constraints, there should be a better solution
+    pub fn compute_size_constraints(
         &mut self,
         fonts: &Assets<Font>,
-        sections: &'a [TextSection],
+        sections: &[TextSection],
         scale_factor: f64,
-    ) -> Result<
-        (
-            Vec<SectionText<'a>>,
-            Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
-        ),
-        TextError,
-    > {
+        text_alignment: TextAlignment,
+        linebreak_behaviour: BreakLineOn,
+    ) -> Result<[Vec2; 2], TextError> {
         let mut scaled_fonts = Vec::new();
         let sections = sections
             .iter()
@@ -151,38 +146,35 @@ impl TextPipeline {
                 Ok(section)
             })
             .collect::<Result<Vec<_>, _>>()?;
-        Ok((sections, scaled_fonts))
-    }
 
-    pub fn compute_size(
-        &self,
-        sections: &Vec<SectionText>,
-        scaled_fonts: &Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
-        text_alignment: TextAlignment,
-        linebreak_behaviour: BreakLineOn,
-        bounds: Vec2,
-    ) -> Vec2 {
-        if let Ok(section_glyphs) =
-            self.brush
-                .compute_glyphs(sections, bounds, text_alignment, linebreak_behaviour)
-        {
-            let mut min_x: f32 = std::f32::MAX;
-            let mut min_y: f32 = std::f32::MAX;
-            let mut max_x: f32 = std::f32::MIN;
-            let mut max_y: f32 = std::f32::MIN;
-
-            for sg in section_glyphs {
-                let scaled_font = &scaled_fonts[sg.section_index];
-                let glyph = &sg.glyph;
-                min_x = min_x.min(glyph.position.x);
-                min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-                max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-                max_y = max_y.max(glyph.position.y - scaled_font.descent());
+        let result = [
+            Vec2::new(0.0, f32::INFINITY),
+            Vec2::new(f32::INFINITY, f32::INFINITY),
+        ]
+        .map(|bounds| {
+            if let Ok(section_glyphs) =
+                self.brush
+                    .compute_glyphs(&sections, bounds, text_alignment, linebreak_behaviour)
+            {
+                let mut min_x: f32 = std::f32::MAX;
+                let mut min_y: f32 = std::f32::MAX;
+                let mut max_x: f32 = std::f32::MIN;
+                let mut max_y: f32 = std::f32::MIN;
+
+                for sg in section_glyphs {
+                    let scaled_font = &scaled_fonts[sg.section_index];
+                    let glyph = &sg.glyph;
+                    min_x = min_x.min(glyph.position.x);
+                    min_y = min_y.min(glyph.position.y - scaled_font.ascent());
+                    max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
+                    max_y = max_y.max(glyph.position.y - scaled_font.descent());
+                }
+
+                Vec2::new(max_x - min_x, max_y - min_y)
+            } else {
+                Vec2::ZERO
             }
-
-            Vec2::new(max_x - min_x, max_y - min_y)
-        } else {
-            Vec2::ZERO
-        }
+        });
+        Ok(result)
     }
 }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 276062251b7e4..1f253f8640f08 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -110,26 +110,14 @@ pub fn measure_text_system(
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
         if let Ok((text, mut intrinsic_size)) = query.get_mut(entity) {
-            match text_pipeline.compute_sections(&fonts, &text.sections, scale_factor) {
-                Ok((sections, scaled_fonts)) => {
-                    // computes the size of the text with the text wrapped after every word
-                    let min = text_pipeline.compute_size(
-                        &sections,
-                        &scaled_fonts,
-                        text.alignment,
-                        text.linebreak_behaviour,
-                        Vec2::new(0., f32::INFINITY),
-                    );
-
-                    // computes the size of the text with no width constraint
-                    let max = text_pipeline.compute_size(
-                        &sections,
-                        &scaled_fonts,
-                        text.alignment,
-                        text.linebreak_behaviour,
-                        Vec2::splat(f32::INFINITY),
-                    );
-
+            match text_pipeline.compute_size_constraints(
+                &fonts,
+                &text.sections,
+                scale_factor,
+                text.alignment,
+                text.linebreak_behaviour,
+            ) {
+                Ok([min, max]) => {
                     let measure = TextMeasure {
                         min_content: min,
                         max_content: max,

From 91a05d2c8e3223a14833d84d0d51923cc91874b7 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Feb 2023 17:48:11 +0000
Subject: [PATCH 14/38] fix derivable impls

---
 crates/bevy_ui/src/measurement.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 08f1dd84433c2..c232610ab3201 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -65,6 +65,7 @@ pub struct IntrinsicSize {
     pub measure: Box<dyn Measure>,
 }
 
+#[allow(clippy::derivable_impls)]
 impl Default for IntrinsicSize {
     fn default() -> Self {
         Self {

From 1ee623383bb9aea947209e618e92d257d0d831c4 Mon Sep 17 00:00:00 2001
From: Ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 27 Feb 2023 09:32:21 +0000
Subject: [PATCH 15/38] added `compute_geometry` function to pipeline

---
 crates/bevy_text/src/pipeline.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index e416fe93c4776..4306a1fc2f521 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -177,4 +177,14 @@ impl TextPipeline {
         });
         Ok(result)
     }
+
+    fn compute_geometry(
+        &mut self,
+        fonts: &Assets<Font>,
+        sections: &[TextSection],
+        scale_factor: f64,
+        text_alignment: TextAlignment,
+        linebreak_behaviour: BreakLineOn,
+    ) {
+    }
 }

From 540f51e00a8f7fe866b74c7d3b40643108eb2497 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 14 Mar 2023 11:39:55 +0000
Subject: [PATCH 16/38] fixed remaining bugs from merge

---
 crates/bevy_ui/src/lib.rs         | 2 +-
 crates/bevy_ui/src/measurement.rs | 3 ++-
 crates/bevy_ui/src/widget/text.rs | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index fff757815be63..08064eb17ae87 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -32,7 +32,7 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, Interaction,
-        UiScale,
+        UiScale, widget::Label,
     };
 }
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index c232610ab3201..345b8774ca8fa 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,8 +1,9 @@
 use bevy_ecs::prelude::Component;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
+pub use taffy::style::AvailableSpace;
 use std::fmt::Formatter;
-pub use taffy::layout::AvailableSpace;
+
 
 impl std::fmt::Debug for IntrinsicSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 1f253f8640f08..e89cd41bb0e5d 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::measurement::AvailableSpace;
+
 use crate::{IntrinsicSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
@@ -14,6 +14,7 @@ use bevy_text::{
     TextSettings, YAxisOrientation,
 };
 use bevy_window::{PrimaryWindow, Window};
+use taffy::style::AvailableSpace;
 
 fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32

From ac267a93ce74b205209e84c6a71a9efa155be291 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 14 Mar 2023 11:55:41 +0000
Subject: [PATCH 17/38] Renamed `IntrinsicSize` back to `CalculatedSize`, too
 many changes in this PR already.

---
 crates/bevy_ui/src/flex/mod.rs     | 14 +++++++-------
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/measurement.rs  |  8 ++++----
 crates/bevy_ui/src/node_bundles.rs |  6 +++---
 crates/bevy_ui/src/widget/image.rs |  6 +++---
 crates/bevy_ui/src/widget/text.rs  |  6 +++---
 6 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 5dbe4a7b7fc99..e63dc8663a379 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -1,6 +1,6 @@
 mod convert;
 
-use crate::{IntrinsicSize, Node, Style, UiScale};
+use crate::{CalculatedSize, Node, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -80,7 +80,7 @@ impl FlexSurface {
         &mut self,
         entity: Entity,
         style: &Style,
-        calculated_size: &IntrinsicSize,
+        calculated_size: &CalculatedSize,
         scale_factor: f64,
     ) {
         let taffy = &mut self.taffy;
@@ -222,11 +222,11 @@ pub fn flex_node_system(
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut flex_surface: ResMut<FlexSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    node_query: Query<(Entity, &Style, Option<&IntrinsicSize>), (With<Node>, Changed<Style>)>,
-    full_node_query: Query<(Entity, &Style, Option<&IntrinsicSize>), With<Node>>,
+    node_query: Query<(Entity, &Style, Option<&CalculatedSize>), (With<Node>, Changed<Style>)>,
+    full_node_query: Query<(Entity, &Style, Option<&CalculatedSize>), With<Node>>,
     changed_size_query: Query<
-        (Entity, &Style, &IntrinsicSize),
-        (With<Node>, Changed<IntrinsicSize>),
+        (Entity, &Style, &CalculatedSize),
+        (With<Node>, Changed<CalculatedSize>),
     >,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
@@ -252,7 +252,7 @@ pub fn flex_node_system(
     fn update_changed<F: ReadOnlyWorldQuery>(
         flex_surface: &mut FlexSurface,
         scaling_factor: f64,
-        query: Query<(Entity, &Style, Option<&IntrinsicSize>), F>,
+        query: Query<(Entity, &Style, Option<&CalculatedSize>), F>,
     ) {
         // update changed nodes
         for (entity, style, calculated_size) in &query {
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 08064eb17ae87..ba702059f3328 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -85,7 +85,7 @@ impl Plugin for UiPlugin {
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
-            .register_type::<IntrinsicSize>()
+            .register_type::<CalculatedSize>()
             .register_type::<Direction>()
             .register_type::<Display>()
             .register_type::<FlexDirection>()
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 345b8774ca8fa..65aad6dcdaa70 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -5,7 +5,7 @@ pub use taffy::style::AvailableSpace;
 use std::fmt::Formatter;
 
 
-impl std::fmt::Debug for IntrinsicSize {
+impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CalculatedSize")
             .field("size", &self.size)
@@ -55,7 +55,7 @@ impl Measure for FixedMeasure {
 /// A node with an intrinsic size component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
-pub struct IntrinsicSize {
+pub struct CalculatedSize {
     /// Used to track changes
     pub size: Vec2,
     pub min_content: Vec2,
@@ -67,7 +67,7 @@ pub struct IntrinsicSize {
 }
 
 #[allow(clippy::derivable_impls)]
-impl Default for IntrinsicSize {
+impl Default for CalculatedSize {
     fn default() -> Self {
         Self {
             size: Default::default(),
@@ -80,7 +80,7 @@ impl Default for IntrinsicSize {
     }
 }
 
-impl Clone for IntrinsicSize {
+impl Clone for CalculatedSize {
     fn clone(&self) -> Self {
         Self {
             size: self.size,
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 7ab5edfa5cb14..3b925fc6527b1 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,7 +1,7 @@
 //! This module contains basic node bundles used to build UIs
 
 use crate::{
-    widget::Button, BackgroundColor, FocusPolicy, Interaction, IntrinsicSize, Node, Style, UiImage,
+    widget::Button, BackgroundColor, FocusPolicy, Interaction, CalculatedSize, Node, Style, UiImage,
     ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
@@ -69,7 +69,7 @@ pub struct ImageBundle {
     /// Describes the style including flexbox settings
     pub style: Style,
     /// The calculated size based on the given image
-    pub calculated_size: IntrinsicSize,
+    pub calculated_size: CalculatedSize,
     /// The background color, which serves as a "fill" for this node
     ///
     /// Combines with `UiImage` to tint the provided image.
@@ -109,7 +109,7 @@ pub struct TextBundle {
     /// Text layout information
     pub text_layout_info: TextLayoutInfo,
     /// The calculated size based on the given image
-    pub calculated_size: IntrinsicSize,
+    pub calculated_size: CalculatedSize,
     /// Whether this node should block interaction with lower nodes
     pub focus_policy: FocusPolicy,
     /// The transform of the node
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 96dd1506c5895..f8c227f0a2dd1 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,4 +1,4 @@
-use crate::{measurement::AvailableSpace, IntrinsicSize, Measure, UiImage};
+use crate::{measurement::AvailableSpace, CalculatedSize, Measure, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -49,8 +49,8 @@ impl Measure for ImageMeasure {
 /// Updates calculated size of the node based on the image provided
 pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
-    #[cfg(feature = "bevy_text")] mut query: Query<(&mut IntrinsicSize, &UiImage), Without<Text>>,
-    #[cfg(not(feature = "bevy_text"))] mut query: Query<(&mut IntrinsicSize, &UiImage)>,
+    #[cfg(feature = "bevy_text")] mut query: Query<(&mut CalculatedSize, &UiImage), Without<Text>>,
+    #[cfg(not(feature = "bevy_text"))] mut query: Query<(&mut CalculatedSize, &UiImage)>,
 ) {
     for (mut calculated_size, image) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index e89cd41bb0e5d..b0a9300aeef56 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,5 +1,5 @@
 
-use crate::{IntrinsicSize, Measure, Node, UiScale};
+use crate::{CalculatedSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
@@ -77,7 +77,7 @@ pub fn measure_text_system(
     mut text_queries: ParamSet<(
         Query<Entity, Changed<Text>>,
         Query<Entity, (With<Text>, With<Node>)>,
-        Query<(&Text, &mut IntrinsicSize)>,
+        Query<(&Text, &mut CalculatedSize)>,
     )>,
 ) {
     let window_scale_factor = windows
@@ -164,7 +164,7 @@ pub fn text_system(
     mut text_queries: ParamSet<(
         Query<Entity, Or<(Changed<Text>, Changed<Node>)>>,
         Query<Entity, (With<Text>, With<Node>)>,
-        Query<(&Node, &Text, &mut IntrinsicSize, &mut TextLayoutInfo)>,
+        Query<(&Node, &Text, &mut CalculatedSize, &mut TextLayoutInfo)>,
     )>,
 ) {
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621

From 70f5422a7ca6a0289c6584d0214b520e2dc2f57b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 14 Mar 2023 20:55:18 +0000
Subject: [PATCH 18/38] Implemented one pass text `MeasureFunc`

---
 crates/bevy_text/src/pipeline.rs  | 95 ++++++++++++++++++++++++++++++-
 crates/bevy_ui/src/widget/text.rs | 71 ++++++++++++++++-------
 2 files changed, 142 insertions(+), 24 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 4306a1fc2f521..fc9d1b60b1374 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -7,7 +7,7 @@ use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_utils::HashMap;
 
-use glyph_brush_layout::{FontId, SectionText};
+use glyph_brush_layout::{FontId, SectionText, SectionGeometry, GlyphPositioner};
 
 use crate::{
     error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font, FontAtlasSet,
@@ -178,13 +178,102 @@ impl TextPipeline {
         Ok(result)
     }
 
-    fn compute_geometry(
+    pub fn compute_auto_text_measure(
         &mut self,
         fonts: &Assets<Font>,
         sections: &[TextSection],
         scale_factor: f64,
         text_alignment: TextAlignment,
         linebreak_behaviour: BreakLineOn,
-    ) {
+    ) -> Result<AutoTextInfo, TextError> {
+        let mut auto_fonts = vec![];
+        let mut scaled_fonts = Vec::new();
+        let sections = sections
+            .iter()
+            .enumerate()
+            .map(|(i, section)| {
+                let font = fonts
+                    .get(&section.style.font)
+                    .ok_or(TextError::NoSuchFont)?;
+                let font_id = self.get_or_insert_font_id(&section.style.font, font);
+                let font_size = scale_value(section.style.font_size, scale_factor);
+                auto_fonts.push(font.font.clone());
+                let px_scale_font = ab_glyph::Font::into_scaled(font.font.clone(), font_size);
+                scaled_fonts.push(px_scale_font);
+
+                let section = AutoTextSection {
+                    font_id: FontId(i),
+                    scale: PxScale::from(font_size),
+                    text: section.value.clone(),
+                };
+
+                Ok(section)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        
+        Ok(AutoTextInfo {
+            fonts: auto_fonts,
+            scaled_fonts,
+            sections,
+            text_alignment,
+            linebreak_behaviour: linebreak_behaviour.into(),
+        })
+
     }
 }
+
+#[derive(Clone)]
+pub struct AutoTextSection {
+    pub text: String, 
+    pub scale: PxScale,
+    pub font_id: FontId,
+}
+
+#[derive(Clone)]
+pub struct AutoTextInfo {
+    pub fonts: Vec<ab_glyph::FontArc>,
+    pub scaled_fonts: Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
+    pub sections: Vec<AutoTextSection>,
+    pub text_alignment: TextAlignment,
+    pub linebreak_behaviour: glyph_brush_layout::BuiltInLineBreaker,
+}
+
+impl AutoTextInfo {
+    pub fn compute_size(
+        &self,
+        bounds: Vec2,
+    ) -> Vec2 {
+        let geom = SectionGeometry {
+            bounds: (bounds.x, bounds.y),
+            ..Default::default()
+        };
+
+        let sections = self.sections.iter().map(|section| {
+            SectionText {
+                font_id: section.font_id,
+                scale: section.scale,
+                text: &section.text,
+            }
+        }).collect::<Vec<_>>();
+
+        let section_glyphs = glyph_brush_layout::Layout::default()
+            .h_align(self.text_alignment.into())
+            .line_breaker(self.linebreak_behaviour)
+            .calculate_glyphs(&self.fonts, &geom, &sections);
+
+        let mut min_x: f32 = std::f32::MAX;
+        let mut min_y: f32 = std::f32::MAX;
+        let mut max_x: f32 = std::f32::MIN;
+        let mut max_y: f32 = std::f32::MIN;
+
+        for sg in section_glyphs {
+            let scaled_font = &self.scaled_fonts[sg.section_index];
+            let glyph = &sg.glyph;
+            min_x = min_x.min(glyph.position.x);
+            min_y = min_y.min(glyph.position.y - scaled_font.ascent());
+            max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
+            max_y = max_y.max(glyph.position.y - scaled_font.descent());
+        }
+        Vec2::new(max_x - min_x, max_y - min_y)
+    }
+}
\ No newline at end of file
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index b0a9300aeef56..b67e08126a512 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -11,7 +11,7 @@ use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_text::{
     Font, FontAtlasSet, FontAtlasWarning, Text, TextError, TextLayoutInfo, TextPipeline,
-    TextSettings, YAxisOrientation,
+    TextSettings, YAxisOrientation, AutoTextInfo,
 };
 use bevy_window::{PrimaryWindow, Window};
 use taffy::style::AvailableSpace;
@@ -65,6 +65,32 @@ impl Measure for TextMeasure {
     }
 }
 
+#[derive(Clone)]
+pub struct AutoTextMeasure {
+    pub auto_text_info: AutoTextInfo,
+}
+
+
+impl Measure for AutoTextMeasure {
+    fn measure(
+        &self,
+        max_width: Option<f32>,
+        max_height: Option<f32>,
+        _available_width: AvailableSpace,
+        _available_height: AvailableSpace,
+    ) -> Vec2 {
+        let bounds = Vec2::new(
+            max_width.unwrap_or(f32::INFINITY),
+            max_height.unwrap_or(f32::INFINITY),
+        );
+        self.auto_text_info.compute_size(bounds)
+    }
+
+    fn dyn_clone(&self) -> Box<dyn Measure> {
+        Box::new(self.clone())
+    }
+}
+
 /// Creates a `Measure` for text nodes that allows the UI to determine the appropriate amount of space
 /// to provide for the text given the fonts, the text itself and the constraints of the layout.
 pub fn measure_text_system(
@@ -111,23 +137,26 @@ pub fn measure_text_system(
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
         if let Ok((text, mut intrinsic_size)) = query.get_mut(entity) {
-            match text_pipeline.compute_size_constraints(
+            match text_pipeline.compute_auto_text_measure(
                 &fonts,
                 &text.sections,
                 scale_factor,
                 text.alignment,
                 text.linebreak_behaviour,
             ) {
-                Ok([min, max]) => {
-                    let measure = TextMeasure {
-                        min_content: min,
-                        max_content: max,
-                        ideal_height: min.y,
-                    };
-                    intrinsic_size.min_content = min;
-                    intrinsic_size.max_content = max;
-                    intrinsic_size.ideal.y = min.y;
-                    intrinsic_size.measure = Box::new(measure);
+                Ok(measure) => {
+                    // let measure = TextMeasure {
+                    //     min_content: min,
+                    //     max_content: max,
+                    //     ideal_height: min.y,
+                    // };
+                    // intrinsic_size.min_content = min;
+                    // intrinsic_size.max_content = max;
+                    // intrinsic_size.ideal.y = min.y;
+                    // intrinsic_size.measure = Box::new(measure);
+                    intrinsic_size.measure = Box::new(AutoTextMeasure {
+                        auto_text_info: measure,
+                    });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);
@@ -224,15 +253,15 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    if info.size.y != intrinsic_size.ideal.y {
-                        let measure = TextMeasure {
-                            min_content: intrinsic_size.min_content,
-                            max_content: intrinsic_size.max_content,
-                            ideal_height: info.size.y,
-                        };
-                        intrinsic_size.ideal = info.size;
-                        intrinsic_size.measure = Box::new(measure);
-                    }
+                    // if info.size.y != intrinsic_size.ideal.y {
+                    //     let measure = TextMeasure {
+                    //         min_content: intrinsic_size.min_content,
+                    //         max_content: intrinsic_size.max_content,
+                    //         ideal_height: info.size.y,
+                    //     };
+                    //     intrinsic_size.ideal = info.size;
+                    //     intrinsic_size.measure = Box::new(measure);
+                    // }
                     *text_layout_info = info;
                 }
             }

From 1fe7ac709513e819a113787c8d1633cb8191bacd Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 16 Mar 2023 12:08:05 +0000
Subject: [PATCH 19/38] update layout on screensize change

---
 crates/bevy_ui/src/flex/mod.rs    |  8 +++++---
 crates/bevy_ui/src/widget/text.rs | 31 ++++++++++++++++++++++++-------
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index e63dc8663a379..39c4474d7bb2e 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -14,7 +14,7 @@ use bevy_log::warn;
 use bevy_math::Vec2;
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
-use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
+use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged, WindowResized};
 use std::fmt;
 use taffy::{
     prelude::{AvailableSpace, Size},
@@ -220,6 +220,7 @@ pub fn flex_node_system(
     windows: Query<(Entity, &Window)>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
+    mut window_resized_events: EventReader<WindowResized>,
     mut flex_surface: ResMut<FlexSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     node_query: Query<(Entity, &Style, Option<&CalculatedSize>), (With<Node>, Changed<Style>)>,
@@ -264,8 +265,9 @@ pub fn flex_node_system(
             }
         }
     }
-
-    if !scale_factor_events.is_empty() || ui_scale.is_changed() {
+    let window_resized = window_resized_events.iter().any(|event| { event.window == primary_window_entity });
+    
+    if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_resized  { 
         scale_factor_events.clear();
         update_changed(&mut flex_surface, scale_factor, full_node_query);
     } else {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index b67e08126a512..b493aca56af7c 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -32,10 +32,12 @@ impl Measure for TextMeasure {
         &self,
         max_width: Option<f32>,
         max_height: Option<f32>,
-        _: AvailableSpace,
-        _: AvailableSpace,
+        w: AvailableSpace,
+        h: AvailableSpace,
     ) -> Vec2 {
         let mut size = Vec2::ZERO;
+        
+
         match (max_width, max_height) {
             (None, None) => {
                 // with no constraints
@@ -58,6 +60,7 @@ impl Measure for TextMeasure {
         size.x = size.x.ceil();
         size.y = size.y.ceil();
         size
+        
     }
 
     fn dyn_clone(&self) -> Box<dyn Measure> {
@@ -76,14 +79,27 @@ impl Measure for AutoTextMeasure {
         &self,
         max_width: Option<f32>,
         max_height: Option<f32>,
-        _available_width: AvailableSpace,
-        _available_height: AvailableSpace,
+        available_width: AvailableSpace,
+        available_height: AvailableSpace,
     ) -> Vec2 {
+
         let bounds = Vec2::new(
-            max_width.unwrap_or(f32::INFINITY),
-            max_height.unwrap_or(f32::INFINITY),
+            max_width
+            .unwrap_or_else(|| match available_width {
+                AvailableSpace::Definite(x) => x,
+                AvailableSpace::MaxContent => f32::INFINITY,
+                AvailableSpace::MinContent => f32::INFINITY,
+            }),
+            max_height.unwrap_or_else(|| match available_height {
+                AvailableSpace::Definite(y) => y,
+                AvailableSpace::MaxContent => f32::INFINITY,
+                AvailableSpace::MinContent => f32::INFINITY,
+            }),
         );
-        self.auto_text_info.compute_size(bounds)
+
+
+        let size = self.auto_text_info.compute_size(bounds);
+        size
     }
 
     fn dyn_clone(&self) -> Box<dyn Measure> {
@@ -230,6 +246,7 @@ pub fn text_system(
                 scale_value(node.size().x, scale_factor),
                 scale_value(node.size().y, scale_factor),
             );
+            
             match text_pipeline.queue_text(
                 &fonts,
                 &text.sections,

From 8a4c73d3db90c65664a4ba0fbfeafb78ade55544 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Mar 2023 09:45:41 +0000
Subject: [PATCH 20/38] Cleaned up unused code and fields. Renamed `size` field
 of `CalculatedSize` to `previous_size`.

---
 crates/bevy_ui/src/measurement.rs  | 21 +++------
 crates/bevy_ui/src/widget/image.rs |  4 +-
 crates/bevy_ui/src/widget/text.rs  | 75 ++----------------------------
 3 files changed, 11 insertions(+), 89 deletions(-)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index 65aad6dcdaa70..b3c4960224b38 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -8,7 +8,7 @@ use std::fmt::Formatter;
 impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CalculatedSize")
-            .field("size", &self.size)
+            .field("size", &self.previous_size)
             .finish()
     }
 }
@@ -52,15 +52,12 @@ impl Measure for FixedMeasure {
     }
 }
 
-/// A node with an intrinsic size component is a node where its size
+/// A node with a `CalculatedSize` component is a node where its size
 /// is based on its content.
 #[derive(Component, Reflect)]
 pub struct CalculatedSize {
-    /// Used to track changes
-    pub size: Vec2,
-    pub min_content: Vec2,
-    pub max_content: Vec2,
-    pub ideal: Vec2,
+    /// Used to track changes, not required to be set.
+    pub previous_size: Vec2,
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
     pub measure: Box<dyn Measure>,
@@ -70,10 +67,7 @@ pub struct CalculatedSize {
 impl Default for CalculatedSize {
     fn default() -> Self {
         Self {
-            size: Default::default(),
-            min_content: Default::default(),
-            max_content: Default::default(),
-            ideal: Default::default(),
+            previous_size: Default::default(),
             // Default `FixedMeasure` always returns zero size.
             measure: Box::<FixedMeasure>::default(),
         }
@@ -83,10 +77,7 @@ impl Default for CalculatedSize {
 impl Clone for CalculatedSize {
     fn clone(&self) -> Self {
         Self {
-            size: self.size,
-            min_content: Default::default(),
-            max_content: Default::default(),
-            ideal: Default::default(),
+            previous_size: self.previous_size,
             measure: self.measure.dyn_clone(),
         }
     }
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index f8c227f0a2dd1..0ffb2ff08ecd7 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -59,8 +59,8 @@ pub fn update_image_calculated_size_system(
                 texture.texture_descriptor.size.height as f32,
             );
             // Update only if size has changed to avoid needless layout calculations
-            if size != calculated_size.size {
-                calculated_size.size = size;
+            if size != calculated_size.previous_size {
+                calculated_size.previous_size = size;
                 calculated_size.measure = Box::new(ImageMeasure { size });
             }
         }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index b493aca56af7c..7cad9d3e893e7 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -20,60 +20,11 @@ fn scale_value(value: f32, factor: f64) -> f32 {
     (value as f64 * factor) as f32
 }
 
-#[derive(Clone)]
-pub struct TextMeasure {
-    pub min_content: Vec2,
-    pub max_content: Vec2,
-    pub ideal_height: f32,
-}
-
-impl Measure for TextMeasure {
-    fn measure(
-        &self,
-        max_width: Option<f32>,
-        max_height: Option<f32>,
-        w: AvailableSpace,
-        h: AvailableSpace,
-    ) -> Vec2 {
-        let mut size = Vec2::ZERO;
-        
-
-        match (max_width, max_height) {
-            (None, None) => {
-                // with no constraints
-                // ask for maximum width space for text with no wrapping
-                size = self.max_content;
-            }
-            (Some(width), None) => {
-                size.x = width;
-                size.y = self.ideal_height;
-            }
-            (None, Some(height)) => {
-                size.y = height;
-                size.x = self.max_content.x;
-            }
-            (Some(width), Some(height)) => {
-                size.x = width;
-                size.y = height;
-            }
-        }
-        size.x = size.x.ceil();
-        size.y = size.y.ceil();
-        size
-        
-    }
-
-    fn dyn_clone(&self) -> Box<dyn Measure> {
-        Box::new(self.clone())
-    }
-}
-
 #[derive(Clone)]
 pub struct AutoTextMeasure {
     pub auto_text_info: AutoTextInfo,
 }
 
-
 impl Measure for AutoTextMeasure {
     fn measure(
         &self,
@@ -96,8 +47,6 @@ impl Measure for AutoTextMeasure {
                 AvailableSpace::MinContent => f32::INFINITY,
             }),
         );
-
-
         let size = self.auto_text_info.compute_size(bounds);
         size
     }
@@ -152,7 +101,7 @@ pub fn measure_text_system(
     let mut new_queue = Vec::new();
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((text, mut intrinsic_size)) = query.get_mut(entity) {
+        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
             match text_pipeline.compute_auto_text_measure(
                 &fonts,
                 &text.sections,
@@ -161,16 +110,7 @@ pub fn measure_text_system(
                 text.linebreak_behaviour,
             ) {
                 Ok(measure) => {
-                    // let measure = TextMeasure {
-                    //     min_content: min,
-                    //     max_content: max,
-                    //     ideal_height: min.y,
-                    // };
-                    // intrinsic_size.min_content = min;
-                    // intrinsic_size.max_content = max;
-                    // intrinsic_size.ideal.y = min.y;
-                    // intrinsic_size.measure = Box::new(measure);
-                    intrinsic_size.measure = Box::new(AutoTextMeasure {
+                    calculated_size.measure = Box::new(AutoTextMeasure {
                         auto_text_info: measure,
                     });
                 }
@@ -239,7 +179,7 @@ pub fn text_system(
     let mut new_queue = Vec::new();
     let mut text_query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((node, text, mut intrinsic_size, mut text_layout_info)) =
+        if let Ok((node, text, mut calculated_size, mut text_layout_info)) =
             text_query.get_mut(entity)
         {
             let node_size = Vec2::new(
@@ -270,15 +210,6 @@ pub fn text_system(
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(info) => {
-                    // if info.size.y != intrinsic_size.ideal.y {
-                    //     let measure = TextMeasure {
-                    //         min_content: intrinsic_size.min_content,
-                    //         max_content: intrinsic_size.max_content,
-                    //         ideal_height: info.size.y,
-                    //     };
-                    //     intrinsic_size.ideal = info.size;
-                    //     intrinsic_size.measure = Box::new(measure);
-                    // }
                     *text_layout_info = info;
                 }
             }

From 711036b9ef318a56f2bc703d047c27afb935255e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 21 Mar 2023 14:33:54 +0000
Subject: [PATCH 21/38] cargo fmt --all

---
 crates/bevy_text/src/pipeline.rs   | 24 +++++++++++-------------
 crates/bevy_text/src/text2d.rs     |  7 +------
 crates/bevy_ui/src/flex/mod.rs     | 12 ++++++++----
 crates/bevy_ui/src/lib.rs          | 17 ++++++++---------
 crates/bevy_ui/src/measurement.rs  |  3 +--
 crates/bevy_ui/src/node_bundles.rs |  4 ++--
 crates/bevy_ui/src/widget/text.rs  | 11 ++++-------
 7 files changed, 35 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index fc9d1b60b1374..7c3f5a7a17c26 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -7,7 +7,7 @@ use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_utils::HashMap;
 
-use glyph_brush_layout::{FontId, SectionText, SectionGeometry, GlyphPositioner};
+use glyph_brush_layout::{FontId, GlyphPositioner, SectionGeometry, SectionText};
 
 use crate::{
     error::TextError, glyph_brush::GlyphBrush, scale_value, BreakLineOn, Font, FontAtlasSet,
@@ -210,7 +210,7 @@ impl TextPipeline {
                 Ok(section)
             })
             .collect::<Result<Vec<_>, _>>()?;
-        
+
         Ok(AutoTextInfo {
             fonts: auto_fonts,
             scaled_fonts,
@@ -218,13 +218,12 @@ impl TextPipeline {
             text_alignment,
             linebreak_behaviour: linebreak_behaviour.into(),
         })
-
     }
 }
 
 #[derive(Clone)]
 pub struct AutoTextSection {
-    pub text: String, 
+    pub text: String,
     pub scale: PxScale,
     pub font_id: FontId,
 }
@@ -239,22 +238,21 @@ pub struct AutoTextInfo {
 }
 
 impl AutoTextInfo {
-    pub fn compute_size(
-        &self,
-        bounds: Vec2,
-    ) -> Vec2 {
+    pub fn compute_size(&self, bounds: Vec2) -> Vec2 {
         let geom = SectionGeometry {
             bounds: (bounds.x, bounds.y),
             ..Default::default()
         };
 
-        let sections = self.sections.iter().map(|section| {
-            SectionText {
+        let sections = self
+            .sections
+            .iter()
+            .map(|section| SectionText {
                 font_id: section.font_id,
                 scale: section.scale,
                 text: &section.text,
-            }
-        }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
 
         let section_glyphs = glyph_brush_layout::Layout::default()
             .h_align(self.text_alignment.into())
@@ -276,4 +274,4 @@ impl AutoTextInfo {
         }
         Vec2::new(max_x - min_x, max_y - min_y)
     }
-}
\ No newline at end of file
+}
diff --git a/crates/bevy_text/src/text2d.rs b/crates/bevy_text/src/text2d.rs
index 7ac024f54fbb7..580ddffba569d 100644
--- a/crates/bevy_text/src/text2d.rs
+++ b/crates/bevy_text/src/text2d.rs
@@ -159,12 +159,7 @@ pub fn update_text2d_layout(
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(
-        Entity,
-        Ref<Text>,
-        Ref<Text2dBounds>,
-        &mut TextLayoutInfo,
-    )>,
+    mut text_query: Query<(Entity, Ref<Text>, Ref<Text2dBounds>, &mut TextLayoutInfo)>,
 ) {
     // We need to consume the entire iterator, hence `last`
     let factor_changed = scale_factor_changed.iter().last().is_some();
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 39c4474d7bb2e..1554b039e99b7 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -14,7 +14,9 @@ use bevy_log::warn;
 use bevy_math::Vec2;
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
-use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged, WindowResized};
+use bevy_window::{
+    PrimaryWindow, Window, WindowResized, WindowResolution, WindowScaleFactorChanged,
+};
 use std::fmt;
 use taffy::{
     prelude::{AvailableSpace, Size},
@@ -265,9 +267,11 @@ pub fn flex_node_system(
             }
         }
     }
-    let window_resized = window_resized_events.iter().any(|event| { event.window == primary_window_entity });
-    
-    if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_resized  { 
+    let window_resized = window_resized_events
+        .iter()
+        .any(|event| event.window == primary_window_entity);
+
+    if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_resized {
         scale_factor_events.clear();
         update_changed(&mut flex_surface, scale_factor, full_node_query);
     } else {
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index fd44099ef70d0..ea31968336e6e 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -31,8 +31,8 @@ pub use ui_node::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, Interaction,
-        UiScale, widget::Label,
+        camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::Button, widget::Label,
+        Interaction, UiScale,
     };
 }
 
@@ -143,13 +143,12 @@ impl Plugin for UiPlugin {
         })
         .add_systems(
             PostUpdate,
-        (
-            flex_node_system
-                .in_set(UiSystem::Flex)
-                .before(TransformSystem::TransformPropagate),
-            ui_stack_system.in_set(UiSystem::Stack),
-            update_clipping_system
-                .after(TransformSystem::TransformPropagate),
+            (
+                flex_node_system
+                    .in_set(UiSystem::Flex)
+                    .before(TransformSystem::TransformPropagate),
+                ui_stack_system.in_set(UiSystem::Stack),
+                update_clipping_system.after(TransformSystem::TransformPropagate),
                 widget::text_system.after(UiSystem::Flex),
             ),
         );
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index b3c4960224b38..e0294ac20b26c 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -1,9 +1,8 @@
 use bevy_ecs::prelude::Component;
 use bevy_math::Vec2;
 use bevy_reflect::Reflect;
-pub use taffy::style::AvailableSpace;
 use std::fmt::Formatter;
-
+pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 3b925fc6527b1..12a8d1517ae3a 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,8 +1,8 @@
 //! This module contains basic node bundles used to build UIs
 
 use crate::{
-    widget::Button, BackgroundColor, FocusPolicy, Interaction, CalculatedSize, Node, Style, UiImage,
-    ZIndex,
+    widget::Button, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style,
+    UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 7cad9d3e893e7..acf7e71b25816 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,3 @@
-
 use crate::{CalculatedSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
@@ -10,8 +9,8 @@ use bevy_math::Vec2;
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_text::{
-    Font, FontAtlasSet, FontAtlasWarning, Text, TextError, TextLayoutInfo, TextPipeline,
-    TextSettings, YAxisOrientation, AutoTextInfo,
+    AutoTextInfo, Font, FontAtlasSet, FontAtlasWarning, Text, TextError, TextLayoutInfo,
+    TextPipeline, TextSettings, YAxisOrientation,
 };
 use bevy_window::{PrimaryWindow, Window};
 use taffy::style::AvailableSpace;
@@ -33,10 +32,8 @@ impl Measure for AutoTextMeasure {
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2 {
-
         let bounds = Vec2::new(
-            max_width
-            .unwrap_or_else(|| match available_width {
+            max_width.unwrap_or_else(|| match available_width {
                 AvailableSpace::Definite(x) => x,
                 AvailableSpace::MaxContent => f32::INFINITY,
                 AvailableSpace::MinContent => f32::INFINITY,
@@ -186,7 +183,7 @@ pub fn text_system(
                 scale_value(node.size().x, scale_factor),
                 scale_value(node.size().y, scale_factor),
             );
-            
+
             match text_pipeline.queue_text(
                 &fonts,
                 &text.sections,

From 941c018ad2bfd50c545175d049d21ebb7791418f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 31 Mar 2023 15:14:07 +0100
Subject: [PATCH 22/38] changes: * rewrote text measurefunc * text bounds for
 min and max content widths are precomputed

---
 crates/bevy_text/src/pipeline.rs  | 23 ++++++++----
 crates/bevy_ui/src/flex/mod.rs    |  4 +-
 crates/bevy_ui/src/widget/text.rs | 61 +++++++++++++++++--------------
 3 files changed, 50 insertions(+), 38 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 7c3f5a7a17c26..175f05167691f 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -185,7 +185,7 @@ impl TextPipeline {
         scale_factor: f64,
         text_alignment: TextAlignment,
         linebreak_behaviour: BreakLineOn,
-    ) -> Result<AutoTextInfo, TextError> {
+    ) -> Result<TextMeasureInfo, TextError> {
         let mut auto_fonts = vec![];
         let mut scaled_fonts = Vec::new();
         let sections = sections
@@ -201,7 +201,7 @@ impl TextPipeline {
                 let px_scale_font = ab_glyph::Font::into_scaled(font.font.clone(), font_size);
                 scaled_fonts.push(px_scale_font);
 
-                let section = AutoTextSection {
+                let section = TextMeasureSection {
                     font_id: FontId(i),
                     scale: PxScale::from(font_size),
                     text: section.value.clone(),
@@ -211,33 +211,40 @@ impl TextPipeline {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(AutoTextInfo {
+        let mut info = TextMeasureInfo {
             fonts: auto_fonts,
             scaled_fonts,
             sections,
             text_alignment,
             linebreak_behaviour: linebreak_behaviour.into(),
-        })
+            min_width_content_size: Vec2::ZERO,
+            max_width_content_size: Vec2::ZERO,
+        };
+        info.min_width_content_size = info.compute_size(Vec2::new(0.0, f32::INFINITY));
+        info.max_width_content_size = info.compute_size(Vec2::new(f32::INFINITY, f32::INFINITY));
+        Ok(info)
     }
 }
 
 #[derive(Clone)]
-pub struct AutoTextSection {
+pub struct TextMeasureSection {
     pub text: String,
     pub scale: PxScale,
     pub font_id: FontId,
 }
 
 #[derive(Clone)]
-pub struct AutoTextInfo {
+pub struct TextMeasureInfo {
     pub fonts: Vec<ab_glyph::FontArc>,
     pub scaled_fonts: Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
-    pub sections: Vec<AutoTextSection>,
+    pub sections: Vec<TextMeasureSection>,
     pub text_alignment: TextAlignment,
     pub linebreak_behaviour: glyph_brush_layout::BuiltInLineBreaker,
+    pub min_width_content_size: Vec2,
+    pub max_width_content_size: Vec2,
 }
 
-impl AutoTextInfo {
+impl TextMeasureInfo {
     pub fn compute_size(&self, bounds: Vec2) -> Vec2 {
         let geom = SectionGeometry {
             bounds: (bounds.x, bounds.y),
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 69c23cec11073..f1fa853aece7b 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -14,9 +14,7 @@ use bevy_log::warn;
 use bevy_math::Vec2;
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
-use bevy_window::{
-    PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged,
-};
+use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
     prelude::{AvailableSpace, Size},
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index acf7e71b25816..d03040ed76ac8 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -9,7 +9,7 @@ use bevy_math::Vec2;
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
 use bevy_text::{
-    AutoTextInfo, Font, FontAtlasSet, FontAtlasWarning, Text, TextError, TextLayoutInfo,
+    Font, FontAtlasSet, FontAtlasWarning, Text, TextError, TextLayoutInfo, TextMeasureInfo,
     TextPipeline, TextSettings, YAxisOrientation,
 };
 use bevy_window::{PrimaryWindow, Window};
@@ -20,32 +20,43 @@ fn scale_value(value: f32, factor: f64) -> f32 {
 }
 
 #[derive(Clone)]
-pub struct AutoTextMeasure {
-    pub auto_text_info: AutoTextInfo,
+pub struct TextMeasure {
+    pub info: TextMeasureInfo,
 }
 
-impl Measure for AutoTextMeasure {
+impl Measure for TextMeasure {
     fn measure(
         &self,
-        max_width: Option<f32>,
-        max_height: Option<f32>,
+        width: Option<f32>,
+        height: Option<f32>,
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2 {
-        let bounds = Vec2::new(
-            max_width.unwrap_or_else(|| match available_width {
-                AvailableSpace::Definite(x) => x,
-                AvailableSpace::MaxContent => f32::INFINITY,
-                AvailableSpace::MinContent => f32::INFINITY,
-            }),
-            max_height.unwrap_or_else(|| match available_height {
-                AvailableSpace::Definite(y) => y,
-                AvailableSpace::MaxContent => f32::INFINITY,
-                AvailableSpace::MinContent => f32::INFINITY,
-            }),
-        );
-        let size = self.auto_text_info.compute_size(bounds);
-        size
+        let x = width.unwrap_or_else(|| match available_width {
+            AvailableSpace::Definite(x) => x.clamp(
+                self.info.min_width_content_size.x,
+                self.info.max_width_content_size.x,
+            ),
+            AvailableSpace::MinContent => self.info.min_width_content_size.x,
+            AvailableSpace::MaxContent => self.info.max_width_content_size.x,
+        });
+
+        height
+            .map_or_else(
+                || match available_height {
+                    AvailableSpace::Definite(y) => {
+                        let y = y.clamp(
+                            self.info.max_width_content_size.y,
+                            self.info.min_width_content_size.y,
+                        );
+                        self.info.compute_size(Vec2::new(x, y))
+                    }
+                    AvailableSpace::MinContent => Vec2::new(x, self.info.max_width_content_size.y),
+                    AvailableSpace::MaxContent => Vec2::new(x, self.info.min_width_content_size.y),
+                },
+                |y| Vec2::new(x, y),
+            )
+            .ceil()
     }
 
     fn dyn_clone(&self) -> Box<dyn Measure> {
@@ -107,9 +118,7 @@ pub fn measure_text_system(
                 text.linebreak_behaviour,
             ) {
                 Ok(measure) => {
-                    calculated_size.measure = Box::new(AutoTextMeasure {
-                        auto_text_info: measure,
-                    });
+                    calculated_size.measure = Box::new(TextMeasure { info: measure });
                 }
                 Err(TextError::NoSuchFont) => {
                     new_queue.push(entity);
@@ -146,7 +155,7 @@ pub fn text_system(
     mut text_queries: ParamSet<(
         Query<Entity, Or<(Changed<Text>, Changed<Node>)>>,
         Query<Entity, (With<Text>, With<Node>)>,
-        Query<(&Node, &Text, &mut CalculatedSize, &mut TextLayoutInfo)>,
+        Query<(&Node, &Text, &mut TextLayoutInfo)>,
     )>,
 ) {
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -176,9 +185,7 @@ pub fn text_system(
     let mut new_queue = Vec::new();
     let mut text_query = text_queries.p2();
     for entity in queued_text.drain(..) {
-        if let Ok((node, text, mut calculated_size, mut text_layout_info)) =
-            text_query.get_mut(entity)
-        {
+        if let Ok((node, text, mut text_layout_info)) = text_query.get_mut(entity) {
             let node_size = Vec2::new(
                 scale_value(node.size().x, scale_factor),
                 scale_value(node.size().y, scale_factor),

From 89eb5052779a57d31e00ddf6f40c5e0a33d2fcf0 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 31 Mar 2023 15:18:24 +0100
Subject: [PATCH 23/38] taffy dependency version to 0.3.10

---
 crates/bevy_ui/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index cfe142b088ebf..b927f278feeab 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -31,7 +31,7 @@ bevy_window = { path = "../bevy_window", version = "0.11.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
 
 # other
-taffy = { version = "0.3.5", default-features = false, features = ["std"] }
+taffy = { version = "0.3.10", default-features = false, features = ["std"] }
 serde = { version = "1", features = ["derive"] }
 smallvec = { version = "1.6", features = ["union", "const_generics"] }
 bytemuck = { version = "1.5", features = ["derive"] }

From ffb59a8d3f20a0f73d8678fb0e6f2534ff2022e6 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 31 Mar 2023 15:26:21 +0100
Subject: [PATCH 24/38] removed some unused code

---
 crates/bevy_text/src/pipeline.rs  | 64 -------------------------------
 crates/bevy_ui/src/measurement.rs |  4 +-
 2 files changed, 2 insertions(+), 66 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 175f05167691f..74e076df29f7d 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -115,69 +115,6 @@ impl TextPipeline {
         Ok(TextLayoutInfo { glyphs, size })
     }
 
-    // hacked up `queue_text` that returns the text size constraints, there should be a better solution
-    pub fn compute_size_constraints(
-        &mut self,
-        fonts: &Assets<Font>,
-        sections: &[TextSection],
-        scale_factor: f64,
-        text_alignment: TextAlignment,
-        linebreak_behaviour: BreakLineOn,
-    ) -> Result<[Vec2; 2], TextError> {
-        let mut scaled_fonts = Vec::new();
-        let sections = sections
-            .iter()
-            .map(|section| {
-                let font = fonts
-                    .get(&section.style.font)
-                    .ok_or(TextError::NoSuchFont)?;
-                let font_id = self.get_or_insert_font_id(&section.style.font, font);
-                let font_size = scale_value(section.style.font_size, scale_factor);
-
-                let px_scale_font = ab_glyph::Font::into_scaled(font.font.clone(), font_size);
-                scaled_fonts.push(px_scale_font);
-
-                let section = SectionText {
-                    font_id,
-                    scale: PxScale::from(font_size),
-                    text: &section.value,
-                };
-
-                Ok(section)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let result = [
-            Vec2::new(0.0, f32::INFINITY),
-            Vec2::new(f32::INFINITY, f32::INFINITY),
-        ]
-        .map(|bounds| {
-            if let Ok(section_glyphs) =
-                self.brush
-                    .compute_glyphs(&sections, bounds, text_alignment, linebreak_behaviour)
-            {
-                let mut min_x: f32 = std::f32::MAX;
-                let mut min_y: f32 = std::f32::MAX;
-                let mut max_x: f32 = std::f32::MIN;
-                let mut max_y: f32 = std::f32::MIN;
-
-                for sg in section_glyphs {
-                    let scaled_font = &scaled_fonts[sg.section_index];
-                    let glyph = &sg.glyph;
-                    min_x = min_x.min(glyph.position.x);
-                    min_y = min_y.min(glyph.position.y - scaled_font.ascent());
-                    max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
-                    max_y = max_y.max(glyph.position.y - scaled_font.descent());
-                }
-
-                Vec2::new(max_x - min_x, max_y - min_y)
-            } else {
-                Vec2::ZERO
-            }
-        });
-        Ok(result)
-    }
-
     pub fn compute_auto_text_measure(
         &mut self,
         fonts: &Assets<Font>,
@@ -195,7 +132,6 @@ impl TextPipeline {
                 let font = fonts
                     .get(&section.style.font)
                     .ok_or(TextError::NoSuchFont)?;
-                let font_id = self.get_or_insert_font_id(&section.style.font, font);
                 let font_size = scale_value(section.style.font_size, scale_factor);
                 auto_fonts.push(font.font.clone());
                 let px_scale_font = ab_glyph::Font::into_scaled(font.font.clone(), font_size);
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index e0294ac20b26c..b267de94f1910 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -18,8 +18,8 @@ pub trait Measure: Send + Sync + 'static {
     /// Calculate the size of the node given the constraints.
     fn measure(
         &self,
-        max_width: Option<f32>,
-        max_height: Option<f32>,
+        width: Option<f32>,
+        height: Option<f32>,
         available_width: AvailableSpace,
         available_height: AvailableSpace,
     ) -> Vec2;

From cbb1d173e956aeebfd102e42b68f8b0fec6ffd7c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 31 Mar 2023 17:19:17 +0100
Subject: [PATCH 25/38] reuse section texts vec when computing min and max
 content size

---
 crates/bevy_text/src/pipeline.rs  | 35 ++++++++++++++++++++-----------
 crates/bevy_ui/src/widget/text.rs |  2 +-
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 74e076df29f7d..e060a0ac297a0 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -115,7 +115,7 @@ impl TextPipeline {
         Ok(TextLayoutInfo { glyphs, size })
     }
 
-    pub fn compute_auto_text_measure(
+    pub fn create_text_measure(
         &mut self,
         fonts: &Assets<Font>,
         sections: &[TextSection],
@@ -156,8 +156,13 @@ impl TextPipeline {
             min_width_content_size: Vec2::ZERO,
             max_width_content_size: Vec2::ZERO,
         };
-        info.min_width_content_size = info.compute_size(Vec2::new(0.0, f32::INFINITY));
-        info.max_width_content_size = info.compute_size(Vec2::new(f32::INFINITY, f32::INFINITY));
+
+        let section_texts = info.prepare_section_texts();
+        let min = info.compute_size_from_section_texts(&section_texts, Vec2::new(0.0, f32::INFINITY));
+        let max = info.compute_size_from_section_texts(&section_texts, Vec2::new(f32::INFINITY, f32::INFINITY));
+        info.min_width_content_size = min;
+        info.max_width_content_size = max;
+
         Ok(info)
     }
 }
@@ -181,22 +186,22 @@ pub struct TextMeasureInfo {
 }
 
 impl TextMeasureInfo {
-    pub fn compute_size(&self, bounds: Vec2) -> Vec2 {
-        let geom = SectionGeometry {
-            bounds: (bounds.x, bounds.y),
-            ..Default::default()
-        };
-
-        let sections = self
-            .sections
+    fn prepare_section_texts(&self) -> Vec<SectionText> {
+        self.sections
             .iter()
             .map(|section| SectionText {
                 font_id: section.font_id,
                 scale: section.scale,
                 text: &section.text,
             })
-            .collect::<Vec<_>>();
+            .collect::<Vec<_>>()
+    }
 
+    fn compute_size_from_section_texts(&self, sections: &[SectionText], bounds: Vec2) -> Vec2 {
+        let geom = SectionGeometry {
+            bounds: (bounds.x, bounds.y),
+            ..Default::default()
+        };
         let section_glyphs = glyph_brush_layout::Layout::default()
             .h_align(self.text_alignment.into())
             .line_breaker(self.linebreak_behaviour)
@@ -215,6 +220,12 @@ impl TextMeasureInfo {
             max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
             max_y = max_y.max(glyph.position.y - scaled_font.descent());
         }
+
         Vec2::new(max_x - min_x, max_y - min_y)
     }
+
+    pub fn compute_size(&self, bounds: Vec2) -> Vec2 {
+        let sections = self.prepare_section_texts();
+        self.compute_size_from_section_texts(&sections, bounds)
+    }
 }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index d03040ed76ac8..7b655831acd3c 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -110,7 +110,7 @@ pub fn measure_text_system(
     let mut query = text_queries.p2();
     for entity in queued_text.drain(..) {
         if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
-            match text_pipeline.compute_auto_text_measure(
+            match text_pipeline.create_text_measure(
                 &fonts,
                 &text.sections,
                 scale_factor,

From 8547ce2cc0a74072c5a78dcd7f8335607f752678 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:04:05 +0100
Subject: [PATCH 26/38] changes: * Removed the `previous_size` field from
 `CalculatedSize` and replaced it with the component `UiImageSize`. The only
 purpose of the `previous_size` component of `CalculatedSize` was for image
 size change detection. It makes much more sense to store the image size
 directly in its own component and it enables users to query the size of a
 node's image if they need to. * Added the `UiImageSize` component to
 `ImageBundle`.

---
 crates/bevy_ui/src/measurement.rs  |  5 -----
 crates/bevy_ui/src/node_bundles.rs |  6 +++++-
 crates/bevy_ui/src/widget/image.rs | 27 ++++++++++++++++++++-------
 3 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index b267de94f1910..fa5180ae3102f 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -7,7 +7,6 @@ pub use taffy::style::AvailableSpace;
 impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CalculatedSize")
-            .field("size", &self.previous_size)
             .finish()
     }
 }
@@ -55,8 +54,6 @@ impl Measure for FixedMeasure {
 /// is based on its content.
 #[derive(Component, Reflect)]
 pub struct CalculatedSize {
-    /// Used to track changes, not required to be set.
-    pub previous_size: Vec2,
     /// The `Measure` used to compute the intrinsic size
     #[reflect(ignore)]
     pub measure: Box<dyn Measure>,
@@ -66,7 +63,6 @@ pub struct CalculatedSize {
 impl Default for CalculatedSize {
     fn default() -> Self {
         Self {
-            previous_size: Default::default(),
             // Default `FixedMeasure` always returns zero size.
             measure: Box::<FixedMeasure>::default(),
         }
@@ -76,7 +72,6 @@ impl Default for CalculatedSize {
 impl Clone for CalculatedSize {
     fn clone(&self) -> Self {
         Self {
-            previous_size: self.previous_size,
             measure: self.measure.dyn_clone(),
         }
     }
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 12a8d1517ae3a..25f6bc47d5e2d 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,7 +1,7 @@
 //! This module contains basic node bundles used to build UIs
 
 use crate::{
-    widget::Button, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style,
+    widget::{Button, UiImageSize}, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style,
     UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
@@ -76,6 +76,10 @@ pub struct ImageBundle {
     pub background_color: BackgroundColor,
     /// The image of the node
     pub image: UiImage,
+    /// The size of the image in pixels
+    /// 
+    /// This field is set automatically
+    pub image_size: UiImageSize,
     /// Whether this node should block interaction with lower nodes
     pub focus_policy: FocusPolicy,
     /// The transform of the node
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 0ffb2ff08ecd7..1935190c84fad 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,13 +1,26 @@
-use crate::{measurement::AvailableSpace, CalculatedSize, Measure, UiImage};
+use crate::{measurement::AvailableSpace, CalculatedSize, Measure, UiImage, Node};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
-use bevy_ecs::system::{Query, Res};
+use bevy_ecs::{system::{Query, Res}, prelude::Component, query::With};
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
 #[cfg(feature = "bevy_text")]
 use bevy_text::Text;
 
+/// The size of the image in pixels
+/// 
+/// This field is set automatically
+
+#[derive(Component, Copy, Clone, Debug, Default)]
+pub struct UiImageSize { size: Vec2 }
+
+impl UiImageSize {
+    pub fn size(&self) -> Vec2 {
+        self.size
+    }
+}
+
 #[derive(Clone)]
 pub struct ImageMeasure {
     // target size of the image
@@ -49,18 +62,18 @@ impl Measure for ImageMeasure {
 /// Updates calculated size of the node based on the image provided
 pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
-    #[cfg(feature = "bevy_text")] mut query: Query<(&mut CalculatedSize, &UiImage), Without<Text>>,
-    #[cfg(not(feature = "bevy_text"))] mut query: Query<(&mut CalculatedSize, &UiImage)>,
+    #[cfg(feature = "bevy_text")] mut query: Query<(&mut CalculatedSize, &UiImage, &mut UiImageSize), (With<Node>, Without<Text>)>,
+    #[cfg(not(feature = "bevy_text"))] mut query: Query<(&mut CalculatedSize, &UiImage, &mut UiImageSize), With<Node>>,
 ) {
-    for (mut calculated_size, image) in &mut query {
+    for (mut calculated_size, image, mut image_size) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {
             let size = Vec2::new(
                 texture.texture_descriptor.size.width as f32,
                 texture.texture_descriptor.size.height as f32,
             );
             // Update only if size has changed to avoid needless layout calculations
-            if size != calculated_size.previous_size {
-                calculated_size.previous_size = size;
+            if size != image_size.size {
+                image_size.size = size;
                 calculated_size.measure = Box::new(ImageMeasure { size });
             }
         }

From 6c15af95b42a7f8554b2ee61a1d38c0ca32c7239 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:24:53 +0100
Subject: [PATCH 27/38] formatting

---
 crates/bevy_text/src/pipeline.rs   | 10 +++++++---
 crates/bevy_ui/src/measurement.rs  |  3 +--
 crates/bevy_ui/src/node_bundles.rs |  6 +++---
 crates/bevy_ui/src/widget/image.rs | 24 ++++++++++++++++++------
 4 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 8f08c4192bfdd..dedc406d4b2fa 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -123,7 +123,7 @@ impl TextPipeline {
         text_alignment: TextAlignment,
         linebreak_behaviour: BreakLineOn,
     ) -> Result<TextMeasureInfo, TextError> {
-        let mut auto_fonts = vec![];
+        let mut auto_fonts = Vec::new();
         let mut scaled_fonts = Vec::new();
         let sections = sections
             .iter()
@@ -158,8 +158,12 @@ impl TextPipeline {
         };
 
         let section_texts = info.prepare_section_texts();
-        let min = info.compute_size_from_section_texts(&section_texts, Vec2::new(0.0, f32::INFINITY));
-        let max = info.compute_size_from_section_texts(&section_texts, Vec2::new(f32::INFINITY, f32::INFINITY));
+        let min =
+            info.compute_size_from_section_texts(&section_texts, Vec2::new(0.0, f32::INFINITY));
+        let max = info.compute_size_from_section_texts(
+            &section_texts,
+            Vec2::new(f32::INFINITY, f32::INFINITY),
+        );
         info.min_width_content_size = min;
         info.max_width_content_size = max;
 
diff --git a/crates/bevy_ui/src/measurement.rs b/crates/bevy_ui/src/measurement.rs
index fa5180ae3102f..1fffffeacbe36 100644
--- a/crates/bevy_ui/src/measurement.rs
+++ b/crates/bevy_ui/src/measurement.rs
@@ -6,8 +6,7 @@ pub use taffy::style::AvailableSpace;
 
 impl std::fmt::Debug for CalculatedSize {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CalculatedSize")
-            .finish()
+        f.debug_struct("CalculatedSize").finish()
     }
 }
 
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 25f6bc47d5e2d..1219597269fd3 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,8 +1,8 @@
 //! This module contains basic node bundles used to build UIs
 
 use crate::{
-    widget::{Button, UiImageSize}, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style,
-    UiImage, ZIndex,
+    widget::{Button, UiImageSize},
+    BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -77,7 +77,7 @@ pub struct ImageBundle {
     /// The image of the node
     pub image: UiImage,
     /// The size of the image in pixels
-    /// 
+    ///
     /// This field is set automatically
     pub image_size: UiImageSize,
     /// Whether this node should block interaction with lower nodes
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 1935190c84fad..00bdd0c8d9831 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,19 +1,25 @@
-use crate::{measurement::AvailableSpace, CalculatedSize, Measure, UiImage, Node};
+use crate::{measurement::AvailableSpace, CalculatedSize, Measure, Node, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
-use bevy_ecs::{system::{Query, Res}, prelude::Component, query::With};
+use bevy_ecs::{
+    prelude::Component,
+    query::With,
+    system::{Query, Res},
+};
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
 #[cfg(feature = "bevy_text")]
 use bevy_text::Text;
 
 /// The size of the image in pixels
-/// 
+///
 /// This field is set automatically
 
 #[derive(Component, Copy, Clone, Debug, Default)]
-pub struct UiImageSize { size: Vec2 }
+pub struct UiImageSize {
+    size: Vec2,
+}
 
 impl UiImageSize {
     pub fn size(&self) -> Vec2 {
@@ -62,8 +68,14 @@ impl Measure for ImageMeasure {
 /// Updates calculated size of the node based on the image provided
 pub fn update_image_calculated_size_system(
     textures: Res<Assets<Image>>,
-    #[cfg(feature = "bevy_text")] mut query: Query<(&mut CalculatedSize, &UiImage, &mut UiImageSize), (With<Node>, Without<Text>)>,
-    #[cfg(not(feature = "bevy_text"))] mut query: Query<(&mut CalculatedSize, &UiImage, &mut UiImageSize), With<Node>>,
+    #[cfg(feature = "bevy_text")] mut query: Query<
+        (&mut CalculatedSize, &UiImage, &mut UiImageSize),
+        (With<Node>, Without<Text>),
+    >,
+    #[cfg(not(feature = "bevy_text"))] mut query: Query<
+        (&mut CalculatedSize, &UiImage, &mut UiImageSize),
+        With<Node>,
+    >,
 ) {
     for (mut calculated_size, image, mut image_size) in &mut query {
         if let Some(texture) = textures.get(&image.texture) {

From 08aa11c2d442226c9f49e2982bf4ae7d12cf3ac0 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:40:30 +0100
Subject: [PATCH 28/38] Added a constructor function to `TextMeasureInfo`

---
 crates/bevy_text/src/pipeline.rs | 51 +++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index dedc406d4b2fa..55ce08d9c9262 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -147,27 +147,13 @@ impl TextPipeline {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let mut info = TextMeasureInfo {
-            fonts: auto_fonts,
+        Ok(TextMeasureInfo::new(
+            auto_fonts,
             scaled_fonts,
             sections,
             text_alignment,
-            linebreak_behaviour: linebreak_behaviour.into(),
-            min_width_content_size: Vec2::ZERO,
-            max_width_content_size: Vec2::ZERO,
-        };
-
-        let section_texts = info.prepare_section_texts();
-        let min =
-            info.compute_size_from_section_texts(&section_texts, Vec2::new(0.0, f32::INFINITY));
-        let max = info.compute_size_from_section_texts(
-            &section_texts,
-            Vec2::new(f32::INFINITY, f32::INFINITY),
-        );
-        info.min_width_content_size = min;
-        info.max_width_content_size = max;
-
-        Ok(info)
+            linebreak_behaviour.into(),
+        ))
     }
 }
 
@@ -190,6 +176,35 @@ pub struct TextMeasureInfo {
 }
 
 impl TextMeasureInfo {
+    fn new(
+        fonts: Vec<ab_glyph::FontArc>,
+        scaled_fonts: Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,
+        sections: Vec<TextMeasureSection>,
+        text_alignment: TextAlignment,
+        linebreak_behaviour: glyph_brush_layout::BuiltInLineBreaker,
+    ) -> Self {
+        let mut info = Self {
+            fonts: auto_fonts,
+            scaled_fonts,
+            sections,
+            text_alignment,
+            linebreak_behaviour: linebreak_behaviour.into(),
+            min_width_content_size: Vec2::ZERO,
+            max_width_content_size: Vec2::ZERO,
+        };
+
+        let section_texts = info.prepare_section_texts();
+        let min =
+            info.compute_size_from_section_texts(&section_texts, Vec2::new(0.0, f32::INFINITY));
+        let max = info.compute_size_from_section_texts(
+            &section_texts,
+            Vec2::new(f32::INFINITY, f32::INFINITY),
+        );
+        info.min_width_content_size = min;
+        info.max_width_content_size = max;
+        info
+    }
+
     fn prepare_section_texts(&self) -> Vec<SectionText> {
         self.sections
             .iter()

From 410a4ec1442592d8ea44ceda7eac55d7b641f021 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:44:13 +0100
Subject: [PATCH 29/38] Added a comment explaining the font coordinate
 calculations.

---
 crates/bevy_text/src/pipeline.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 55ce08d9c9262..d10382c9e8bc7 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -92,6 +92,9 @@ impl TextPipeline {
         for sg in &section_glyphs {
             let scaled_font = scaled_fonts[sg.section_index];
             let glyph = &sg.glyph;
+            // The fonts use a coordinate system increasing upwards so ascent is a positive value
+            //  and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
+            // so we have to subtract from the baseline position to get the minimum and maximum values.
             min_x = min_x.min(glyph.position.x);
             min_y = min_y.min(glyph.position.y - scaled_font.ascent());
             max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));
@@ -234,6 +237,9 @@ impl TextMeasureInfo {
         for sg in section_glyphs {
             let scaled_font = &self.scaled_fonts[sg.section_index];
             let glyph = &sg.glyph;
+            // The fonts use a coordinate system increasing upwards so ascent is a positive value
+            //  and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
+            // so we have to subtract from the baseline position to get the minimum and maximum values.
             min_x = min_x.min(glyph.position.x);
             min_y = min_y.min(glyph.position.y - scaled_font.ascent());
             max_x = max_x.max(glyph.position.x + scaled_font.h_advance(glyph.id));

From a04e100bc21a229fe4e13cf27a50e63840e24d57 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:47:00 +0100
Subject: [PATCH 30/38] fix misnamed variable

---
 crates/bevy_text/src/pipeline.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index d10382c9e8bc7..d485f1c679568 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -187,7 +187,7 @@ impl TextMeasureInfo {
         linebreak_behaviour: glyph_brush_layout::BuiltInLineBreaker,
     ) -> Self {
         let mut info = Self {
-            fonts: auto_fonts,
+            fonts,
             scaled_fonts,
             sections,
             text_alignment,

From af1f990d932ca02b23341d3c91a3d9454ec28ebb Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 23:52:00 +0100
Subject: [PATCH 31/38] fix misnamed variables

---
 crates/bevy_text/src/pipeline.rs  | 4 ++--
 crates/bevy_ui/src/widget/text.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index d10382c9e8bc7..07def2d679aed 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -187,11 +187,11 @@ impl TextMeasureInfo {
         linebreak_behaviour: glyph_brush_layout::BuiltInLineBreaker,
     ) -> Self {
         let mut info = Self {
-            fonts: auto_fonts,
+            fonts,
             scaled_fonts,
             sections,
             text_alignment,
-            linebreak_behaviour: linebreak_behaviour.into(),
+            linebreak_behaviour,
             min_width_content_size: Vec2::ZERO,
             max_width_content_size: Vec2::ZERO,
         };
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 94672d6b4f3b5..0181a8a579720 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -115,7 +115,7 @@ pub fn measure_text_system(
                 &text.sections,
                 scale_factor,
                 text.alignment,
-                text.linebreak_behaviour,
+                text.linebreak_behavior,
             ) {
                 Ok(measure) => {
                     calculated_size.measure = Box::new(TextMeasure { info: measure });

From ee1d1f3290dc4bf56e0e9ae14c094abb90128b09 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 00:34:31 +0100
Subject: [PATCH 32/38] use `with_capacity` to construct the vecs with the
 correct length

---
 crates/bevy_text/src/pipeline.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 07def2d679aed..81ddcb50307b7 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -54,7 +54,7 @@ impl TextPipeline {
         font_atlas_warning: &mut FontAtlasWarning,
         y_axis_orientation: YAxisOrientation,
     ) -> Result<TextLayoutInfo, TextError> {
-        let mut scaled_fonts = Vec::new();
+        let mut scaled_fonts = Vec::with_capacity(sections.len());
         let sections = sections
             .iter()
             .map(|section| {
@@ -126,8 +126,8 @@ impl TextPipeline {
         text_alignment: TextAlignment,
         linebreak_behaviour: BreakLineOn,
     ) -> Result<TextMeasureInfo, TextError> {
-        let mut auto_fonts = Vec::new();
-        let mut scaled_fonts = Vec::new();
+        let mut auto_fonts = Vec::with_capacity(sections.len());
+        let mut scaled_fonts = Vec::with_capacity(sections.len());
         let sections = sections
             .iter()
             .enumerate()

From 8f1eb15ee7c53c4a7fa77d7232e6b1a68620163c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 00:35:29 +0100
Subject: [PATCH 33/38] fixed extra space

---
 crates/bevy_text/src/pipeline.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 81ddcb50307b7..946a54ca2dc3c 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -238,7 +238,7 @@ impl TextMeasureInfo {
             let scaled_font = &self.scaled_fonts[sg.section_index];
             let glyph = &sg.glyph;
             // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            //  and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
+            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
             // so we have to subtract from the baseline position to get the minimum and maximum values.
             min_x = min_x.min(glyph.position.x);
             min_y = min_y.min(glyph.position.y - scaled_font.ascent());

From 2ec10d84cdc3a50415fa9a1da48e280277f75fdd Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 01:01:00 +0100
Subject: [PATCH 34/38] Update crates/bevy_ui/src/widget/image.rs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: François <mockersf@gmail.com>
---
 crates/bevy_ui/src/widget/image.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 00bdd0c8d9831..09ddeceebc6c5 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -15,7 +15,6 @@ use bevy_text::Text;
 /// The size of the image in pixels
 ///
 /// This field is set automatically
-
 #[derive(Component, Copy, Clone, Debug, Default)]
 pub struct UiImageSize {
     size: Vec2,

From be4053ced99482a2134f48b5d67b021b2a5e19c8 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 01:04:15 +0100
Subject: [PATCH 35/38] added `Debug` derive to new types

---
 crates/bevy_text/src/pipeline.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 946a54ca2dc3c..a0646b4c30fab 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -160,14 +160,14 @@ impl TextPipeline {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct TextMeasureSection {
     pub text: String,
     pub scale: PxScale,
     pub font_id: FontId,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct TextMeasureInfo {
     pub fonts: Vec<ab_glyph::FontArc>,
     pub scaled_fonts: Vec<ab_glyph::PxScaleFont<ab_glyph::FontArc>>,

From 7526fc6818ab06d7ce08b437d7244974fb0053cc Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 01:09:26 +0100
Subject: [PATCH 36/38] Added comment to `text_layout_info` field of
 `Text2dBundle`

---
 crates/bevy_text/src/text2d.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_text/src/text2d.rs b/crates/bevy_text/src/text2d.rs
index 74a0c52b75c24..fdabddab07b8f 100644
--- a/crates/bevy_text/src/text2d.rs
+++ b/crates/bevy_text/src/text2d.rs
@@ -72,6 +72,7 @@ pub struct Text2dBundle {
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering.
     pub computed_visibility: ComputedVisibility,
+    /// Contains the size of the text and its glyph's position and scale data. Generated via [`TextPipeline::queue_text`]
     pub text_layout_info: TextLayoutInfo,
 }
 

From e33bc19f533cbcc60fd9c1839148c49fa6b0d195 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 01:10:06 +0100
Subject: [PATCH 37/38] Update crates/bevy_text/src/pipeline.rs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: François <mockersf@gmail.com>
---
 crates/bevy_text/src/pipeline.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index a0646b4c30fab..a50fc64bca62f 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -93,7 +93,7 @@ impl TextPipeline {
             let scaled_font = scaled_fonts[sg.section_index];
             let glyph = &sg.glyph;
             // The fonts use a coordinate system increasing upwards so ascent is a positive value
-            //  and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
+            // and descent is negative, but Bevy UI uses a downwards increasing coordinate system,
             // so we have to subtract from the baseline position to get the minimum and maximum values.
             min_x = min_x.min(glyph.position.x);
             min_y = min_y.min(glyph.position.y - scaled_font.ascent());

From 68c6e98d973ec7750cc414905151750883c5022d Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 01:26:44 +0100
Subject: [PATCH 38/38] fixed needless borrow

---
 crates/bevy_text/src/pipeline.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index a0646b4c30fab..43792ee42fcf7 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -227,7 +227,7 @@ impl TextMeasureInfo {
         let section_glyphs = glyph_brush_layout::Layout::default()
             .h_align(self.text_alignment.into())
             .line_breaker(self.linebreak_behaviour)
-            .calculate_glyphs(&self.fonts, &geom, &sections);
+            .calculate_glyphs(&self.fonts, &geom, sections);
 
         let mut min_x: f32 = std::f32::MAX;
         let mut min_y: f32 = std::f32::MAX;