From 7e24dffaa3f5dd61ce32aecf52487e2644abaf65 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 3 Apr 2023 19:43:28 +0100
Subject: [PATCH 01/60] changes:

* Added new components "TaffyNode" and "TaffyParent"
* Added `insert_node` method to `FlexSurface`
* Added `make_measure` function to `flex` module.
* `flex_node_system` stores taffy nodes keys in the "TaffyNode" and "TaffyParent" components instead of looking them up using the `entity_to_taffy` map.
---
 crates/bevy_ui/src/flex/mod.rs | 205 +++++++++++++++++++++------------
 1 file changed, 129 insertions(+), 76 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 62ab50196e5ee..287d4bb623c56 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -1,13 +1,15 @@
 mod convert;
 
 use crate::{CalculatedSize, Node, Style, UiScale};
+use bevy_core_pipeline::core_2d::graph::input::VIEW_ENTITY;
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
+    prelude::Component,
     query::{Changed, ReadOnlyWorldQuery, With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource},
+    system::{Commands, Query, Res, ResMut, Resource},
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -22,6 +24,16 @@ use taffy::{
     Taffy,
 };
 
+#[derive(Component, Copy, Clone)]
+pub struct TaffyNode {
+    key: taffy::node::Node,
+}
+
+#[derive(Component, Copy, Clone)]
+pub struct TaffyParent {
+    key: taffy::node::Node,
+}
+
 pub struct LayoutContext {
     pub scale_factor: f64,
     pub physical_size: Vec2,
@@ -78,73 +90,62 @@ impl Default for FlexSurface {
 }
 
 impl FlexSurface {
-    pub fn upsert_node(&mut self, entity: Entity, style: &Style, context: &LayoutContext) {
-        let mut added = false;
-        let taffy = &mut self.taffy;
-        let taffy_node = self.entity_to_taffy.entry(entity).or_insert_with(|| {
-            added = true;
-            taffy.new_leaf(convert::from_style(context, style)).unwrap()
-        });
+    pub fn insert_node(
+        &mut self,
+        entity: Entity,
+        style: &Style,
+        calculated_size: Option<&CalculatedSize>,
+        context: &LayoutContext,
+    ) -> taffy::node::Node {
+        let style = convert::from_style(context, style);
+        let taffy_node = if let Some(calculated_size) = calculated_size {
+            let measure = make_measure(*calculated_size, context.scale_factor);
+            self.taffy.new_leaf_with_measure(style, measure).unwrap()
+        } else {
+            self.taffy.new_leaf(style).unwrap()
+        };
+        self.entity_to_taffy.insert(entity, taffy_node);
+        taffy_node
+    }
 
-        if !added {
-            self.taffy
-                .set_style(*taffy_node, convert::from_style(context, style))
-                .unwrap();
-        }
+    pub fn upsert_node(
+        &mut self,
+        taffy_node: taffy::node::Node,
+        style: &Style,
+        context: &LayoutContext,
+    ) {
+        self.taffy
+            .set_style(taffy_node, convert::from_style(context, style))
+            .unwrap();
     }
 
     pub fn upsert_leaf(
         &mut self,
-        entity: Entity,
+        taffy_node: taffy::node::Node,
         style: &Style,
         calculated_size: CalculatedSize,
         context: &LayoutContext,
     ) {
-        let taffy = &mut self.taffy;
         let taffy_style = convert::from_style(context, style);
-        let scale_factor = context.scale_factor;
-        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;
-                    }
-                }
-                size
-            },
-        ));
-        if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_style(*taffy_node, taffy_style).unwrap();
-            self.taffy.set_measure(*taffy_node, Some(measure)).unwrap();
-        } else {
-            let taffy_node = taffy.new_leaf_with_measure(taffy_style, measure).unwrap();
-            self.entity_to_taffy.insert(entity, taffy_node);
-        }
+        let measure = make_measure(calculated_size, context.scale_factor);
+        self.taffy.set_style(taffy_node, taffy_style).unwrap();
+        self.taffy.set_measure(taffy_node, Some(measure)).unwrap();
     }
 
-    pub fn update_children(&mut self, entity: Entity, children: &Children) {
+    pub fn update_children(
+        &mut self,
+        entity: Entity,
+        children: &Children,
+        commands: &mut Commands,
+    ) {
+        let taffy_parent = self.entity_to_taffy.get(&entity).unwrap();
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
                 taffy_children.push(*taffy_node);
+                commands
+                    .entity(*child)
+                    .insert(TaffyParent { key: *taffy_parent });
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -153,9 +154,8 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
         self.taffy
-            .set_children(*taffy_node, &taffy_children)
+            .set_children(*taffy_parent, &taffy_children)
             .unwrap();
     }
 
@@ -195,12 +195,17 @@ without UI components as a child of an entity with UI components, results may be
         &mut self,
         parent_window: Entity,
         children: impl Iterator<Item = Entity>,
-    ) {
-        let taffy_node = self.window_nodes.get(&parent_window).unwrap();
+        commands: &mut Commands,
+    ) -> taffy::node::Node {
+        let window_node = *self.window_nodes.get(&parent_window).unwrap();
         let child_nodes = children
-            .map(|e| *self.entity_to_taffy.get(&e).unwrap())
+            .map(|e| {
+                commands.entity(e).insert(TaffyParent { key: window_node });
+                *self.entity_to_taffy.get(&e).unwrap()
+            })
             .collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
+        self.taffy.set_children(window_node, &child_nodes).unwrap();
+        window_node
     }
 
     pub fn compute_window_layouts(&mut self) {
@@ -250,16 +255,21 @@ pub fn flex_node_system(
     mut resize_events: EventReader<bevy_window::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>)>,
-    full_node_query: Query<(Entity, &Style, Option<&CalculatedSize>), With<Node>>,
+    node_query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), (With<Node>, Changed<Style>)>,
+    full_node_query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), With<Node>>,
     changed_size_query: Query<
-        (Entity, &Style, &CalculatedSize),
+        (&TaffyNode, &Style, &CalculatedSize),
         (With<Node>, Changed<CalculatedSize>),
     >,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
-    mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
+    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform, &TaffyParent)>,
     mut removed_nodes: RemovedComponents<Node>,
+    new_node_query: Query<
+        (Entity, &Style, Option<&CalculatedSize>),
+        (Without<TaffyNode>, With<Node>),
+    >,
+    mut commands: Commands,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -290,18 +300,23 @@ pub fn flex_node_system(
 
     let viewport_values = LayoutContext::new(scale_factor, physical_size);
 
+    for (entity, style, calculated_size) in new_node_query.iter() {
+        let node_key = flex_surface.insert_node(entity, style, calculated_size, &viewport_values);
+        commands.entity(entity).insert(TaffyNode { key: node_key });
+    }
+
     fn update_changed<F: ReadOnlyWorldQuery>(
         flex_surface: &mut FlexSurface,
         viewport_values: &LayoutContext,
-        query: Query<(Entity, &Style, Option<&CalculatedSize>), F>,
+        query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), F>,
     ) {
         // update changed nodes
-        for (entity, style, calculated_size) in &query {
+        for (node_key, 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, viewport_values);
+                flex_surface.upsert_leaf(node_key.key, style, *calculated_size, viewport_values);
             } else {
-                flex_surface.upsert_node(entity, style, viewport_values);
+                flex_surface.upsert_node(node_key.key, style, viewport_values);
             }
         }
     }
@@ -314,21 +329,25 @@ pub fn flex_node_system(
     }
 
     for (entity, style, calculated_size) in &changed_size_query {
-        flex_surface.upsert_leaf(entity, style, *calculated_size, &viewport_values);
+        flex_surface.upsert_leaf(entity.key, style, *calculated_size, &viewport_values);
     }
 
     // clean up removed nodes
     flex_surface.remove_entities(removed_nodes.iter());
 
     // update window children (for now assuming all Nodes live in the primary window)
-    flex_surface.set_window_children(primary_window_entity, root_node_query.iter());
+    let primary_node = flex_surface.set_window_children(
+        primary_window_entity,
+        root_node_query.iter(),
+        &mut commands,
+    );
 
     // update and remove children
     for entity in removed_children.iter() {
         flex_surface.try_remove_children(entity);
     }
     for (entity, children) in &children_query {
-        flex_surface.update_children(entity, children);
+        flex_surface.update_children(entity, children, &mut commands);
     }
 
     // compute layouts
@@ -339,8 +358,8 @@ pub fn flex_node_system(
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
     // PERF: try doing this incrementally
-    for (entity, mut node, mut transform, parent) in &mut node_transform_query {
-        let layout = flex_surface.get_layout(entity).unwrap();
+    for (taffy_node, mut node, mut transform, taffy_parent) in &mut node_transform_query {
+        let layout = flex_surface.taffy.layout(taffy_node.key).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -352,15 +371,49 @@ pub fn flex_node_system(
         let mut new_position = transform.translation;
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if let Some(parent) = parent {
-            if let Ok(parent_layout) = flex_surface.get_layout(**parent) {
-                new_position.x -= to_logical(parent_layout.size.width / 2.0);
-                new_position.y -= to_logical(parent_layout.size.height / 2.0);
-            }
+        if taffy_parent.key != primary_node {
+            let parent_layout = flex_surface.taffy.layout(taffy_parent.key).unwrap();
+            new_position.x -= to_logical(parent_layout.size.width / 2.0);
+            new_position.y -= to_logical(parent_layout.size.height / 2.0);
         }
+
         // only trigger change detection when the new value is different
         if transform.translation != new_position {
             transform.translation = new_position;
         }
     }
 }
+
+pub fn make_measure(
+    calculated_size: CalculatedSize,
+    scale_factor: f64,
+) -> taffy::node::MeasureFunc {
+    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;
+                }
+            }
+            size
+        },
+    ))
+}

From 460c438c659629c4f0913252d2ad010ecf8aa38d Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 3 Apr 2023 21:50:26 +0100
Subject: [PATCH 02/60] Remove `TaffyNode` and `TaffyParent` components when
 `Node` is removed.

---
 crates/bevy_ui/src/flex/mod.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 287d4bb623c56..fbd396e5de81b 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -217,11 +217,19 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Removes each entity from the internal map and then removes their associated node from taffy
-    pub fn remove_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
+    pub fn remove_entities(
+        &mut self,
+        entities: impl IntoIterator<Item = Entity>,
+        commands: &mut Commands,
+    ) {
         for entity in entities {
             if let Some(node) = self.entity_to_taffy.remove(&entity) {
                 self.taffy.remove(node).unwrap();
             }
+
+            if let Some(mut entity_commands) = commands.get_entity(entity) {
+                entity_commands.remove::<(TaffyNode, TaffyParent)>();
+            }
         }
     }
 
@@ -333,7 +341,7 @@ pub fn flex_node_system(
     }
 
     // clean up removed nodes
-    flex_surface.remove_entities(removed_nodes.iter());
+    flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
 
     // update window children (for now assuming all Nodes live in the primary window)
     let primary_node = flex_surface.set_window_children(

From 7060b944e286f2767029837abb5f341ace72c0fa Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 3 Apr 2023 23:25:21 +0100
Subject: [PATCH 03/60] changes:

* added `primary_node` and `physical_to_logical_factor` fields to `FlexSurface`.
* added the `Transforms` variant to the `UiSystem` enum.
* split off the transforms update from `flex_node_system` into a separate function `update_ui_node_transform`
and scheduled it to run after `UiSystem::Flex` and before `TransformSystem::TransformPropagate`.
---
 crates/bevy_ui/src/flex/mod.rs | 27 +++++++++++++++++----------
 crates/bevy_ui/src/lib.rs      |  6 ++++++
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index fbd396e5de81b..02050882a47fd 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -57,7 +57,9 @@ impl LayoutContext {
 pub struct FlexSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
     window_nodes: HashMap<Entity, taffy::node::Node>,
+    primary_node: taffy::node::Node,
     taffy: Taffy,
+    physical_to_logical_factor: f64,
 }
 
 // SAFETY: as long as MeasureFunc is Send + Sync. https://github.com/DioxusLabs/taffy/issues/146
@@ -85,6 +87,8 @@ impl Default for FlexSurface {
             entity_to_taffy: Default::default(),
             window_nodes: Default::default(),
             taffy: Taffy::new(),
+            primary_node: taffy::node::Node::default(),
+            physical_to_logical_factor: 1.0,
         }
     }
 }
@@ -196,16 +200,15 @@ without UI components as a child of an entity with UI components, results may be
         parent_window: Entity,
         children: impl Iterator<Item = Entity>,
         commands: &mut Commands,
-    ) -> taffy::node::Node {
-        let window_node = *self.window_nodes.get(&parent_window).unwrap();
+    ) {
+        self.primary_node = *self.window_nodes.get(&parent_window).unwrap();
         let child_nodes = children
             .map(|e| {
-                commands.entity(e).insert(TaffyParent { key: window_node });
+                commands.entity(e).insert(TaffyParent { key: self.primary_node });
                 *self.entity_to_taffy.get(&e).unwrap()
             })
             .collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(window_node, &child_nodes).unwrap();
-        window_node
+        self.taffy.set_children(self.primary_node, &child_nodes).unwrap();
     }
 
     pub fn compute_window_layouts(&mut self) {
@@ -307,6 +310,7 @@ pub fn flex_node_system(
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
 
     let viewport_values = LayoutContext::new(scale_factor, physical_size);
+    flex_surface.physical_to_logical_factor = 1. / logical_to_physical_factor;
 
     for (entity, style, calculated_size) in new_node_query.iter() {
         let node_key = flex_surface.insert_node(entity, style, calculated_size, &viewport_values);
@@ -344,7 +348,7 @@ pub fn flex_node_system(
     flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
 
     // update window children (for now assuming all Nodes live in the primary window)
-    let primary_node = flex_surface.set_window_children(
+    flex_surface.set_window_children(
         primary_window_entity,
         root_node_query.iter(),
         &mut commands,
@@ -360,10 +364,13 @@ pub fn flex_node_system(
 
     // compute layouts
     flex_surface.compute_window_layouts();
+}
 
-    let physical_to_logical_factor = 1. / logical_to_physical_factor;
-
-    let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
+pub fn update_ui_node_transforms(
+    flex_surface: Res<FlexSurface>,
+    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform, &TaffyParent)>,
+) {
+    let to_logical = |v| (flex_surface.physical_to_logical_factor * v as f64) as f32;
 
     // PERF: try doing this incrementally
     for (taffy_node, mut node, mut transform, taffy_parent) in &mut node_transform_query {
@@ -379,7 +386,7 @@ pub fn flex_node_system(
         let mut new_position = transform.translation;
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if taffy_parent.key != primary_node {
+        if taffy_parent.key != flex_surface.primary_node {
             let parent_layout = flex_surface.taffy.layout(taffy_parent.key).unwrap();
             new_position.x -= to_logical(parent_layout.size.width / 2.0);
             new_position.y -= to_logical(parent_layout.size.height / 2.0);
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 1f1408c888eef..6d6535a5ae0e6 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -52,6 +52,8 @@ pub struct UiPlugin;
 pub enum UiSystem {
     /// After this label, the ui flex state has been updated
     Flex,
+    /// After this label, the ui node transforms have been updated
+    Transforms,
     /// After this label, input interactions with UI entities have been updated for this frame
     Focus,
     /// After this label, the [`UiStack`] resource has been updated
@@ -144,6 +146,10 @@ impl Plugin for UiPlugin {
             (
                 flex_node_system
                     .in_set(UiSystem::Flex)
+                    .before(UiSystem::Transforms),
+                update_ui_node_transforms
+                    .in_set(UiSystem::Transforms)
+                    .after(UiSystem::Flex)
                     .before(TransformSystem::TransformPropagate),
                 ui_stack_system.in_set(UiSystem::Stack),
                 update_clipping_system.after(TransformSystem::TransformPropagate),

From 0fd7b89eb087a321eef065e2985d4e28d8e2a0b0 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 4 Apr 2023 00:41:22 +0100
Subject: [PATCH 04/60] changes: * removed `TaffyParent` component, added
 `parent` field to `TaffyNode` component * removed `PrimaryNode` field from
 `FlexSurface`

---
 crates/bevy_ui/src/flex/mod.rs | 85 ++++++++++++++++------------------
 1 file changed, 40 insertions(+), 45 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 02050882a47fd..99a68107969de 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -27,11 +27,7 @@ use taffy::{
 #[derive(Component, Copy, Clone)]
 pub struct TaffyNode {
     key: taffy::node::Node,
-}
-
-#[derive(Component, Copy, Clone)]
-pub struct TaffyParent {
-    key: taffy::node::Node,
+    parent: taffy::node::Node,
 }
 
 pub struct LayoutContext {
@@ -57,7 +53,6 @@ impl LayoutContext {
 pub struct FlexSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
     window_nodes: HashMap<Entity, taffy::node::Node>,
-    primary_node: taffy::node::Node,
     taffy: Taffy,
     physical_to_logical_factor: f64,
 }
@@ -87,7 +82,6 @@ impl Default for FlexSurface {
             entity_to_taffy: Default::default(),
             window_nodes: Default::default(),
             taffy: Taffy::new(),
-            primary_node: taffy::node::Node::default(),
             physical_to_logical_factor: 1.0,
         }
     }
@@ -147,9 +141,10 @@ impl FlexSurface {
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
                 taffy_children.push(*taffy_node);
-                commands
-                    .entity(*child)
-                    .insert(TaffyParent { key: *taffy_parent });
+                commands.entity(*child).insert(TaffyNode {
+                    key: *taffy_node,
+                    parent: *taffy_parent,
+                });
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -201,14 +196,18 @@ without UI components as a child of an entity with UI components, results may be
         children: impl Iterator<Item = Entity>,
         commands: &mut Commands,
     ) {
-        self.primary_node = *self.window_nodes.get(&parent_window).unwrap();
+        let window_node = *self.window_nodes.get(&parent_window).unwrap();
         let child_nodes = children
             .map(|e| {
-                commands.entity(e).insert(TaffyParent { key: self.primary_node });
-                *self.entity_to_taffy.get(&e).unwrap()
+                let taffy_node = *self.entity_to_taffy.get(&e).unwrap();
+                commands.entity(e).insert(TaffyNode {
+                    key: taffy_node,
+                    parent: window_node,
+                });
+                taffy_node
             })
             .collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(self.primary_node, &child_nodes).unwrap();
+        self.taffy.set_children(window_node, &child_nodes).unwrap();
     }
 
     pub fn compute_window_layouts(&mut self) {
@@ -231,7 +230,7 @@ without UI components as a child of an entity with UI components, results may be
             }
 
             if let Some(mut entity_commands) = commands.get_entity(entity) {
-                entity_commands.remove::<(TaffyNode, TaffyParent)>();
+                entity_commands.remove::<TaffyNode>();
             }
         }
     }
@@ -274,7 +273,6 @@ pub fn flex_node_system(
     >,
     children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
     mut removed_children: RemovedComponents<Children>,
-    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform, &TaffyParent)>,
     mut removed_nodes: RemovedComponents<Node>,
     new_node_query: Query<
         (Entity, &Style, Option<&CalculatedSize>),
@@ -313,8 +311,7 @@ pub fn flex_node_system(
     flex_surface.physical_to_logical_factor = 1. / logical_to_physical_factor;
 
     for (entity, style, calculated_size) in new_node_query.iter() {
-        let node_key = flex_surface.insert_node(entity, style, calculated_size, &viewport_values);
-        commands.entity(entity).insert(TaffyNode { key: node_key });
+        flex_surface.insert_node(entity, style, calculated_size, &viewport_values);
     }
 
     fn update_changed<F: ReadOnlyWorldQuery>(
@@ -348,11 +345,7 @@ pub fn flex_node_system(
     flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
 
     // update window children (for now assuming all Nodes live in the primary window)
-    flex_surface.set_window_children(
-        primary_window_entity,
-        root_node_query.iter(),
-        &mut commands,
-    );
+    flex_surface.set_window_children(primary_window_entity, root_node_query.iter(), &mut commands);
 
     // update and remove children
     for entity in removed_children.iter() {
@@ -368,33 +361,35 @@ pub fn flex_node_system(
 
 pub fn update_ui_node_transforms(
     flex_surface: Res<FlexSurface>,
-    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform, &TaffyParent)>,
+    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform)>,
 ) {
     let to_logical = |v| (flex_surface.physical_to_logical_factor * v as f64) as f32;
 
     // PERF: try doing this incrementally
-    for (taffy_node, mut node, mut transform, taffy_parent) in &mut node_transform_query {
-        let layout = flex_surface.taffy.layout(taffy_node.key).unwrap();
-        let new_size = Vec2::new(
-            to_logical(layout.size.width),
-            to_logical(layout.size.height),
-        );
-        // only trigger change detection when the new value is different
-        if node.calculated_size != new_size {
-            node.calculated_size = new_size;
-        }
-        let mut new_position = transform.translation;
-        new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-        new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if taffy_parent.key != flex_surface.primary_node {
-            let parent_layout = flex_surface.taffy.layout(taffy_parent.key).unwrap();
-            new_position.x -= to_logical(parent_layout.size.width / 2.0);
-            new_position.y -= to_logical(parent_layout.size.height / 2.0);
-        }
+    for &primary_node in flex_surface.window_nodes.values() {
+        for (taffy_node, mut node, mut transform) in &mut node_transform_query {
+            let layout = flex_surface.taffy.layout(taffy_node.key).unwrap();
+            let new_size = Vec2::new(
+                to_logical(layout.size.width),
+                to_logical(layout.size.height),
+            );
+            // only trigger change detection when the new value is different
+            if node.calculated_size != new_size {
+                node.calculated_size = new_size;
+            }
+            let mut new_position = transform.translation;
+            new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
+            new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
+            if taffy_node.parent != primary_node {
+                let parent_layout = flex_surface.taffy.layout(taffy_node.parent).unwrap();
+                new_position.x -= to_logical(parent_layout.size.width / 2.0);
+                new_position.y -= to_logical(parent_layout.size.height / 2.0);
+            }
 
-        // only trigger change detection when the new value is different
-        if transform.translation != new_position {
-            transform.translation = new_position;
+            // only trigger change detection when the new value is different
+            if transform.translation != new_position {
+                transform.translation = new_position;
+            }
         }
     }
 }

From 584d6c72de83deb6268e216514ab8cb2ec3c07ec Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 14:14:53 +0100
Subject: [PATCH 05/60] changes: * Renamed `Node` to `NodeSize` * Renamed
 `TaffyNode` to `Node` and removed its `Parent` field. * Split off parts of
 `flex_node_system` into separate systems: `synchronise_children`,
 `insert_new_ui_nodes_into_layout` and `clean_up_removed_ui_nodes`.

---
 crates/bevy_ui/src/accessibility.rs |   6 +-
 crates/bevy_ui/src/flex/mod.rs      | 150 ++++++++++++++--------------
 crates/bevy_ui/src/focus.rs         |   4 +-
 crates/bevy_ui/src/lib.rs           |  22 +++-
 crates/bevy_ui/src/node_bundles.rs  |  35 ++++---
 crates/bevy_ui/src/render/mod.rs    |   6 +-
 crates/bevy_ui/src/stack.rs         |  18 ++--
 crates/bevy_ui/src/ui_node.rs       |   8 +-
 crates/bevy_ui/src/update.rs        |  18 +++-
 crates/bevy_ui/src/widget/text.rs   |   4 +-
 examples/input/text_input.rs        |  10 +-
 examples/ui/ui.rs                   |   4 +-
 12 files changed, 161 insertions(+), 124 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 42b2137e9c984..28d211abe58d2 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -1,6 +1,6 @@
 use crate::{
     prelude::{Button, Label},
-    Node, UiImage,
+    NodeSize, UiImage,
 };
 use bevy_a11y::{
     accesskit::{NodeBuilder, Rect, Role},
@@ -35,8 +35,8 @@ fn calc_name(texts: &Query<&Text>, children: &Children) -> Option<Box<str>> {
 fn calc_bounds(
     camera: Query<(&Camera, &GlobalTransform)>,
     mut nodes: Query<
-        (&mut AccessibilityNode, &Node, &GlobalTransform),
-        Or<(Changed<Node>, Changed<GlobalTransform>)>,
+        (&mut AccessibilityNode, &NodeSize, &GlobalTransform),
+        Or<(Changed<NodeSize>, Changed<GlobalTransform>)>,
     >,
 ) {
     if let Ok((camera, camera_transform)) = camera.get_single() {
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 99a68107969de..d98c610b25760 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -1,19 +1,19 @@
 mod convert;
 
-use crate::{CalculatedSize, Node, Style, UiScale};
-use bevy_core_pipeline::core_2d::graph::input::VIEW_ENTITY;
+use crate::{CalculatedSize, NodeSize, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
     prelude::Component,
-    query::{Changed, ReadOnlyWorldQuery, With, Without},
+    query::{Added, Changed, ReadOnlyWorldQuery, With, Without},
     removal_detection::RemovedComponents,
     system::{Commands, Query, Res, ResMut, Resource},
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::Vec2;
+use bevy_reflect::Reflect;
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
@@ -21,13 +21,14 @@ use std::fmt;
 use taffy::{
     prelude::{AvailableSpace, Size},
     style_helpers::TaffyMaxContent,
+    tree::LayoutTree,
     Taffy,
 };
 
-#[derive(Component, Copy, Clone)]
-pub struct TaffyNode {
+#[derive(Component, Default, Debug, Reflect)]
+pub struct Node {
+    #[reflect(ignore)]
     key: taffy::node::Node,
-    parent: taffy::node::Node,
 }
 
 pub struct LayoutContext {
@@ -97,7 +98,7 @@ impl FlexSurface {
     ) -> taffy::node::Node {
         let style = convert::from_style(context, style);
         let taffy_node = if let Some(calculated_size) = calculated_size {
-            let measure = make_measure(*calculated_size, context.scale_factor);
+            let measure = measure(*calculated_size, context.scale_factor);
             self.taffy.new_leaf_with_measure(style, measure).unwrap()
         } else {
             self.taffy.new_leaf(style).unwrap()
@@ -106,7 +107,7 @@ impl FlexSurface {
         taffy_node
     }
 
-    pub fn upsert_node(
+    pub fn update_node(
         &mut self,
         taffy_node: taffy::node::Node,
         style: &Style,
@@ -117,7 +118,7 @@ impl FlexSurface {
             .unwrap();
     }
 
-    pub fn upsert_leaf(
+    pub fn update_leaf(
         &mut self,
         taffy_node: taffy::node::Node,
         style: &Style,
@@ -125,26 +126,16 @@ impl FlexSurface {
         context: &LayoutContext,
     ) {
         let taffy_style = convert::from_style(context, style);
-        let measure = make_measure(calculated_size, context.scale_factor);
+        let measure = measure(calculated_size, context.scale_factor);
         self.taffy.set_style(taffy_node, taffy_style).unwrap();
         self.taffy.set_measure(taffy_node, Some(measure)).unwrap();
     }
 
-    pub fn update_children(
-        &mut self,
-        entity: Entity,
-        children: &Children,
-        commands: &mut Commands,
-    ) {
-        let taffy_parent = self.entity_to_taffy.get(&entity).unwrap();
+    pub fn update_children(&mut self, parent: taffy::node::Node, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
                 taffy_children.push(*taffy_node);
-                commands.entity(*child).insert(TaffyNode {
-                    key: *taffy_node,
-                    parent: *taffy_parent,
-                });
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -153,9 +144,7 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        self.taffy
-            .set_children(*taffy_parent, &taffy_children)
-            .unwrap();
+        self.taffy.set_children(parent, &taffy_children).unwrap();
     }
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
@@ -194,16 +183,11 @@ without UI components as a child of an entity with UI components, results may be
         &mut self,
         parent_window: Entity,
         children: impl Iterator<Item = Entity>,
-        commands: &mut Commands,
     ) {
         let window_node = *self.window_nodes.get(&parent_window).unwrap();
         let child_nodes = children
             .map(|e| {
                 let taffy_node = *self.entity_to_taffy.get(&e).unwrap();
-                commands.entity(e).insert(TaffyNode {
-                    key: taffy_node,
-                    parent: window_node,
-                });
                 taffy_node
             })
             .collect::<Vec<taffy::node::Node>>();
@@ -230,7 +214,7 @@ without UI components as a child of an entity with UI components, results may be
             }
 
             if let Some(mut entity_commands) = commands.get_entity(entity) {
-                entity_commands.remove::<TaffyNode>();
+                entity_commands.remove::<Node>();
             }
         }
     }
@@ -256,6 +240,49 @@ pub enum FlexError {
     TaffyError(taffy::error::TaffyError),
 }
 
+/// Remove the corresponding taffy node for any entity that has its `Node` component removed.
+pub fn clean_up_removed_ui_nodes(
+    mut commands: Commands,
+    mut flex_surface: ResMut<FlexSurface>,
+    mut removed_nodes: RemovedComponents<Node>,
+) {
+    // clean up removed nodes
+    flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
+}
+
+/// Insert a new taffy node into the layout for any entity that a `Node` component added.
+pub fn insert_new_ui_nodes_into_layout(
+    mut flex_surface: ResMut<FlexSurface>,
+    mut new_node_query: Query<(Entity, &mut Node), Added<Node>>,
+) {
+    for (entity, mut node) in new_node_query.iter_mut() {
+        node.key = flex_surface
+            .taffy
+            .new_leaf(taffy::style::Style::DEFAULT)
+            .unwrap();
+        if let Some(old_key) = flex_surface.entity_to_taffy.insert(entity, node.key) {
+            flex_surface.taffy.remove(old_key).ok();
+        }
+    }
+}
+
+/// Synchonise the Bevy and Taffy Parent-Children trees
+pub fn synchonise_children(
+    mut flex_surface: ResMut<FlexSurface>,
+    mut removed_children: RemovedComponents<Children>,
+    children_query: Query<(&Node, &Children), Changed<Children>>,
+) {
+    // Iterate through all entities with a removed `Children` component and if they have a corresponding Taffy node, remove their children from the Taffy tree.
+    for entity in removed_children.iter() {
+        flex_surface.try_remove_children(entity);
+    }
+
+    // Update the corresponding Taffy children of Bevy entities with changed `Children`
+    for (node, children) in &children_query {
+        flex_surface.update_children(node.key, children);
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn flex_node_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
@@ -265,20 +292,9 @@ pub fn flex_node_system(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     mut flex_surface: ResMut<FlexSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    node_query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), (With<Node>, Changed<Style>)>,
-    full_node_query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), With<Node>>,
-    changed_size_query: Query<
-        (&TaffyNode, &Style, &CalculatedSize),
-        (With<Node>, Changed<CalculatedSize>),
-    >,
-    children_query: Query<(Entity, &Children), (With<Node>, Changed<Children>)>,
-    mut removed_children: RemovedComponents<Children>,
-    mut removed_nodes: RemovedComponents<Node>,
-    new_node_query: Query<
-        (Entity, &Style, Option<&CalculatedSize>),
-        (Without<TaffyNode>, With<Node>),
-    >,
-    mut commands: Commands,
+    node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
+    full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
+    changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -310,22 +326,18 @@ pub fn flex_node_system(
     let viewport_values = LayoutContext::new(scale_factor, physical_size);
     flex_surface.physical_to_logical_factor = 1. / logical_to_physical_factor;
 
-    for (entity, style, calculated_size) in new_node_query.iter() {
-        flex_surface.insert_node(entity, style, calculated_size, &viewport_values);
-    }
-
     fn update_changed<F: ReadOnlyWorldQuery>(
         flex_surface: &mut FlexSurface,
         viewport_values: &LayoutContext,
-        query: Query<(&TaffyNode, &Style, Option<&CalculatedSize>), F>,
+        query: Query<(&Node, &Style, Option<&CalculatedSize>), F>,
     ) {
         // update changed nodes
         for (node_key, 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(node_key.key, style, *calculated_size, viewport_values);
+                flex_surface.update_leaf(node_key.key, style, *calculated_size, viewport_values);
             } else {
-                flex_surface.upsert_node(node_key.key, style, viewport_values);
+                flex_surface.update_node(node_key.key, style, viewport_values);
             }
         }
     }
@@ -338,22 +350,11 @@ pub fn flex_node_system(
     }
 
     for (entity, style, calculated_size) in &changed_size_query {
-        flex_surface.upsert_leaf(entity.key, style, *calculated_size, &viewport_values);
+        flex_surface.update_leaf(entity.key, style, *calculated_size, &viewport_values);
     }
 
-    // clean up removed nodes
-    flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
-
     // update window children (for now assuming all Nodes live in the primary window)
-    flex_surface.set_window_children(primary_window_entity, root_node_query.iter(), &mut commands);
-
-    // update and remove children
-    for entity in removed_children.iter() {
-        flex_surface.try_remove_children(entity);
-    }
-    for (entity, children) in &children_query {
-        flex_surface.update_children(entity, children, &mut commands);
-    }
+    flex_surface.set_window_children(primary_window_entity, root_node_query.iter());
 
     // compute layouts
     flex_surface.compute_window_layouts();
@@ -361,27 +362,29 @@ pub fn flex_node_system(
 
 pub fn update_ui_node_transforms(
     flex_surface: Res<FlexSurface>,
-    mut node_transform_query: Query<(&TaffyNode, &mut Node, &mut Transform)>,
+    mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
     let to_logical = |v| (flex_surface.physical_to_logical_factor * v as f64) as f32;
 
     // PERF: try doing this incrementally
     for &primary_node in flex_surface.window_nodes.values() {
-        for (taffy_node, mut node, mut transform) in &mut node_transform_query {
-            let layout = flex_surface.taffy.layout(taffy_node.key).unwrap();
+        for (node, mut node_size, mut transform) in &mut node_transform_query {
+            let layout = flex_surface.taffy.layout(node.key).unwrap();
             let new_size = Vec2::new(
                 to_logical(layout.size.width),
                 to_logical(layout.size.height),
             );
             // only trigger change detection when the new value is different
-            if node.calculated_size != new_size {
-                node.calculated_size = new_size;
+            if node_size.calculated_size != new_size {
+                node_size.calculated_size = new_size;
             }
             let mut new_position = transform.translation;
             new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
             new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-            if taffy_node.parent != primary_node {
-                let parent_layout = flex_surface.taffy.layout(taffy_node.parent).unwrap();
+
+            let parent_key = flex_surface.taffy.parent(node.key).unwrap();
+            if parent_key != primary_node {
+                let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
                 new_position.y -= to_logical(parent_layout.size.height / 2.0);
             }
@@ -394,10 +397,7 @@ pub fn update_ui_node_transforms(
     }
 }
 
-pub fn make_measure(
-    calculated_size: CalculatedSize,
-    scale_factor: f64,
-) -> taffy::node::MeasureFunc {
+pub fn measure(calculated_size: CalculatedSize, scale_factor: f64) -> taffy::node::MeasureFunc {
     taffy::node::MeasureFunc::Boxed(Box::new(
         move |constraints: Size<Option<f32>>, _available: Size<AvailableSpace>| {
             let mut size = Size {
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 07829f3c2e6d5..8cafb5ecf9cdf 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, NodeSize, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -117,7 +117,7 @@ pub struct State {
 #[world_query(mutable)]
 pub struct NodeQuery {
     entity: Entity,
-    node: &'static Node,
+    node: &'static NodeSize,
     global_transform: &'static GlobalTransform,
     interaction: Option<&'static mut Interaction>,
     relative_cursor_position: Option<&'static mut RelativeCursorPosition>,
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 6d6535a5ae0e6..06b46a45d0c7b 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -29,7 +29,8 @@ pub use ui_node::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        camera_config::*, geometry::*, node_bundles::*, ui_node::*, widget::*, Interaction, UiScale,
+        camera_config::*, flex::Node, geometry::*, node_bundles::*, ui_node::*, widget::*,
+        Interaction, UiScale,
     };
 }
 
@@ -50,6 +51,12 @@ pub struct UiPlugin;
 /// The label enum labeling the types of systems in the Bevy UI
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum UiSystem {
+    /// After this label, removed ui nodes have been removed from the layout tree
+    Removal,
+    /// After this label, new ui nodes have been added to the layout tree
+    Insertion,
+    /// After this label, the Bevy and Taffy Parent-Children trees have been synchonised
+    Children,
     /// After this label, the ui flex state has been updated
     Flex,
     /// After this label, the ui node transforms have been updated
@@ -93,7 +100,7 @@ impl Plugin for UiPlugin {
             .register_type::<FocusPolicy>()
             .register_type::<Interaction>()
             .register_type::<JustifyContent>()
-            .register_type::<Node>()
+            .register_type::<NodeSize>()
             // NOTE: used by Style::aspect_ratio
             .register_type::<Option<f32>>()
             .register_type::<Overflow>()
@@ -106,6 +113,7 @@ impl Plugin for UiPlugin {
             .register_type::<Val>()
             .register_type::<widget::Button>()
             .register_type::<widget::Label>()
+            .register_type::<Node>()
             .add_systems(
                 PreUpdate,
                 ui_focus_system.in_set(UiSystem::Focus).after(InputSystem),
@@ -144,12 +152,20 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
+                clean_up_removed_ui_nodes
+                    .in_set(UiSystem::Removal)
+                    .before(UiSystem::Insertion),
+                insert_new_ui_nodes_into_layout
+                    .in_set(UiSystem::Insertion)
+                    .before(UiSystem::Children),
+                synchonise_children
+                    .in_set(UiSystem::Children)
+                    .before(UiSystem::Flex),
                 flex_node_system
                     .in_set(UiSystem::Flex)
                     .before(UiSystem::Transforms),
                 update_ui_node_transforms
                     .in_set(UiSystem::Transforms)
-                    .after(UiSystem::Flex)
                     .before(TransformSystem::TransformPropagate),
                 ui_stack_system.in_set(UiSystem::Stack),
                 update_clipping_system.after(TransformSystem::TransformPropagate),
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index e0eee6a61062a..e5218dd1518d9 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, CalculatedSize, FocusPolicy, Interaction, Node, Style,
-    UiImage, ZIndex,
+    widget::Button, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, NodeSize,
+    Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -16,13 +16,15 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 /// The basic UI node
 ///
 /// Useful as a container for a variety of child nodes.
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct NodeBundle {
-    /// Describes the logical size of the node
+    /// Identifier for the Node in the layout.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Describes the style including flexbox settings
     pub style: Style,
-    /// The background color, which serves as a "fill" for this node
+    /// The background color, which serves as a "fill" for this nodet
     pub background_color: BackgroundColor,
     /// Whether this node should block interaction with lower nodes
     pub focus_policy: FocusPolicy,
@@ -50,6 +52,7 @@ impl Default for NodeBundle {
             // Transparent background
             background_color: Color::NONE.into(),
             node: Default::default(),
+            node_size: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -62,10 +65,12 @@ 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 logical size of the node
+    /// Identifier for the Node in the layout.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Describes the style including flexbox settings
     pub style: Style,
     /// The calculated size based on the given image
@@ -98,10 +103,12 @@ pub struct ImageBundle {
 
 #[cfg(feature = "bevy_text")]
 /// A UI node that is text
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct TextBundle {
-    /// Describes the logical size of the node
+    /// Identifier for the Node in the layout.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Describes the style including flexbox settings
     pub style: Style,
     /// Contains the text of the node
@@ -134,11 +141,12 @@ pub struct TextBundle {
 impl Default for TextBundle {
     fn default() -> Self {
         Self {
+            node: Default::default(),
             text: Default::default(),
             calculated_size: Default::default(),
             // Transparent background
             background_color: BackgroundColor(Color::NONE),
-            node: Default::default(),
+            node_size: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -192,10 +200,12 @@ impl TextBundle {
 }
 
 /// A UI node that is a button
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct ButtonBundle {
-    /// Describes the logical size of the node
+    /// Identifier for the Node in the layout.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Marker component that signals this node is a button
     pub button: Button,
     /// Describes the style including flexbox settings
@@ -233,6 +243,7 @@ impl Default for ButtonBundle {
         Self {
             focus_policy: FocusPolicy::Block,
             node: Default::default(),
+            node_size: Default::default(),
             button: Default::default(),
             style: Default::default(),
             interaction: Default::default(),
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 9eccf115c77c8..89043eb282708 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,7 +8,7 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, Node, UiImage, UiStack};
+use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, NodeSize, UiImage, UiStack};
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
@@ -168,7 +168,7 @@ pub fn extract_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &Node,
+            &NodeSize,
             &GlobalTransform,
             &BackgroundColor,
             Option<&UiImage>,
@@ -281,7 +281,7 @@ pub fn extract_text_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &Node,
+            &NodeSize,
             &GlobalTransform,
             &Text,
             &TextLayoutInfo,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 6dd063b02ffbc..a5e84b8d39b4e 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -3,7 +3,7 @@
 use bevy_ecs::prelude::*;
 use bevy_hierarchy::prelude::*;
 
-use crate::{Node, ZIndex};
+use crate::{NodeSize, ZIndex};
 
 /// The current UI stack, which contains all UI nodes ordered by their depth (back-to-front).
 ///
@@ -32,8 +32,8 @@ struct StackingContextEntry {
 /// Then flatten that tree into back-to-front ordered `UiStack`.
 pub fn ui_stack_system(
     mut ui_stack: ResMut<UiStack>,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    zindex_query: Query<&ZIndex, With<Node>>,
+    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
+    zindex_query: Query<&ZIndex, With<NodeSize>>,
     children_query: Query<&Children>,
 ) {
     // Generate `StackingContext` tree
@@ -59,7 +59,7 @@ pub fn ui_stack_system(
 
 /// Generate z-index based UI node tree
 fn insert_context_hierarchy(
-    zindex_query: &Query<&ZIndex, With<Node>>,
+    zindex_query: &Query<&ZIndex, With<NodeSize>>,
     children_query: &Query<&Children>,
     entity: Entity,
     global_context: &mut StackingContext,
@@ -124,19 +124,19 @@ mod tests {
     };
     use bevy_hierarchy::BuildChildren;
 
-    use crate::{Node, UiStack, ZIndex};
+    use crate::{NodeSize, UiStack, ZIndex};
 
     use super::ui_stack_system;
 
     #[derive(Component, PartialEq, Debug, Clone)]
     struct Label(&'static str);
 
-    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, Node, ZIndex) {
-        (Label(name), Node::default(), z_index)
+    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, NodeSize, ZIndex) {
+        (Label(name), NodeSize::default(), z_index)
     }
 
-    fn node_without_zindex(name: &'static str) -> (Label, Node) {
-        (Label(name), Node::default())
+    fn node_without_zindex(name: &'static str) -> (Label, NodeSize) {
+        (Label(name), NodeSize::default())
     }
 
     /// Tests the UI Stack system.
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 230b29f0ed23f..0c0a0fe053ea3 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -15,13 +15,13 @@ use thiserror::Error;
 /// Describes the size of a UI node
 #[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component, Default)]
-pub struct Node {
+pub struct NodeSize {
     /// The size of the node as width and height in logical pixels
     /// automatically calculated by [`super::flex::flex_node_system`]
     pub(crate) calculated_size: Vec2,
 }
 
-impl Node {
+impl NodeSize {
     /// The calculated node size as width and height in logical pixels
     /// automatically calculated by [`super::flex::flex_node_system`]
     pub fn size(&self) -> Vec2 {
@@ -45,13 +45,13 @@ impl Node {
     }
 }
 
-impl Node {
+impl NodeSize {
     pub const DEFAULT: Self = Self {
         calculated_size: Vec2::ZERO,
     };
 }
 
-impl Default for Node {
+impl Default for NodeSize {
     fn default() -> Self {
         Self::DEFAULT
     }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index d7ed301e42aea..e63c0ea9f43f1 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -2,7 +2,7 @@
 
 use crate::{CalculatedClip, Overflow, Style};
 
-use super::Node;
+use super::NodeSize;
 use bevy_ecs::{
     entity::Entity,
     query::{With, Without},
@@ -15,8 +15,13 @@ use bevy_transform::components::GlobalTransform;
 /// Updates clipping for all nodes
 pub fn update_clipping_system(
     mut commands: Commands,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    mut node_query: Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
+    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
+    mut node_query: Query<(
+        &NodeSize,
+        &GlobalTransform,
+        &Style,
+        Option<&mut CalculatedClip>,
+    )>,
     children_query: Query<&Children>,
 ) {
     for root_node in &root_node_query {
@@ -33,7 +38,12 @@ pub fn update_clipping_system(
 fn update_clipping(
     commands: &mut Commands,
     children_query: &Query<&Children>,
-    node_query: &mut Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
+    node_query: &mut Query<(
+        &NodeSize,
+        &GlobalTransform,
+        &Style,
+        Option<&mut CalculatedClip>,
+    )>,
     entity: Entity,
     maybe_inherited_clip: Option<Rect>,
 ) {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index e3404575e8ee3..e89e0540cb254 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, NodeSize, Style, UiScale, Val};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,
@@ -52,7 +52,7 @@ 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, Or<(Changed<Text>, Changed<NodeSize>, Changed<Style>)>>,
         Query<Entity, (With<Text>, With<Style>)>,
         Query<(
             &Text,
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index 97e90ad033f60..2a5d358f20e82 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -103,7 +103,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 fn toggle_ime(
     input: Res<Input<MouseButton>>,
     mut windows: Query<&mut Window>,
-    mut text: Query<&mut Text, With<Node>>,
+    mut text: Query<&mut Text, With<NodeSize>>,
 ) {
     if input.just_pressed(MouseButton::Left) {
         let mut window = windows.single_mut();
@@ -142,8 +142,8 @@ fn bubbling_text(
 
 fn listen_ime_events(
     mut events: EventReader<Ime>,
-    mut status_text: Query<&mut Text, With<Node>>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut status_text: Query<&mut Text, With<NodeSize>>,
+    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event {
@@ -169,7 +169,7 @@ fn listen_ime_events(
 
 fn listen_received_character_events(
     mut events: EventReader<ReceivedCharacter>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         edit_text.single_mut().sections[0].value.push(event.char);
@@ -179,7 +179,7 @@ fn listen_received_character_events(
 fn listen_keyboard_input_events(
     mut commands: Commands,
     mut events: EventReader<KeyboardInput>,
-    mut edit_text: Query<(Entity, &mut Text), (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<(Entity, &mut Text), (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event.key_code {
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index f2761193c33f4..6cf5a438d7762 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -286,8 +286,8 @@ struct ScrollingList {
 
 fn mouse_scroll(
     mut mouse_wheel_events: EventReader<MouseWheel>,
-    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &Node)>,
-    query_node: Query<&Node>,
+    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &NodeSize)>,
+    query_node: Query<&NodeSize>,
 ) {
     for mouse_wheel_event in mouse_wheel_events.iter() {
         for (mut scrolling_list, mut style, parent, list_node) in &mut query_list {

From 6739af22de84f654c6fd31687869bde74dd0c467 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 14:37:46 +0100
Subject: [PATCH 06/60] cargo fmt

---
 crates/bevy_ui/src/flex/mod.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index d132fcf19e7fc..5d780ee7bdf8e 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -307,10 +307,7 @@ pub fn flex_node_system(
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
     full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
-    changed_size_query: Query<
-        (&Node, &Style, &CalculatedSize),
-        Changed<CalculatedSize>,
-    >,
+    changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -369,8 +366,6 @@ pub fn flex_node_system(
         flex_surface.update_leaf(node.key, style, *calculated_size, &viewport_values);
     }
 
-    
-
     // update window children (for now assuming all Nodes live in the primary window)
     flex_surface.set_window_children(primary_window_entity, root_node_query.iter());
 

From feb61f7e30faf9a2182ca93c51efd0b3ec5f418b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 16:08:24 +0100
Subject: [PATCH 07/60] handle window events for ui in a separate system

---
 crates/bevy_ui/src/flex/convert.rs |   6 +-
 crates/bevy_ui/src/flex/mod.rs     | 132 +++++++++++++++++------------
 crates/bevy_ui/src/lib.rs          |   6 ++
 3 files changed, 87 insertions(+), 57 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index a2bb1af48c053..5c077e56533fa 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -212,6 +212,8 @@ impl From<FlexWrap> for taffy::style::FlexWrap {
 
 #[cfg(test)]
 mod tests {
+    use bevy_ecs::world::World;
+
     use super::*;
 
     #[test]
@@ -270,7 +272,7 @@ mod tests {
                 height: Val::Percent(0.),
             },
         };
-        let viewport_values = LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.));
+        let viewport_values = LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false, false, World::new().spawn_empty().id());
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
@@ -400,7 +402,7 @@ mod tests {
     #[test]
     fn test_into_length_percentage() {
         use taffy::style::LengthPercentage;
-        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.));
+        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.), false, false, World::new().spawn_empty().id());
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),
             (Val::Percent(1.), LengthPercentage::Percent(0.01)),
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 5d780ee7bdf8e..fdc1b90943a48 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -16,7 +16,7 @@ use bevy_math::Vec2;
 use bevy_reflect::Reflect;
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
-use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
+use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
     prelude::{AvailableSpace, Size},
@@ -31,21 +31,32 @@ pub struct Node {
     key: taffy::node::Node,
 }
 
+#[derive(Resource, Default)]
+pub struct UiViewport(pub Option<LayoutContext>);
+
 pub struct LayoutContext {
+    pub window_entity: Entity,
+    pub resized: bool,
     pub scale_factor: f64,
     pub physical_size: Vec2,
+    pub physical_to_logical_factor: f64,
+    pub scale_factor_changed: bool,
     pub min_size: f32,
     pub max_size: f32,
 }
 
 impl LayoutContext {
     /// create new a [`LayoutContext`] from the window's physical size and scale factor
-    fn new(scale_factor: f64, physical_size: Vec2) -> Self {
+    fn new(scale_factor: f64, physical_size: Vec2, resized: bool, scale_factor_changed: bool, window_entity: Entity) -> Self {
         Self {
+            window_entity,
+            resized,
             scale_factor,
             physical_size,
             min_size: physical_size.x.min(physical_size.y),
             max_size: physical_size.x.max(physical_size.y),
+            physical_to_logical_factor: 1. / scale_factor,
+            scale_factor_changed,
         }
     }
 }
@@ -55,7 +66,6 @@ pub struct FlexSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
     window_nodes: HashMap<Entity, taffy::node::Node>,
     taffy: Taffy,
-    physical_to_logical_factor: f64,
 }
 
 // SAFETY: as long as MeasureFunc is Send + Sync. https://github.com/DioxusLabs/taffy/issues/146
@@ -83,7 +93,6 @@ impl Default for FlexSurface {
             entity_to_taffy: Default::default(),
             window_nodes: Default::default(),
             taffy: Taffy::new(),
-            physical_to_logical_factor: 1.0,
         }
     }
 }
@@ -161,7 +170,7 @@ without UI components as a child of an entity with UI components, results may be
         }
     }
 
-    pub fn update_window(&mut self, window: Entity, window_resolution: &WindowResolution) {
+    pub fn update_window(&mut self, window: Entity, window_resolution: Vec2) {
         let taffy = &mut self.taffy;
         let node = self
             .window_nodes
@@ -174,10 +183,10 @@ without UI components as a child of an entity with UI components, results may be
                 taffy::style::Style {
                     size: taffy::geometry::Size {
                         width: taffy::style::Dimension::Points(
-                            window_resolution.physical_width() as f32
+                            window_resolution.x
                         ),
                         height: taffy::style::Dimension::Points(
-                            window_resolution.physical_height() as f32,
+                            window_resolution.y
                         ),
                     },
                     ..Default::default()
@@ -296,18 +305,13 @@ pub fn synchonise_children(
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-pub fn flex_node_system(
+pub fn update_window_layouts(
+    mut resize_events: EventReader<bevy_window::WindowResized>,
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
-    windows: Query<(Entity, &Window)>,
     ui_scale: Res<UiScale>,
-    mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
-    mut resize_events: EventReader<bevy_window::WindowResized>,
     mut flex_surface: ResMut<FlexSurface>,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
-    full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
-    changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
+    mut ui_viewport: ResMut<UiViewport>,
+    mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -322,23 +326,37 @@ pub fn flex_node_system(
                 ),
             )
         } else {
+            ui_viewport.0 = None;
             return;
         };
 
+    // update window root nodes
+    flex_surface.update_window(primary_window_entity, physical_size);
+
     let resized = resize_events
         .iter()
         .any(|resized_window| resized_window.window == primary_window_entity);
-
-    // update window root nodes
-    for (entity, window) in windows.iter() {
-        flex_surface.update_window(entity, &window.resolution);
-    }
-
+    let scale_factor_changed = scale_factor_events.is_empty() || ui_scale.is_changed();
+    scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
+    let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed, primary_window_entity);
+    ui_viewport.0 = Some(context);
+    
+}
 
-    let viewport_values = LayoutContext::new(scale_factor, physical_size);
-    flex_surface.physical_to_logical_factor = 1. / logical_to_physical_factor;
-
+#[allow(clippy::too_many_arguments)]
+pub fn flex_node_system(
+    ui_viewport: ResMut<UiViewport>,
+    mut flex_surface: ResMut<FlexSurface>,
+    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
+    node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
+    full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
+    changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
+) {
+    let Some(ref viewport_values) = ui_viewport.0 else {
+        return
+    };
+    
     fn update_changed<F: ReadOnlyWorldQuery>(
         flex_surface: &mut FlexSurface,
         viewport_values: &LayoutContext,
@@ -355,8 +373,8 @@ pub fn flex_node_system(
         }
     }
 
-    if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
-        scale_factor_events.clear();
+    if viewport_values.scale_factor_changed || viewport_values.resized {
+        
         update_changed(&mut flex_surface, &viewport_values, full_node_query);
     } else {
         update_changed(&mut flex_surface, &viewport_values, node_query);
@@ -367,7 +385,8 @@ pub fn flex_node_system(
     }
 
     // update window children (for now assuming all Nodes live in the primary window)
-    flex_surface.set_window_children(primary_window_entity, root_node_query.iter());
+    let window_entity = *flex_surface.window_nodes.keys().next().unwrap();
+    flex_surface.set_window_children(window_entity, root_node_query.iter());
 
     // compute layouts
     flex_surface.compute_window_layouts();
@@ -375,36 +394,39 @@ pub fn flex_node_system(
 
 pub fn update_ui_node_transforms(
     flex_surface: Res<FlexSurface>,
+    ui_viewport: ResMut<UiViewport>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
-    let to_logical = |v| (flex_surface.physical_to_logical_factor * v as f64) as f32;
-
-    // PERF: try doing this incrementally
-    for &primary_node in flex_surface.window_nodes.values() {
-        for (node, mut node_size, mut transform) in &mut node_transform_query {
-            let layout = flex_surface.taffy.layout(node.key).unwrap();
-            let new_size = Vec2::new(
-                to_logical(layout.size.width),
-                to_logical(layout.size.height),
-            );
-            // only trigger change detection when the new value is different
-            if node_size.calculated_size != new_size {
-                node_size.calculated_size = new_size;
-            }
-            let mut new_position = transform.translation;
-            new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-            new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-
-            let parent_key = flex_surface.taffy.parent(node.key).unwrap();
-            if parent_key != primary_node {
-                let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
-                new_position.x -= to_logical(parent_layout.size.width / 2.0);
-                new_position.y -= to_logical(parent_layout.size.height / 2.0);
-            }
+    if let Some(physical_to_logical_factor) = ui_viewport.0.as_ref().map(|context| context.physical_to_logical_factor) {
+        let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
+
+        // PERF: try doing this incrementally
+        for &primary_node in flex_surface.window_nodes.values() {
+            for (node, mut node_size, mut transform) in &mut node_transform_query {
+                let layout = flex_surface.taffy.layout(node.key).unwrap();
+                let new_size = Vec2::new(
+                    to_logical(layout.size.width),
+                    to_logical(layout.size.height),
+                );
+                // only trigger change detection when the new value is different
+                if node_size.calculated_size != new_size {
+                    node_size.calculated_size = new_size;
+                }
+                let mut new_position = transform.translation;
+                new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
+                new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
+
+                let parent_key = flex_surface.taffy.parent(node.key).unwrap();
+                if parent_key != primary_node {
+                    let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
+                    new_position.x -= to_logical(parent_layout.size.width / 2.0);
+                    new_position.y -= to_logical(parent_layout.size.height / 2.0);
+                }
 
-            // only trigger change detection when the new value is different
-            if transform.translation != new_position {
-                transform.translation = new_position;
+                // only trigger change detection when the new value is different
+                if transform.translation != new_position {
+                    transform.translation = new_position;
+                }
             }
         }
     }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 79c4bcc5c8456..b89001df51e14 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -53,6 +53,8 @@ pub struct UiPlugin;
 /// The label enum labeling the types of systems in the Bevy UI
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum UiSystem {
+    /// After this label, window events have been handled and windows have been associated to taffy nodes
+    Windows,
     /// After this label, removed ui nodes have been removed from the layout tree
     Removal,
     /// After this label, new ui nodes have been added to the layout tree
@@ -91,6 +93,7 @@ impl Plugin for UiPlugin {
             .init_resource::<FlexSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
+            .init_resource::<UiViewport>()
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
@@ -154,6 +157,9 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
+                update_window_layouts
+                    .in_set(UiSystem::Windows)
+                    .before(UiSystem::Flex),
                 clean_up_removed_ui_nodes
                     .in_set(UiSystem::Removal)
                     .before(UiSystem::Insertion),

From b4a6a7a6e23adf7a14b31d6631462e9229defe69 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 16:52:19 +0100
Subject: [PATCH 08/60] fix scale factor changed check

---
 crates/bevy_ui/src/flex/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index fdc1b90943a48..0055bd4a1c2bd 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -336,7 +336,7 @@ pub fn update_window_layouts(
     let resized = resize_events
         .iter()
         .any(|resized_window| resized_window.window == primary_window_entity);
-    let scale_factor_changed = scale_factor_events.is_empty() || ui_scale.is_changed();
+    let scale_factor_changed = !scale_factor_events.is_empty() || ui_scale.is_changed();
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
     let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed, primary_window_entity);
@@ -374,7 +374,6 @@ pub fn flex_node_system(
     }
 
     if viewport_values.scale_factor_changed || viewport_values.resized {
-        
         update_changed(&mut flex_surface, &viewport_values, full_node_query);
     } else {
         update_changed(&mut flex_surface, &viewport_values, node_query);

From f7dbefbb0cdacf79d7a5b3e52fe5af95628516c9 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 16:53:54 +0100
Subject: [PATCH 09/60] cargo fmt

---
 crates/bevy_ui/src/flex/convert.rs | 16 +++++++++++++--
 crates/bevy_ui/src/flex/mod.rs     | 33 ++++++++++++++++++++----------
 2 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 5c077e56533fa..5a8eb0667a6d2 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -272,7 +272,13 @@ mod tests {
                 height: Val::Percent(0.),
             },
         };
-        let viewport_values = LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false, false, World::new().spawn_empty().id());
+        let viewport_values = LayoutContext::new(
+            1.0,
+            bevy_math::Vec2::new(800., 600.),
+            false,
+            false,
+            World::new().spawn_empty().id(),
+        );
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
@@ -402,7 +408,13 @@ mod tests {
     #[test]
     fn test_into_length_percentage() {
         use taffy::style::LengthPercentage;
-        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.), false, false, World::new().spawn_empty().id());
+        let context = LayoutContext::new(
+            2.0,
+            bevy_math::Vec2::new(800., 600.),
+            false,
+            false,
+            World::new().spawn_empty().id(),
+        );
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),
             (Val::Percent(1.), LengthPercentage::Percent(0.01)),
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 0055bd4a1c2bd..0bd599992f77f 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -47,7 +47,13 @@ pub struct LayoutContext {
 
 impl LayoutContext {
     /// create new a [`LayoutContext`] from the window's physical size and scale factor
-    fn new(scale_factor: f64, physical_size: Vec2, resized: bool, scale_factor_changed: bool, window_entity: Entity) -> Self {
+    fn new(
+        scale_factor: f64,
+        physical_size: Vec2,
+        resized: bool,
+        scale_factor_changed: bool,
+        window_entity: Entity,
+    ) -> Self {
         Self {
             window_entity,
             resized,
@@ -182,12 +188,8 @@ without UI components as a child of an entity with UI components, results may be
                 *node,
                 taffy::style::Style {
                     size: taffy::geometry::Size {
-                        width: taffy::style::Dimension::Points(
-                            window_resolution.x
-                        ),
-                        height: taffy::style::Dimension::Points(
-                            window_resolution.y
-                        ),
+                        width: taffy::style::Dimension::Points(window_resolution.x),
+                        height: taffy::style::Dimension::Points(window_resolution.y),
                     },
                     ..Default::default()
                 },
@@ -339,9 +341,14 @@ pub fn update_window_layouts(
     let scale_factor_changed = !scale_factor_events.is_empty() || ui_scale.is_changed();
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
-    let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed, primary_window_entity);
+    let context = LayoutContext::new(
+        scale_factor,
+        physical_size,
+        resized,
+        scale_factor_changed,
+        primary_window_entity,
+    );
     ui_viewport.0 = Some(context);
-    
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -356,7 +363,7 @@ pub fn flex_node_system(
     let Some(ref viewport_values) = ui_viewport.0 else {
         return
     };
-    
+
     fn update_changed<F: ReadOnlyWorldQuery>(
         flex_surface: &mut FlexSurface,
         viewport_values: &LayoutContext,
@@ -396,7 +403,11 @@ pub fn update_ui_node_transforms(
     ui_viewport: ResMut<UiViewport>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
-    if let Some(physical_to_logical_factor) = ui_viewport.0.as_ref().map(|context| context.physical_to_logical_factor) {
+    if let Some(physical_to_logical_factor) = ui_viewport
+        .0
+        .as_ref()
+        .map(|context| context.physical_to_logical_factor)
+    {
         let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
         // PERF: try doing this incrementally

From d2a7eac259a43f3cf12f96d04b1fdb2cba9d237a Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 17:13:43 +0100
Subject: [PATCH 10/60] move window update back into `flex_node_system`

---
 crates/bevy_ui/src/flex/mod.rs | 77 +++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 39 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 0bd599992f77f..e36a5e2464a19 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -311,7 +311,6 @@ pub fn update_window_layouts(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
-    mut flex_surface: ResMut<FlexSurface>,
     mut ui_viewport: ResMut<UiViewport>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
 ) {
@@ -332,9 +331,6 @@ pub fn update_window_layouts(
             return;
         };
 
-    // update window root nodes
-    flex_surface.update_window(primary_window_entity, physical_size);
-
     let resized = resize_events
         .iter()
         .any(|resized_window| resized_window.window == primary_window_entity);
@@ -390,9 +386,11 @@ pub fn flex_node_system(
         flex_surface.update_leaf(node.key, style, *calculated_size, &viewport_values);
     }
 
-    // update window children (for now assuming all Nodes live in the primary window)
-    let window_entity = *flex_surface.window_nodes.keys().next().unwrap();
-    flex_surface.set_window_children(window_entity, root_node_query.iter());
+    // update window root nodes
+    flex_surface.update_window(viewport_values.window_entity, viewport_values.physical_size);
+
+    // update window children 
+    flex_surface.set_window_children(viewport_values.window_entity, root_node_query.iter());
 
     // compute layouts
     flex_surface.compute_window_layouts();
@@ -403,41 +401,42 @@ pub fn update_ui_node_transforms(
     ui_viewport: ResMut<UiViewport>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
-    if let Some(physical_to_logical_factor) = ui_viewport
+    let Some((primary_window, physical_to_logical_factor)) = ui_viewport
         .0
         .as_ref()
-        .map(|context| context.physical_to_logical_factor)
-    {
-        let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
-
-        // PERF: try doing this incrementally
-        for &primary_node in flex_surface.window_nodes.values() {
-            for (node, mut node_size, mut transform) in &mut node_transform_query {
-                let layout = flex_surface.taffy.layout(node.key).unwrap();
-                let new_size = Vec2::new(
-                    to_logical(layout.size.width),
-                    to_logical(layout.size.height),
-                );
-                // only trigger change detection when the new value is different
-                if node_size.calculated_size != new_size {
-                    node_size.calculated_size = new_size;
-                }
-                let mut new_position = transform.translation;
-                new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-                new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-
-                let parent_key = flex_surface.taffy.parent(node.key).unwrap();
-                if parent_key != primary_node {
-                    let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
-                    new_position.x -= to_logical(parent_layout.size.width / 2.0);
-                    new_position.y -= to_logical(parent_layout.size.height / 2.0);
-                }
+        .map(|context| (context.window_entity, context.physical_to_logical_factor))
+    else {
+        return;
+    };
 
-                // only trigger change detection when the new value is different
-                if transform.translation != new_position {
-                    transform.translation = new_position;
-                }
-            }
+    let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
+    let primary_node = *flex_surface.window_nodes.get(&primary_window).unwrap();
+    
+    // PERF: try doing this incrementally
+    for (node, mut node_size, mut transform) in &mut node_transform_query {
+        let layout = flex_surface.taffy.layout(node.key).unwrap();
+        let new_size = Vec2::new(
+            to_logical(layout.size.width),
+            to_logical(layout.size.height),
+        );
+        // only trigger change detection when the new value is different
+        if node_size.calculated_size != new_size {
+            node_size.calculated_size = new_size;
+        }
+        let mut new_position = transform.translation;
+        new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
+        new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
+
+        let parent_key = flex_surface.taffy.parent(node.key).unwrap();
+        if parent_key != primary_node {
+            let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
+            new_position.x -= to_logical(parent_layout.size.width / 2.0);
+            new_position.y -= to_logical(parent_layout.size.height / 2.0);
+        }
+
+        // only trigger change detection when the new value is different
+        if transform.translation != new_position {
+            transform.translation = new_position;
         }
     }
 }

From 183677acbe87a459b1c95057604f81af4d226358 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 20:55:55 +0100
Subject: [PATCH 11/60] * Renamed `FlexSuface` to `UiSurface`. * Renamed
 `flex_node_system` to `update_ui_layout`. * Replaced the `window_nodes` map
 field of  `UiSurface` with a single `window_node` node field.

---
 crates/bevy_ui/src/flex/mod.rs | 111 ++++++++++++++-------------------
 crates/bevy_ui/src/lib.rs      |   6 +-
 2 files changed, 49 insertions(+), 68 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index e36a5e2464a19..e5a9e016ac64a 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -32,10 +32,9 @@ pub struct Node {
 }
 
 #[derive(Resource, Default)]
-pub struct UiViewport(pub Option<LayoutContext>);
+pub struct UiContext(pub Option<LayoutContext>);
 
 pub struct LayoutContext {
-    pub window_entity: Entity,
     pub resized: bool,
     pub scale_factor: f64,
     pub physical_size: Vec2,
@@ -52,10 +51,8 @@ impl LayoutContext {
         physical_size: Vec2,
         resized: bool,
         scale_factor_changed: bool,
-        window_entity: Entity,
     ) -> Self {
         Self {
-            window_entity,
             resized,
             scale_factor,
             physical_size,
@@ -68,15 +65,15 @@ impl LayoutContext {
 }
 
 #[derive(Resource)]
-pub struct FlexSurface {
+pub struct UiSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    window_nodes: HashMap<Entity, taffy::node::Node>,
+    window_node: taffy::node::Node,
     taffy: Taffy,
 }
 
 // SAFETY: as long as MeasureFunc is Send + Sync. https://github.com/DioxusLabs/taffy/issues/146
-unsafe impl Send for FlexSurface {}
-unsafe impl Sync for FlexSurface {}
+unsafe impl Send for UiSurface {}
+unsafe impl Sync for UiSurface {}
 
 fn _assert_send_sync_flex_surface_impl_safe() {
     fn _assert_send_sync<T: Send + Sync>() {}
@@ -84,26 +81,26 @@ fn _assert_send_sync_flex_surface_impl_safe() {
     _assert_send_sync::<Taffy>();
 }
 
-impl fmt::Debug for FlexSurface {
+impl fmt::Debug for UiSurface {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("FlexSurface")
             .field("entity_to_taffy", &self.entity_to_taffy)
-            .field("window_nodes", &self.window_nodes)
+            .field("window_node", &self.window_node)
             .finish()
     }
 }
 
-impl Default for FlexSurface {
+impl Default for UiSurface {
     fn default() -> Self {
         Self {
             entity_to_taffy: Default::default(),
-            window_nodes: Default::default(),
+            window_node: Default::default(),
             taffy: Taffy::new(),
         }
     }
 }
 
-impl FlexSurface {
+impl UiSurface {
     pub fn insert_node(
         &mut self,
         entity: Entity,
@@ -176,16 +173,13 @@ without UI components as a child of an entity with UI components, results may be
         }
     }
 
-    pub fn update_window(&mut self, window: Entity, window_resolution: Vec2) {
-        let taffy = &mut self.taffy;
-        let node = self
-            .window_nodes
-            .entry(window)
-            .or_insert_with(|| taffy.new_leaf(taffy::style::Style::default()).unwrap());
-
-        taffy
+    pub fn update_window(&mut self, window_resolution: Vec2) {
+        if self.window_node == taffy::node::Node::default() {
+            self.window_node = self.taffy.new_leaf(taffy::style::Style::default()).unwrap()
+        }
+        self.taffy
             .set_style(
-                *node,
+                self.window_node,
                 taffy::style::Style {
                     size: taffy::geometry::Size {
                         width: taffy::style::Dimension::Points(window_resolution.x),
@@ -197,12 +191,8 @@ without UI components as a child of an entity with UI components, results may be
             .unwrap();
     }
 
-    pub fn set_window_children(
-        &mut self,
-        parent_window: Entity,
-        children: impl Iterator<Item = Entity>,
-    ) {
-        let window_node = *self.window_nodes.get(&parent_window).unwrap();
+    pub fn set_window_children(&mut self, children: impl Iterator<Item = Entity>) {
+        let window_node = self.window_node;
         let child_nodes = children
             .map(|e| {
                 let taffy_node = *self.entity_to_taffy.get(&e).unwrap();
@@ -212,12 +202,10 @@ without UI components as a child of an entity with UI components, results may be
         self.taffy.set_children(window_node, &child_nodes).unwrap();
     }
 
-    pub fn compute_window_layouts(&mut self) {
-        for window_node in self.window_nodes.values() {
-            self.taffy
-                .compute_layout(*window_node, Size::MAX_CONTENT)
-                .unwrap();
-        }
+    pub fn compute_window_layout(&mut self) {
+        self.taffy
+            .compute_layout(self.window_node, Size::MAX_CONTENT)
+            .unwrap();
     }
 
     /// Removes each entity from the internal map and then removes their associated node from taffy
@@ -261,7 +249,7 @@ pub enum FlexError {
 /// Remove the corresponding taffy node for any entity that has its `Node` component removed.
 pub fn clean_up_removed_ui_nodes(
     mut commands: Commands,
-    mut flex_surface: ResMut<FlexSurface>,
+    mut flex_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<Node>,
     mut removed_calculated_sizes: RemovedComponents<CalculatedSize>,
 ) {
@@ -276,7 +264,7 @@ pub fn clean_up_removed_ui_nodes(
 
 /// Insert a new taffy node into the layout for any entity that a `Node` component added.
 pub fn insert_new_ui_nodes_into_layout(
-    mut flex_surface: ResMut<FlexSurface>,
+    mut flex_surface: ResMut<UiSurface>,
     mut new_node_query: Query<(Entity, &mut Node), Added<Node>>,
 ) {
     for (entity, mut node) in new_node_query.iter_mut() {
@@ -292,7 +280,7 @@ pub fn insert_new_ui_nodes_into_layout(
 
 /// Synchonise the Bevy and Taffy Parent-Children trees
 pub fn synchonise_children(
-    mut flex_surface: ResMut<FlexSurface>,
+    mut flex_surface: ResMut<UiSurface>,
     mut removed_children: RemovedComponents<Children>,
     children_query: Query<(&Node, &Children), Changed<Children>>,
 ) {
@@ -311,7 +299,7 @@ pub fn update_window_layouts(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
-    mut ui_viewport: ResMut<UiViewport>,
+    mut ui_viewport: ResMut<UiContext>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
 ) {
     // assume one window for time being...
@@ -337,31 +325,25 @@ pub fn update_window_layouts(
     let scale_factor_changed = !scale_factor_events.is_empty() || ui_scale.is_changed();
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
-    let context = LayoutContext::new(
-        scale_factor,
-        physical_size,
-        resized,
-        scale_factor_changed,
-        primary_window_entity,
-    );
+    let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed);
     ui_viewport.0 = Some(context);
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn flex_node_system(
-    ui_viewport: ResMut<UiViewport>,
-    mut flex_surface: ResMut<FlexSurface>,
+pub fn update_ui_layout(
+    ui_viewport: ResMut<UiContext>,
+    mut flex_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
     full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
     changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
 ) {
-    let Some(ref viewport_values) = ui_viewport.0 else {
+    let Some(ref layout_context) = ui_viewport.0 else {
         return
     };
 
     fn update_changed<F: ReadOnlyWorldQuery>(
-        flex_surface: &mut FlexSurface,
+        flex_surface: &mut UiSurface,
         viewport_values: &LayoutContext,
         query: Query<(&Node, &Style, Option<&CalculatedSize>), F>,
     ) {
@@ -376,42 +358,41 @@ pub fn flex_node_system(
         }
     }
 
-    if viewport_values.scale_factor_changed || viewport_values.resized {
-        update_changed(&mut flex_surface, &viewport_values, full_node_query);
+    if layout_context.scale_factor_changed || layout_context.resized {
+        update_changed(&mut flex_surface, &layout_context, full_node_query);
     } else {
-        update_changed(&mut flex_surface, &viewport_values, node_query);
+        update_changed(&mut flex_surface, &layout_context, node_query);
     }
 
     for (node, style, calculated_size) in &changed_size_query {
-        flex_surface.update_leaf(node.key, style, *calculated_size, &viewport_values);
+        flex_surface.update_leaf(node.key, style, *calculated_size, &layout_context);
     }
 
     // update window root nodes
-    flex_surface.update_window(viewport_values.window_entity, viewport_values.physical_size);
+    flex_surface.update_window(layout_context.physical_size);
 
-    // update window children 
-    flex_surface.set_window_children(viewport_values.window_entity, root_node_query.iter());
+    // update window children
+    flex_surface.set_window_children(root_node_query.iter());
 
     // compute layouts
-    flex_surface.compute_window_layouts();
+    flex_surface.compute_window_layout();
 }
 
 pub fn update_ui_node_transforms(
-    flex_surface: Res<FlexSurface>,
-    ui_viewport: ResMut<UiViewport>,
+    flex_surface: Res<UiSurface>,
+    ui_viewport: ResMut<UiContext>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
-    let Some((primary_window, physical_to_logical_factor)) = ui_viewport
+    let Some(physical_to_logical_factor) = ui_viewport
         .0
         .as_ref()
-        .map(|context| (context.window_entity, context.physical_to_logical_factor))
+        .map(|context|  context.physical_to_logical_factor)
     else {
         return;
     };
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
-    let primary_node = *flex_surface.window_nodes.get(&primary_window).unwrap();
-    
+
     // PERF: try doing this incrementally
     for (node, mut node_size, mut transform) in &mut node_transform_query {
         let layout = flex_surface.taffy.layout(node.key).unwrap();
@@ -428,7 +409,7 @@ pub fn update_ui_node_transforms(
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
         let parent_key = flex_surface.taffy.parent(node.key).unwrap();
-        if parent_key != primary_node {
+        if parent_key != flex_surface.window_node {
             let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
             new_position.x -= to_logical(parent_layout.size.width / 2.0);
             new_position.y -= to_logical(parent_layout.size.height / 2.0);
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index b89001df51e14..24d0dc4120590 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -90,10 +90,10 @@ impl Default for UiScale {
 impl Plugin for UiPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugin(ExtractComponentPlugin::<UiCameraConfig>::default())
-            .init_resource::<FlexSurface>()
+            .init_resource::<UiSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
-            .init_resource::<UiViewport>()
+            .init_resource::<UiContext>()
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
             .register_type::<AlignSelf>()
@@ -169,7 +169,7 @@ impl Plugin for UiPlugin {
                 synchonise_children
                     .in_set(UiSystem::Children)
                     .before(UiSystem::Flex),
-                flex_node_system
+                update_ui_layout
                     .in_set(UiSystem::Flex)
                     .before(UiSystem::Transforms),
                 update_ui_node_transforms

From c93106f0d77b1efe7b1163ff871c905bd2526e31 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 21:02:30 +0100
Subject: [PATCH 12/60] fixed tests

---
 crates/bevy_ui/src/flex/convert.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 5a8eb0667a6d2..0b6f567a662a4 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -212,8 +212,6 @@ impl From<FlexWrap> for taffy::style::FlexWrap {
 
 #[cfg(test)]
 mod tests {
-    use bevy_ecs::world::World;
-
     use super::*;
 
     #[test]
@@ -277,7 +275,6 @@ mod tests {
             bevy_math::Vec2::new(800., 600.),
             false,
             false,
-            World::new().spawn_empty().id(),
         );
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
@@ -413,7 +410,6 @@ mod tests {
             bevy_math::Vec2::new(800., 600.),
             false,
             false,
-            World::new().spawn_empty().id(),
         );
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),

From accd08ec8763d1e8b83560b446d46db444e07622 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 21:03:03 +0100
Subject: [PATCH 13/60] Cargo fmt --all

---
 crates/bevy_ui/src/flex/convert.rs | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 0b6f567a662a4..f834b04bcbe04 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -270,12 +270,8 @@ mod tests {
                 height: Val::Percent(0.),
             },
         };
-        let viewport_values = LayoutContext::new(
-            1.0,
-            bevy_math::Vec2::new(800., 600.),
-            false,
-            false,
-        );
+        let viewport_values =
+            LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false, false);
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
@@ -405,12 +401,7 @@ mod tests {
     #[test]
     fn test_into_length_percentage() {
         use taffy::style::LengthPercentage;
-        let context = LayoutContext::new(
-            2.0,
-            bevy_math::Vec2::new(800., 600.),
-            false,
-            false,
-        );
+        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.), false, false);
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),
             (Val::Percent(1.), LengthPercentage::Percent(0.01)),

From 51c69be5a8ab2ccb43f20870d0f32b4f7b243d8b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Thu, 13 Apr 2023 21:49:56 +0100
Subject: [PATCH 14/60] doc comment and clippy fixes

---
 crates/bevy_ui/src/flex/mod.rs | 62 +++++++++++++++++-----------------
 crates/bevy_ui/src/ui_node.rs  |  8 ++---
 2 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index e5a9e016ac64a..2e7731af3cfd4 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -175,7 +175,7 @@ without UI components as a child of an entity with UI components, results may be
 
     pub fn update_window(&mut self, window_resolution: Vec2) {
         if self.window_node == taffy::node::Node::default() {
-            self.window_node = self.taffy.new_leaf(taffy::style::Style::default()).unwrap()
+            self.window_node = self.taffy.new_leaf(taffy::style::Style::default()).unwrap();
         }
         self.taffy
             .set_style(
@@ -249,31 +249,31 @@ pub enum FlexError {
 /// Remove the corresponding taffy node for any entity that has its `Node` component removed.
 pub fn clean_up_removed_ui_nodes(
     mut commands: Commands,
-    mut flex_surface: ResMut<UiSurface>,
+    mut ui_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<Node>,
     mut removed_calculated_sizes: RemovedComponents<CalculatedSize>,
 ) {
     // clean up removed nodes
-    flex_surface.remove_entities(removed_nodes.iter(), &mut commands);
+    ui_surface.remove_entities(removed_nodes.iter(), &mut commands);
 
     // When a `CalculatedSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
     for entity in removed_calculated_sizes.iter() {
-        flex_surface.try_remove_measure(entity);
+        ui_surface.try_remove_measure(entity);
     }
 }
 
 /// Insert a new taffy node into the layout for any entity that a `Node` component added.
 pub fn insert_new_ui_nodes_into_layout(
-    mut flex_surface: ResMut<UiSurface>,
+    mut ui_surface: ResMut<UiSurface>,
     mut new_node_query: Query<(Entity, &mut Node), Added<Node>>,
 ) {
     for (entity, mut node) in new_node_query.iter_mut() {
-        node.key = flex_surface
+        node.key = ui_surface
             .taffy
             .new_leaf(taffy::style::Style::DEFAULT)
             .unwrap();
-        if let Some(old_key) = flex_surface.entity_to_taffy.insert(entity, node.key) {
-            flex_surface.taffy.remove(old_key).ok();
+        if let Some(old_key) = ui_surface.entity_to_taffy.insert(entity, node.key) {
+            ui_surface.taffy.remove(old_key).ok();
         }
     }
 }
@@ -299,7 +299,7 @@ pub fn update_window_layouts(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
-    mut ui_viewport: ResMut<UiContext>,
+    mut ui_context: ResMut<UiContext>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
 ) {
     // assume one window for time being...
@@ -315,7 +315,7 @@ pub fn update_window_layouts(
                 ),
             )
         } else {
-            ui_viewport.0 = None;
+            ui_context.0 = None;
             return;
         };
 
@@ -326,64 +326,64 @@ pub fn update_window_layouts(
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
     let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed);
-    ui_viewport.0 = Some(context);
+    ui_context.0 = Some(context);
 }
 
 #[allow(clippy::too_many_arguments)]
 pub fn update_ui_layout(
-    ui_viewport: ResMut<UiContext>,
-    mut flex_surface: ResMut<UiSurface>,
+    ui_context: ResMut<UiContext>,
+    mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
     full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
     changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
 ) {
-    let Some(ref layout_context) = ui_viewport.0 else {
+    let Some(ref layout_context) = ui_context.0 else {
         return
     };
 
     fn update_changed<F: ReadOnlyWorldQuery>(
-        flex_surface: &mut UiSurface,
-        viewport_values: &LayoutContext,
+        ui_surface: &mut UiSurface,
+        layout_context: &LayoutContext,
         query: Query<(&Node, &Style, Option<&CalculatedSize>), F>,
     ) {
         // update changed nodes
         for (node_key, 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.update_leaf(node_key.key, style, *calculated_size, viewport_values);
+                ui_surface.update_leaf(node_key.key, style, *calculated_size, layout_context);
             } else {
-                flex_surface.update_node(node_key.key, style, viewport_values);
+                ui_surface.update_node(node_key.key, style, layout_context);
             }
         }
     }
 
     if layout_context.scale_factor_changed || layout_context.resized {
-        update_changed(&mut flex_surface, &layout_context, full_node_query);
+        update_changed(&mut ui_surface, layout_context, full_node_query);
     } else {
-        update_changed(&mut flex_surface, &layout_context, node_query);
+        update_changed(&mut ui_surface, layout_context, node_query);
     }
 
     for (node, style, calculated_size) in &changed_size_query {
-        flex_surface.update_leaf(node.key, style, *calculated_size, &layout_context);
+        ui_surface.update_leaf(node.key, style, *calculated_size, layout_context);
     }
 
     // update window root nodes
-    flex_surface.update_window(layout_context.physical_size);
+    ui_surface.update_window(layout_context.physical_size);
 
     // update window children
-    flex_surface.set_window_children(root_node_query.iter());
+    ui_surface.set_window_children(root_node_query.iter());
 
     // compute layouts
-    flex_surface.compute_window_layout();
+    ui_surface.compute_window_layout();
 }
 
 pub fn update_ui_node_transforms(
-    flex_surface: Res<UiSurface>,
-    ui_viewport: ResMut<UiContext>,
+    ui_surface: Res<UiSurface>,
+    ui_context: ResMut<UiContext>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
-    let Some(physical_to_logical_factor) = ui_viewport
+    let Some(physical_to_logical_factor) = ui_context
         .0
         .as_ref()
         .map(|context|  context.physical_to_logical_factor)
@@ -395,7 +395,7 @@ pub fn update_ui_node_transforms(
 
     // PERF: try doing this incrementally
     for (node, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = flex_surface.taffy.layout(node.key).unwrap();
+        let layout = ui_surface.taffy.layout(node.key).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -408,9 +408,9 @@ pub fn update_ui_node_transforms(
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
-        let parent_key = flex_surface.taffy.parent(node.key).unwrap();
-        if parent_key != flex_surface.window_node {
-            let parent_layout = flex_surface.taffy.layout(parent_key).unwrap();
+        let parent_key = ui_surface.taffy.parent(node.key).unwrap();
+        if parent_key != ui_surface.window_node {
+            let parent_layout = ui_surface.taffy.layout(parent_key).unwrap();
             new_position.x -= to_logical(parent_layout.size.width / 2.0);
             new_position.y -= to_logical(parent_layout.size.height / 2.0);
         }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index bba8d80e08ef7..f9ea4deed4621 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -17,13 +17,13 @@ use thiserror::Error;
 #[reflect(Component, Default)]
 pub struct NodeSize {
     /// The size of the node as width and height in logical pixels
-    /// automatically calculated by [`super::flex::flex_node_system`]
+    /// automatically calculated by [`super::flex::update_ui_layout`]
     pub(crate) calculated_size: Vec2,
 }
 
 impl NodeSize {
     /// The calculated node size as width and height in logical pixels
-    /// automatically calculated by [`super::flex::flex_node_system`]
+    /// automatically calculated by [`super::flex::update_ui_layout`]
     pub fn size(&self) -> Vec2 {
         self.calculated_size
     }
@@ -543,7 +543,7 @@ impl Default for Direction {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize, Reflect)]
 #[reflect(PartialEq, Serialize, Deserialize)]
 pub enum Display {
-    /// Use Flexbox layout model to determine the position of this [`Node`].
+    /// Use Flexbox layout model to determine the position of this [`super::flex::Node`].
     Flex,
     /// Use no layout, don't render this node and its children.
     ///
@@ -788,7 +788,7 @@ pub struct CalculatedClip {
     pub clip: Rect,
 }
 
-/// Indicates that this [`Node`] entity's front-to-back ordering is not controlled solely
+/// Indicates that this [`super::flex::Node`] entity's front-to-back ordering is not controlled solely
 /// by its location in the UI hierarchy. A node with a higher z-index will appear on top
 /// of other nodes with a lower z-index.
 ///

From a189982207a5351b7bfc5fce1947816acb11316f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 10:15:39 +0100
Subject: [PATCH 15/60] changes: * Removed redundant `Node` component removal.
 * Query for `Node` components of root nodes instead of `Entity` so that
 `set_window_children` doesn't have to look up the keys. * Added a a simple
 test for node insertion and removal.

---
 crates/bevy_ui/src/flex/mod.rs | 117 ++++++++++++++++++++++++++-------
 1 file changed, 92 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 2e7731af3cfd4..9f5cbd30e72ba 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -8,7 +8,7 @@ use bevy_ecs::{
     prelude::Component,
     query::{Added, Changed, ReadOnlyWorldQuery, With, Without},
     removal_detection::RemovedComponents,
-    system::{Commands, Query, Res, ResMut, Resource},
+    system::{Query, Res, ResMut, Resource},
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -116,6 +116,7 @@ impl UiSurface {
             self.taffy.new_leaf(style).unwrap()
         };
         self.entity_to_taffy.insert(entity, taffy_node);
+
         taffy_node
     }
 
@@ -127,7 +128,7 @@ impl UiSurface {
     ) {
         self.taffy
             .set_style(taffy_node, convert::from_style(context, style))
-            .unwrap();
+            .ok();
     }
 
     pub fn update_leaf(
@@ -191,15 +192,11 @@ without UI components as a child of an entity with UI components, results may be
             .unwrap();
     }
 
-    pub fn set_window_children(&mut self, children: impl Iterator<Item = Entity>) {
-        let window_node = self.window_node;
-        let child_nodes = children
-            .map(|e| {
-                let taffy_node = *self.entity_to_taffy.get(&e).unwrap();
-                taffy_node
-            })
-            .collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(window_node, &child_nodes).unwrap();
+    pub fn set_window_children(&mut self, children: impl Iterator<Item = taffy::node::Node>) {
+        let child_nodes = children.collect::<Vec<taffy::node::Node>>();
+        self.taffy
+            .set_children(self.window_node, &child_nodes)
+            .unwrap();
     }
 
     pub fn compute_window_layout(&mut self) {
@@ -209,19 +206,11 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Removes each entity from the internal map and then removes their associated node from taffy
-    pub fn remove_entities(
-        &mut self,
-        entities: impl IntoIterator<Item = Entity>,
-        commands: &mut Commands,
-    ) {
+    pub fn remove_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
         for entity in entities {
             if let Some(node) = self.entity_to_taffy.remove(&entity) {
                 self.taffy.remove(node).unwrap();
             }
-
-            if let Some(mut entity_commands) = commands.get_entity(entity) {
-                entity_commands.remove::<Node>();
-            }
         }
     }
 
@@ -248,13 +237,12 @@ pub enum FlexError {
 
 /// Remove the corresponding taffy node for any entity that has its `Node` component removed.
 pub fn clean_up_removed_ui_nodes(
-    mut commands: Commands,
     mut ui_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<Node>,
     mut removed_calculated_sizes: RemovedComponents<CalculatedSize>,
 ) {
     // clean up removed nodes
-    ui_surface.remove_entities(removed_nodes.iter(), &mut commands);
+    ui_surface.remove_entities(removed_nodes.iter());
 
     // When a `CalculatedSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
     for entity in removed_calculated_sizes.iter() {
@@ -262,7 +250,7 @@ pub fn clean_up_removed_ui_nodes(
     }
 }
 
-/// Insert a new taffy node into the layout for any entity that a `Node` component added.
+/// Insert a new taffy node into the layout for any entity that had a `Node` component added.
 pub fn insert_new_ui_nodes_into_layout(
     mut ui_surface: ResMut<UiSurface>,
     mut new_node_query: Query<(Entity, &mut Node), Added<Node>>,
@@ -333,7 +321,7 @@ pub fn update_window_layouts(
 pub fn update_ui_layout(
     ui_context: ResMut<UiContext>,
     mut ui_surface: ResMut<UiSurface>,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
+    root_node_query: Query<&Node, (With<Style>, Without<Parent>)>,
     node_query: Query<(&Node, &Style, Option<&CalculatedSize>), Changed<Style>>,
     full_node_query: Query<(&Node, &Style, Option<&CalculatedSize>)>,
     changed_size_query: Query<(&Node, &Style, &CalculatedSize), Changed<CalculatedSize>>,
@@ -372,7 +360,7 @@ pub fn update_ui_layout(
     ui_surface.update_window(layout_context.physical_size);
 
     // update window children
-    ui_surface.set_window_children(root_node_query.iter());
+    ui_surface.set_window_children(root_node_query.iter().map(|node| node.key));
 
     // compute layouts
     ui_surface.compute_window_layout();
@@ -452,3 +440,82 @@ pub fn measure(calculated_size: CalculatedSize, scale_factor: f64) -> taffy::nod
         },
     ))
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::clean_up_removed_ui_nodes;
+    use crate::insert_new_ui_nodes_into_layout;
+    use crate::synchonise_children;
+    use crate::update_ui_layout;
+    use crate::LayoutContext;
+    use crate::Node;
+    use crate::NodeSize;
+    use crate::Style;
+    use crate::UiContext;
+    use crate::UiSurface;
+    use bevy_ecs::prelude::*;
+    use bevy_math::Vec2;
+    use taffy::tree::LayoutTree;
+
+    fn node_bundle() -> (Node, NodeSize, Style) {
+        (Node::default(), NodeSize::default(), Style::default())
+    }
+
+    fn test_schedule() -> Schedule {
+        let mut schedule = Schedule::default();
+
+        schedule.add_systems((
+            clean_up_removed_ui_nodes.before(insert_new_ui_nodes_into_layout),
+            insert_new_ui_nodes_into_layout.before(synchonise_children),
+            synchonise_children.before(update_ui_layout),
+            update_ui_layout,
+        ));
+        schedule
+    }
+
+    #[test]
+    fn insert_and_remove_node() {
+        let mut world = World::new();
+
+        world.init_resource::<UiSurface>();
+        world.insert_resource(UiContext(Some(LayoutContext::new(
+            3.0,
+            Vec2::new(1000., 500.),
+            true,
+            true,
+        ))));
+
+        // add ui node entity to world
+        let entity = world.spawn(node_bundle()).id();
+
+        // ui update
+        let mut schedule = test_schedule();
+        schedule.run(&mut world);
+
+        let key = world.get::<Node>(entity).unwrap().key;
+        let surface = world.resource::<UiSurface>();
+
+        // ui node entity should be associated with a taffy node
+        assert_eq!(surface.entity_to_taffy[&entity], key);
+
+        // taffy node should be a child of the window node
+        assert_eq!(surface.taffy.parent(key).unwrap(), surface.window_node);
+
+        // despawn the ui node entity
+        world.entity_mut(entity).despawn();
+
+        schedule.run(&mut world);
+
+        let surface = world.resource::<UiSurface>();
+
+        // the despawned entity's associated taffy node should also be removed
+        assert!(!surface.entity_to_taffy.contains_key(&entity));
+
+        // window node should have no children
+        assert!(surface
+            .taffy
+            .children(surface.window_node)
+            .unwrap()
+            .is_empty());
+    }
+}

From bf07f5d6b512dd3cd04821a2f48ba8fcf7a9d073 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 13:53:56 +0100
Subject: [PATCH 16/60] added another test

---
 crates/bevy_ui/src/flex/mod.rs | 57 ++++++++++++++++++++++++++++------
 1 file changed, 47 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 9f5cbd30e72ba..de8e501aef8bd 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -447,6 +447,7 @@ mod tests {
     use crate::insert_new_ui_nodes_into_layout;
     use crate::synchonise_children;
     use crate::update_ui_layout;
+    use crate::AlignItems;
     use crate::LayoutContext;
     use crate::Node;
     use crate::NodeSize;
@@ -461,22 +462,20 @@ mod tests {
         (Node::default(), NodeSize::default(), Style::default())
     }
 
-    fn test_schedule() -> Schedule {
-        let mut schedule = Schedule::default();
-
-        schedule.add_systems((
+    fn ui_schedule() -> Schedule {
+        let mut ui_schedule = Schedule::default();
+        ui_schedule.add_systems((
             clean_up_removed_ui_nodes.before(insert_new_ui_nodes_into_layout),
             insert_new_ui_nodes_into_layout.before(synchonise_children),
             synchonise_children.before(update_ui_layout),
             update_ui_layout,
         ));
-        schedule
+        ui_schedule
     }
 
     #[test]
-    fn insert_and_remove_node() {
+    fn test_insert_and_remove_node() {
         let mut world = World::new();
-
         world.init_resource::<UiSurface>();
         world.insert_resource(UiContext(Some(LayoutContext::new(
             3.0,
@@ -484,13 +483,13 @@ mod tests {
             true,
             true,
         ))));
+        let mut ui_schedule = ui_schedule();
 
         // add ui node entity to world
         let entity = world.spawn(node_bundle()).id();
 
         // ui update
-        let mut schedule = test_schedule();
-        schedule.run(&mut world);
+        ui_schedule.run(&mut world);
 
         let key = world.get::<Node>(entity).unwrap().key;
         let surface = world.resource::<UiSurface>();
@@ -504,7 +503,7 @@ mod tests {
         // despawn the ui node entity
         world.entity_mut(entity).despawn();
 
-        schedule.run(&mut world);
+        ui_schedule.run(&mut world);
 
         let surface = world.resource::<UiSurface>();
 
@@ -518,4 +517,42 @@ mod tests {
             .unwrap()
             .is_empty());
     }
+
+    #[test]
+    fn test_node_style_update() {
+        let mut world = World::new();
+        world.init_resource::<UiSurface>();
+        world.insert_resource(UiContext(Some(LayoutContext::new(
+            3.0,
+            Vec2::new(1000., 500.),
+            true,
+            true,
+        ))));
+        let mut ui_schedule = ui_schedule();
+
+        // add a ui node entity to the world and run the ui schedule to add a corresponding node to the taffy layout tree
+        let entity = world.spawn(node_bundle()).id();
+        ui_schedule.run(&mut world);
+
+        // modify the ui node's style component and rerun the schedule
+        world.get_mut::<Style>(entity).unwrap().align_items = AlignItems::Baseline;
+
+        // don't want a full update
+        world.insert_resource(UiContext(Some(LayoutContext::new(
+            3.0,
+            Vec2::new(1000., 500.),
+            false,
+            false,
+        ))));
+
+        ui_schedule.run(&mut world);
+
+        // check the corresponding taffy node's style is also updated
+        let ui_surface = world.resource::<UiSurface>();
+        let key = ui_surface.entity_to_taffy[&entity];
+        assert_eq!(
+            ui_surface.taffy.style(key).unwrap().align_items,
+            Some(taffy::style::AlignItems::Baseline)
+        );
+    }
 }

From 9a3c942226c494f06b94cc8cd442639fee035363 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 14 Apr 2023 22:41:23 +0100
Subject: [PATCH 17/60] replaced `scale_factor_changed` and `resized` fields
 with a single `require_full_update` field

---
 crates/bevy_ui/src/flex/convert.rs |  4 ++--
 crates/bevy_ui/src/flex/mod.rs     | 33 +++++++++++++++---------------
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index f834b04bcbe04..e32fc2355b116 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -271,7 +271,7 @@ mod tests {
             },
         };
         let viewport_values =
-            LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false, false);
+            LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false);
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
@@ -401,7 +401,7 @@ mod tests {
     #[test]
     fn test_into_length_percentage() {
         use taffy::style::LengthPercentage;
-        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.), false, false);
+        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.), false);
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),
             (Val::Percent(1.), LengthPercentage::Percent(0.01)),
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index de8e501aef8bd..ea553a7e2ac80 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -35,11 +35,11 @@ pub struct Node {
 pub struct UiContext(pub Option<LayoutContext>);
 
 pub struct LayoutContext {
-    pub resized: bool,
+    pub require_full_update: bool,
     pub scale_factor: f64,
+    pub logical_size: Vec2,
     pub physical_size: Vec2,
     pub physical_to_logical_factor: f64,
-    pub scale_factor_changed: bool,
     pub min_size: f32,
     pub max_size: f32,
 }
@@ -49,17 +49,17 @@ impl LayoutContext {
     fn new(
         scale_factor: f64,
         physical_size: Vec2,
-        resized: bool,
-        scale_factor_changed: bool,
+        require_full_update: bool,
     ) -> Self {
+        let physical_to_logical_factor = 1. / scale_factor;
         Self {
-            resized,
+            require_full_update,
             scale_factor,
+            logical_size: physical_size * physical_to_logical_factor as f32,
             physical_size,
             min_size: physical_size.x.min(physical_size.y),
             max_size: physical_size.x.max(physical_size.y),
-            physical_to_logical_factor: 1. / scale_factor,
-            scale_factor_changed,
+            physical_to_logical_factor,
         }
     }
 }
@@ -116,7 +116,6 @@ impl UiSurface {
             self.taffy.new_leaf(style).unwrap()
         };
         self.entity_to_taffy.insert(entity, taffy_node);
-
         taffy_node
     }
 
@@ -307,13 +306,16 @@ pub fn update_window_layouts(
             return;
         };
 
-    let resized = resize_events
-        .iter()
-        .any(|resized_window| resized_window.window == primary_window_entity);
-    let scale_factor_changed = !scale_factor_events.is_empty() || ui_scale.is_changed();
+    let require_full_update = 
+        ui_context.0.is_none()
+        || resize_events
+            .iter()
+            .any(|resized_window| resized_window.window == primary_window_entity)
+        || !scale_factor_events.is_empty() 
+        || ui_scale.is_changed();
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;
-    let context = LayoutContext::new(scale_factor, physical_size, resized, scale_factor_changed);
+    let context = LayoutContext::new(scale_factor, physical_size, require_full_update);
     ui_context.0 = Some(context);
 }
 
@@ -346,7 +348,7 @@ pub fn update_ui_layout(
         }
     }
 
-    if layout_context.scale_factor_changed || layout_context.resized {
+    if layout_context.require_full_update {
         update_changed(&mut ui_surface, layout_context, full_node_query);
     } else {
         update_changed(&mut ui_surface, layout_context, node_query);
@@ -481,7 +483,6 @@ mod tests {
             3.0,
             Vec2::new(1000., 500.),
             true,
-            true,
         ))));
         let mut ui_schedule = ui_schedule();
 
@@ -526,7 +527,6 @@ mod tests {
             3.0,
             Vec2::new(1000., 500.),
             true,
-            true,
         ))));
         let mut ui_schedule = ui_schedule();
 
@@ -542,7 +542,6 @@ mod tests {
             3.0,
             Vec2::new(1000., 500.),
             false,
-            false,
         ))));
 
         ui_schedule.run(&mut world);

From ea557811b1661540bfa6441016dd4a423feb548e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 17:03:32 +0100
Subject: [PATCH 18/60] Renamed `insert_new_ui_nodes_into_layout` to
 `insert_new_uinodes` and `synchonise_children` to `synchronise_ui_children`.

---
 crates/bevy_ui/src/flex/mod.rs | 16 ++++++++--------
 crates/bevy_ui/src/lib.rs      |  6 +++---
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index ea553a7e2ac80..602094ce3d209 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -250,7 +250,7 @@ pub fn clean_up_removed_ui_nodes(
 }
 
 /// Insert a new taffy node into the layout for any entity that had a `Node` component added.
-pub fn insert_new_ui_nodes_into_layout(
+pub fn insert_new_ui_nodes(
     mut ui_surface: ResMut<UiSurface>,
     mut new_node_query: Query<(Entity, &mut Node), Added<Node>>,
 ) {
@@ -266,7 +266,7 @@ pub fn insert_new_ui_nodes_into_layout(
 }
 
 /// Synchonise the Bevy and Taffy Parent-Children trees
-pub fn synchonise_children(
+pub fn synchonise_ui_children(
     mut flex_surface: ResMut<UiSurface>,
     mut removed_children: RemovedComponents<Children>,
     children_query: Query<(&Node, &Children), Changed<Children>>,
@@ -282,7 +282,7 @@ pub fn synchonise_children(
     }
 }
 
-pub fn update_window_layouts(
+pub fn update_ui_windows(
     mut resize_events: EventReader<bevy_window::WindowResized>,
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
@@ -446,8 +446,8 @@ pub fn measure(calculated_size: CalculatedSize, scale_factor: f64) -> taffy::nod
 #[cfg(test)]
 mod tests {
     use crate::clean_up_removed_ui_nodes;
-    use crate::insert_new_ui_nodes_into_layout;
-    use crate::synchonise_children;
+    use crate::insert_new_ui_nodes;
+    use crate::synchonise_ui_children;
     use crate::update_ui_layout;
     use crate::AlignItems;
     use crate::LayoutContext;
@@ -467,9 +467,9 @@ mod tests {
     fn ui_schedule() -> Schedule {
         let mut ui_schedule = Schedule::default();
         ui_schedule.add_systems((
-            clean_up_removed_ui_nodes.before(insert_new_ui_nodes_into_layout),
-            insert_new_ui_nodes_into_layout.before(synchonise_children),
-            synchonise_children.before(update_ui_layout),
+            clean_up_removed_ui_nodes.before(insert_new_ui_nodes),
+            insert_new_ui_nodes.before(synchonise_ui_children),
+            synchonise_ui_children.before(update_ui_layout),
             update_ui_layout,
         ));
         ui_schedule
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 24d0dc4120590..215892981239c 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -157,16 +157,16 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
-                update_window_layouts
+                update_ui_windows
                     .in_set(UiSystem::Windows)
                     .before(UiSystem::Flex),
                 clean_up_removed_ui_nodes
                     .in_set(UiSystem::Removal)
                     .before(UiSystem::Insertion),
-                insert_new_ui_nodes_into_layout
+                insert_new_ui_nodes
                     .in_set(UiSystem::Insertion)
                     .before(UiSystem::Children),
-                synchonise_children
+                synchonise_ui_children
                     .in_set(UiSystem::Children)
                     .before(UiSystem::Flex),
                 update_ui_layout

From 1a05f2a509f5c6c4dc2e283abbf36e6175fbc91c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 15 Apr 2023 17:05:16 +0100
Subject: [PATCH 19/60] cargo fmt

---
 crates/bevy_ui/src/flex/convert.rs |  3 +--
 crates/bevy_ui/src/flex/mod.rs     | 11 +++--------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index e32fc2355b116..7cbbb4d695d26 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -270,8 +270,7 @@ mod tests {
                 height: Val::Percent(0.),
             },
         };
-        let viewport_values =
-            LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false);
+        let viewport_values = LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.), false);
         let taffy_style = from_style(&viewport_values, &bevy_style);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index 602094ce3d209..17c480086f3cd 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -46,11 +46,7 @@ pub struct LayoutContext {
 
 impl LayoutContext {
     /// create new a [`LayoutContext`] from the window's physical size and scale factor
-    fn new(
-        scale_factor: f64,
-        physical_size: Vec2,
-        require_full_update: bool,
-    ) -> Self {
+    fn new(scale_factor: f64, physical_size: Vec2, require_full_update: bool) -> Self {
         let physical_to_logical_factor = 1. / scale_factor;
         Self {
             require_full_update,
@@ -306,12 +302,11 @@ pub fn update_ui_windows(
             return;
         };
 
-    let require_full_update = 
-        ui_context.0.is_none()
+    let require_full_update = ui_context.0.is_none()
         || resize_events
             .iter()
             .any(|resized_window| resized_window.window == primary_window_entity)
-        || !scale_factor_events.is_empty() 
+        || !scale_factor_events.is_empty()
         || ui_scale.is_changed();
     scale_factor_events.clear();
     let scale_factor = logical_to_physical_factor * ui_scale.scale;

From 9589cf74446165436e49678e1ff93b88282d4def Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 00:33:14 +0100
Subject: [PATCH 20/60] fix errors from merge

---
 crates/bevy_ui/src/lib.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 2660183188d91..a894d5a4b77f1 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -170,7 +170,7 @@ impl Plugin for UiPlugin {
             (
                 update_ui_windows
                     .in_set(UiSystem::Windows)
-                    .before(UiSystem::Flex),
+                    .before(UiSystem::Layout),
                 clean_up_removed_ui_nodes
                     .in_set(UiSystem::Removal)
                     .before(UiSystem::Insertion),
@@ -179,15 +179,12 @@ impl Plugin for UiPlugin {
                     .before(UiSystem::Children),
                 synchonise_ui_children
                     .in_set(UiSystem::Children)
-                    .before(UiSystem::Flex),
+                    .before(UiSystem::Layout),
                 update_ui_layout
-                    .in_set(UiSystem::Flex)
+                    .in_set(UiSystem::Layout)
                     .before(UiSystem::Transforms),
                 update_ui_node_transforms
                     .in_set(UiSystem::Transforms),
-                ui_layout_system
-                    .in_set(UiSystem::Layout)
-                    .before(TransformSystem::TransformPropagate),
                 ui_stack_system.in_set(UiSystem::Stack),
                 update_clipping_system.after(TransformSystem::TransformPropagate),
             ),

From b8419d59af702fd7e3cb11b664d4221281ddb599 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 07:50:47 +0100
Subject: [PATCH 21/60] Fixed remaining errors from merge

---
 crates/bevy_ui/src/layout/mod.rs  | 25 ++++++++++++++++++++-----
 crates/bevy_ui/src/widget/text.rs |  2 +-
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index e941390bbd262..0afb9fac6c03d 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -94,7 +94,6 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
-
     pub fn insert_node(
         &mut self,
         entity: Entity,
@@ -104,8 +103,22 @@ impl UiSurface {
     ) -> taffy::node::Node {
         let style = convert::from_style(context, style);
         let taffy_node = if let Some(calculated_size) = calculated_size {
-            let measure = measure(*calculated_size, context.scale_factor);
-            self.taffy.new_leaf_with_measure(style, measure).unwrap()
+            let measure = calculated_size.measure.dyn_clone();
+            let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
+                move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
+                    let size = measure.measure(
+                        constraints.width,
+                        constraints.height,
+                        available.width,
+                        available.height,
+                    );
+                    taffy::geometry::Size {
+                        width: size.x,
+                        height: size.y,
+                    }
+                },
+            ));
+            self.taffy.new_leaf_with_measure(style, measure_func).unwrap()
         } else {
             self.taffy.new_leaf(style).unwrap()
         };
@@ -147,6 +160,8 @@ impl UiSurface {
                 }
             },
         ));
+        self.taffy.set_style(taffy_node, taffy_style).unwrap();
+        self.taffy.set_measure(taffy_node, Some(measure_func)).unwrap();
     }
 
     pub fn update_children(&mut self, parent: taffy::node::Node, children: &Children) {
@@ -347,7 +362,7 @@ pub fn update_ui_layout(
         for (node_key, style, calculated_size) in &query {
             // TODO: remove node from old hierarchy if its root has changed
             if let Some(calculated_size) = calculated_size {
-                ui_surface.update_leaf(node_key.key, style, *calculated_size, layout_context);
+                ui_surface.update_leaf(node_key.key, style, calculated_size, layout_context);
             } else {
                 ui_surface.update_node(node_key.key, style, layout_context);
             }
@@ -361,7 +376,7 @@ pub fn update_ui_layout(
     }
 
     for (node, style, calculated_size) in &changed_size_query {
-        ui_surface.update_leaf(node.key, style, *calculated_size, layout_context);
+        ui_surface.update_leaf(node.key, style, calculated_size, layout_context);
     }
 
     // update window root nodes
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index cdd144d7272ca..9ee3d258460e7 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Measure, NodeSize, Style, UiScale, Val};
+use crate::{CalculatedSize, Measure, NodeSize, Style, UiScale, Val, Node};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,

From bd83803bbf7eaefe3d16ed22a5ec61963ff9138e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 21 Apr 2023 07:50:59 +0100
Subject: [PATCH 22/60] fix imports

---
 crates/bevy_ui/src/widget/text.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 9ee3d258460e7..46c731a47748d 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Measure, NodeSize, Style, UiScale, Val, Node};
+use crate::{CalculatedSize, Measure, NodeSize, UiScale, Node};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,

From 8d7a365f446304bb3a59e17673b65f90ade9069e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Sat, 22 Apr 2023 14:05:18 +0100
Subject: [PATCH 23/60] use a parallel iterator to update UI transforms

---
 crates/bevy_ui/src/layout/mod.rs   | 61 +++++++++++++++++-------------
 crates/bevy_ui/src/lib.rs          |  3 +-
 crates/bevy_ui/src/node_bundles.rs |  7 ++--
 crates/bevy_ui/src/widget/text.rs  |  2 +-
 4 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 0afb9fac6c03d..ef834990571db 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -118,7 +118,9 @@ impl UiSurface {
                     }
                 },
             ));
-            self.taffy.new_leaf_with_measure(style, measure_func).unwrap()
+            self.taffy
+                .new_leaf_with_measure(style, measure_func)
+                .unwrap()
         } else {
             self.taffy.new_leaf(style).unwrap()
         };
@@ -161,7 +163,9 @@ impl UiSurface {
             },
         ));
         self.taffy.set_style(taffy_node, taffy_style).unwrap();
-        self.taffy.set_measure(taffy_node, Some(measure_func)).unwrap();
+        self.taffy
+            .set_measure(taffy_node, Some(measure_func))
+            .unwrap();
     }
 
     pub fn update_children(&mut self, parent: taffy::node::Node, children: &Children) {
@@ -405,32 +409,35 @@ pub fn update_ui_node_transforms(
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
     // PERF: try doing this incrementally
-    for (node, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(node.key).unwrap();
-        let new_size = Vec2::new(
-            to_logical(layout.size.width),
-            to_logical(layout.size.height),
-        );
-        // only trigger change detection when the new value is different
-        if node_size.calculated_size != new_size {
-            node_size.calculated_size = new_size;
-        }
-        let mut new_position = transform.translation;
-        new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
-        new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-
-        let parent_key = ui_surface.taffy.parent(node.key).unwrap();
-        if parent_key != ui_surface.window_node {
-            let parent_layout = ui_surface.taffy.layout(parent_key).unwrap();
-            new_position.x -= to_logical(parent_layout.size.width / 2.0);
-            new_position.y -= to_logical(parent_layout.size.height / 2.0);
-        }
+    //for (node, mut node_size, mut transform) in &mut node_transform_query {
+    node_transform_query
+        .par_iter_mut()
+        .for_each_mut(|(node, mut node_size, mut transform)| {
+            let layout = ui_surface.taffy.layout(node.key).unwrap();
+            let new_size = Vec2::new(
+                to_logical(layout.size.width),
+                to_logical(layout.size.height),
+            );
+            // only trigger change detection when the new value is different
+            if node_size.calculated_size != new_size {
+                node_size.calculated_size = new_size;
+            }
+            let mut new_position = transform.translation;
+            new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
+            new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
+
+            let parent_key = ui_surface.taffy.parent(node.key).unwrap();
+            if parent_key != ui_surface.window_node {
+                let parent_layout = ui_surface.taffy.layout(parent_key).unwrap();
+                new_position.x -= to_logical(parent_layout.size.width / 2.0);
+                new_position.y -= to_logical(parent_layout.size.height / 2.0);
+            }
 
-        // only trigger change detection when the new value is different
-        if transform.translation != new_position {
-            transform.translation = new_position;
-        }
-    }
+            // only trigger change detection when the new value is different
+            if transform.translation != new_position {
+                transform.translation = new_position;
+            }
+        });
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index a894d5a4b77f1..da50dbc2d2668 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -183,8 +183,7 @@ impl Plugin for UiPlugin {
                 update_ui_layout
                     .in_set(UiSystem::Layout)
                     .before(UiSystem::Transforms),
-                update_ui_node_transforms
-                    .in_set(UiSystem::Transforms),
+                update_ui_node_transforms.in_set(UiSystem::Transforms),
                 ui_stack_system.in_set(UiSystem::Stack),
                 update_clipping_system.after(TransformSystem::TransformPropagate),
             ),
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 210472a2ad9d2..4a8ac1c255f28 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -1,8 +1,9 @@
 //! This module contains basic node bundles used to build UIs
 
 use crate::{
-    widget::{Button, UiImageSize}, BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, NodeSize,
-        Style, UiImage, ZIndex,
+    widget::{Button, UiImageSize},
+    BackgroundColor, CalculatedSize, FocusPolicy, Interaction, Node, NodeSize, Style, UiImage,
+    ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -71,7 +72,7 @@ pub struct ImageBundle {
     /// Identifier for the Node in the layout.
     pub node: Node,
     /// Describes the logical size of the node
-    /// 
+    ///
     /// This field is automatically managed by the UI layout system.
     /// To alter the position of the `NodeBundle`, use the properties of the [`Style`] component.
     pub node_size: NodeSize,
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 46c731a47748d..ee2c4dd0e9f25 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{CalculatedSize, Measure, NodeSize, UiScale, Node};
+use crate::{CalculatedSize, Measure, Node, NodeSize, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     entity::Entity,

From e08a4aa332ff33b67d1bb0df49df9cc5db371d99 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 14:52:55 +0100
Subject: [PATCH 24/60] fixed errors from merge

---
 crates/bevy_ui/src/layout/mod.rs | 114 ++++---------------------------
 1 file changed, 15 insertions(+), 99 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index cb51073858a2f..3fb4109ed5787 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -6,10 +6,9 @@ use bevy_ecs::{
     entity::Entity,
     event::EventReader,
     prelude::Component,
-    query::{Added, Changed, ReadOnlyWorldQuery, With, Without},
+    query::{Added, Changed, With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource},
-    world::Ref,
+    system::{Query, Res, ResMut, Resource}, world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -20,7 +19,7 @@ use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{
-    prelude::{AvailableSpace, Size},
+    prelude::Size,
     style_helpers::TaffyMaxContent,
     tree::LayoutTree,
     Taffy,
@@ -95,41 +94,7 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
-    pub fn insert_node(
-        &mut self,
-        entity: Entity,
-        style: &Style,
-        calculated_size: Option<&ContentSize>,
-        context: &LayoutContext,
-    ) -> taffy::node::Node {
-        let style = convert::from_style(context, style);
-        let taffy_node = if let Some(calculated_size) = calculated_size {
-            let measure = calculated_size.measure.dyn_clone();
-            let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
-                move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
-                    let size = measure.measure(
-                        constraints.width,
-                        constraints.height,
-                        available.width,
-                        available.height,
-                    );
-                    taffy::geometry::Size {
-                        width: size.x,
-                        height: size.y,
-                    }
-                },
-            ));
-            self.taffy
-                .new_leaf_with_measure(style, measure_func)
-                .unwrap()
-        } else {
-            self.taffy.new_leaf(style).unwrap()
-        };
-        self.entity_to_taffy.insert(entity, taffy_node);
-        taffy_node
-    }
-
-    pub fn update_node(
+    pub fn update_style(
         &mut self,
         taffy_node: taffy::node::Node,
         style: &Style,
@@ -140,57 +105,9 @@ impl UiSurface {
             .ok();
     }
 
-    pub fn update_leaf(
-        &mut self,
-        taffy_node: taffy::node::Node,
-        style: &Style,
-        calculated_size: &ContentSize,
-        context: &LayoutContext,
-    ) {
-        let taffy_style = convert::from_style(context, style);
-        let measure = calculated_size.measure.dyn_clone();
-        let measure_func = taffy::node::MeasureFunc::Boxed(Box::new(
-            move |constraints: Size<Option<f32>>, available: Size<AvailableSpace>| {
-                let size = measure.measure(
-                    constraints.width,
-                    constraints.height,
-                    available.width,
-                    available.height,
-                );
-                taffy::geometry::Size {
-                    width: size.x,
-                    height: size.y,
-                }
-            },
-        ));
-        self.taffy.set_style(taffy_node, taffy_style).unwrap();
-        self.taffy
-            .set_measure(taffy_node, Some(measure_func))
-            .unwrap();
-    }
-
-    
-    /// Retrieves the taffy node corresponding to given entity exists, or inserts a new taffy node into the layout if no corresponding node exists.
-    /// Then convert the given `Style` and use it update the taffy node's style.
-    pub fn upsert_node(&mut self, entity: Entity, style: &Style, context: &LayoutContext) {
-        let mut added = false;
-        let taffy = &mut self.taffy;
-        let taffy_node = self.entity_to_taffy.entry(entity).or_insert_with(|| {
-            added = true;
-            taffy.new_leaf(convert::from_style(context, style)).unwrap()
-        });
-
-        if !added {
-            self.taffy
-                .set_style(*taffy_node, convert::from_style(context, style))
-                .unwrap();
-        }
-    }
-
     /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
-    pub fn update_measure(&mut self, entity: Entity, measure_func: taffy::node::MeasureFunc) {
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
+    pub fn update_measure(&mut self, taffy_node: taffy::node::Node, measure_func: taffy::node::MeasureFunc) {
+        self.taffy.set_measure(taffy_node, Some(measure_func)).ok();
     }
 
     /// Update the children of the taffy node corresponding to the given [`Entity`].
@@ -383,31 +300,30 @@ pub fn update_ui_layout(
     ui_context: ResMut<UiContext>,
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<&Node, (With<Style>, Without<Parent>)>,
-    node_query: Query<(&Node, &Style, Option<&ContentSize>), Changed<Style>>,
-    full_node_query: Query<(&Node, &Style, Option<&ContentSize>)>,
-    changed_size_query: Query<(&Node, &Style, &ContentSize), Changed<ContentSize>>,
+    style_query: Query<(&Node, Ref<Style>)>,
+    full_style_query: Query<(&Node, &Style)>,
+    mut measure_query: Query<(&Node, &mut ContentSize)>,
 ) {
     let Some(ref layout_context) = ui_context.0 else {
         return
     };
 
-
     if layout_context.require_full_update {
         // update all nodes
-        for (entity, style) in style_query.iter() {
-            ui_surface.upsert_node(entity, &style, &layout_context);
+        for (node, style) in full_style_query.iter() {
+            ui_surface.update_style(node.key, &style, &layout_context);
         }
     } else {
-        for (entity, style) in style_query.iter() {
+        for (node, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface.upsert_node(entity, &style, &layout_context);
+                ui_surface.update_style(node.key, &style, &layout_context);
             }
         }
     }
 
-    for (entity, mut content_size) in measure_query.iter_mut() {
+    for (node, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.update_measure(entity, measure_func);
+            ui_surface.update_measure(node.key, measure_func);
         }
     }
 

From 975d97c3905ce4099e12a7e227f0b055e8cb9629 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 15:52:02 +0100
Subject: [PATCH 25/60] cargo fmt

---
 crates/bevy_ui/src/layout/mod.rs   | 34 ++++++++++++++----------------
 crates/bevy_ui/src/node_bundles.rs |  3 +--
 2 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 3fb4109ed5787..45ffea6e6094e 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -8,7 +8,8 @@ use bevy_ecs::{
     prelude::Component,
     query::{Added, Changed, With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource}, world::Ref,
+    system::{Query, Res, ResMut, Resource},
+    world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
@@ -18,12 +19,7 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{
-    prelude::Size,
-    style_helpers::TaffyMaxContent,
-    tree::LayoutTree,
-    Taffy,
-};
+use taffy::{prelude::Size, style_helpers::TaffyMaxContent, tree::LayoutTree, Taffy};
 
 #[derive(Component, Default, Debug, Reflect)]
 pub struct Node {
@@ -106,7 +102,11 @@ impl UiSurface {
     }
 
     /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
-    pub fn update_measure(&mut self, taffy_node: taffy::node::Node, measure_func: taffy::node::MeasureFunc) {
+    pub fn update_measure(
+        &mut self,
+        taffy_node: taffy::node::Node,
+        measure_func: taffy::node::MeasureFunc,
+    ) {
         self.taffy.set_measure(taffy_node, Some(measure_func)).ok();
     }
 
@@ -147,7 +147,6 @@ without UI components as a child of an entity with UI components, results may be
             self.window_node = self.taffy.new_leaf(taffy::style::Style::default()).unwrap();
         }
         self.taffy
-
             .set_style(
                 self.window_node,
                 taffy::style::Style {
@@ -208,21 +207,20 @@ pub enum LayoutError {
     TaffyError(taffy::error::TaffyError),
 }
 
-
 /// Remove the corresponding taffy node for any entity that has its `Node` component removed.
 pub fn clean_up_removed_ui_nodes(
     mut ui_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<Node>,
     mut removed_calculated_sizes: RemovedComponents<ContentSize>,
 ) {
-     // clean up removed nodes
-     ui_surface.remove_entities(removed_nodes.iter());
-
-     // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
-     for entity in removed_calculated_sizes.iter() {
-         ui_surface.try_remove_measure(entity);
-     }
-}   
+    // clean up removed nodes
+    ui_surface.remove_entities(removed_nodes.iter());
+
+    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
+    for entity in removed_calculated_sizes.iter() {
+        ui_surface.try_remove_measure(entity);
+    }
+}
 
 /// Insert a new taffy node into the layout for any entity that had a `Node` component added.
 pub fn insert_new_ui_nodes(
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index deced9eef038f..aaa8350cbd95f 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,8 +2,7 @@
 
 use crate::{
     widget::{Button, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, NodeSize, Style, UiImage,
-    ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, NodeSize, Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{

From e6232888d95fc25812d99f614007d0fc30c6c481 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 15:53:45 +0100
Subject: [PATCH 26/60] fix doc comments

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

diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index c338025b480ff..d6706220a0174 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -829,9 +829,9 @@ impl Default for Direction {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize, Reflect, FromReflect)]
 #[reflect(FromReflect, PartialEq, Serialize, Deserialize)]
 pub enum Display {
-    /// Use Flexbox layout model to determine the position of this [`super::flex::Node`].
+    /// Use Flexbox layout model to determine the position of this [`Node`](crate::Node).
     Flex,
-    /// Use CSS Grid layout model to determine the position of this [`Node`].
+    /// Use CSS Grid layout model to determine the position of this [`Node`](crate::Node).
     Grid,
     /// Use no layout, don't render this node and its children.
     ///

From 1fb196d06551c167673664650bb822dc0e9f6e1e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 15:55:26 +0100
Subject: [PATCH 27/60] fixed needless borrows

---
 crates/bevy_ui/src/layout/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 45ffea6e6094e..9e6d0bd5324f7 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -309,12 +309,12 @@ pub fn update_ui_layout(
     if layout_context.require_full_update {
         // update all nodes
         for (node, style) in full_style_query.iter() {
-            ui_surface.update_style(node.key, &style, &layout_context);
+            ui_surface.update_style(node.key, style, layout_context);
         }
     } else {
         for (node, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface.update_style(node.key, &style, &layout_context);
+                ui_surface.update_style(node.key, &style, layout_context);
             }
         }
     }

From 7572eb641720535a2c850865e4b681cf14b1fb04 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 20:37:45 +0100
Subject: [PATCH 28/60] more doc comment fixes

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

diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index d6706220a0174..1722177eed119 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1593,7 +1593,7 @@ pub struct CalculatedClip {
     pub clip: Rect,
 }
 
-/// Indicates that this [`super::flex::Node`] entity's front-to-back ordering is not controlled solely
+/// Indicates that this [`Node`](crate::layout::Node) entity's front-to-back ordering is not controlled solely
 /// by its location in the UI hierarchy. A node with a higher z-index will appear on top
 /// of other nodes with a lower z-index.
 ///

From e62e63a1d77e3d6b835ee875cda5e999ec52766c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 3 May 2023 20:44:43 +0100
Subject: [PATCH 29/60] Renamed `remove_entities` to `remove_nodes`

---
 crates/bevy_ui/src/layout/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 9e6d0bd5324f7..20086bd77223b 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -176,7 +176,7 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Removes each entity from the internal map and then removes their associated node from taffy
-    pub fn remove_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
+    pub fn remove_nodes(&mut self, entities: impl IntoIterator<Item = Entity>) {
         for entity in entities {
             if let Some(node) = self.entity_to_taffy.remove(&entity) {
                 self.taffy.remove(node).unwrap();
@@ -214,7 +214,7 @@ pub fn clean_up_removed_ui_nodes(
     mut removed_calculated_sizes: RemovedComponents<ContentSize>,
 ) {
     // clean up removed nodes
-    ui_surface.remove_entities(removed_nodes.iter());
+    ui_surface.remove_nodes(removed_nodes.iter());
 
     // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
     for entity in removed_calculated_sizes.iter() {

From 5444d9cb78ee65c7aa1a2344da79978b00ecec65 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 9 May 2023 11:36:52 +0100
Subject: [PATCH 30/60] * Fixed bugs in `debug` and `accessibility` caused by
 merge.

---
 crates/bevy_ui/src/accessibility.rs |  2 +-
 crates/bevy_ui/src/layout/debug.rs  | 25 ++++++++++++-------------
 crates/bevy_ui/src/widget/text.rs   |  2 +-
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 54066b83c8cc3..66f7a6be98d83 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -35,7 +35,7 @@ fn calc_name(texts: &Query<&Text>, children: &Children) -> Option<Box<str>> {
 
 fn calc_bounds(
     camera: Query<(&Camera, &GlobalTransform)>,
-    mut nodes: Query<(&mut AccessibilityNode, Ref<Node>, Ref<GlobalTransform>)>,
+    mut nodes: Query<(&mut AccessibilityNode, Ref<NodeSize>, Ref<GlobalTransform>)>,
 ) {
     if let Ok((camera, camera_transform)) = camera.get_single() {
         for (mut accessible, node, transform) in &mut nodes {
diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index cc04b6d31033c..dc90c725bcf3b 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -12,19 +12,18 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
         .iter()
         .map(|(entity, node)| (*node, *entity))
         .collect();
-    for (&entity, &node) in ui_surface.window_nodes.iter() {
-        let mut out = String::new();
-        print_node(
-            ui_surface,
-            &taffy_to_entity,
-            entity,
-            node,
-            false,
-            String::new(),
-            &mut out,
-        );
-        bevy_log::info!("Layout tree for window entity: {entity:?}\n{out}");
-    }
+    
+    let mut out = String::new();
+    print_node(
+        ui_surface,
+        &taffy_to_entity,
+        taffy_to_entity[&ui_surface.window_node],
+        ui_surface.window_node,
+        false,
+        String::new(),
+        &mut out,
+    );
+    bevy_log::info!("Layout tree for primary window entity:\n{out}");
 }
 
 /// Recursively navigates the layout tree printing each node's information.
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index cec53e9bb3211..08713ebab5191 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -172,7 +172,7 @@ fn queue_text(
     text_settings: &TextSettings,
     scale_factor: f64,
     text: &Text,
-    node: Ref<Node>,
+    node: Ref<NodeSize>,
     mut text_flags: Mut<TextFlags>,
     mut text_layout_info: Mut<TextLayoutInfo>,
 ) {

From ae0120645cca34fb866acf41eeaa2be1215e860e Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 9 May 2023 11:40:00 +0100
Subject: [PATCH 31/60] cargo fmt --all

---
 crates/bevy_ui/src/layout/debug.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index dc90c725bcf3b..9f83f4b75f1b9 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -12,7 +12,7 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
         .iter()
         .map(|(entity, node)| (*node, *entity))
         .collect();
-    
+
     let mut out = String::new();
     print_node(
         ui_surface,

From 8b34f5980a2633f7d6760d1dd71579f865ed4161 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 12:37:37 +0100
Subject: [PATCH 32/60] changes: * Renamed `Node` to `NodeSize` * Created a new
 `Node` component that holds an index to the corresponding Taffy node in
 `UiSurface`. * Added `Node` to the UI's node bundles. * Added a new system
 `insert_new_ui_nodes_system` that runs in `PostUpdate` before
 `ui_layout_system` that inserts new UI nodes into the taffy layout tree.
 Removed the `get_layout`, `upsert_leaf` and `update_measure` methods from
 `UiSurface`. * Change `ui_layout_system` to use `Node` to look up taffy nodes
 where possible.

---
 crates/bevy_ui/src/accessibility.rs |   4 +-
 crates/bevy_ui/src/focus.rs         |   4 +-
 crates/bevy_ui/src/layout/mod.rs    | 131 +++++++++++++---------------
 crates/bevy_ui/src/lib.rs           |   9 +-
 crates/bevy_ui/src/node_bundles.rs  |  23 +++--
 crates/bevy_ui/src/render/mod.rs    |   7 +-
 crates/bevy_ui/src/stack.rs         |  18 ++--
 crates/bevy_ui/src/ui_node.rs       |  39 ++++++++-
 crates/bevy_ui/src/update.rs        |  18 +++-
 crates/bevy_ui/src/widget/image.rs  |   6 +-
 crates/bevy_ui/src/widget/text.rs   |   8 +-
 examples/input/text_input.rs        |  10 +--
 examples/ui/ui.rs                   |   4 +-
 13 files changed, 167 insertions(+), 114 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index f54d2efff3690..66f7a6be98d83 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -1,6 +1,6 @@
 use crate::{
     prelude::{Button, Label},
-    Node, UiImage,
+    NodeSize, UiImage,
 };
 use bevy_a11y::{
     accesskit::{NodeBuilder, Rect, Role},
@@ -35,7 +35,7 @@ fn calc_name(texts: &Query<&Text>, children: &Children) -> Option<Box<str>> {
 
 fn calc_bounds(
     camera: Query<(&Camera, &GlobalTransform)>,
-    mut nodes: Query<(&mut AccessibilityNode, Ref<Node>, Ref<GlobalTransform>)>,
+    mut nodes: Query<(&mut AccessibilityNode, Ref<NodeSize>, Ref<GlobalTransform>)>,
 ) {
     if let Ok((camera, camera_transform)) = camera.get_single() {
         for (mut accessible, node, transform) in &mut nodes {
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index c73ff172b3f54..fe6b8edd1db40 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, NodeSize, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -124,7 +124,7 @@ pub struct State {
 #[world_query(mutable)]
 pub struct NodeQuery {
     entity: Entity,
-    node: &'static Node,
+    node: &'static NodeSize,
     global_transform: &'static GlobalTransform,
     interaction: Option<&'static mut Interaction>,
     relative_cursor_position: Option<&'static mut RelativeCursorPosition>,
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 14da00866ddd8..790c678a5e48a 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,7 +1,7 @@
 mod convert;
 pub mod debug;
 
-use crate::{ContentSize, Node, Style, UiScale};
+use crate::{ContentSize, Node, NodeSize, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -73,31 +73,8 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
-    /// Retrieves the taffy node corresponding to given entity exists, or inserts a new taffy node into the layout if no corresponding node exists.
-    /// Then convert the given `Style` and use it update the taffy node's style.
-    pub fn upsert_node(&mut self, entity: Entity, style: &Style, context: &LayoutContext) {
-        let mut added = false;
-        let taffy = &mut self.taffy;
-        let taffy_node = self.entity_to_taffy.entry(entity).or_insert_with(|| {
-            added = true;
-            taffy.new_leaf(convert::from_style(context, style)).unwrap()
-        });
-
-        if !added {
-            self.taffy
-                .set_style(*taffy_node, convert::from_style(context, style))
-                .unwrap();
-        }
-    }
-
-    /// Update the `MeasureFunc` of the taffy node corresponding to the given [`Entity`].
-    pub fn update_measure(&mut self, entity: Entity, measure_func: taffy::node::MeasureFunc) {
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
-        self.taffy.set_measure(*taffy_node, Some(measure_func)).ok();
-    }
-
     /// Update the children of the taffy node corresponding to the given [`Entity`].
-    pub fn update_children(&mut self, entity: Entity, children: &Children) {
+    pub fn update_children(&mut self, taffy_node: taffy::node::Node, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
@@ -110,9 +87,8 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        let taffy_node = self.entity_to_taffy.get(&entity).unwrap();
         self.taffy
-            .set_children(*taffy_node, &taffy_children)
+            .set_children(taffy_node, &taffy_children)
             .unwrap();
     }
 
@@ -160,12 +136,10 @@ without UI components as a child of an entity with UI components, results may be
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
-        children: impl Iterator<Item = Entity>,
+        children: impl Iterator<Item = taffy::node::Node>,
     ) {
         let taffy_node = self.window_nodes.get(&parent_window).unwrap();
-        let child_nodes = children
-            .map(|e| *self.entity_to_taffy.get(&e).unwrap())
-            .collect::<Vec<taffy::node::Node>>();
+        let child_nodes = children.collect::<Vec<taffy::node::Node>>();
         self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
     }
 
@@ -186,22 +160,6 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
     }
-
-    /// Get the layout geometry for the taffy node corresponding to the ui node [`Entity`].
-    /// Does not compute the layout geometry, `compute_window_layouts` should be run before using this function.
-    pub fn get_layout(&self, entity: Entity) -> Result<&taffy::layout::Layout, LayoutError> {
-        if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
-            self.taffy
-                .layout(*taffy_node)
-                .map_err(LayoutError::TaffyError)
-        } else {
-            warn!(
-                "Styled child in a non-UI entity hierarchy. You are using an entity \
-with UI components as a child of an entity without UI components, results may be unexpected."
-            );
-            Err(LayoutError::InvalidHierarchy)
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -210,6 +168,26 @@ pub enum LayoutError {
     TaffyError(taffy::error::TaffyError),
 }
 
+// Insert new UI nodes into the UI layout
+pub fn insert_new_ui_nodes_system(
+    mut ui_surface: ResMut<UiSurface>,
+    mut node_keys_query: Query<(Entity, &mut Node)>,
+) {
+    for (entity, mut node) in node_keys_query.iter_mut() {
+        // Users can only instantiate `Node` components containing a null key
+        if node.is_null() {
+            node.taffy_key = ui_surface
+                .taffy
+                .new_leaf(taffy::style::Style::default())
+                .unwrap();
+            if let Some(replaced_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_key) {
+                // If the user has replaced the `Node` component of a UI node entity that already has an associated taffy node, the old taffy node must be removed.
+                ui_surface.taffy.remove(replaced_node).unwrap();
+            }
+        }
+    }
+}
+
 /// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(
@@ -219,14 +197,14 @@ pub fn ui_layout_system(
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut resize_events: EventReader<bevy_window::WindowResized>,
     mut ui_surface: ResMut<UiSurface>,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    style_query: Query<(Entity, Ref<Style>), With<Node>>,
-    mut measure_query: Query<(Entity, &mut ContentSize)>,
-    children_query: Query<(Entity, Ref<Children>), With<Node>>,
+    root_node_query: Query<&Node, Without<Parent>>,
+    style_query: Query<(&Node, Ref<Style>)>,
+    mut measure_query: Query<(&Node, &mut ContentSize)>,
+    children_query: Query<(&Node, Ref<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
-    mut node_transform_query: Query<(Entity, &mut Node, &mut Transform, Option<&Parent>)>,
-    mut removed_nodes: RemovedComponents<Node>,
+    mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
+    mut removed_nodes: RemovedComponents<NodeSize>,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -260,20 +238,29 @@ pub fn ui_layout_system(
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
         scale_factor_events.clear();
         // update all nodes
-        for (entity, style) in style_query.iter() {
-            ui_surface.upsert_node(entity, &style, &layout_context);
+        for (node, style) in style_query.iter() {
+            ui_surface
+                .taffy
+                .set_style(node.taffy_key, convert::from_style(&layout_context, &style))
+                .unwrap();
         }
     } else {
-        for (entity, style) in style_query.iter() {
+        for (node, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface.upsert_node(entity, &style, &layout_context);
+                ui_surface
+                    .taffy
+                    .set_style(node.taffy_key, convert::from_style(&layout_context, &style))
+                    .unwrap();
             }
         }
     }
 
-    for (entity, mut content_size) in measure_query.iter_mut() {
+    for (node, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.update_measure(entity, measure_func);
+            ui_surface
+                .taffy
+                .set_measure(node.taffy_key, Some(measure_func))
+                .ok();
         }
     }
 
@@ -286,15 +273,18 @@ pub fn ui_layout_system(
     }
 
     // update window children (for now assuming all Nodes live in the primary window)
-    ui_surface.set_window_children(primary_window_entity, root_node_query.iter());
+    ui_surface.set_window_children(
+        primary_window_entity,
+        root_node_query.iter().map(|node| node.taffy_key),
+    );
 
     // update and remove children
     for entity in removed_children.iter() {
         ui_surface.try_remove_children(entity);
     }
-    for (entity, children) in &children_query {
+    for (node, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(entity, &children);
+            ui_surface.update_children(node.taffy_key, &children);
         }
     }
 
@@ -305,22 +295,27 @@ pub fn ui_layout_system(
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
+    let taffy_window = ui_surface.window_nodes.get(&primary_window_entity).unwrap();
+
     // PERF: try doing this incrementally
-    for (entity, mut node, mut transform, parent) in &mut node_transform_query {
-        let layout = ui_surface.get_layout(entity).unwrap();
+    for (node, mut node_size, mut transform) in &mut node_transform_query {
+        let layout = ui_surface.taffy.layout(node.taffy_key).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
         );
         // only trigger change detection when the new value is different
-        if node.calculated_size != new_size {
-            node.calculated_size = new_size;
+        if node_size.calculated_size != new_size {
+            node_size.calculated_size = new_size;
         }
         let mut new_position = transform.translation;
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if let Some(parent) = parent {
-            if let Ok(parent_layout) = ui_surface.get_layout(**parent) {
+
+        let taffy_parent =
+            taffy::tree::LayoutTree::parent(&ui_surface.taffy, node.taffy_key).unwrap();
+        if taffy_parent != *taffy_window {
+            if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
                 new_position.y -= to_logical(parent_layout.size.height / 2.0);
             }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 3cc3c9b157485..150876b457d7c 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -55,7 +55,9 @@ pub struct UiPlugin;
 /// The label enum labeling the types of systems in the Bevy UI
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum UiSystem {
-    /// After this label, the ui layout state has been updated
+    /// After this label, new UI nodes have been inserted
+    Insert,
+    /// After this label, the UI layout state has been updated
     Layout,
     /// After this label, input interactions with UI entities have been updated for this frame
     Focus,
@@ -102,7 +104,7 @@ impl Plugin for UiPlugin {
             .register_type::<JustifyContent>()
             .register_type::<JustifyItems>()
             .register_type::<JustifySelf>()
-            .register_type::<Node>()
+            .register_type::<NodeSize>()
             .register_type::<ZIndex>()
             // NOTE: used by Style::aspect_ratio
             .register_type::<Option<f32>>()
@@ -158,6 +160,9 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
+                insert_new_ui_nodes_system
+                    .in_set(UiSystem::Insert)
+                    .before(UiSystem::Layout),
                 ui_layout_system
                     .in_set(UiSystem::Layout)
                     .before(TransformSystem::TransformPropagate),
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index dbd5f74f057ef..49baa7815d4fe 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, TextFlags, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, NodeSize, Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -18,8 +18,10 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 /// Useful as a container for a variety of child nodes.
 #[derive(Bundle, Clone, Debug)]
 pub struct NodeBundle {
-    /// Describes the logical size of the node
+    /// Used internally. All UI nodes must have this component.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -51,6 +53,7 @@ impl Default for NodeBundle {
             // Transparent background
             background_color: Color::NONE.into(),
             node: Default::default(),
+            node_size: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -65,11 +68,13 @@ impl Default for NodeBundle {
 /// A UI node that is an image
 #[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
+    /// Used internally. All UI nodes must have this component.
+    pub node: Node,
     /// Describes the logical size of the node
     ///
     /// This field is automatically managed by the UI layout system.
     /// To alter the position of the `NodeBundle`, use the properties of the [`Style`] component.
-    pub node: Node,
+    pub node_size: NodeSize,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -109,8 +114,10 @@ pub struct ImageBundle {
 /// A UI node that is text
 #[derive(Bundle, Debug)]
 pub struct TextBundle {
+    /// Used internally. All UI nodes must have this component.
+    pub taffy: Node,
     /// Describes the logical size of the node
-    pub node: Node,
+    pub node_size: NodeSize,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -154,7 +161,8 @@ impl Default for TextBundle {
             calculated_size: Default::default(),
             // Transparent background
             background_color: BackgroundColor(Color::NONE),
-            node: Default::default(),
+            taffy: Default::default(),
+            node_size: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -210,8 +218,10 @@ impl TextBundle {
 /// A UI node that is a button
 #[derive(Bundle, Clone, Debug)]
 pub struct ButtonBundle {
-    /// Describes the logical size of the node
+    /// Used internally. All UI nodes must have this component.
     pub node: Node,
+    /// Describes the logical size of the node
+    pub node_size: NodeSize,
     /// Marker component that signals this node is a button
     pub button: Button,
     /// Styles which control the layout (size and position) of the node and it's children
@@ -250,6 +260,7 @@ impl Default for ButtonBundle {
         Self {
             focus_policy: FocusPolicy::Block,
             node: Default::default(),
+            node_size: Default::default(),
             button: Default::default(),
             style: Default::default(),
             interaction: Default::default(),
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index f203c4b227565..8030a3f3b8d26 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,7 +8,8 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, Node, UiImage, UiStack};
+use crate::NodeSize;
+use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, UiImage, UiStack};
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
@@ -167,7 +168,7 @@ pub fn extract_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &Node,
+            &NodeSize,
             &GlobalTransform,
             &BackgroundColor,
             Option<&UiImage>,
@@ -280,7 +281,7 @@ pub fn extract_text_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &Node,
+            &NodeSize,
             &GlobalTransform,
             &Text,
             &TextLayoutInfo,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 6dd063b02ffbc..a5e84b8d39b4e 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -3,7 +3,7 @@
 use bevy_ecs::prelude::*;
 use bevy_hierarchy::prelude::*;
 
-use crate::{Node, ZIndex};
+use crate::{NodeSize, ZIndex};
 
 /// The current UI stack, which contains all UI nodes ordered by their depth (back-to-front).
 ///
@@ -32,8 +32,8 @@ struct StackingContextEntry {
 /// Then flatten that tree into back-to-front ordered `UiStack`.
 pub fn ui_stack_system(
     mut ui_stack: ResMut<UiStack>,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    zindex_query: Query<&ZIndex, With<Node>>,
+    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
+    zindex_query: Query<&ZIndex, With<NodeSize>>,
     children_query: Query<&Children>,
 ) {
     // Generate `StackingContext` tree
@@ -59,7 +59,7 @@ pub fn ui_stack_system(
 
 /// Generate z-index based UI node tree
 fn insert_context_hierarchy(
-    zindex_query: &Query<&ZIndex, With<Node>>,
+    zindex_query: &Query<&ZIndex, With<NodeSize>>,
     children_query: &Query<&Children>,
     entity: Entity,
     global_context: &mut StackingContext,
@@ -124,19 +124,19 @@ mod tests {
     };
     use bevy_hierarchy::BuildChildren;
 
-    use crate::{Node, UiStack, ZIndex};
+    use crate::{NodeSize, UiStack, ZIndex};
 
     use super::ui_stack_system;
 
     #[derive(Component, PartialEq, Debug, Clone)]
     struct Label(&'static str);
 
-    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, Node, ZIndex) {
-        (Label(name), Node::default(), z_index)
+    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, NodeSize, ZIndex) {
+        (Label(name), NodeSize::default(), z_index)
     }
 
-    fn node_without_zindex(name: &'static str) -> (Label, Node) {
-        (Label(name), Node::default())
+    fn node_without_zindex(name: &'static str) -> (Label, NodeSize) {
+        (Label(name), NodeSize::default())
     }
 
     /// Tests the UI Stack system.
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index e9857566e0c83..2a772af15f647 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -14,16 +14,45 @@ use smallvec::SmallVec;
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 use thiserror::Error;
 
+/// Used internally to lookup a UI node's corresponding entry in the UI's layout tree.
+///
+/// UI nodes must have this component
+#[derive(Component, Debug, Default)]
+pub struct Node {
+    // Indentifier for the Taffy node in the Taffy layout tree stored in [`crate::layout::UiSurface`] that corresponds to the UI node entity with this component.
+    //
+    // Users can only instantiate null nodes, the keys are managed internally by the UI's layout systems.
+    pub(crate) taffy_key: taffy::node::Node,
+}
+
+impl Node {
+    // Returns true if this taffy key is null.
+    // A UI node entity with a null `taffy_node` value has not been added to the layout tree.
+    #[inline]
+    pub(crate) fn is_null(&self) -> bool {
+        // The default value for `taffy::node::Node` is null
+        self.taffy_key == taffy::node::Node::default()
+    }
+}
+
+impl Clone for Node {
+    fn clone(&self) -> Self {
+        Self::default()
+    }
+}
+
 /// Describes the size of a UI node
+///
+/// All UI nodes must have this component.
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[reflect(Component, Default)]
-pub struct Node {
+pub struct NodeSize {
     /// The size of the node as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub(crate) calculated_size: Vec2,
 }
 
-impl Node {
+impl NodeSize {
     /// The calculated node size as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub const fn size(&self) -> Vec2 {
@@ -62,13 +91,13 @@ impl Node {
     }
 }
 
-impl Node {
+impl NodeSize {
     pub const DEFAULT: Self = Self {
         calculated_size: Vec2::ZERO,
     };
 }
 
-impl Default for Node {
+impl Default for NodeSize {
     fn default() -> Self {
         Self::DEFAULT
     }
@@ -279,6 +308,8 @@ impl Val {
 
 /// Describes the style of a UI container node
 ///
+/// All UI nodes must have this component
+///
 /// Node's can be laid out using either Flexbox or CSS Grid Layout.<br />
 /// See below for general learning resources and for documentation on the individual style properties.
 ///
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 1da4395b55196..5462652c80078 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -2,7 +2,7 @@
 
 use crate::{CalculatedClip, OverflowAxis, Style};
 
-use super::Node;
+use super::NodeSize;
 use bevy_ecs::{
     entity::Entity,
     query::{With, Without},
@@ -15,8 +15,13 @@ use bevy_transform::components::GlobalTransform;
 /// Updates clipping for all nodes
 pub fn update_clipping_system(
     mut commands: Commands,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    mut node_query: Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
+    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
+    mut node_query: Query<(
+        &NodeSize,
+        &GlobalTransform,
+        &Style,
+        Option<&mut CalculatedClip>,
+    )>,
     children_query: Query<&Children>,
 ) {
     for root_node in &root_node_query {
@@ -33,7 +38,12 @@ pub fn update_clipping_system(
 fn update_clipping(
     commands: &mut Commands,
     children_query: &Query<&Children>,
-    node_query: &mut Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
+    node_query: &mut Query<(
+        &NodeSize,
+        &GlobalTransform,
+        &Style,
+        Option<&mut CalculatedClip>,
+    )>,
     entity: Entity,
     maybe_inherited_clip: Option<Rect>,
 ) {
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 2453c9dd438a5..1548a253fab8c 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, ContentSize, Measure, Node, UiImage};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, NodeSize, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -68,11 +68,11 @@ pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        (With<Node>, Without<Text>),
+        (With<NodeSize>, Without<Text>),
     >,
     #[cfg(not(feature = "bevy_text"))] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        With<Node>,
+        With<NodeSize>,
     >,
 ) {
     for (mut content_size, image, mut image_size) in &mut query {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index c56ae98bc5997..7849fe098e99e 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{ContentSize, Measure, Node, UiScale};
+use crate::{ContentSize, Measure, NodeSize, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     prelude::{Component, DetectChanges},
@@ -115,7 +115,7 @@ pub fn measure_text_system(
     windows: Query<&Window, With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(Ref<Text>, &mut ContentSize, &mut TextFlags), With<Node>>,
+    mut text_query: Query<(Ref<Text>, &mut ContentSize, &mut TextFlags), With<NodeSize>>,
 ) {
     let window_scale_factor = windows
         .get_single()
@@ -168,7 +168,7 @@ fn queue_text(
     text_settings: &TextSettings,
     scale_factor: f64,
     text: &Text,
-    node: Ref<Node>,
+    node: Ref<NodeSize>,
     mut text_flags: Mut<TextFlags>,
     mut text_layout_info: Mut<TextLayoutInfo>,
 ) {
@@ -224,7 +224,7 @@ pub fn text_system(
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(Ref<Node>, &Text, &mut TextLayoutInfo, &mut TextFlags)>,
+    mut text_query: Query<(Ref<NodeSize>, &Text, &mut TextLayoutInfo, &mut TextFlags)>,
 ) {
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
     let window_scale_factor = windows
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index 8140325094df2..2e0dbbb4634a5 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -103,7 +103,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 fn toggle_ime(
     input: Res<Input<MouseButton>>,
     mut windows: Query<&mut Window>,
-    mut text: Query<&mut Text, With<Node>>,
+    mut text: Query<&mut Text, With<NodeSize>>,
 ) {
     if input.just_pressed(MouseButton::Left) {
         let mut window = windows.single_mut();
@@ -139,8 +139,8 @@ fn bubbling_text(
 
 fn listen_ime_events(
     mut events: EventReader<Ime>,
-    mut status_text: Query<&mut Text, With<Node>>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut status_text: Query<&mut Text, With<NodeSize>>,
+    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event {
@@ -166,7 +166,7 @@ fn listen_ime_events(
 
 fn listen_received_character_events(
     mut events: EventReader<ReceivedCharacter>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         edit_text.single_mut().sections[0].value.push(event.char);
@@ -176,7 +176,7 @@ fn listen_received_character_events(
 fn listen_keyboard_input_events(
     mut commands: Commands,
     mut events: EventReader<KeyboardInput>,
-    mut edit_text: Query<(Entity, &mut Text), (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<(Entity, &mut Text), (Without<NodeSize>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event.key_code {
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index d338446f9136b..2938e4cf63fe9 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -295,8 +295,8 @@ struct ScrollingList {
 
 fn mouse_scroll(
     mut mouse_wheel_events: EventReader<MouseWheel>,
-    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &Node)>,
-    query_node: Query<&Node>,
+    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &NodeSize)>,
+    query_node: Query<&NodeSize>,
 ) {
     for mouse_wheel_event in mouse_wheel_events.iter() {
         for (mut scrolling_list, mut style, parent, list_node) in &mut query_list {

From 4313bf09ee3a0020b5523dd3363aa2b361459aeb Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 12:56:15 +0100
Subject: [PATCH 33/60] changes: Changed queries to use `With<Node>`.

---
 crates/bevy_ui/src/stack.rs        |  8 ++++----
 crates/bevy_ui/src/widget/image.rs |  6 +++---
 crates/bevy_ui/src/widget/text.rs  |  4 ++--
 examples/input/text_input.rs       | 10 +++++-----
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index a5e84b8d39b4e..07f41064c7784 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -3,7 +3,7 @@
 use bevy_ecs::prelude::*;
 use bevy_hierarchy::prelude::*;
 
-use crate::{NodeSize, ZIndex};
+use crate::{Node, ZIndex};
 
 /// The current UI stack, which contains all UI nodes ordered by their depth (back-to-front).
 ///
@@ -32,8 +32,8 @@ struct StackingContextEntry {
 /// Then flatten that tree into back-to-front ordered `UiStack`.
 pub fn ui_stack_system(
     mut ui_stack: ResMut<UiStack>,
-    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
-    zindex_query: Query<&ZIndex, With<NodeSize>>,
+    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
+    zindex_query: Query<&ZIndex, With<Node>>,
     children_query: Query<&Children>,
 ) {
     // Generate `StackingContext` tree
@@ -59,7 +59,7 @@ pub fn ui_stack_system(
 
 /// Generate z-index based UI node tree
 fn insert_context_hierarchy(
-    zindex_query: &Query<&ZIndex, With<NodeSize>>,
+    zindex_query: &Query<&ZIndex, With<Node>>,
     children_query: &Query<&Children>,
     entity: Entity,
     global_context: &mut StackingContext,
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 1548a253fab8c..2453c9dd438a5 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, ContentSize, Measure, NodeSize, UiImage};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, Node, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -68,11 +68,11 @@ pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        (With<NodeSize>, Without<Text>),
+        (With<Node>, Without<Text>),
     >,
     #[cfg(not(feature = "bevy_text"))] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        With<NodeSize>,
+        With<Node>,
     >,
 ) {
     for (mut content_size, image, mut image_size) in &mut query {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 7849fe098e99e..400bd247e9344 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{ContentSize, Measure, NodeSize, UiScale};
+use crate::{ContentSize, Measure, Node, NodeSize, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     prelude::{Component, DetectChanges},
@@ -115,7 +115,7 @@ pub fn measure_text_system(
     windows: Query<&Window, With<PrimaryWindow>>,
     ui_scale: Res<UiScale>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(Ref<Text>, &mut ContentSize, &mut TextFlags), With<NodeSize>>,
+    mut text_query: Query<(Ref<Text>, &mut ContentSize, &mut TextFlags), With<Node>>,
 ) {
     let window_scale_factor = windows
         .get_single()
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index 2e0dbbb4634a5..8140325094df2 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -103,7 +103,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 fn toggle_ime(
     input: Res<Input<MouseButton>>,
     mut windows: Query<&mut Window>,
-    mut text: Query<&mut Text, With<NodeSize>>,
+    mut text: Query<&mut Text, With<Node>>,
 ) {
     if input.just_pressed(MouseButton::Left) {
         let mut window = windows.single_mut();
@@ -139,8 +139,8 @@ fn bubbling_text(
 
 fn listen_ime_events(
     mut events: EventReader<Ime>,
-    mut status_text: Query<&mut Text, With<NodeSize>>,
-    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
+    mut status_text: Query<&mut Text, With<Node>>,
+    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event {
@@ -166,7 +166,7 @@ fn listen_ime_events(
 
 fn listen_received_character_events(
     mut events: EventReader<ReceivedCharacter>,
-    mut edit_text: Query<&mut Text, (Without<NodeSize>, Without<Bubble>)>,
+    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         edit_text.single_mut().sections[0].value.push(event.char);
@@ -176,7 +176,7 @@ fn listen_received_character_events(
 fn listen_keyboard_input_events(
     mut commands: Commands,
     mut events: EventReader<KeyboardInput>,
-    mut edit_text: Query<(Entity, &mut Text), (Without<NodeSize>, Without<Bubble>)>,
+    mut edit_text: Query<(Entity, &mut Text), (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event.key_code {

From 0c9e9c1352c5ecbcaa2f0bd74512791da00d3407 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 14:16:46 +0100
Subject: [PATCH 34/60] changes: * renamed `insert_new_ui_nodes_system` to
 `insert_ui_nodes_system` * moved node removal to `insert_ui_nodes_system` *
 renamed `taffy_key` field to `taffy_node`

---
 crates/bevy_ui/src/layout/mod.rs | 46 ++++++++++++++++----------------
 crates/bevy_ui/src/ui_node.rs    |  4 +--
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 790c678a5e48a..e5dd7910954c8 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -171,18 +171,22 @@ pub enum LayoutError {
 // Insert new UI nodes into the UI layout
 pub fn insert_new_ui_nodes_system(
     mut ui_surface: ResMut<UiSurface>,
+    mut removed_nodes: RemovedComponents<NodeSize>,
     mut node_keys_query: Query<(Entity, &mut Node)>,
 ) {
+    // clean up removed nodes first
+    ui_surface.remove_entities(removed_nodes.iter());
+
     for (entity, mut node) in node_keys_query.iter_mut() {
         // Users can only instantiate `Node` components containing a null key
         if node.is_null() {
-            node.taffy_key = ui_surface
-                .taffy
-                .new_leaf(taffy::style::Style::default())
-                .unwrap();
-            if let Some(replaced_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_key) {
-                // If the user has replaced the `Node` component of a UI node entity that already has an associated taffy node, the old taffy node must be removed.
-                ui_surface.taffy.remove(replaced_node).unwrap();
+            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node) {
+                node.taffy_node = old_taffy_node;
+            } else {
+                node.taffy_node = ui_surface
+                    .taffy
+                    .new_leaf(taffy::style::Style::default())
+                    .unwrap();
             }
         }
     }
@@ -204,7 +208,6 @@ pub fn ui_layout_system(
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
-    mut removed_nodes: RemovedComponents<NodeSize>,
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -241,7 +244,7 @@ pub fn ui_layout_system(
         for (node, style) in style_query.iter() {
             ui_surface
                 .taffy
-                .set_style(node.taffy_key, convert::from_style(&layout_context, &style))
+                .set_style(node.taffy_node, convert::from_style(&layout_context, &style))
                 .unwrap();
         }
     } else {
@@ -249,33 +252,30 @@ pub fn ui_layout_system(
             if style.is_changed() {
                 ui_surface
                     .taffy
-                    .set_style(node.taffy_key, convert::from_style(&layout_context, &style))
+                    .set_style(node.taffy_node, convert::from_style(&layout_context, &style))
                     .unwrap();
             }
         }
     }
 
+    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
+    for entity in removed_content_sizes.iter() {
+        ui_surface.try_remove_measure(entity);
+    }
+
     for (node, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
             ui_surface
                 .taffy
-                .set_measure(node.taffy_key, Some(measure_func))
+                .set_measure(node.taffy_node, Some(measure_func))
                 .ok();
         }
     }
 
-    // clean up removed nodes
-    ui_surface.remove_entities(removed_nodes.iter());
-
-    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
-    for entity in removed_content_sizes.iter() {
-        ui_surface.try_remove_measure(entity);
-    }
-
     // update window children (for now assuming all Nodes live in the primary window)
     ui_surface.set_window_children(
         primary_window_entity,
-        root_node_query.iter().map(|node| node.taffy_key),
+        root_node_query.iter().map(|node| node.taffy_node),
     );
 
     // update and remove children
@@ -284,7 +284,7 @@ pub fn ui_layout_system(
     }
     for (node, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(node.taffy_key, &children);
+            ui_surface.update_children(node.taffy_node, &children);
         }
     }
 
@@ -299,7 +299,7 @@ pub fn ui_layout_system(
 
     // PERF: try doing this incrementally
     for (node, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(node.taffy_key).unwrap();
+        let layout = ui_surface.taffy.layout(node.taffy_node).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -313,7 +313,7 @@ pub fn ui_layout_system(
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
         let taffy_parent =
-            taffy::tree::LayoutTree::parent(&ui_surface.taffy, node.taffy_key).unwrap();
+            taffy::tree::LayoutTree::parent(&ui_surface.taffy, node.taffy_node).unwrap();
         if taffy_parent != *taffy_window {
             if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 2a772af15f647..b43490c0bb108 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -22,7 +22,7 @@ pub struct Node {
     // Indentifier for the Taffy node in the Taffy layout tree stored in [`crate::layout::UiSurface`] that corresponds to the UI node entity with this component.
     //
     // Users can only instantiate null nodes, the keys are managed internally by the UI's layout systems.
-    pub(crate) taffy_key: taffy::node::Node,
+    pub(crate) taffy_node: taffy::node::Node,
 }
 
 impl Node {
@@ -31,7 +31,7 @@ impl Node {
     #[inline]
     pub(crate) fn is_null(&self) -> bool {
         // The default value for `taffy::node::Node` is null
-        self.taffy_key == taffy::node::Node::default()
+        self.taffy_node == taffy::node::Node::default()
     }
 }
 

From 523b536c3f215c8ef7692adf77bdfe59a51f22ea Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 14:18:29 +0100
Subject: [PATCH 35/60] changes: * renamed `taffy_key` field to `taffy_node` *
 renamed `insert_new_ui_nodes_system` to `insert_ui_nodes_system` * moved node
 removal to `insert_ui_nodes_system` * remove orphaned measure funcs before
 measure funcs updates

---
 crates/bevy_ui/src/layout/mod.rs | 2 +-
 crates/bevy_ui/src/lib.rs        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index e5dd7910954c8..c59250ac58de2 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -169,7 +169,7 @@ pub enum LayoutError {
 }
 
 // Insert new UI nodes into the UI layout
-pub fn insert_new_ui_nodes_system(
+pub fn insert_ui_nodes_system(
     mut ui_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<NodeSize>,
     mut node_keys_query: Query<(Entity, &mut Node)>,
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 150876b457d7c..7e960f355dc24 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -160,7 +160,7 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
-                insert_new_ui_nodes_system
+                insert_ui_nodes_system
                     .in_set(UiSystem::Insert)
                     .before(UiSystem::Layout),
                 ui_layout_system

From fc38722d77f11f717835ee7b25e0b0bb0556925f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 14:23:38 +0100
Subject: [PATCH 36/60] check for `Node` not `NodeSize` removed components

---
 crates/bevy_ui/src/layout/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index c59250ac58de2..978f72fa91a54 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -171,7 +171,7 @@ pub enum LayoutError {
 // Insert new UI nodes into the UI layout
 pub fn insert_ui_nodes_system(
     mut ui_surface: ResMut<UiSurface>,
-    mut removed_nodes: RemovedComponents<NodeSize>,
+    mut removed_nodes: RemovedComponents<Node>,
     mut node_keys_query: Query<(Entity, &mut Node)>,
 ) {
     // clean up removed nodes first

From 1430d68a7e5abf7b6ac213a8004b6471f0bcf1d8 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 22 May 2023 18:04:58 +0100
Subject: [PATCH 37/60] fixed removal detection

---
 crates/bevy_ui/src/layout/mod.rs | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 978f72fa91a54..86c3005a01e6d 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -209,6 +209,16 @@ pub fn ui_layout_system(
     mut removed_content_sizes: RemovedComponents<ContentSize>,
     mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
 ) {
+    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
+    for entity in removed_content_sizes.iter() {
+        ui_surface.try_remove_measure(entity);
+    }
+
+    // remove children
+    for entity in removed_children.iter() {
+        ui_surface.try_remove_children(entity);
+    }
+
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
     let (primary_window_entity, logical_to_physical_factor, physical_size) =
@@ -258,11 +268,6 @@ pub fn ui_layout_system(
         }
     }
 
-    // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
-    for entity in removed_content_sizes.iter() {
-        ui_surface.try_remove_measure(entity);
-    }
-
     for (node, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
             ui_surface
@@ -278,10 +283,7 @@ pub fn ui_layout_system(
         root_node_query.iter().map(|node| node.taffy_node),
     );
 
-    // update and remove children
-    for entity in removed_children.iter() {
-        ui_surface.try_remove_children(entity);
-    }
+    // update children
     for (node, children) in &children_query {
         if children.is_changed() {
             ui_surface.update_children(node.taffy_node, &children);

From 4f05ae62d9497280844d742ac512229097641d82 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 23 May 2023 17:53:40 +0100
Subject: [PATCH 38/60] remove rather than reuse old taffy nodes

---
 crates/bevy_ui/src/layout/mod.rs | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 86c3005a01e6d..f2722744da26a 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -180,13 +180,12 @@ pub fn insert_ui_nodes_system(
     for (entity, mut node) in node_keys_query.iter_mut() {
         // Users can only instantiate `Node` components containing a null key
         if node.is_null() {
-            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node) {
-                node.taffy_node = old_taffy_node;
-            } else {
-                node.taffy_node = ui_surface
+            node.taffy_node = ui_surface
                     .taffy
                     .new_leaf(taffy::style::Style::default())
                     .unwrap();
+            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node) {
+                ui_surface.taffy.remove(old_taffy_node).unwrap();
             }
         }
     }
@@ -219,6 +218,13 @@ pub fn ui_layout_system(
         ui_surface.try_remove_children(entity);
     }
 
+    // update children
+    for (node, children) in &children_query {
+        if children.is_changed() {
+            ui_surface.update_children(node.taffy_node, &children);
+        }
+    }
+
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
     let (primary_window_entity, logical_to_physical_factor, physical_size) =
@@ -283,13 +289,6 @@ pub fn ui_layout_system(
         root_node_query.iter().map(|node| node.taffy_node),
     );
 
-    // update children
-    for (node, children) in &children_query {
-        if children.is_changed() {
-            ui_surface.update_children(node.taffy_node, &children);
-        }
-    }
-
     // compute layouts
     ui_surface.compute_window_layouts();
 

From 2b2908e7c3dc4477a19b11e9d440f16288924d55 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 23 May 2023 17:59:59 +0100
Subject: [PATCH 39/60] also do a full update on window creation

---
 crates/bevy_ui/src/layout/mod.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index f2722744da26a..ee327a2eb3477 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -198,7 +198,8 @@ pub fn ui_layout_system(
     windows: Query<(Entity, &Window)>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
-    mut resize_events: EventReader<bevy_window::WindowResized>,
+    mut window_resized_events: EventReader<bevy_window::WindowResized>,
+    mut window_created_events: EventReader<bevy_window::WindowCreated>,
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<&Node, Without<Parent>>,
     style_query: Query<(&Node, Ref<Style>)>,
@@ -241,9 +242,13 @@ pub fn ui_layout_system(
             return;
         };
 
-    let resized = resize_events
+    let window_changed = window_resized_events
         .iter()
-        .any(|resized_window| resized_window.window == primary_window_entity);
+        .any(|resized_window| resized_window.window == primary_window_entity)
+        ||
+        window_created_events
+        .iter()
+        .any(|created_window| created_window.window == primary_window_entity);
 
     // update window root nodes
     for (entity, window) in windows.iter() {
@@ -254,7 +259,7 @@ pub fn ui_layout_system(
 
     let layout_context = LayoutContext::new(scale_factor, physical_size);
 
-    if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
+    if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();
         // update all nodes
         for (node, style) in style_query.iter() {

From f021661923235bc552b28c611bcf8c26d70df93f Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 23 May 2023 23:26:46 +0100
Subject: [PATCH 40/60] `window_changed` check refactor

---
 crates/bevy_ui/src/layout/mod.rs | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ee327a2eb3477..4174621dafa93 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -181,10 +181,11 @@ pub fn insert_ui_nodes_system(
         // Users can only instantiate `Node` components containing a null key
         if node.is_null() {
             node.taffy_node = ui_surface
-                    .taffy
-                    .new_leaf(taffy::style::Style::default())
-                    .unwrap();
-            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node) {
+                .taffy
+                .new_leaf(taffy::style::Style::default())
+                .unwrap();
+            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node)
+            {
                 ui_surface.taffy.remove(old_taffy_node).unwrap();
             }
         }
@@ -244,11 +245,9 @@ pub fn ui_layout_system(
 
     let window_changed = window_resized_events
         .iter()
-        .any(|resized_window| resized_window.window == primary_window_entity)
-        ||
-        window_created_events
-        .iter()
-        .any(|created_window| created_window.window == primary_window_entity);
+        .map(|resized| resized.window)
+        .chain(window_created_events.iter().map(|created| created.window))
+        .any(|window| window == primary_window_entity);
 
     // update window root nodes
     for (entity, window) in windows.iter() {
@@ -265,7 +264,10 @@ pub fn ui_layout_system(
         for (node, style) in style_query.iter() {
             ui_surface
                 .taffy
-                .set_style(node.taffy_node, convert::from_style(&layout_context, &style))
+                .set_style(
+                    node.taffy_node,
+                    convert::from_style(&layout_context, &style),
+                )
                 .unwrap();
         }
     } else {
@@ -273,7 +275,10 @@ pub fn ui_layout_system(
             if style.is_changed() {
                 ui_surface
                     .taffy
-                    .set_style(node.taffy_node, convert::from_style(&layout_context, &style))
+                    .set_style(
+                        node.taffy_node,
+                        convert::from_style(&layout_context, &style),
+                    )
                     .unwrap();
             }
         }

From 011bc4ac7209e41f14e255ff6161622d6a0d5432 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 26 May 2023 22:52:02 +0100
Subject: [PATCH 41/60] changed name of taffy key component to `UiKey`

---
 crates/bevy_ui/src/accessibility.rs |  4 ++--
 crates/bevy_ui/src/focus.rs         |  4 ++--
 crates/bevy_ui/src/layout/mod.rs    | 16 ++++++++--------
 crates/bevy_ui/src/lib.rs           |  3 ++-
 crates/bevy_ui/src/node_bundles.rs  | 18 +++++++++---------
 crates/bevy_ui/src/render/mod.rs    |  6 +++---
 crates/bevy_ui/src/stack.rs         | 10 +++++-----
 crates/bevy_ui/src/ui_node.rs       | 18 ++++++++++--------
 crates/bevy_ui/src/update.rs        |  8 ++++----
 crates/bevy_ui/src/widget/image.rs  |  6 +++---
 crates/bevy_ui/src/widget/text.rs   |  6 +++---
 examples/input/text_input.rs        | 10 +++++-----
 examples/ui/ui.rs                   |  4 ++--
 13 files changed, 58 insertions(+), 55 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 66f7a6be98d83..f54d2efff3690 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -1,6 +1,6 @@
 use crate::{
     prelude::{Button, Label},
-    NodeSize, UiImage,
+    Node, UiImage,
 };
 use bevy_a11y::{
     accesskit::{NodeBuilder, Rect, Role},
@@ -35,7 +35,7 @@ fn calc_name(texts: &Query<&Text>, children: &Children) -> Option<Box<str>> {
 
 fn calc_bounds(
     camera: Query<(&Camera, &GlobalTransform)>,
-    mut nodes: Query<(&mut AccessibilityNode, Ref<NodeSize>, Ref<GlobalTransform>)>,
+    mut nodes: Query<(&mut AccessibilityNode, Ref<Node>, Ref<GlobalTransform>)>,
 ) {
     if let Ok((camera, camera_transform)) = camera.get_single() {
         for (mut accessible, node, transform) in &mut nodes {
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index fe6b8edd1db40..c73ff172b3f54 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, NodeSize, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -124,7 +124,7 @@ pub struct State {
 #[world_query(mutable)]
 pub struct NodeQuery {
     entity: Entity,
-    node: &'static NodeSize,
+    node: &'static Node,
     global_transform: &'static GlobalTransform,
     interaction: Option<&'static mut Interaction>,
     relative_cursor_position: Option<&'static mut RelativeCursorPosition>,
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 4174621dafa93..17986f51e6b4b 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,7 +1,7 @@
 mod convert;
 pub mod debug;
 
-use crate::{ContentSize, Node, NodeSize, Style, UiScale};
+use crate::{ContentSize, UiKey, Node, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -171,8 +171,8 @@ pub enum LayoutError {
 // Insert new UI nodes into the UI layout
 pub fn insert_ui_nodes_system(
     mut ui_surface: ResMut<UiSurface>,
-    mut removed_nodes: RemovedComponents<Node>,
-    mut node_keys_query: Query<(Entity, &mut Node)>,
+    mut removed_nodes: RemovedComponents<UiKey>,
+    mut node_keys_query: Query<(Entity, &mut UiKey)>,
 ) {
     // clean up removed nodes first
     ui_surface.remove_entities(removed_nodes.iter());
@@ -202,13 +202,13 @@ pub fn ui_layout_system(
     mut window_resized_events: EventReader<bevy_window::WindowResized>,
     mut window_created_events: EventReader<bevy_window::WindowCreated>,
     mut ui_surface: ResMut<UiSurface>,
-    root_node_query: Query<&Node, Without<Parent>>,
-    style_query: Query<(&Node, Ref<Style>)>,
-    mut measure_query: Query<(&Node, &mut ContentSize)>,
-    children_query: Query<(&Node, Ref<Children>)>,
+    root_node_query: Query<&UiKey, Without<Parent>>,
+    style_query: Query<(&UiKey, Ref<Style>)>,
+    mut measure_query: Query<(&UiKey, &mut ContentSize)>,
+    children_query: Query<(&UiKey, Ref<Children>)>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
-    mut node_transform_query: Query<(&Node, &mut NodeSize, &mut Transform)>,
+    mut node_transform_query: Query<(&UiKey, &mut Node, &mut Transform)>,
 ) {
     // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
     for entity in removed_content_sizes.iter() {
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 7e960f355dc24..da57791390028 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -104,7 +104,8 @@ impl Plugin for UiPlugin {
             .register_type::<JustifyContent>()
             .register_type::<JustifyItems>()
             .register_type::<JustifySelf>()
-            .register_type::<NodeSize>()
+            .register_type::<UiKey>()
+            .register_type::<Node>()
             .register_type::<ZIndex>()
             // NOTE: used by Style::aspect_ratio
             .register_type::<Option<f32>>()
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 49baa7815d4fe..275db6650463d 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, TextFlags, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, NodeSize, Style, UiImage, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, UiKey, Node, Style, UiImage, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -19,9 +19,9 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 #[derive(Bundle, Clone, Debug)]
 pub struct NodeBundle {
     /// Used internally. All UI nodes must have this component.
-    pub node: Node,
+    pub node: UiKey,
     /// Describes the logical size of the node
-    pub node_size: NodeSize,
+    pub node_size: Node,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -69,12 +69,12 @@ impl Default for NodeBundle {
 #[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Used internally. All UI nodes must have this component.
-    pub node: Node,
+    pub ui_key: UiKey,
     /// Describes the logical size of the node
     ///
     /// This field is automatically managed by the UI layout system.
     /// To alter the position of the `NodeBundle`, use the properties of the [`Style`] component.
-    pub node_size: NodeSize,
+    pub node: Node,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -115,9 +115,9 @@ pub struct ImageBundle {
 #[derive(Bundle, Debug)]
 pub struct TextBundle {
     /// Used internally. All UI nodes must have this component.
-    pub taffy: Node,
+    pub taffy: UiKey,
     /// Describes the logical size of the node
-    pub node_size: NodeSize,
+    pub node_size: Node,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -219,9 +219,9 @@ impl TextBundle {
 #[derive(Bundle, Clone, Debug)]
 pub struct ButtonBundle {
     /// Used internally. All UI nodes must have this component.
-    pub node: Node,
+    pub node: UiKey,
     /// Describes the logical size of the node
-    pub node_size: NodeSize,
+    pub node_size: Node,
     /// Marker component that signals this node is a button
     pub button: Button,
     /// Styles which control the layout (size and position) of the node and it's children
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 8030a3f3b8d26..321ea04eae3ce 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,7 +8,7 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::NodeSize;
+use crate::Node;
 use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, UiImage, UiStack};
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
@@ -168,7 +168,7 @@ pub fn extract_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &NodeSize,
+            &Node,
             &GlobalTransform,
             &BackgroundColor,
             Option<&UiImage>,
@@ -281,7 +281,7 @@ pub fn extract_text_uinodes(
     ui_stack: Extract<Res<UiStack>>,
     uinode_query: Extract<
         Query<(
-            &NodeSize,
+            &Node,
             &GlobalTransform,
             &Text,
             &TextLayoutInfo,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 07f41064c7784..6dd063b02ffbc 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -124,19 +124,19 @@ mod tests {
     };
     use bevy_hierarchy::BuildChildren;
 
-    use crate::{NodeSize, UiStack, ZIndex};
+    use crate::{Node, UiStack, ZIndex};
 
     use super::ui_stack_system;
 
     #[derive(Component, PartialEq, Debug, Clone)]
     struct Label(&'static str);
 
-    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, NodeSize, ZIndex) {
-        (Label(name), NodeSize::default(), z_index)
+    fn node_with_zindex(name: &'static str, z_index: ZIndex) -> (Label, Node, ZIndex) {
+        (Label(name), Node::default(), z_index)
     }
 
-    fn node_without_zindex(name: &'static str) -> (Label, NodeSize) {
-        (Label(name), NodeSize::default())
+    fn node_without_zindex(name: &'static str) -> (Label, Node) {
+        (Label(name), Node::default())
     }
 
     /// Tests the UI Stack system.
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index b43490c0bb108..81d10741fb36c 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -17,15 +17,17 @@ use thiserror::Error;
 /// Used internally to lookup a UI node's corresponding entry in the UI's layout tree.
 ///
 /// UI nodes must have this component
-#[derive(Component, Debug, Default)]
-pub struct Node {
+#[derive(Component, Debug, Default, Reflect)]
+#[reflect(Component, Default)]
+pub struct UiKey {
     // Indentifier for the Taffy node in the Taffy layout tree stored in [`crate::layout::UiSurface`] that corresponds to the UI node entity with this component.
     //
     // Users can only instantiate null nodes, the keys are managed internally by the UI's layout systems.
+    #[reflect(ignore)]
     pub(crate) taffy_node: taffy::node::Node,
 }
 
-impl Node {
+impl UiKey {
     // Returns true if this taffy key is null.
     // A UI node entity with a null `taffy_node` value has not been added to the layout tree.
     #[inline]
@@ -35,7 +37,7 @@ impl Node {
     }
 }
 
-impl Clone for Node {
+impl Clone for UiKey {
     fn clone(&self) -> Self {
         Self::default()
     }
@@ -46,13 +48,13 @@ impl Clone for Node {
 /// All UI nodes must have this component.
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[reflect(Component, Default)]
-pub struct NodeSize {
+pub struct Node {
     /// The size of the node as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub(crate) calculated_size: Vec2,
 }
 
-impl NodeSize {
+impl Node {
     /// The calculated node size as width and height in logical pixels
     /// automatically calculated by [`super::layout::ui_layout_system`]
     pub const fn size(&self) -> Vec2 {
@@ -91,13 +93,13 @@ impl NodeSize {
     }
 }
 
-impl NodeSize {
+impl Node {
     pub const DEFAULT: Self = Self {
         calculated_size: Vec2::ZERO,
     };
 }
 
-impl Default for NodeSize {
+impl Default for Node {
     fn default() -> Self {
         Self::DEFAULT
     }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 5462652c80078..7db846266db25 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -2,7 +2,7 @@
 
 use crate::{CalculatedClip, OverflowAxis, Style};
 
-use super::NodeSize;
+use super::Node;
 use bevy_ecs::{
     entity::Entity,
     query::{With, Without},
@@ -15,9 +15,9 @@ use bevy_transform::components::GlobalTransform;
 /// Updates clipping for all nodes
 pub fn update_clipping_system(
     mut commands: Commands,
-    root_node_query: Query<Entity, (With<NodeSize>, Without<Parent>)>,
+    root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
     mut node_query: Query<(
-        &NodeSize,
+        &Node,
         &GlobalTransform,
         &Style,
         Option<&mut CalculatedClip>,
@@ -39,7 +39,7 @@ fn update_clipping(
     commands: &mut Commands,
     children_query: &Query<&Children>,
     node_query: &mut Query<(
-        &NodeSize,
+        &Node,
         &GlobalTransform,
         &Style,
         Option<&mut CalculatedClip>,
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 2453c9dd438a5..1022bcd365f39 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, ContentSize, Measure, Node, UiImage};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, UiKey, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -68,11 +68,11 @@ pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        (With<Node>, Without<Text>),
+        (With<UiKey>, Without<Text>),
     >,
     #[cfg(not(feature = "bevy_text"))] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        With<Node>,
+        With<UiKey>,
     >,
 ) {
     for (mut content_size, image, mut image_size) in &mut query {
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 400bd247e9344..c56ae98bc5997 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,4 +1,4 @@
-use crate::{ContentSize, Measure, Node, NodeSize, UiScale};
+use crate::{ContentSize, Measure, Node, UiScale};
 use bevy_asset::Assets;
 use bevy_ecs::{
     prelude::{Component, DetectChanges},
@@ -168,7 +168,7 @@ fn queue_text(
     text_settings: &TextSettings,
     scale_factor: f64,
     text: &Text,
-    node: Ref<NodeSize>,
+    node: Ref<Node>,
     mut text_flags: Mut<TextFlags>,
     mut text_layout_info: Mut<TextLayoutInfo>,
 ) {
@@ -224,7 +224,7 @@ pub fn text_system(
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
     mut text_pipeline: ResMut<TextPipeline>,
-    mut text_query: Query<(Ref<NodeSize>, &Text, &mut TextLayoutInfo, &mut TextFlags)>,
+    mut text_query: Query<(Ref<Node>, &Text, &mut TextLayoutInfo, &mut TextFlags)>,
 ) {
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
     let window_scale_factor = windows
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index 8140325094df2..2c50149c9966c 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -103,7 +103,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 fn toggle_ime(
     input: Res<Input<MouseButton>>,
     mut windows: Query<&mut Window>,
-    mut text: Query<&mut Text, With<Node>>,
+    mut text: Query<&mut Text, With<UiKey>>,
 ) {
     if input.just_pressed(MouseButton::Left) {
         let mut window = windows.single_mut();
@@ -139,8 +139,8 @@ fn bubbling_text(
 
 fn listen_ime_events(
     mut events: EventReader<Ime>,
-    mut status_text: Query<&mut Text, With<Node>>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut status_text: Query<&mut Text, With<UiKey>>,
+    mut edit_text: Query<&mut Text, (Without<UiKey>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event {
@@ -166,7 +166,7 @@ fn listen_ime_events(
 
 fn listen_received_character_events(
     mut events: EventReader<ReceivedCharacter>,
-    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<&mut Text, (Without<UiKey>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         edit_text.single_mut().sections[0].value.push(event.char);
@@ -176,7 +176,7 @@ fn listen_received_character_events(
 fn listen_keyboard_input_events(
     mut commands: Commands,
     mut events: EventReader<KeyboardInput>,
-    mut edit_text: Query<(Entity, &mut Text), (Without<Node>, Without<Bubble>)>,
+    mut edit_text: Query<(Entity, &mut Text), (Without<UiKey>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event.key_code {
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 2938e4cf63fe9..d338446f9136b 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -295,8 +295,8 @@ struct ScrollingList {
 
 fn mouse_scroll(
     mut mouse_wheel_events: EventReader<MouseWheel>,
-    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &NodeSize)>,
-    query_node: Query<&NodeSize>,
+    mut query_list: Query<(&mut ScrollingList, &mut Style, &Parent, &Node)>,
+    query_node: Query<&Node>,
 ) {
     for mouse_wheel_event in mouse_wheel_events.iter() {
         for (mut scrolling_list, mut style, parent, list_node) in &mut query_list {

From c4eda4f48dacc96aed84e18bd6e94be5213b592b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 29 May 2023 11:06:08 +0100
Subject: [PATCH 42/60] Removed the insertion system

---
 crates/bevy_ui/src/layout/mod.rs   | 82 ++++++++++++++++--------------
 crates/bevy_ui/src/lib.rs          |  5 --
 crates/bevy_ui/src/node_bundles.rs |  2 +-
 crates/bevy_ui/src/update.rs       | 14 +----
 crates/bevy_ui/src/widget/image.rs |  2 +-
 5 files changed, 47 insertions(+), 58 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 17986f51e6b4b..5c4d4d4eec678 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,14 +1,14 @@
 mod convert;
 pub mod debug;
 
-use crate::{ContentSize, UiKey, Node, Style, UiScale};
+use crate::{ContentSize, Node, Style, UiKey, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
     query::{With, Without},
     removal_detection::RemovedComponents,
-    system::{Query, Res, ResMut, Resource},
+    system::{ParamSet, Query, Res, ResMut, Resource},
     world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
@@ -168,48 +168,49 @@ pub enum LayoutError {
     TaffyError(taffy::error::TaffyError),
 }
 
-// Insert new UI nodes into the UI layout
-pub fn insert_ui_nodes_system(
+/// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
+#[allow(clippy::too_many_arguments)]
+pub fn ui_layout_system(
+    primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
+    windows: Query<(Entity, &Window)>,
+    ui_scale: Res<UiScale>,
+    mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
+    mut window_resized_events: EventReader<bevy_window::WindowResized>,
+    mut window_created_events: EventReader<bevy_window::WindowCreated>,
     mut ui_surface: ResMut<UiSurface>,
     mut removed_nodes: RemovedComponents<UiKey>,
-    mut node_keys_query: Query<(Entity, &mut UiKey)>,
+    mut removed_children: RemovedComponents<Children>,
+    mut removed_content_sizes: RemovedComponents<ContentSize>,
+    mut ui_queries_param_set: ParamSet<(
+        Query<(Entity, &mut UiKey)>,
+        (
+            Query<(&UiKey, &mut Node, &mut Transform)>,
+            Query<(&UiKey, Ref<Children>)>,
+            Query<(&UiKey, &mut ContentSize)>,
+            Query<(&UiKey, Ref<Style>)>,
+            Query<&UiKey, Without<Parent>>,
+        ),
+    )>,
 ) {
     // clean up removed nodes first
     ui_surface.remove_entities(removed_nodes.iter());
 
-    for (entity, mut node) in node_keys_query.iter_mut() {
+    let mut ui_keys_query = ui_queries_param_set.p0();
+    for (entity, mut ui_key) in ui_keys_query.iter_mut() {
         // Users can only instantiate `Node` components containing a null key
-        if node.is_null() {
-            node.taffy_node = ui_surface
+        if ui_key.is_null() {
+            ui_key.taffy_node = ui_surface
                 .taffy
                 .new_leaf(taffy::style::Style::default())
                 .unwrap();
-            if let Some(old_taffy_node) = ui_surface.entity_to_taffy.insert(entity, node.taffy_node)
+            if let Some(old_taffy_node) =
+                ui_surface.entity_to_taffy.insert(entity, ui_key.taffy_node)
             {
                 ui_surface.taffy.remove(old_taffy_node).unwrap();
             }
         }
     }
-}
 
-/// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
-#[allow(clippy::too_many_arguments)]
-pub fn ui_layout_system(
-    primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
-    windows: Query<(Entity, &Window)>,
-    ui_scale: Res<UiScale>,
-    mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
-    mut window_resized_events: EventReader<bevy_window::WindowResized>,
-    mut window_created_events: EventReader<bevy_window::WindowCreated>,
-    mut ui_surface: ResMut<UiSurface>,
-    root_node_query: Query<&UiKey, Without<Parent>>,
-    style_query: Query<(&UiKey, Ref<Style>)>,
-    mut measure_query: Query<(&UiKey, &mut ContentSize)>,
-    children_query: Query<(&UiKey, Ref<Children>)>,
-    mut removed_children: RemovedComponents<Children>,
-    mut removed_content_sizes: RemovedComponents<ContentSize>,
-    mut node_transform_query: Query<(&UiKey, &mut Node, &mut Transform)>,
-) {
     // When a `ContentSize` component is removed from an entity, we need to remove the measure from the corresponding taffy node.
     for entity in removed_content_sizes.iter() {
         ui_surface.try_remove_measure(entity);
@@ -220,10 +221,13 @@ pub fn ui_layout_system(
         ui_surface.try_remove_children(entity);
     }
 
+    let (mut node_transform_query, children_query, mut measure_query, style_query, root_node_query) =
+        ui_queries_param_set.p1();
+
     // update children
-    for (node, children) in &children_query {
+    for (ui_key, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(node.taffy_node, &children);
+            ui_surface.update_children(ui_key.taffy_node, &children);
         }
     }
 
@@ -261,22 +265,22 @@ pub fn ui_layout_system(
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();
         // update all nodes
-        for (node, style) in style_query.iter() {
+        for (ui_key, style) in style_query.iter() {
             ui_surface
                 .taffy
                 .set_style(
-                    node.taffy_node,
+                    ui_key.taffy_node,
                     convert::from_style(&layout_context, &style),
                 )
                 .unwrap();
         }
     } else {
-        for (node, style) in style_query.iter() {
+        for (ui_key, style) in style_query.iter() {
             if style.is_changed() {
                 ui_surface
                     .taffy
                     .set_style(
-                        node.taffy_node,
+                        ui_key.taffy_node,
                         convert::from_style(&layout_context, &style),
                     )
                     .unwrap();
@@ -284,11 +288,11 @@ pub fn ui_layout_system(
         }
     }
 
-    for (node, mut content_size) in measure_query.iter_mut() {
+    for (ui_key, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
             ui_surface
                 .taffy
-                .set_measure(node.taffy_node, Some(measure_func))
+                .set_measure(ui_key.taffy_node, Some(measure_func))
                 .ok();
         }
     }
@@ -309,8 +313,8 @@ pub fn ui_layout_system(
     let taffy_window = ui_surface.window_nodes.get(&primary_window_entity).unwrap();
 
     // PERF: try doing this incrementally
-    for (node, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(node.taffy_node).unwrap();
+    for (ui_key, mut node_size, mut transform) in &mut node_transform_query {
+        let layout = ui_surface.taffy.layout(ui_key.taffy_node).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -324,7 +328,7 @@ pub fn ui_layout_system(
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
         let taffy_parent =
-            taffy::tree::LayoutTree::parent(&ui_surface.taffy, node.taffy_node).unwrap();
+            taffy::tree::LayoutTree::parent(&ui_surface.taffy, ui_key.taffy_node).unwrap();
         if taffy_parent != *taffy_window {
             if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index da57791390028..344a6de84efaf 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -55,8 +55,6 @@ pub struct UiPlugin;
 /// The label enum labeling the types of systems in the Bevy UI
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum UiSystem {
-    /// After this label, new UI nodes have been inserted
-    Insert,
     /// After this label, the UI layout state has been updated
     Layout,
     /// After this label, input interactions with UI entities have been updated for this frame
@@ -161,9 +159,6 @@ impl Plugin for UiPlugin {
         .add_systems(
             PostUpdate,
             (
-                insert_ui_nodes_system
-                    .in_set(UiSystem::Insert)
-                    .before(UiSystem::Layout),
                 ui_layout_system
                     .in_set(UiSystem::Layout)
                     .before(TransformSystem::TransformPropagate),
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 275db6650463d..2fa16db1c8edf 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, TextFlags, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, UiKey, Node, Style, UiImage, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, UiKey, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 7db846266db25..1da4395b55196 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -16,12 +16,7 @@ use bevy_transform::components::GlobalTransform;
 pub fn update_clipping_system(
     mut commands: Commands,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    mut node_query: Query<(
-        &Node,
-        &GlobalTransform,
-        &Style,
-        Option<&mut CalculatedClip>,
-    )>,
+    mut node_query: Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
     children_query: Query<&Children>,
 ) {
     for root_node in &root_node_query {
@@ -38,12 +33,7 @@ pub fn update_clipping_system(
 fn update_clipping(
     commands: &mut Commands,
     children_query: &Query<&Children>,
-    node_query: &mut Query<(
-        &Node,
-        &GlobalTransform,
-        &Style,
-        Option<&mut CalculatedClip>,
-    )>,
+    node_query: &mut Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
     entity: Entity,
     maybe_inherited_clip: Option<Rect>,
 ) {
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 1022bcd365f39..ed35ba411e1e1 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, ContentSize, Measure, UiKey, UiImage};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, UiImage, UiKey};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;

From 40abcf4d1f032c87580324fa451b0b5ff5ee479c Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 29 May 2023 13:31:36 +0100
Subject: [PATCH 43/60] Cleaned up some comments, removed the `Clone` impl for
 `UiKey`.

---
 crates/bevy_ui/src/layout/mod.rs   |  2 +-
 crates/bevy_ui/src/node_bundles.rs |  4 ++--
 crates/bevy_ui/src/ui_node.rs      | 14 ++++----------
 3 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 5c4d4d4eec678..5b739e31c28e6 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -197,7 +197,7 @@ pub fn ui_layout_system(
 
     let mut ui_keys_query = ui_queries_param_set.p0();
     for (entity, mut ui_key) in ui_keys_query.iter_mut() {
-        // Users can only instantiate `Node` components containing a null key
+        // Users can only instantiate `UiKey` components containing a null key
         if ui_key.is_null() {
             ui_key.taffy_node = ui_surface
                 .taffy
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 2fa16db1c8edf..6b36a8602b782 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -16,7 +16,7 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 /// The basic UI node
 ///
 /// Useful as a container for a variety of child nodes.
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct NodeBundle {
     /// Used internally. All UI nodes must have this component.
     pub node: UiKey,
@@ -216,7 +216,7 @@ impl TextBundle {
 }
 
 /// A UI node that is a button
-#[derive(Bundle, Clone, Debug)]
+#[derive(Bundle, Debug)]
 pub struct ButtonBundle {
     /// Used internally. All UI nodes must have this component.
     pub node: UiKey,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 81d10741fb36c..ca7119efa90bb 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -14,15 +14,15 @@ use smallvec::SmallVec;
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 use thiserror::Error;
 
-/// Used internally to lookup a UI node's corresponding entry in the UI's layout tree.
+/// Used internally to identify a UI node's corresponding entry in the UI's layout tree.
 ///
 /// UI nodes must have this component
 #[derive(Component, Debug, Default, Reflect)]
 #[reflect(Component, Default)]
 pub struct UiKey {
-    // Indentifier for the Taffy node in the Taffy layout tree stored in [`crate::layout::UiSurface`] that corresponds to the UI node entity with this component.
-    //
-    // Users can only instantiate null nodes, the keys are managed internally by the UI's layout systems.
+    /// Indentifier for the Taffy node in the Taffy layout tree stored in [`super::layout::UiSurface`] that corresponds to the UI node entity with this component.
+    ///
+    /// Users can only instantiate null nodes using `UiKey::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
     #[reflect(ignore)]
     pub(crate) taffy_node: taffy::node::Node,
 }
@@ -37,12 +37,6 @@ impl UiKey {
     }
 }
 
-impl Clone for UiKey {
-    fn clone(&self) -> Self {
-        Self::default()
-    }
-}
-
 /// Describes the size of a UI node
 ///
 /// All UI nodes must have this component.

From 601ccd97599951ce0dbd55ced608fda40e38e268 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 29 May 2023 13:39:05 +0100
Subject: [PATCH 44/60] Doc comments edit.

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

diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index ca7119efa90bb..eda3d3f45cc0f 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -16,7 +16,7 @@ use thiserror::Error;
 
 /// Used internally to identify a UI node's corresponding entry in the UI's layout tree.
 ///
-/// UI nodes must have this component
+/// All UI nodes must have this component.
 #[derive(Component, Debug, Default, Reflect)]
 #[reflect(Component, Default)]
 pub struct UiKey {

From 67c92b9e8398cc0478aa1c32c963dd2657a24b81 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 29 May 2023 13:57:24 +0100
Subject: [PATCH 45/60] removed unnecessary changes

---
 crates/bevy_ui/src/layout/mod.rs   |  2 +-
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/render/mod.rs   |  3 +--
 crates/bevy_ui/src/ui_node.rs      |  2 --
 crates/bevy_ui/src/widget/image.rs |  6 +++---
 examples/input/text_input.rs       | 10 +++++-----
 6 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 5b739e31c28e6..5b627637ba149 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -293,7 +293,7 @@ pub fn ui_layout_system(
             ui_surface
                 .taffy
                 .set_measure(ui_key.taffy_node, Some(measure_func))
-                .ok();
+                .unwrap();
         }
     }
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 344a6de84efaf..e813539ddc1c7 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -55,7 +55,7 @@ pub struct UiPlugin;
 /// The label enum labeling the types of systems in the Bevy UI
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum UiSystem {
-    /// After this label, the UI layout state has been updated
+    /// After this label, the ui layout state has been updated
     Layout,
     /// After this label, input interactions with UI entities have been updated for this frame
     Focus,
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 321ea04eae3ce..f203c4b227565 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -8,8 +8,7 @@ use bevy_window::{PrimaryWindow, Window};
 pub use pipeline::*;
 pub use render_pass::*;
 
-use crate::Node;
-use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, UiImage, UiStack};
+use crate::{prelude::UiCameraConfig, BackgroundColor, CalculatedClip, Node, UiImage, UiStack};
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index eda3d3f45cc0f..2e8bcd7ce3ac9 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -38,8 +38,6 @@ impl UiKey {
 }
 
 /// Describes the size of a UI node
-///
-/// All UI nodes must have this component.
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[reflect(Component, Default)]
 pub struct Node {
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index ed35ba411e1e1..2453c9dd438a5 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, ContentSize, Measure, UiImage, UiKey};
+use crate::{measurement::AvailableSpace, ContentSize, Measure, Node, UiImage};
 use bevy_asset::Assets;
 #[cfg(feature = "bevy_text")]
 use bevy_ecs::query::Without;
@@ -68,11 +68,11 @@ pub fn update_image_content_size_system(
     textures: Res<Assets<Image>>,
     #[cfg(feature = "bevy_text")] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        (With<UiKey>, Without<Text>),
+        (With<Node>, Without<Text>),
     >,
     #[cfg(not(feature = "bevy_text"))] mut query: Query<
         (&mut ContentSize, &UiImage, &mut UiImageSize),
-        With<UiKey>,
+        With<Node>,
     >,
 ) {
     for (mut content_size, image, mut image_size) in &mut query {
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index 2c50149c9966c..8140325094df2 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -103,7 +103,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 fn toggle_ime(
     input: Res<Input<MouseButton>>,
     mut windows: Query<&mut Window>,
-    mut text: Query<&mut Text, With<UiKey>>,
+    mut text: Query<&mut Text, With<Node>>,
 ) {
     if input.just_pressed(MouseButton::Left) {
         let mut window = windows.single_mut();
@@ -139,8 +139,8 @@ fn bubbling_text(
 
 fn listen_ime_events(
     mut events: EventReader<Ime>,
-    mut status_text: Query<&mut Text, With<UiKey>>,
-    mut edit_text: Query<&mut Text, (Without<UiKey>, Without<Bubble>)>,
+    mut status_text: Query<&mut Text, With<Node>>,
+    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event {
@@ -166,7 +166,7 @@ fn listen_ime_events(
 
 fn listen_received_character_events(
     mut events: EventReader<ReceivedCharacter>,
-    mut edit_text: Query<&mut Text, (Without<UiKey>, Without<Bubble>)>,
+    mut edit_text: Query<&mut Text, (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         edit_text.single_mut().sections[0].value.push(event.char);
@@ -176,7 +176,7 @@ fn listen_received_character_events(
 fn listen_keyboard_input_events(
     mut commands: Commands,
     mut events: EventReader<KeyboardInput>,
-    mut edit_text: Query<(Entity, &mut Text), (Without<UiKey>, Without<Bubble>)>,
+    mut edit_text: Query<(Entity, &mut Text), (Without<Node>, Without<Bubble>)>,
 ) {
     for event in events.iter() {
         match event.key_code {

From 487d78fc16710eb2413b1a2bc8403cebdb49cdf3 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 29 May 2023 14:02:56 +0100
Subject: [PATCH 46/60] removed `is_null` method, cargo fmt --all

---
 crates/bevy_ui/src/layout/mod.rs |  2 +-
 crates/bevy_ui/src/ui_node.rs    | 10 ----------
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 5b627637ba149..be758faa5d758 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -198,7 +198,7 @@ pub fn ui_layout_system(
     let mut ui_keys_query = ui_queries_param_set.p0();
     for (entity, mut ui_key) in ui_keys_query.iter_mut() {
         // Users can only instantiate `UiKey` components containing a null key
-        if ui_key.is_null() {
+        if ui_key.is_changed() {
             ui_key.taffy_node = ui_surface
                 .taffy
                 .new_leaf(taffy::style::Style::default())
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 2e8bcd7ce3ac9..3f9835f99a1f2 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -27,16 +27,6 @@ pub struct UiKey {
     pub(crate) taffy_node: taffy::node::Node,
 }
 
-impl UiKey {
-    // Returns true if this taffy key is null.
-    // A UI node entity with a null `taffy_node` value has not been added to the layout tree.
-    #[inline]
-    pub(crate) fn is_null(&self) -> bool {
-        // The default value for `taffy::node::Node` is null
-        self.taffy_node == taffy::node::Node::default()
-    }
-}
-
 /// Describes the size of a UI node
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[reflect(Component, Default)]

From ff8e1176dc39eabb808a48a42979b7c9e9ef63a9 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 30 May 2023 09:49:58 +0100
Subject: [PATCH 47/60] Renamed `UiKey` to `UiNodeId`, added type alias
 `NodeId` for `taffy::node::Node`

---
 crates/bevy_ui/src/layout/mod.rs   | 61 +++++++++++++++++-------------
 crates/bevy_ui/src/lib.rs          |  2 +-
 crates/bevy_ui/src/node_bundles.rs | 24 ++++++------
 crates/bevy_ui/src/ui_node.rs      | 13 +++----
 4 files changed, 53 insertions(+), 47 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index be758faa5d758..1e61259ccca3c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,7 +1,7 @@
 mod convert;
 pub mod debug;
 
-use crate::{ContentSize, Node, Style, UiKey, UiScale};
+use crate::{ContentSize, Node, Style, UiNodeId, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -20,6 +20,8 @@ use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChan
 use std::fmt;
 use taffy::{prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
+pub(crate) type NodeId = NodeId;
+
 pub struct LayoutContext {
     pub scale_factor: f64,
     pub physical_size: Vec2,
@@ -41,14 +43,14 @@ impl LayoutContext {
 
 #[derive(Resource)]
 pub struct UiSurface {
-    entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    window_nodes: HashMap<Entity, taffy::node::Node>,
+    entity_to_taffy: HashMap<Entity, NodeId>,
+    window_nodes: HashMap<Entity, NodeId>,
     taffy: Taffy,
 }
 
 fn _assert_send_sync_ui_surface_impl_safe() {
     fn _assert_send_sync<T: Send + Sync>() {}
-    _assert_send_sync::<HashMap<Entity, taffy::node::Node>>();
+    _assert_send_sync::<HashMap<Entity, NodeId>>();
     _assert_send_sync::<Taffy>();
     _assert_send_sync::<UiSurface>();
 }
@@ -73,8 +75,21 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
+    pub fn insert_node(&mut self, entity: Entity) -> UiNodeId {
+        let taffy_node = self
+                .taffy
+                .new_leaf(taffy::style::Style::default())
+                .unwrap();
+        if let Some(old_taffy_node) = self.entity_to_taffy.insert(entity, taffy_node) {
+            self.taffy.remove(old_taffy_node).unwrap();
+        }
+        UiNodeId(taffy_node)
+    }
+
+    pub fn set_style(&mut self, NodeId: Taffy
+
     /// Update the children of the taffy node corresponding to the given [`Entity`].
-    pub fn update_children(&mut self, taffy_node: taffy::node::Node, children: &Children) {
+    pub fn update_children(&mut self, taffy_node: NodeId, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
@@ -136,10 +151,10 @@ without UI components as a child of an entity with UI components, results may be
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
-        children: impl Iterator<Item = taffy::node::Node>,
+        children: impl Iterator<Item = NodeId>,
     ) {
         let taffy_node = self.window_nodes.get(&parent_window).unwrap();
-        let child_nodes = children.collect::<Vec<taffy::node::Node>>();
+        let child_nodes = children.collect::<Vec<NodeId>>();
         self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
     }
 
@@ -178,36 +193,28 @@ pub fn ui_layout_system(
     mut window_resized_events: EventReader<bevy_window::WindowResized>,
     mut window_created_events: EventReader<bevy_window::WindowCreated>,
     mut ui_surface: ResMut<UiSurface>,
-    mut removed_nodes: RemovedComponents<UiKey>,
+    mut removed_nodes: RemovedComponents<UiNodeId>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
     mut ui_queries_param_set: ParamSet<(
-        Query<(Entity, &mut UiKey)>,
+        Query<(Entity, &mut UiNodeId)>,
         (
-            Query<(&UiKey, &mut Node, &mut Transform)>,
-            Query<(&UiKey, Ref<Children>)>,
-            Query<(&UiKey, &mut ContentSize)>,
-            Query<(&UiKey, Ref<Style>)>,
-            Query<&UiKey, Without<Parent>>,
+            Query<(&UiNodeId, &mut Node, &mut Transform)>,
+            Query<(&UiNodeId, Ref<Children>)>,
+            Query<(&UiNodeId, &mut ContentSize)>,
+            Query<(&UiNodeId, Ref<Style>)>,
+            Query<&UiNodeId, Without<Parent>>,
         ),
     )>,
 ) {
     // clean up removed nodes first
     ui_surface.remove_entities(removed_nodes.iter());
 
-    let mut ui_keys_query = ui_queries_param_set.p0();
-    for (entity, mut ui_key) in ui_keys_query.iter_mut() {
+    let mut ids_query = ui_queries_param_set.p0();
+    for (entity, mut ui_key) in ids_query.iter_mut() {
         // Users can only instantiate `UiKey` components containing a null key
         if ui_key.is_changed() {
-            ui_key.taffy_node = ui_surface
-                .taffy
-                .new_leaf(taffy::style::Style::default())
-                .unwrap();
-            if let Some(old_taffy_node) =
-                ui_surface.entity_to_taffy.insert(entity, ui_key.taffy_node)
-            {
-                ui_surface.taffy.remove(old_taffy_node).unwrap();
-            }
+            *ui_key = ui_surface.insert_node(entity);
         }
     }
 
@@ -225,9 +232,9 @@ pub fn ui_layout_system(
         ui_queries_param_set.p1();
 
     // update children
-    for (ui_key, children) in &children_query {
+    for (id, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(ui_key.taffy_node, &children);
+            ui_surface.update_children(id.taffy_node, &children);
         }
     }
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index e813539ddc1c7..b39e221bb6e6a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -102,7 +102,7 @@ impl Plugin for UiPlugin {
             .register_type::<JustifyContent>()
             .register_type::<JustifyItems>()
             .register_type::<JustifySelf>()
-            .register_type::<UiKey>()
+            .register_type::<UiNodeId>()
             .register_type::<Node>()
             .register_type::<ZIndex>()
             // NOTE: used by Style::aspect_ratio
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index 6b36a8602b782..bca9efa961f59 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, TextFlags, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, UiKey, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, UiNodeId, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -19,9 +19,9 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 #[derive(Bundle, Debug)]
 pub struct NodeBundle {
     /// Used internally. All UI nodes must have this component.
-    pub node: UiKey,
+    pub id: UiNodeId,
     /// Describes the logical size of the node
-    pub node_size: Node,
+    pub node: Node,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -52,8 +52,8 @@ impl Default for NodeBundle {
         NodeBundle {
             // Transparent background
             background_color: Color::NONE.into(),
+            id: Default::default(),
             node: Default::default(),
-            node_size: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -69,7 +69,7 @@ impl Default for NodeBundle {
 #[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Used internally. All UI nodes must have this component.
-    pub ui_key: UiKey,
+    pub id: UiNodeId,
     /// Describes the logical size of the node
     ///
     /// This field is automatically managed by the UI layout system.
@@ -115,9 +115,9 @@ pub struct ImageBundle {
 #[derive(Bundle, Debug)]
 pub struct TextBundle {
     /// Used internally. All UI nodes must have this component.
-    pub taffy: UiKey,
+    pub id: UiNodeId,
     /// Describes the logical size of the node
-    pub node_size: Node,
+    pub node: Node,
     /// Styles which control the layout (size and position) of the node and it's children
     /// In some cases these styles also affect how the node drawn/painted.
     pub style: Style,
@@ -161,8 +161,8 @@ impl Default for TextBundle {
             calculated_size: Default::default(),
             // Transparent background
             background_color: BackgroundColor(Color::NONE),
-            taffy: Default::default(),
-            node_size: Default::default(),
+            id: Default::default(),
+            node: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
             transform: Default::default(),
@@ -219,9 +219,9 @@ impl TextBundle {
 #[derive(Bundle, Debug)]
 pub struct ButtonBundle {
     /// Used internally. All UI nodes must have this component.
-    pub node: UiKey,
+    pub id: UiNodeId,
     /// Describes the logical size of the node
-    pub node_size: Node,
+    pub node: Node,
     /// Marker component that signals this node is a button
     pub button: Button,
     /// Styles which control the layout (size and position) of the node and it's children
@@ -259,8 +259,8 @@ impl Default for ButtonBundle {
     fn default() -> Self {
         Self {
             focus_policy: FocusPolicy::Block,
+            id: Default::default(),
             node: Default::default(),
-            node_size: Default::default(),
             button: Default::default(),
             style: Default::default(),
             interaction: Default::default(),
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 3f9835f99a1f2..9275ca1daf753 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -14,17 +14,16 @@ use smallvec::SmallVec;
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 use thiserror::Error;
 
-/// Used internally to identify a UI node's corresponding entry in the UI's layout tree.
+/// Identifier for the UI node's associated entry in the UI's layout tree.
 ///
+/// Users can only instantiate null nodes using `UiNodeId::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
 /// All UI nodes must have this component.
-#[derive(Component, Debug, Default, Reflect)]
+#[derive(Component, Debug, Default, Deref, Reflect)]
 #[reflect(Component, Default)]
-pub struct UiKey {
-    /// Indentifier for the Taffy node in the Taffy layout tree stored in [`super::layout::UiSurface`] that corresponds to the UI node entity with this component.
-    ///
-    /// Users can only instantiate null nodes using `UiKey::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
+pub struct UiNodeId {
+    
     #[reflect(ignore)]
-    pub(crate) taffy_node: taffy::node::Node,
+    pub(crate) id: NodeId,
 }
 
 /// Describes the size of a UI node

From aa4f9329038732ea46afa55ddda11ced2f8e2ec4 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 30 May 2023 23:55:26 +0100
Subject: [PATCH 48/60] added `UiSurface` methods for insertion, and setting
 style and measure funcs

---
 crates/bevy_ui/src/layout/mod.rs | 90 ++++++++++++++------------------
 crates/bevy_ui/src/ui_node.rs    |  7 +--
 2 files changed, 42 insertions(+), 55 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 1e61259ccca3c..98fc812f8957c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -18,9 +18,7 @@ use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
-use taffy::{prelude::Size, style_helpers::TaffyMaxContent, Taffy};
-
-pub(crate) type NodeId = NodeId;
+use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
 pub struct LayoutContext {
     pub scale_factor: f64,
@@ -43,14 +41,14 @@ impl LayoutContext {
 
 #[derive(Resource)]
 pub struct UiSurface {
-    entity_to_taffy: HashMap<Entity, NodeId>,
-    window_nodes: HashMap<Entity, NodeId>,
+    entity_to_taffy: HashMap<Entity, taffy::node::Node>,
+    window_nodes: HashMap<Entity, taffy::node::Node>,
     taffy: Taffy,
 }
 
 fn _assert_send_sync_ui_surface_impl_safe() {
     fn _assert_send_sync<T: Send + Sync>() {}
-    _assert_send_sync::<HashMap<Entity, NodeId>>();
+    _assert_send_sync::<HashMap<Entity, taffy::node::Node>>();
     _assert_send_sync::<Taffy>();
     _assert_send_sync::<UiSurface>();
 }
@@ -75,21 +73,31 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
-    pub fn insert_node(&mut self, entity: Entity) -> UiNodeId {
-        let taffy_node = self
-                .taffy
-                .new_leaf(taffy::style::Style::default())
-                .unwrap();
-        if let Some(old_taffy_node) = self.entity_to_taffy.insert(entity, taffy_node) {
+    pub fn insert_node(&mut self, entity: Entity) -> taffy::node::Node {
+        let id = self.taffy.new_leaf(taffy::style::Style::default()).unwrap();
+        if let Some(old_taffy_node) = self.entity_to_taffy.insert(entity, id) {
             self.taffy.remove(old_taffy_node).unwrap();
         }
-        UiNodeId(taffy_node)
+        id
     }
 
-    pub fn set_style(&mut self, NodeId: Taffy
+    pub fn set_style(
+        &mut self,
+        id: taffy::node::Node,
+        style: &Style,
+        layout_context: &LayoutContext,
+    ) {
+        self.taffy
+            .set_style(id, convert::from_style(layout_context, style))
+            .unwrap();
+    }
+
+    pub fn set_measure(&mut self, id: taffy::node::Node, measure: MeasureFunc) {
+        self.taffy.set_measure(id, Some(measure)).unwrap();
+    }
 
     /// Update the children of the taffy node corresponding to the given [`Entity`].
-    pub fn update_children(&mut self, taffy_node: NodeId, children: &Children) {
+    pub fn update_children(&mut self, id: taffy::node::Node, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
             if let Some(taffy_node) = self.entity_to_taffy.get(child) {
@@ -102,9 +110,7 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        self.taffy
-            .set_children(taffy_node, &taffy_children)
-            .unwrap();
+        self.taffy.set_children(id, &taffy_children).unwrap();
     }
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
@@ -124,14 +130,14 @@ without UI components as a child of an entity with UI components, results may be
     /// Retrieve or insert the root layout node and update its size to match the size of the window.
     pub fn update_window(&mut self, window: Entity, window_resolution: &WindowResolution) {
         let taffy = &mut self.taffy;
-        let node = self
+        let id = self
             .window_nodes
             .entry(window)
             .or_insert_with(|| taffy.new_leaf(taffy::style::Style::default()).unwrap());
 
         taffy
             .set_style(
-                *node,
+                *id,
                 taffy::style::Style {
                     size: taffy::geometry::Size {
                         width: taffy::style::Dimension::Points(
@@ -151,10 +157,10 @@ without UI components as a child of an entity with UI components, results may be
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
-        children: impl Iterator<Item = NodeId>,
+        children: impl Iterator<Item = taffy::node::Node>,
     ) {
         let taffy_node = self.window_nodes.get(&parent_window).unwrap();
-        let child_nodes = children.collect::<Vec<NodeId>>();
+        let child_nodes = children.collect::<Vec<taffy::node::Node>>();
         self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
     }
 
@@ -211,10 +217,10 @@ pub fn ui_layout_system(
     ui_surface.remove_entities(removed_nodes.iter());
 
     let mut ids_query = ui_queries_param_set.p0();
-    for (entity, mut ui_key) in ids_query.iter_mut() {
+    for (entity, mut ui_node_id) in ids_query.iter_mut() {
         // Users can only instantiate `UiKey` components containing a null key
-        if ui_key.is_changed() {
-            *ui_key = ui_surface.insert_node(entity);
+        if ui_node_id.is_changed() {
+            ui_node_id.0 = ui_surface.insert_node(entity);
         }
     }
 
@@ -232,9 +238,9 @@ pub fn ui_layout_system(
         ui_queries_param_set.p1();
 
     // update children
-    for (id, children) in &children_query {
+    for (ui_node_id, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(id.taffy_node, &children);
+            ui_surface.update_children(**ui_node_id, &children);
         }
     }
 
@@ -273,41 +279,26 @@ pub fn ui_layout_system(
         scale_factor_events.clear();
         // update all nodes
         for (ui_key, style) in style_query.iter() {
-            ui_surface
-                .taffy
-                .set_style(
-                    ui_key.taffy_node,
-                    convert::from_style(&layout_context, &style),
-                )
-                .unwrap();
+            ui_surface.set_style(ui_key.0, &style, &layout_context);
         }
     } else {
         for (ui_key, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface
-                    .taffy
-                    .set_style(
-                        ui_key.taffy_node,
-                        convert::from_style(&layout_context, &style),
-                    )
-                    .unwrap();
+                ui_surface.set_style(ui_key.0, &style, &layout_context);
             }
         }
     }
 
-    for (ui_key, mut content_size) in measure_query.iter_mut() {
+    for (ui_node_id, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface
-                .taffy
-                .set_measure(ui_key.taffy_node, Some(measure_func))
-                .unwrap();
+            ui_surface.set_measure(ui_node_id.0, measure_func);
         }
     }
 
     // update window children (for now assuming all Nodes live in the primary window)
     ui_surface.set_window_children(
         primary_window_entity,
-        root_node_query.iter().map(|node| node.taffy_node),
+        root_node_query.iter().map(|node| **node),
     );
 
     // compute layouts
@@ -321,7 +312,7 @@ pub fn ui_layout_system(
 
     // PERF: try doing this incrementally
     for (ui_key, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(ui_key.taffy_node).unwrap();
+        let layout = ui_surface.taffy.layout(**ui_key).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -334,8 +325,7 @@ pub fn ui_layout_system(
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
-        let taffy_parent =
-            taffy::tree::LayoutTree::parent(&ui_surface.taffy, ui_key.taffy_node).unwrap();
+        let taffy_parent = taffy::tree::LayoutTree::parent(&ui_surface.taffy, **ui_key).unwrap();
         if taffy_parent != *taffy_window {
             if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 9275ca1daf753..e93a70fade878 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,5 +1,6 @@
 use crate::UiRect;
 use bevy_asset::Handle;
+use bevy_derive::Deref;
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
 use bevy_reflect::prelude::*;
@@ -20,11 +21,7 @@ use thiserror::Error;
 /// All UI nodes must have this component.
 #[derive(Component, Debug, Default, Deref, Reflect)]
 #[reflect(Component, Default)]
-pub struct UiNodeId {
-    
-    #[reflect(ignore)]
-    pub(crate) id: NodeId,
-}
+pub struct UiNodeId(#[reflect(ignore)] pub(crate) taffy::node::Node);
 
 /// Describes the size of a UI node
 #[derive(Component, Debug, Copy, Clone, Reflect)]

From 7d5c8ad865abfa3d7ccb6f739674d8724b4f518b Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 14:41:06 +0100
Subject: [PATCH 49/60] cargo fmt --all

---
 crates/bevy_ui/src/layout/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ce90aeb3eb240..c515caa52c150 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -275,7 +275,8 @@ pub fn ui_layout_system(
         ui_surface.update_window(entity, &window.resolution);
     }
 
-    let layout_context = LayoutContext::new(logical_to_physical_factor * ui_scale.scale, physical_size);
+    let layout_context =
+        LayoutContext::new(logical_to_physical_factor * ui_scale.scale, physical_size);
 
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();

From 79ddbcd36e3b4e0cec802b99c8cefe0cc6c65c46 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 15:20:48 +0100
Subject: [PATCH 50/60] Changed `UiNodeId` from a tuple struct to a stuct with
 a `taffy_id` field and `get` method.

Edited the doc comment for `insert_node`.
---
 crates/bevy_ui/src/layout/mod.rs | 36 ++++++++++++++++----------------
 crates/bevy_ui/src/ui_node.rs    | 14 ++++++++++---
 2 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index c515caa52c150..ff3bbff1c340c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -73,7 +73,7 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
-    /// Inserts a node into the Taffy layout and associates it with the given entity.
+    /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
     pub fn insert_node(&mut self, entity: Entity) -> taffy::node::Node {
         let id = self.taffy.new_leaf(taffy::style::Style::default()).unwrap();
         if let Some(old_taffy_node) = self.entity_to_taffy.insert(entity, id) {
@@ -220,10 +220,10 @@ pub fn ui_layout_system(
     ui_surface.remove_entities(removed_nodes.iter());
 
     let mut ids_query = ui_queries_param_set.p0();
-    for (entity, mut ui_node_id) in ids_query.iter_mut() {
+    for (entity, mut uinode_id) in ids_query.iter_mut() {
         // Users can only instantiate `UiKey` components containing a null key
-        if ui_node_id.is_changed() {
-            ui_node_id.0 = ui_surface.insert_node(entity);
+        if uinode_id.is_changed() {
+            uinode_id.taffy_id = ui_surface.insert_node(entity);
         }
     }
 
@@ -241,9 +241,9 @@ pub fn ui_layout_system(
         ui_queries_param_set.p1();
 
     // update children
-    for (ui_node_id, children) in &children_query {
+    for (uinode_id, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(**ui_node_id, &children);
+            ui_surface.update_children(uinode_id.get(), &children);
         }
     }
 
@@ -281,27 +281,27 @@ pub fn ui_layout_system(
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();
         // update all nodes
-        for (ui_key, style) in style_query.iter() {
-            ui_surface.set_style(ui_key.0, &style, &layout_context);
+        for (uinode_id, style) in style_query.iter() {
+            ui_surface.set_style(uinode_id.get(), &style, &layout_context);
         }
     } else {
-        for (ui_key, style) in style_query.iter() {
+        for (uinode_id, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface.set_style(ui_key.0, &style, &layout_context);
+                ui_surface.set_style(uinode_id.get(), &style, &layout_context);
             }
         }
     }
 
-    for (ui_node_id, mut content_size) in measure_query.iter_mut() {
+    for (uinode_id, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.set_measure(ui_node_id.0, measure_func);
+            ui_surface.set_measure(uinode_id.get(), measure_func);
         }
     }
 
     // update window children (for now assuming all Nodes live in the primary window)
     ui_surface.set_window_children(
         primary_window_entity,
-        root_node_query.iter().map(|node| **node),
+        root_node_query.iter().map(|uinode_id| uinode_id.get()),
     );
 
     // compute layouts
@@ -311,11 +311,11 @@ pub fn ui_layout_system(
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
-    let taffy_window = ui_surface.window_nodes.get(&primary_window_entity).unwrap();
+    let layout_root_id = *ui_surface.window_nodes.get(&primary_window_entity).unwrap();
 
     // PERF: try doing this incrementally
-    for (ui_key, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(**ui_key).unwrap();
+    for (uinode_id, mut node_size, mut transform) in &mut node_transform_query {
+        let layout = ui_surface.taffy.layout(uinode_id.get()).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -328,8 +328,8 @@ pub fn ui_layout_system(
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
-        let taffy_parent = taffy::tree::LayoutTree::parent(&ui_surface.taffy, **ui_key).unwrap();
-        if taffy_parent != *taffy_window {
+        let taffy_parent = taffy::tree::LayoutTree::parent(&ui_surface.taffy, uinode_id.get()).unwrap();
+        if taffy_parent != layout_root_id {
             if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
                 new_position.y -= to_logical(parent_layout.size.height / 2.0);
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index e93a70fade878..1f3ac685180e8 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,6 +1,5 @@
 use crate::UiRect;
 use bevy_asset::Handle;
-use bevy_derive::Deref;
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
 use bevy_reflect::prelude::*;
@@ -19,9 +18,18 @@ use thiserror::Error;
 ///
 /// Users can only instantiate null nodes using `UiNodeId::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
 /// All UI nodes must have this component.
-#[derive(Component, Debug, Default, Deref, Reflect)]
+#[derive(Component, Debug, Default, Reflect)]
 #[reflect(Component, Default)]
-pub struct UiNodeId(#[reflect(ignore)] pub(crate) taffy::node::Node);
+pub struct UiNodeId {
+    #[reflect(ignore)]
+    pub (crate) taffy_id: taffy::node::Node,
+}
+
+impl UiNodeId {
+    pub fn get(&self) -> taffy::node::Node {
+        self.taffy_id
+    }
+}
 
 /// Describes the size of a UI node
 #[derive(Component, Debug, Copy, Clone, Reflect)]

From 97be1c4685cf46b34fbefdc414dfe26dae6699c8 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 19:31:28 +0100
Subject: [PATCH 51/60] Renamed `UiNodeId` to `UiKey`, and moved its struct
 declaration to the `layout` module.

Renamed some variables to be consistant with the name change.

`UiSurface::insert_node` reuses the previous taffy node associated to the given `entity`, if one exists.
---
 crates/bevy_ui/src/layout/mod.rs   | 137 +++++++++++++++++------------
 crates/bevy_ui/src/lib.rs          |   2 +-
 crates/bevy_ui/src/node_bundles.rs |  16 ++--
 crates/bevy_ui/src/ui_node.rs      |  17 ----
 4 files changed, 90 insertions(+), 82 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index ff3bbff1c340c..05a72ac3eca9e 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,7 +1,7 @@
 mod convert;
 pub mod debug;
 
-use crate::{ContentSize, Node, Style, UiNodeId, UiScale};
+use crate::{ContentSize, Node, Style, UiScale};
 use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
@@ -9,17 +9,42 @@ use bevy_ecs::{
     query::{With, Without},
     removal_detection::RemovedComponents,
     system::{ParamSet, Query, Res, ResMut, Resource},
-    world::Ref,
+    world::Ref, prelude::Component, reflect::ReflectComponent,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::Vec2;
+use bevy_reflect::{Reflect, std_traits::ReflectDefault};
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
+/// Identifier for the UI node's associated entry in the UI's layout tree.
+///
+/// Users can only instantiate null nodes using `UiKey::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
+/// All UI nodes must have this component.
+#[derive(Component, Debug, Default, Reflect)]
+#[reflect(Component, Default)]
+pub struct UiKey {
+    // The id of the taffy node associated with the entity possessing this component.
+    #[reflect(ignore)]
+    taffy_key: taffy::node::Node,
+}
+
+impl UiKey {
+    // Returns the id of the taffy node associated with the entity that has this component.
+    pub fn get(&self) -> taffy::node::Node {
+        self.taffy_key
+    }
+
+    // A null `UiKey` signifies that a UI node entity does not have an associated Taffy node in the UI layout tree.
+    pub fn is_null(&self) -> bool {
+        self.taffy_key == Default::default()
+    }
+}
+
 pub struct LayoutContext {
     pub scale_factor: f64,
     pub physical_size: Vec2,
@@ -75,36 +100,35 @@ impl Default for UiSurface {
 impl UiSurface {
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
     pub fn insert_node(&mut self, entity: Entity) -> taffy::node::Node {
-        let id = self.taffy.new_leaf(taffy::style::Style::default()).unwrap();
-        if let Some(old_taffy_node) = self.entity_to_taffy.insert(entity, id) {
-            self.taffy.remove(old_taffy_node).unwrap();
-        }
-        id
+        // It's possible for a user to overwrite an active `UiKey` component with `UiKey::default()`.
+        // In which case we reuse the existing node.
+        *self.entity_to_taffy.entry(entity)
+            .or_insert_with(|| self.taffy.new_leaf(taffy::style::Style::default()).unwrap())
     }
 
-    /// Converts the given Bevy UI `Style` to a taffy style and applies it to the taffy node with identifier `id`.
+    /// Converts the given Bevy UI `Style` to a taffy style and applies it to the taffy node with identifier `key`.
     pub fn set_style(
         &mut self,
-        id: taffy::node::Node,
+        key: taffy::node::Node,
         style: &Style,
         layout_context: &LayoutContext,
     ) {
         self.taffy
-            .set_style(id, convert::from_style(layout_context, style))
+            .set_style(key, convert::from_style(layout_context, style))
             .unwrap();
     }
 
-    /// Sets the `MeasureFunc` for taffy node `id` to `measure`.
-    pub fn set_measure(&mut self, id: taffy::node::Node, measure: MeasureFunc) {
-        self.taffy.set_measure(id, Some(measure)).unwrap();
+    /// Sets the `MeasureFunc` for the taffy node `key` to `measure`.
+    pub fn set_measure(&mut self, key: taffy::node::Node, measure: MeasureFunc) {
+        self.taffy.set_measure(key, Some(measure)).unwrap();
     }
 
-    /// Update the children of the taffy node corresponding to the given [`Entity`].
-    pub fn update_children(&mut self, id: taffy::node::Node, children: &Children) {
+    /// Update the children of the taffy node `parent_key` .
+    pub fn update_children(&mut self, parent_key: taffy::node::Node, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
         for child in children {
-            if let Some(taffy_node) = self.entity_to_taffy.get(child) {
-                taffy_children.push(*taffy_node);
+            if let Some(child_key) = self.entity_to_taffy.get(child) {
+                taffy_children.push(*child_key);
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -113,34 +137,34 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        self.taffy.set_children(id, &taffy_children).unwrap();
+        self.taffy.set_children(parent_key, &taffy_children).unwrap();
     }
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_children(&mut self, entity: Entity) {
-        if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_children(*taffy_node, &[]).unwrap();
+        if let Some(key) = self.entity_to_taffy.get(&entity) {
+            self.taffy.set_children(*key, &[]).unwrap();
         }
     }
 
     /// Removes the measure from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_measure(&mut self, entity: Entity) {
-        if let Some(taffy_node) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_measure(*taffy_node, None).unwrap();
+        if let Some(key) = self.entity_to_taffy.get(&entity) {
+            self.taffy.set_measure(*key, None).unwrap();
         }
     }
 
     /// Retrieve or insert the root layout node and update its size to match the size of the window.
     pub fn update_window(&mut self, window: Entity, window_resolution: &WindowResolution) {
         let taffy = &mut self.taffy;
-        let id = self
+        let key = self
             .window_nodes
             .entry(window)
             .or_insert_with(|| taffy.new_leaf(taffy::style::Style::default()).unwrap());
 
         taffy
             .set_style(
-                *id,
+                *key,
                 taffy::style::Style {
                     size: taffy::geometry::Size {
                         width: taffy::style::Dimension::Points(
@@ -162,16 +186,16 @@ without UI components as a child of an entity with UI components, results may be
         parent_window: Entity,
         children: impl Iterator<Item = taffy::node::Node>,
     ) {
-        let taffy_node = self.window_nodes.get(&parent_window).unwrap();
-        let child_nodes = children.collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(*taffy_node, &child_nodes).unwrap();
+        let key = self.window_nodes.get(&parent_window).unwrap();
+        let child_keys = children.collect::<Vec<taffy::node::Node>>();
+        self.taffy.set_children(*key, &child_keys).unwrap();
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.
     pub fn compute_window_layouts(&mut self) {
-        for window_node in self.window_nodes.values() {
+        for window_key in self.window_nodes.values() {
             self.taffy
-                .compute_layout(*window_node, Size::MAX_CONTENT)
+                .compute_layout(*window_key, Size::MAX_CONTENT)
                 .unwrap();
         }
     }
@@ -179,8 +203,8 @@ without UI components as a child of an entity with UI components, results may be
     /// Removes each entity from the internal map and then removes their associated node from taffy
     pub fn remove_entities(&mut self, entities: impl IntoIterator<Item = Entity>) {
         for entity in entities {
-            if let Some(node) = self.entity_to_taffy.remove(&entity) {
-                self.taffy.remove(node).unwrap();
+            if let Some(key) = self.entity_to_taffy.remove(&entity) {
+                self.taffy.remove(key).unwrap();
             }
         }
     }
@@ -202,17 +226,17 @@ pub fn ui_layout_system(
     mut window_resized_events: EventReader<bevy_window::WindowResized>,
     mut window_created_events: EventReader<bevy_window::WindowCreated>,
     mut ui_surface: ResMut<UiSurface>,
-    mut removed_nodes: RemovedComponents<UiNodeId>,
+    mut removed_nodes: RemovedComponents<UiKey>,
     mut removed_children: RemovedComponents<Children>,
     mut removed_content_sizes: RemovedComponents<ContentSize>,
     mut ui_queries_param_set: ParamSet<(
-        Query<(Entity, &mut UiNodeId)>,
+        Query<(Entity, &mut UiKey)>,
         (
-            Query<(&UiNodeId, &mut Node, &mut Transform)>,
-            Query<(&UiNodeId, Ref<Children>)>,
-            Query<(&UiNodeId, &mut ContentSize)>,
-            Query<(&UiNodeId, Ref<Style>)>,
-            Query<&UiNodeId, Without<Parent>>,
+            Query<(&UiKey, &mut Node, &mut Transform)>,
+            Query<(&UiKey, Ref<Children>)>,
+            Query<(&UiKey, &mut ContentSize)>,
+            Query<(&UiKey, Ref<Style>)>,
+            Query<&UiKey, Without<Parent>>,
         ),
     )>,
 ) {
@@ -220,10 +244,10 @@ pub fn ui_layout_system(
     ui_surface.remove_entities(removed_nodes.iter());
 
     let mut ids_query = ui_queries_param_set.p0();
-    for (entity, mut uinode_id) in ids_query.iter_mut() {
-        // Users can only instantiate `UiKey` components containing a null key
-        if uinode_id.is_changed() {
-            uinode_id.taffy_id = ui_surface.insert_node(entity);
+    for (entity, mut uikey) in ids_query.iter_mut() {
+        // Users can only instantiate `UiKey` components containing a null key with `UiKey::default()`
+        if uikey.is_null() {
+            uikey.taffy_key = ui_surface.insert_node(entity);
         }
     }
 
@@ -241,9 +265,9 @@ pub fn ui_layout_system(
         ui_queries_param_set.p1();
 
     // update children
-    for (uinode_id, children) in &children_query {
+    for (uikey, children) in &children_query {
         if children.is_changed() {
-            ui_surface.update_children(uinode_id.get(), &children);
+            ui_surface.update_children(uikey.get(), &children);
         }
     }
 
@@ -281,27 +305,28 @@ pub fn ui_layout_system(
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();
         // update all nodes
-        for (uinode_id, style) in style_query.iter() {
-            ui_surface.set_style(uinode_id.get(), &style, &layout_context);
+        for (uikey, style) in style_query.iter() {
+            ui_surface.set_style(uikey.get(), &style, &layout_context);
         }
     } else {
-        for (uinode_id, style) in style_query.iter() {
+        for (uikey, style) in style_query.iter() {
             if style.is_changed() {
-                ui_surface.set_style(uinode_id.get(), &style, &layout_context);
+                ui_surface.set_style(uikey.get(), &style, &layout_context);
             }
         }
     }
 
-    for (uinode_id, mut content_size) in measure_query.iter_mut() {
+    // The `Taffy` tree takes ownership of any new `MeasureFunc`s
+    for (uikey, mut content_size) in measure_query.iter_mut() {
         if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.set_measure(uinode_id.get(), measure_func);
+            ui_surface.set_measure(uikey.get(), measure_func);
         }
     }
 
     // update window children (for now assuming all Nodes live in the primary window)
     ui_surface.set_window_children(
         primary_window_entity,
-        root_node_query.iter().map(|uinode_id| uinode_id.get()),
+        root_node_query.iter().map(|uikey| uikey.get()),
     );
 
     // compute layouts
@@ -311,11 +336,11 @@ pub fn ui_layout_system(
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
-    let layout_root_id = *ui_surface.window_nodes.get(&primary_window_entity).unwrap();
+    let layout_root_key = *ui_surface.window_nodes.get(&primary_window_entity).unwrap();
 
     // PERF: try doing this incrementally
-    for (uinode_id, mut node_size, mut transform) in &mut node_transform_query {
-        let layout = ui_surface.taffy.layout(uinode_id.get()).unwrap();
+    for (uikey, mut node_size, mut transform) in &mut node_transform_query {
+        let layout = ui_surface.taffy.layout(uikey.get()).unwrap();
         let new_size = Vec2::new(
             to_logical(layout.size.width),
             to_logical(layout.size.height),
@@ -328,8 +353,8 @@ pub fn ui_layout_system(
         new_position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         new_position.y = to_logical(layout.location.y + layout.size.height / 2.0);
 
-        let taffy_parent = taffy::tree::LayoutTree::parent(&ui_surface.taffy, uinode_id.get()).unwrap();
-        if taffy_parent != layout_root_id {
+        let taffy_parent = taffy::tree::LayoutTree::parent(&ui_surface.taffy, uikey.get()).unwrap();
+        if taffy_parent != layout_root_key {
             if let Ok(parent_layout) = ui_surface.taffy.layout(taffy_parent) {
                 new_position.x -= to_logical(parent_layout.size.width / 2.0);
                 new_position.y -= to_logical(parent_layout.size.height / 2.0);
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 4dcfa3e69ea2c..d11c55db592f2 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -103,7 +103,7 @@ impl Plugin for UiPlugin {
             .register_type::<JustifyContent>()
             .register_type::<JustifyItems>()
             .register_type::<JustifySelf>()
-            .register_type::<UiNodeId>()
+            .register_type::<UiKey>()
             .register_type::<Node>()
             // NOTE: used by Style::aspect_ratio
             .register_type::<Option<f32>>()
diff --git a/crates/bevy_ui/src/node_bundles.rs b/crates/bevy_ui/src/node_bundles.rs
index bca9efa961f59..333bc62e4559d 100644
--- a/crates/bevy_ui/src/node_bundles.rs
+++ b/crates/bevy_ui/src/node_bundles.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     widget::{Button, TextFlags, UiImageSize},
-    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, UiNodeId, ZIndex,
+    BackgroundColor, ContentSize, FocusPolicy, Interaction, Node, Style, UiImage, UiKey, ZIndex,
 };
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -19,7 +19,7 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 #[derive(Bundle, Debug)]
 pub struct NodeBundle {
     /// Used internally. All UI nodes must have this component.
-    pub id: UiNodeId,
+    pub key: UiKey,
     /// Describes the logical size of the node
     pub node: Node,
     /// Styles which control the layout (size and position) of the node and it's children
@@ -52,7 +52,7 @@ impl Default for NodeBundle {
         NodeBundle {
             // Transparent background
             background_color: Color::NONE.into(),
-            id: Default::default(),
+            key: Default::default(),
             node: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
@@ -69,7 +69,7 @@ impl Default for NodeBundle {
 #[derive(Bundle, Debug, Default)]
 pub struct ImageBundle {
     /// Used internally. All UI nodes must have this component.
-    pub id: UiNodeId,
+    pub key: UiKey,
     /// Describes the logical size of the node
     ///
     /// This field is automatically managed by the UI layout system.
@@ -115,7 +115,7 @@ pub struct ImageBundle {
 #[derive(Bundle, Debug)]
 pub struct TextBundle {
     /// Used internally. All UI nodes must have this component.
-    pub id: UiNodeId,
+    pub key: UiKey,
     /// Describes the logical size of the node
     pub node: Node,
     /// Styles which control the layout (size and position) of the node and it's children
@@ -161,7 +161,7 @@ impl Default for TextBundle {
             calculated_size: Default::default(),
             // Transparent background
             background_color: BackgroundColor(Color::NONE),
-            id: Default::default(),
+            key: Default::default(),
             node: Default::default(),
             style: Default::default(),
             focus_policy: Default::default(),
@@ -219,7 +219,7 @@ impl TextBundle {
 #[derive(Bundle, Debug)]
 pub struct ButtonBundle {
     /// Used internally. All UI nodes must have this component.
-    pub id: UiNodeId,
+    pub key: UiKey,
     /// Describes the logical size of the node
     pub node: Node,
     /// Marker component that signals this node is a button
@@ -259,7 +259,7 @@ impl Default for ButtonBundle {
     fn default() -> Self {
         Self {
             focus_policy: FocusPolicy::Block,
-            id: Default::default(),
+            key: Default::default(),
             node: Default::default(),
             button: Default::default(),
             style: Default::default(),
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 1f3ac685180e8..d4371660a74b9 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -14,23 +14,6 @@ use smallvec::SmallVec;
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 use thiserror::Error;
 
-/// Identifier for the UI node's associated entry in the UI's layout tree.
-///
-/// Users can only instantiate null nodes using `UiNodeId::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
-/// All UI nodes must have this component.
-#[derive(Component, Debug, Default, Reflect)]
-#[reflect(Component, Default)]
-pub struct UiNodeId {
-    #[reflect(ignore)]
-    pub (crate) taffy_id: taffy::node::Node,
-}
-
-impl UiNodeId {
-    pub fn get(&self) -> taffy::node::Node {
-        self.taffy_id
-    }
-}
-
 /// Describes the size of a UI node
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[reflect(Component, Default)]

From afc397a9b158dbf89f7d3c8bd82f7ca46cf59b92 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 20:57:39 +0100
Subject: [PATCH 52/60] cargo fmt --all

---
 crates/bevy_ui/src/layout/mod.rs | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 05a72ac3eca9e..f66047083aed7 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -6,15 +6,17 @@ use bevy_ecs::{
     change_detection::DetectChanges,
     entity::Entity,
     event::EventReader,
+    prelude::Component,
     query::{With, Without},
+    reflect::ReflectComponent,
     removal_detection::RemovedComponents,
     system::{ParamSet, Query, Res, ResMut, Resource},
-    world::Ref, prelude::Component, reflect::ReflectComponent,
+    world::Ref,
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::Vec2;
-use bevy_reflect::{Reflect, std_traits::ReflectDefault};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_transform::components::Transform;
 use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
@@ -101,8 +103,10 @@ impl UiSurface {
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
     pub fn insert_node(&mut self, entity: Entity) -> taffy::node::Node {
         // It's possible for a user to overwrite an active `UiKey` component with `UiKey::default()`.
-        // In which case we reuse the existing node.
-        *self.entity_to_taffy.entry(entity)
+        // In which case we reuse the existing taffy node.
+        *self
+            .entity_to_taffy
+            .entry(entity)
             .or_insert_with(|| self.taffy.new_leaf(taffy::style::Style::default()).unwrap())
     }
 
@@ -137,7 +141,9 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        self.taffy.set_children(parent_key, &taffy_children).unwrap();
+        self.taffy
+            .set_children(parent_key, &taffy_children)
+            .unwrap();
     }
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.

From 997fc32eb4d40d75c8db588f502cd22ab51ccd45 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 21:22:21 +0100
Subject: [PATCH 53/60] Changed some paramter names to be more descriptive.

---
 crates/bevy_ui/src/layout/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index f66047083aed7..4edc52bf7db73 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -101,12 +101,12 @@ impl Default for UiSurface {
 
 impl UiSurface {
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
-    pub fn insert_node(&mut self, entity: Entity) -> taffy::node::Node {
+    pub fn insert_node(&mut self, uinode: Entity) -> taffy::node::Node {
         // It's possible for a user to overwrite an active `UiKey` component with `UiKey::default()`.
         // In which case we reuse the existing taffy node.
         *self
             .entity_to_taffy
-            .entry(entity)
+            .entry(uinode)
             .or_insert_with(|| self.taffy.new_leaf(taffy::style::Style::default()).unwrap())
     }
 
@@ -147,8 +147,8 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
-    pub fn try_remove_children(&mut self, entity: Entity) {
-        if let Some(key) = self.entity_to_taffy.get(&entity) {
+    pub fn try_remove_children(&mut self, parent: Entity) {
+        if let Some(key) = self.entity_to_taffy.get(&parent) {
             self.taffy.set_children(*key, &[]).unwrap();
         }
     }

From 68c150fe74fc8e17df1d7867cfa462101484ae35 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Wed, 14 Jun 2023 21:32:34 +0100
Subject: [PATCH 54/60] Removed `LayoutError` as it's no longer used.

---
 crates/bevy_ui/src/layout/mod.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 4edc52bf7db73..c8456758b2cbe 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -216,12 +216,6 @@ without UI components as a child of an entity with UI components, results may be
     }
 }
 
-#[derive(Debug)]
-pub enum LayoutError {
-    InvalidHierarchy,
-    TaffyError(taffy::error::TaffyError),
-}
-
 /// Updates the UI's layout tree, computes the new layout geometry and then updates the sizes and transforms of all the UI nodes.
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(

From 73f25968dac6b54e46714599323b6d997dc0a5b4 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 16 Jun 2023 11:06:42 +0100
Subject: [PATCH 55/60] `layout` module: Changed the ordering of parameters for
 the `from_style` and `LayoutContext::new` functions to put the most important
 parameter first.

`UiSurface`:
Added a test `uisurface_insert_and_remove_nodes`.
---
 crates/bevy_ui/src/layout/convert.rs |  8 +--
 crates/bevy_ui/src/layout/mod.rs     | 81 ++++++++++++++++++++++++++--
 2 files changed, 82 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ui/src/layout/convert.rs b/crates/bevy_ui/src/layout/convert.rs
index d3fe37679849d..57e2e3b2dab88 100644
--- a/crates/bevy_ui/src/layout/convert.rs
+++ b/crates/bevy_ui/src/layout/convert.rs
@@ -63,7 +63,7 @@ impl UiRect {
     }
 }
 
-pub fn from_style(context: &LayoutContext, style: &Style) -> taffy::style::Style {
+pub fn from_style(style: &Style, context: &LayoutContext) -> taffy::style::Style {
     taffy::style::Style {
         display: style.display.into(),
         position: style.position_type.into(),
@@ -466,8 +466,8 @@ mod tests {
             grid_column: GridPlacement::start(4),
             grid_row: GridPlacement::span(3),
         };
-        let viewport_values = LayoutContext::new(1.0, bevy_math::Vec2::new(800., 600.));
-        let taffy_style = from_style(&viewport_values, &bevy_style);
+        let context = LayoutContext::new(bevy_math::Vec2::new(800., 600.), 1.0);
+        let taffy_style = from_style(&bevy_style, &context);
         assert_eq!(taffy_style.display, taffy::style::Display::Flex);
         assert_eq!(taffy_style.position, taffy::style::Position::Absolute);
         assert!(matches!(
@@ -633,7 +633,7 @@ mod tests {
     #[test]
     fn test_into_length_percentage() {
         use taffy::style::LengthPercentage;
-        let context = LayoutContext::new(2.0, bevy_math::Vec2::new(800., 600.));
+        let context = LayoutContext::new(bevy_math::Vec2::new(800., 600.), 2.);
         let cases = [
             (Val::Auto, LengthPercentage::Points(0.)),
             (Val::Percent(1.), LengthPercentage::Percent(0.01)),
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index c8456758b2cbe..95c0c43b19d74 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -56,7 +56,7 @@ pub struct LayoutContext {
 
 impl LayoutContext {
     /// create new a [`LayoutContext`] from the window's physical size and scale factor
-    fn new(scale_factor: f64, physical_size: Vec2) -> Self {
+    fn new(physical_size: Vec2, scale_factor: f64) -> Self {
         Self {
             scale_factor,
             physical_size,
@@ -118,7 +118,7 @@ impl UiSurface {
         layout_context: &LayoutContext,
     ) {
         self.taffy
-            .set_style(key, convert::from_style(layout_context, style))
+            .set_style(key, convert::from_style(style, layout_context))
             .unwrap();
     }
 
@@ -300,7 +300,7 @@ pub fn ui_layout_system(
     }
 
     let layout_context =
-        LayoutContext::new(logical_to_physical_factor * ui_scale.scale, physical_size);
+        LayoutContext::new(physical_size, logical_to_physical_factor * ui_scale.scale);
 
     if !scale_factor_events.is_empty() || ui_scale.is_changed() || window_changed {
         scale_factor_events.clear();
@@ -366,3 +366,78 @@ pub fn ui_layout_system(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use bevy_ecs::world::World;
+    use bevy_math::Vec2;
+
+    use crate::layout::convert::from_style;
+    use crate::UiSurface;
+
+    #[test]
+    fn uisurface_insert_and_remove_nodes() {
+        let mut world = World::new();
+        let mut ui_surface = UiSurface::default();
+        let uinode_a = world.spawn_empty().id();
+        let uinode_b = world.spawn_empty().id();
+        let context = crate::LayoutContext::new(Vec2::new(800., 600.), 1.0);
+        let style_a = crate::Style::default();
+        let style_b = crate::Style {
+            flex_direction: crate::FlexDirection::Column,
+            ..Default::default()
+        };
+        let taffystyle_a = from_style(&style_a, &context);
+        let taffystyle_b = from_style(&style_a, &context);
+        let taffynode_a = ui_surface.insert_node(uinode_a);
+        let taffynode_b = ui_surface.insert_node(uinode_b);
+        ui_surface.set_style(taffynode_a, &style_a, &context);
+        ui_surface.set_style(taffynode_b, &style_b, &context);
+        assert_eq!(
+            taffynode_a,
+            *ui_surface.entity_to_taffy.get(&uinode_a).unwrap()
+        );
+        assert_eq!(
+            taffynode_b,
+            *ui_surface.entity_to_taffy.get(&uinode_b).unwrap()
+        );
+
+        // The should be be two nodes in the layout
+        assert_eq!(ui_surface.entity_to_taffy.len(), 2);
+
+        // The ids for the associated taffy nodes should be different
+        assert_ne!(taffynode_a, taffynode_b);
+
+        // Check the UI nodes each have an associated taffy node with the correct style
+        assert_eq!(ui_surface.taffy.style(taffynode_a).unwrap(), &taffystyle_a);
+        assert_eq!(ui_surface.taffy.style(taffynode_b).unwrap(), &taffystyle_b);
+
+        // Swap the styles of the associated nodes
+        ui_surface.set_style(taffynode_a, &style_b, &context);
+        ui_surface.set_style(taffynode_b, &style_a, &context);
+
+        // The styles should be swapped
+        assert_eq!(ui_surface.taffy.style(taffynode_a).unwrap(), &taffystyle_b);
+        assert_eq!(ui_surface.taffy.style(taffynode_b).unwrap(), &taffystyle_a);
+
+        // But the ids of the associated nodes should be unchanged
+        assert_eq!(
+            *ui_surface.entity_to_taffy.get(&uinode_a).unwrap(),
+            taffynode_a
+        );
+        assert_eq!(
+            *ui_surface.entity_to_taffy.get(&uinode_b).unwrap(),
+            taffynode_b
+        );
+
+        // There should still be exactly two nodes in the layout
+        assert_eq!(ui_surface.entity_to_taffy.len(), 2);
+
+        // Remove the uinodes from the layout and check styles are also removed
+        ui_surface.remove_entities([uinode_a, uinode_b]);
+
+        assert!(ui_surface.entity_to_taffy.is_empty());
+        assert!(ui_surface.taffy.style(taffynode_a).is_err());
+        assert!(ui_surface.taffy.style(taffynode_b).is_err());
+    }
+}

From 9546431b936f245e530f546edbbb46fbe42568bb Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 16 Jun 2023 15:04:51 +0100
Subject: [PATCH 56/60] `Taffykey`: Type alias for `taffy::node::Node`.

`UiSurface::get_key`
Method that can be used to lookup taffy nodes from `entity_to_taffy` but takes and returns a value rather than a borrow.
---
 crates/bevy_ui/src/layout/mod.rs | 49 +++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 95c0c43b19d74..a14eeaeee624c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -23,6 +23,8 @@ use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChan
 use std::fmt;
 use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
+type TaffyKey = taffy::node::Node;
+
 /// Identifier for the UI node's associated entry in the UI's layout tree.
 ///
 /// Users can only instantiate null nodes using `UiKey::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
@@ -32,12 +34,12 @@ use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Ta
 pub struct UiKey {
     // The id of the taffy node associated with the entity possessing this component.
     #[reflect(ignore)]
-    taffy_key: taffy::node::Node,
+    taffy_key: TaffyKey,
 }
 
 impl UiKey {
     // Returns the id of the taffy node associated with the entity that has this component.
-    pub fn get(&self) -> taffy::node::Node {
+    pub fn get(&self) -> TaffyKey {
         self.taffy_key
     }
 
@@ -68,14 +70,14 @@ impl LayoutContext {
 
 #[derive(Resource)]
 pub struct UiSurface {
-    entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    window_nodes: HashMap<Entity, taffy::node::Node>,
+    entity_to_taffy: HashMap<Entity, TaffyKey>,
+    window_nodes: HashMap<Entity, TaffyKey>,
     taffy: Taffy,
 }
 
 fn _assert_send_sync_ui_surface_impl_safe() {
     fn _assert_send_sync<T: Send + Sync>() {}
-    _assert_send_sync::<HashMap<Entity, taffy::node::Node>>();
+    _assert_send_sync::<HashMap<Entity, TaffyKey>>();
     _assert_send_sync::<Taffy>();
     _assert_send_sync::<UiSurface>();
 }
@@ -100,8 +102,15 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
+    /// Returns a key identifying the internal layout tree node associated with the given `Entity`
+    /// or `None` if no such association exists.
+    #[inline]
+    pub fn get_key(&self, entity: Entity) -> Option<TaffyKey> {
+        self.entity_to_taffy.get(&entity).copied()
+    } 
+
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
-    pub fn insert_node(&mut self, uinode: Entity) -> taffy::node::Node {
+    pub fn insert_node(&mut self, uinode: Entity) -> TaffyKey {
         // It's possible for a user to overwrite an active `UiKey` component with `UiKey::default()`.
         // In which case we reuse the existing taffy node.
         *self
@@ -113,7 +122,7 @@ impl UiSurface {
     /// Converts the given Bevy UI `Style` to a taffy style and applies it to the taffy node with identifier `key`.
     pub fn set_style(
         &mut self,
-        key: taffy::node::Node,
+        key: TaffyKey,
         style: &Style,
         layout_context: &LayoutContext,
     ) {
@@ -123,16 +132,16 @@ impl UiSurface {
     }
 
     /// Sets the `MeasureFunc` for the taffy node `key` to `measure`.
-    pub fn set_measure(&mut self, key: taffy::node::Node, measure: MeasureFunc) {
+    pub fn set_measure(&mut self, key: TaffyKey, measure: MeasureFunc) {
         self.taffy.set_measure(key, Some(measure)).unwrap();
     }
 
     /// Update the children of the taffy node `parent_key` .
-    pub fn update_children(&mut self, parent_key: taffy::node::Node, children: &Children) {
+    pub fn update_children(&mut self, parent_key: TaffyKey, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
-        for child in children {
-            if let Some(child_key) = self.entity_to_taffy.get(child) {
-                taffy_children.push(*child_key);
+        for &child in children {
+            if let Some(child_key) = self.get_key(child) {
+                taffy_children.push(child_key);
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -148,15 +157,15 @@ without UI components as a child of an entity with UI components, results may be
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_children(&mut self, parent: Entity) {
-        if let Some(key) = self.entity_to_taffy.get(&parent) {
-            self.taffy.set_children(*key, &[]).unwrap();
+        if let Some(key) = self.get_key(parent) {
+            self.taffy.set_children(key, &[]).unwrap();
         }
     }
 
     /// Removes the measure from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_measure(&mut self, entity: Entity) {
-        if let Some(key) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_measure(*key, None).unwrap();
+        if let Some(key) = self.get_key(entity) {
+            self.taffy.set_measure(key, None).unwrap();
         }
     }
 
@@ -190,11 +199,11 @@ without UI components as a child of an entity with UI components, results may be
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
-        children: impl Iterator<Item = taffy::node::Node>,
+        children: impl Iterator<Item = TaffyKey>,
     ) {
-        let key = self.window_nodes.get(&parent_window).unwrap();
-        let child_keys = children.collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(*key, &child_keys).unwrap();
+        let window_key = self.get_key(parent_window).unwrap();
+        let child_keys = children.collect::<Vec<TaffyKey>>();
+        self.taffy.set_children(window_key, &child_keys).unwrap();
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.

From e8388a579b9c940e230541166578fdb9c883ecdd Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 16 Jun 2023 15:10:19 +0100
Subject: [PATCH 57/60] `Taffykey`: Type alias for `taffy::node::Node`.

`UiSurface::get_key`
Method that can be used to lookup taffy nodes from `entity_to_taffy` but takes and returns a value rather than a borrow.
---
 crates/bevy_ui/src/layout/mod.rs | 91 ++++++++++++++++++--------------
 1 file changed, 50 insertions(+), 41 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 95c0c43b19d74..7c2b4ce6991df 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -23,6 +23,8 @@ use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChan
 use std::fmt;
 use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Taffy};
 
+type TaffyKey = taffy::node::Node;
+
 /// Identifier for the UI node's associated entry in the UI's layout tree.
 ///
 /// Users can only instantiate null nodes using `UiKey::default()`, the keys are set and managed internally by [`super::layout::ui_layout_system`].
@@ -32,12 +34,12 @@ use taffy::{node::MeasureFunc, prelude::Size, style_helpers::TaffyMaxContent, Ta
 pub struct UiKey {
     // The id of the taffy node associated with the entity possessing this component.
     #[reflect(ignore)]
-    taffy_key: taffy::node::Node,
+    taffy_key: TaffyKey,
 }
 
 impl UiKey {
     // Returns the id of the taffy node associated with the entity that has this component.
-    pub fn get(&self) -> taffy::node::Node {
+    pub fn get(&self) -> TaffyKey {
         self.taffy_key
     }
 
@@ -68,14 +70,14 @@ impl LayoutContext {
 
 #[derive(Resource)]
 pub struct UiSurface {
-    entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    window_nodes: HashMap<Entity, taffy::node::Node>,
+    entity_to_taffy: HashMap<Entity, TaffyKey>,
+    window_nodes: HashMap<Entity, TaffyKey>,
     taffy: Taffy,
 }
 
 fn _assert_send_sync_ui_surface_impl_safe() {
     fn _assert_send_sync<T: Send + Sync>() {}
-    _assert_send_sync::<HashMap<Entity, taffy::node::Node>>();
+    _assert_send_sync::<HashMap<Entity, TaffyKey>>();
     _assert_send_sync::<Taffy>();
     _assert_send_sync::<UiSurface>();
 }
@@ -100,8 +102,15 @@ impl Default for UiSurface {
 }
 
 impl UiSurface {
+    /// Returns a key identifying the internal layout tree node associated with the given `Entity`
+    /// or `None` if no such association exists.
+    #[inline]
+    pub fn get_key(&self, entity: Entity) -> Option<TaffyKey> {
+        self.entity_to_taffy.get(&entity).copied()
+    } 
+
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
-    pub fn insert_node(&mut self, uinode: Entity) -> taffy::node::Node {
+    pub fn insert_node(&mut self, uinode: Entity) -> TaffyKey {
         // It's possible for a user to overwrite an active `UiKey` component with `UiKey::default()`.
         // In which case we reuse the existing taffy node.
         *self
@@ -113,7 +122,7 @@ impl UiSurface {
     /// Converts the given Bevy UI `Style` to a taffy style and applies it to the taffy node with identifier `key`.
     pub fn set_style(
         &mut self,
-        key: taffy::node::Node,
+        key: TaffyKey,
         style: &Style,
         layout_context: &LayoutContext,
     ) {
@@ -123,16 +132,16 @@ impl UiSurface {
     }
 
     /// Sets the `MeasureFunc` for the taffy node `key` to `measure`.
-    pub fn set_measure(&mut self, key: taffy::node::Node, measure: MeasureFunc) {
+    pub fn set_measure(&mut self, key: TaffyKey, measure: MeasureFunc) {
         self.taffy.set_measure(key, Some(measure)).unwrap();
     }
 
     /// Update the children of the taffy node `parent_key` .
-    pub fn update_children(&mut self, parent_key: taffy::node::Node, children: &Children) {
+    pub fn update_children(&mut self, parent_key: TaffyKey, children: &Children) {
         let mut taffy_children = Vec::with_capacity(children.len());
-        for child in children {
-            if let Some(child_key) = self.entity_to_taffy.get(child) {
-                taffy_children.push(*child_key);
+        for &child in children {
+            if let Some(child_key) = self.get_key(child) {
+                taffy_children.push(child_key);
             } else {
                 warn!(
                     "Unstyled child in a UI entity hierarchy. You are using an entity \
@@ -148,15 +157,15 @@ without UI components as a child of an entity with UI components, results may be
 
     /// Removes children from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_children(&mut self, parent: Entity) {
-        if let Some(key) = self.entity_to_taffy.get(&parent) {
-            self.taffy.set_children(*key, &[]).unwrap();
+        if let Some(key) = self.get_key(parent) {
+            self.taffy.set_children(key, &[]).unwrap();
         }
     }
 
     /// Removes the measure from the entity's taffy node if it exists. Does nothing otherwise.
     pub fn try_remove_measure(&mut self, entity: Entity) {
-        if let Some(key) = self.entity_to_taffy.get(&entity) {
-            self.taffy.set_measure(*key, None).unwrap();
+        if let Some(key) = self.get_key(entity) {
+            self.taffy.set_measure(key, None).unwrap();
         }
     }
 
@@ -190,11 +199,11 @@ without UI components as a child of an entity with UI components, results may be
     pub fn set_window_children(
         &mut self,
         parent_window: Entity,
-        children: impl Iterator<Item = taffy::node::Node>,
+        children: impl Iterator<Item = TaffyKey>,
     ) {
-        let key = self.window_nodes.get(&parent_window).unwrap();
-        let child_keys = children.collect::<Vec<taffy::node::Node>>();
-        self.taffy.set_children(*key, &child_keys).unwrap();
+        let window_key = self.window_nodes.get(&parent_window).unwrap();
+        let child_keys = children.collect::<Vec<TaffyKey>>();
+        self.taffy.set_children(*window_key, &child_keys).unwrap();
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.
@@ -389,45 +398,45 @@ mod tests {
         };
         let taffystyle_a = from_style(&style_a, &context);
         let taffystyle_b = from_style(&style_a, &context);
-        let taffynode_a = ui_surface.insert_node(uinode_a);
-        let taffynode_b = ui_surface.insert_node(uinode_b);
-        ui_surface.set_style(taffynode_a, &style_a, &context);
-        ui_surface.set_style(taffynode_b, &style_b, &context);
+        let taffykey_a = ui_surface.insert_node(uinode_a);
+        let taffykey_b = ui_surface.insert_node(uinode_b);
+        ui_surface.set_style(taffykey_a, &style_a, &context);
+        ui_surface.set_style(taffykey_b, &style_b, &context);
         assert_eq!(
-            taffynode_a,
-            *ui_surface.entity_to_taffy.get(&uinode_a).unwrap()
+            taffykey_a,
+            ui_surface.get_key(uinode_a).unwrap()
         );
         assert_eq!(
-            taffynode_b,
-            *ui_surface.entity_to_taffy.get(&uinode_b).unwrap()
+            taffykey_b,
+            ui_surface.get_key(uinode_b).unwrap()
         );
 
         // The should be be two nodes in the layout
         assert_eq!(ui_surface.entity_to_taffy.len(), 2);
 
         // The ids for the associated taffy nodes should be different
-        assert_ne!(taffynode_a, taffynode_b);
+        assert_ne!(taffykey_a, taffykey_b);
 
         // Check the UI nodes each have an associated taffy node with the correct style
-        assert_eq!(ui_surface.taffy.style(taffynode_a).unwrap(), &taffystyle_a);
-        assert_eq!(ui_surface.taffy.style(taffynode_b).unwrap(), &taffystyle_b);
+        assert_eq!(ui_surface.taffy.style(taffykey_a).unwrap(), &taffystyle_a);
+        assert_eq!(ui_surface.taffy.style(taffykey_b).unwrap(), &taffystyle_b);
 
         // Swap the styles of the associated nodes
-        ui_surface.set_style(taffynode_a, &style_b, &context);
-        ui_surface.set_style(taffynode_b, &style_a, &context);
+        ui_surface.set_style(taffykey_a, &style_b, &context);
+        ui_surface.set_style(taffykey_b, &style_a, &context);
 
         // The styles should be swapped
-        assert_eq!(ui_surface.taffy.style(taffynode_a).unwrap(), &taffystyle_b);
-        assert_eq!(ui_surface.taffy.style(taffynode_b).unwrap(), &taffystyle_a);
+        assert_eq!(ui_surface.taffy.style(taffykey_a).unwrap(), &taffystyle_b);
+        assert_eq!(ui_surface.taffy.style(taffykey_b).unwrap(), &taffystyle_a);
 
         // But the ids of the associated nodes should be unchanged
         assert_eq!(
-            *ui_surface.entity_to_taffy.get(&uinode_a).unwrap(),
-            taffynode_a
+            ui_surface.get_key(uinode_a).unwrap(),
+            taffykey_a
         );
         assert_eq!(
-            *ui_surface.entity_to_taffy.get(&uinode_b).unwrap(),
-            taffynode_b
+            ui_surface.get_key(uinode_b).unwrap(),
+            taffykey_b
         );
 
         // There should still be exactly two nodes in the layout
@@ -437,7 +446,7 @@ mod tests {
         ui_surface.remove_entities([uinode_a, uinode_b]);
 
         assert!(ui_surface.entity_to_taffy.is_empty());
-        assert!(ui_surface.taffy.style(taffynode_a).is_err());
-        assert!(ui_surface.taffy.style(taffynode_b).is_err());
+        assert!(ui_surface.taffy.style(taffykey_a).is_err());
+        assert!(ui_surface.taffy.style(taffykey_b).is_err());
     }
 }

From 5fc76a1f3a475e49fb73b3c303a6c118a6be72c1 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 16 Jun 2023 15:12:35 +0100
Subject: [PATCH 58/60] cargo fmt

---
 crates/bevy_ui/src/layout/mod.rs | 29 ++++++-----------------------
 1 file changed, 6 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 7c2b4ce6991df..b063d23174cb3 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -107,7 +107,7 @@ impl UiSurface {
     #[inline]
     pub fn get_key(&self, entity: Entity) -> Option<TaffyKey> {
         self.entity_to_taffy.get(&entity).copied()
-    } 
+    }
 
     /// Inserts a node into the Taffy layout, associates it with the given entity, and returns its taffy id.
     pub fn insert_node(&mut self, uinode: Entity) -> TaffyKey {
@@ -120,12 +120,7 @@ impl UiSurface {
     }
 
     /// Converts the given Bevy UI `Style` to a taffy style and applies it to the taffy node with identifier `key`.
-    pub fn set_style(
-        &mut self,
-        key: TaffyKey,
-        style: &Style,
-        layout_context: &LayoutContext,
-    ) {
+    pub fn set_style(&mut self, key: TaffyKey, style: &Style, layout_context: &LayoutContext) {
         self.taffy
             .set_style(key, convert::from_style(style, layout_context))
             .unwrap();
@@ -402,14 +397,8 @@ mod tests {
         let taffykey_b = ui_surface.insert_node(uinode_b);
         ui_surface.set_style(taffykey_a, &style_a, &context);
         ui_surface.set_style(taffykey_b, &style_b, &context);
-        assert_eq!(
-            taffykey_a,
-            ui_surface.get_key(uinode_a).unwrap()
-        );
-        assert_eq!(
-            taffykey_b,
-            ui_surface.get_key(uinode_b).unwrap()
-        );
+        assert_eq!(taffykey_a, ui_surface.get_key(uinode_a).unwrap());
+        assert_eq!(taffykey_b, ui_surface.get_key(uinode_b).unwrap());
 
         // The should be be two nodes in the layout
         assert_eq!(ui_surface.entity_to_taffy.len(), 2);
@@ -430,14 +419,8 @@ mod tests {
         assert_eq!(ui_surface.taffy.style(taffykey_b).unwrap(), &taffystyle_a);
 
         // But the ids of the associated nodes should be unchanged
-        assert_eq!(
-            ui_surface.get_key(uinode_a).unwrap(),
-            taffykey_a
-        );
-        assert_eq!(
-            ui_surface.get_key(uinode_b).unwrap(),
-            taffykey_b
-        );
+        assert_eq!(ui_surface.get_key(uinode_a).unwrap(), taffykey_a);
+        assert_eq!(ui_surface.get_key(uinode_b).unwrap(), taffykey_b);
 
         // There should still be exactly two nodes in the layout
         assert_eq!(ui_surface.entity_to_taffy.len(), 2);

From 7deab35be04afb4e92ce8aed96a52dafafaee07a Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Fri, 16 Jun 2023 15:20:45 +0100
Subject: [PATCH 59/60] moved window handling in `ui_layout_system` outside of
 the update logic.

---
 crates/bevy_ui/src/layout/mod.rs | 46 ++++++++++++++++----------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index b063d23174cb3..a6442c7de2d3f 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -244,6 +244,29 @@ pub fn ui_layout_system(
         ),
     )>,
 ) {
+    // assume one window for time being...
+    // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
+    let (primary_window_entity, logical_to_physical_factor, physical_size) =
+        if let Ok((entity, primary_window)) = primary_window.get_single() {
+            (
+                entity,
+                primary_window.resolution.scale_factor(),
+                Vec2::new(
+                    primary_window.resolution.physical_width() as f32,
+                    primary_window.resolution.physical_height() as f32,
+                ),
+            )
+        } else {
+            return;
+        };
+
+    // Set the `window_changed` flag if the primary window was resized or created since the last UI update.
+    let window_changed = window_resized_events
+        .iter()
+        .map(|resized| resized.window)
+        .chain(window_created_events.iter().map(|created| created.window))
+        .any(|window| window == primary_window_entity);
+
     // clean up removed nodes first
     ui_surface.remove_entities(removed_nodes.iter());
 
@@ -275,29 +298,6 @@ pub fn ui_layout_system(
         }
     }
 
-    // assume one window for time being...
-    // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
-    let (primary_window_entity, logical_to_physical_factor, physical_size) =
-        if let Ok((entity, primary_window)) = primary_window.get_single() {
-            (
-                entity,
-                primary_window.resolution.scale_factor(),
-                Vec2::new(
-                    primary_window.resolution.physical_width() as f32,
-                    primary_window.resolution.physical_height() as f32,
-                ),
-            )
-        } else {
-            return;
-        };
-
-    // Set the `window_changed` flag if the primary window was resized or created since the last UI update.
-    let window_changed = window_resized_events
-        .iter()
-        .map(|resized| resized.window)
-        .chain(window_created_events.iter().map(|created| created.window))
-        .any(|window| window == primary_window_entity);
-
     // update window root nodes
     for (entity, window) in windows.iter() {
         ui_surface.update_window(entity, &window.resolution);

From b67c30c869fa963f3dc889744a5b0dc7393974b4 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Mon, 21 Aug 2023 23:00:46 +0100
Subject: [PATCH 60/60] Cleaned up left over comments from merge

---
 crates/bevy_ui/src/layout/mod.rs | 46 --------------------------------
 1 file changed, 46 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 854369a666785..a2a368c9b813c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -247,17 +247,6 @@ pub fn ui_layout_system(
             Query<&Children, With<UiKey>>,
         ),
     )>,
-// =======
-//     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-//     style_query: Query<(Entity, Ref<Style>), With<Node>>,
-//     mut measure_query: Query<(Entity, &mut ContentSize)>,
-//     children_query: Query<(Entity, Ref<Children>), With<Node>>,
-//     just_children_query: Query<&Children>,
-//     mut removed_children: RemovedComponents<Children>,
-//     mut removed_content_sizes: RemovedComponents<ContentSize>,
-//     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
-//     mut removed_nodes: RemovedComponents<Node>,
-// >>>>>>> main
 ) {
     // assume one window for time being...
     // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
@@ -282,7 +271,6 @@ pub fn ui_layout_system(
         .chain(window_created_events.iter().map(|created| created.window))
         .any(|window| window == primary_window_entity);
 
-//<<<<<<< HEAD
     // clean up removed nodes first
     ui_surface.remove_entities(removed_nodes.iter());
 
@@ -314,40 +302,6 @@ pub fn ui_layout_system(
         }
     }
 
-// =======
-//     // update window root nodes
-//     for (entity, window) in windows.iter() {
-//         ui_surface.update_window(entity, &window.resolution);
-//     }
-
-//     let scale_factor = logical_to_physical_factor * ui_scale.0;
-
-//     let layout_context = LayoutContext::new(scale_factor, physical_size);
-
-//     if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
-//         scale_factor_events.clear();
-//         // update all nodes
-//         for (entity, style) in style_query.iter() {
-//             ui_surface.upsert_node(entity, &style, &layout_context);
-//         }
-//     } else {
-//         for (entity, style) in style_query.iter() {
-//             if style.is_changed() {
-//                 ui_surface.upsert_node(entity, &style, &layout_context);
-//             }
-//         }
-//     }
-
-//     for (entity, mut content_size) in measure_query.iter_mut() {
-//         if let Some(measure_func) = content_size.measure_func.take() {
-//             ui_surface.update_measure(entity, measure_func);
-//         }
-//     }
-
-//     // clean up removed nodes
-// >>>>>>> main
-    
-
     // update window root nodes
     for (entity, window) in windows.iter() {
         ui_surface.update_window(entity, &window.resolution);