From 00590e2f6d18d5ef27b13e7bf4e3830d58cb775a Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:28:16 +0200
Subject: [PATCH 01/18] Rename get_parent -> parent

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

diff --git a/crates/bevy_ui/src/ghost_hierarchy.rs b/crates/bevy_ui/src/ghost_hierarchy.rs
index ad5a88948052a..303b2c481c788 100644
--- a/crates/bevy_ui/src/ghost_hierarchy.rs
+++ b/crates/bevy_ui/src/ghost_hierarchy.rs
@@ -77,7 +77,7 @@ impl<'w, 's> UiChildren<'w, 's> {
     }
 
     /// Returns the UI parent of the provided entity, skipping over [`GhostNode`].
-    pub fn get_parent(&'s self, entity: Entity) -> Option<Entity> {
+    pub fn parent(&'s self, entity: Entity) -> Option<Entity> {
         self.parents_query
             .iter_ancestors(entity)
             .find(|entity| !self.ghost_nodes_query.contains(*entity))

From 41592e1041a3dd47569320f55a6a0ee193fb3cf9 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:31:02 +0200
Subject: [PATCH 02/18] Rename iter_ui_children -> iter_children

---
 crates/bevy_ui/src/accessibility.rs   |  4 ++--
 crates/bevy_ui/src/ghost_hierarchy.rs | 10 ++++------
 crates/bevy_ui/src/layout/mod.rs      |  6 +++---
 crates/bevy_ui/src/stack.rs           |  2 +-
 crates/bevy_ui/src/update.rs          |  4 ++--
 5 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index 2a5944f40a371..cfe0af7bc4e94 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -65,7 +65,7 @@ fn button_changed(
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_ui_children(entity));
+        let name = calc_name(&mut text_reader, ui_children.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Button);
             if let Some(name) = name {
@@ -92,7 +92,7 @@ fn image_changed(
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_ui_children(entity));
+        let name = calc_name(&mut text_reader, ui_children.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Image);
             if let Some(name) = name {
diff --git a/crates/bevy_ui/src/ghost_hierarchy.rs b/crates/bevy_ui/src/ghost_hierarchy.rs
index 303b2c481c788..4745e7b542cbe 100644
--- a/crates/bevy_ui/src/ghost_hierarchy.rs
+++ b/crates/bevy_ui/src/ghost_hierarchy.rs
@@ -36,7 +36,7 @@ impl<'w, 's> UiRootNodes<'w, 's> {
             .iter()
             .chain(self.root_ghost_node_query.iter().flat_map(|root_ghost| {
                 self.all_nodes_query
-                    .iter_many(self.ui_children.iter_ui_children(root_ghost))
+                    .iter_many(self.ui_children.iter_children(root_ghost))
             }))
     }
 }
@@ -57,14 +57,14 @@ pub struct UiChildren<'w, 's> {
 }
 
 impl<'w, 's> UiChildren<'w, 's> {
-    /// Iterates the children of `entity`, skipping over [`GhostNode`].
+    /// Iterates the [`Node`] children of `entity`, skipping over [`GhostNode`].
     ///
     /// Traverses the hierarchy depth-first to ensure child order.
     ///
     /// # Performance
     ///
     /// This iterator allocates if the `entity` node has more than 8 children (including ghost nodes).
-    pub fn iter_ui_children(&'s self, entity: Entity) -> UiChildrenIter<'w, 's> {
+    pub fn iter_children(&'s self, entity: Entity) -> UiChildrenIter<'w, 's> {
         UiChildrenIter {
             stack: self
                 .ui_children_query
@@ -214,9 +214,7 @@ mod tests {
         let mut system_state = SystemState::<(UiChildren, Query<&A>)>::new(world);
         let (ui_children, a_query) = system_state.get(world);
 
-        let result: Vec<_> = a_query
-            .iter_many(ui_children.iter_ui_children(n1))
-            .collect();
+        let result: Vec<_> = a_query.iter_many(ui_children.iter_children(n1)).collect();
 
         assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
     }
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 492f1c1e0f2d4..146e7a56d3c87 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -263,7 +263,7 @@ with UI components as a child of an entity without UI components, your UI layout
         }
 
         if ui_children.is_changed(entity) {
-            ui_surface.update_children(entity, ui_children.iter_ui_children(entity));
+            ui_surface.update_children(entity, ui_children.iter_children(entity));
         }
     });
 
@@ -275,7 +275,7 @@ with UI components as a child of an entity without UI components, your UI layout
     // Re-sync changed children: avoid layout glitches caused by removed nodes that are still set as a child of another node
     node_query.iter().for_each(|(entity, _)| {
         if ui_children.is_changed(entity) {
-            ui_surface.update_children(entity, ui_children.iter_ui_children(entity));
+            ui_surface.update_children(entity, ui_children.iter_children(entity));
         }
     });
 
@@ -435,7 +435,7 @@ with UI components as a child of an entity without UI components, your UI layout
                     .insert(ScrollPosition::from(&clamped_scroll_position));
             }
 
-            for child_uinode in ui_children.iter_ui_children(entity) {
+            for child_uinode in ui_children.iter_children(entity) {
                 update_uinode_geometry_recursive(
                     commands,
                     child_uinode,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index a8d535fa2ff27..81b627fba342d 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -107,7 +107,7 @@ fn update_uistack_recursive(
     let mut child_buffer = cache.pop();
     child_buffer.extend(
         ui_children
-            .iter_ui_children(node_entity)
+            .iter_children(node_entity)
             .filter_map(|child_entity| {
                 zindex_query
                     .get(child_entity)
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 87abca8ad96de..d72fd7cdec379 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -105,7 +105,7 @@ fn update_clipping(
         Some(maybe_inherited_clip.map_or(node_rect, |c| c.intersect(node_rect)))
     };
 
-    for child in ui_children.iter_ui_children(entity) {
+    for child in ui_children.iter_children(entity) {
         update_clipping(commands, ui_children, node_query, child, children_clip);
     }
 }
@@ -164,7 +164,7 @@ fn update_children_target_camera(
     commands: &mut Commands,
     updated_entities: &mut HashSet<Entity>,
 ) {
-    for child in ui_children.iter_ui_children(entity) {
+    for child in ui_children.iter_children(entity) {
         // Skip if the child has already been updated or update is not needed
         if updated_entities.contains(&child)
             || camera_to_set == node_query.get(child).ok().and_then(|(_, camera)| camera)

From 4e4048713e677a72c6bb6cc3a41679d297f71500 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:32:58 +0200
Subject: [PATCH 03/18] Rename is_ui_node -> is_ui_entity

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

diff --git a/crates/bevy_ui/src/ghost_hierarchy.rs b/crates/bevy_ui/src/ghost_hierarchy.rs
index 4745e7b542cbe..1c87a64e6f2d9 100644
--- a/crates/bevy_ui/src/ghost_hierarchy.rs
+++ b/crates/bevy_ui/src/ghost_hierarchy.rs
@@ -108,7 +108,7 @@ impl<'w, 's> UiChildren<'w, 's> {
     }
 
     /// Returns `true` if the given entity is either a [`Node`] or a [`GhostNode`].
-    pub fn is_ui_node(&'s self, entity: Entity) -> bool {
+    pub fn is_ui_entity(&'s self, entity: Entity) -> bool {
         self.ui_children_query.contains(entity)
     }
 }
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 146e7a56d3c87..c72111867da53 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -254,7 +254,7 @@ pub fn ui_layout_system(
             // Note: This does not cover the case where a parent's Node component was removed.
             // Users are responsible for fixing hierarchies if they do that (it is not recommended).
             // Detecting it here would be a permanent perf burden on the hot path.
-            if parent.is_changed() && !ui_children.is_ui_node(parent.get()) {
+            if parent.is_changed() && !ui_children.is_ui_entity(parent.get()) {
                 warn!(
                     "Styled child ({entity}) in a non-UI entity hierarchy. You are using an entity \
 with UI components as a child of an entity without UI components, your UI layout may be broken."

From d2a0e557649a9c175f4b475539978b1875b34a08 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:35:18 +0200
Subject: [PATCH 04/18] Rename is_changed -> children_is_changed

---
 crates/bevy_ui/src/ghost_hierarchy.rs | 2 +-
 crates/bevy_ui/src/layout/mod.rs      | 4 ++--
 crates/bevy_ui/src/update.rs          | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ui/src/ghost_hierarchy.rs b/crates/bevy_ui/src/ghost_hierarchy.rs
index 1c87a64e6f2d9..e993551378266 100644
--- a/crates/bevy_ui/src/ghost_hierarchy.rs
+++ b/crates/bevy_ui/src/ghost_hierarchy.rs
@@ -100,7 +100,7 @@ impl<'w, 's> UiChildren<'w, 's> {
     }
 
     /// Given an entity in the UI hierarchy, check if its set of children has changed, e.g if children has been added/removed or if the order has changed.
-    pub fn is_changed(&'s self, entity: Entity) -> bool {
+    pub fn children_is_changed(&'s self, entity: Entity) -> bool {
         self.changed_children_query.contains(entity)
             || self
                 .iter_ghost_nodes(entity)
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index c72111867da53..28981333211c0 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -262,7 +262,7 @@ with UI components as a child of an entity without UI components, your UI layout
             }
         }
 
-        if ui_children.is_changed(entity) {
+        if ui_children.children_is_changed(entity) {
             ui_surface.update_children(entity, ui_children.iter_children(entity));
         }
     });
@@ -274,7 +274,7 @@ with UI components as a child of an entity without UI components, your UI layout
 
     // Re-sync changed children: avoid layout glitches caused by removed nodes that are still set as a child of another node
     node_query.iter().for_each(|(entity, _)| {
-        if ui_children.is_changed(entity) {
+        if ui_children.children_is_changed(entity) {
             ui_surface.update_children(entity, ui_children.iter_children(entity));
         }
     });
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index d72fd7cdec379..f47e808acd1de 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -141,7 +141,7 @@ pub fn update_target_camera_system(
     // by this point, and iteration will be skipped.
     // Otherwise, update changed children
     for (parent, target_camera) in &node_query {
-        if !ui_children.is_changed(parent) {
+        if !ui_children.children_is_changed(parent) {
             continue;
         }
 

From 457153279059bc2eaf81c64d36af0a5fbb58dbad Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:40:40 +0200
Subject: [PATCH 05/18] Rename ghost_hierarchy -> ui_tree

---
 crates/bevy_ui/src/lib.rs                             | 4 ++--
 crates/bevy_ui/src/{ghost_hierarchy.rs => ui_tree.rs} | 0
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename crates/bevy_ui/src/{ghost_hierarchy.rs => ui_tree.rs} (100%)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 007959402ba8b..3f28330730cac 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -26,20 +26,20 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 mod accessibility;
 mod focus;
 mod geometry;
-mod ghost_hierarchy;
 mod layout;
 mod render;
 mod stack;
 mod ui_node;
+mod ui_tree;
 
 pub use focus::*;
 pub use geometry::*;
-pub use ghost_hierarchy::*;
 pub use layout::*;
 pub use measurement::*;
 pub use render::*;
 pub use ui_material::*;
 pub use ui_node::*;
+pub use ui_tree::*;
 use widget::UiImageSize;
 
 /// The UI prelude.
diff --git a/crates/bevy_ui/src/ghost_hierarchy.rs b/crates/bevy_ui/src/ui_tree.rs
similarity index 100%
rename from crates/bevy_ui/src/ghost_hierarchy.rs
rename to crates/bevy_ui/src/ui_tree.rs

From 72ffa1e4bdcd81a349b5b7d6297e9ec24a88a648 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 18:45:51 +0200
Subject: [PATCH 06/18] Rename UiChildren -> UiTree

---
 crates/bevy_ui/src/accessibility.rs | 10 ++++-----
 crates/bevy_ui/src/layout/mod.rs    | 22 ++++++++++----------
 crates/bevy_ui/src/stack.rs         | 12 +++++------
 crates/bevy_ui/src/ui_tree.rs       | 14 ++++++-------
 crates/bevy_ui/src/update.rs        | 32 ++++++++++++-----------------
 5 files changed, 42 insertions(+), 48 deletions(-)

diff --git a/crates/bevy_ui/src/accessibility.rs b/crates/bevy_ui/src/accessibility.rs
index cfe0af7bc4e94..6599cde9f34d7 100644
--- a/crates/bevy_ui/src/accessibility.rs
+++ b/crates/bevy_ui/src/accessibility.rs
@@ -1,7 +1,7 @@
 use crate::{
     prelude::{Button, Label},
     widget::TextUiReader,
-    Node, UiChildren, UiImage,
+    Node, UiImage, UiTree,
 };
 use bevy_a11y::{
     accesskit::{NodeBuilder, Rect, Role},
@@ -61,11 +61,11 @@ fn calc_bounds(
 fn button_changed(
     mut commands: Commands,
     mut query: Query<(Entity, Option<&mut AccessibilityNode>), Changed<Button>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_children(entity));
+        let name = calc_name(&mut text_reader, ui_tree.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Button);
             if let Some(name) = name {
@@ -88,11 +88,11 @@ fn button_changed(
 fn image_changed(
     mut commands: Commands,
     mut query: Query<(Entity, Option<&mut AccessibilityNode>), (Changed<UiImage>, Without<Button>)>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut text_reader: TextUiReader,
 ) {
     for (entity, accessible) in &mut query {
-        let name = calc_name(&mut text_reader, ui_children.iter_children(entity));
+        let name = calc_name(&mut text_reader, ui_tree.iter_children(entity));
         if let Some(mut accessible) = accessible {
             accessible.set_role(Role::Image);
             if let Some(name) = name {
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 28981333211c0..13a3cb693507c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     BorderRadius, ContentSize, DefaultUiCamera, Display, Node, Outline, OverflowAxis,
-    ScrollPosition, Style, TargetCamera, UiChildren, UiRootNodes, UiScale,
+    ScrollPosition, Style, TargetCamera, UiRootNodes, UiScale, UiTree,
 };
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
@@ -115,7 +115,7 @@ pub fn ui_layout_system(
         With<Node>,
     >,
     node_query: Query<(Entity, Option<Ref<Parent>>), With<Node>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     mut removed_components: UiLayoutSystemRemovedComponentParam,
     mut node_transform_query: Query<(
         &mut Node,
@@ -254,7 +254,7 @@ pub fn ui_layout_system(
             // Note: This does not cover the case where a parent's Node component was removed.
             // Users are responsible for fixing hierarchies if they do that (it is not recommended).
             // Detecting it here would be a permanent perf burden on the hot path.
-            if parent.is_changed() && !ui_children.is_ui_entity(parent.get()) {
+            if parent.is_changed() && !ui_tree.is_ui_entity(parent.get()) {
                 warn!(
                     "Styled child ({entity}) in a non-UI entity hierarchy. You are using an entity \
 with UI components as a child of an entity without UI components, your UI layout may be broken."
@@ -262,8 +262,8 @@ with UI components as a child of an entity without UI components, your UI layout
             }
         }
 
-        if ui_children.children_is_changed(entity) {
-            ui_surface.update_children(entity, ui_children.iter_children(entity));
+        if ui_tree.children_is_changed(entity) {
+            ui_surface.update_children(entity, ui_tree.iter_children(entity));
         }
     });
 
@@ -274,8 +274,8 @@ with UI components as a child of an entity without UI components, your UI layout
 
     // Re-sync changed children: avoid layout glitches caused by removed nodes that are still set as a child of another node
     node_query.iter().for_each(|(entity, _)| {
-        if ui_children.children_is_changed(entity) {
-            ui_surface.update_children(entity, ui_children.iter_children(entity));
+        if ui_tree.children_is_changed(entity) {
+            ui_surface.update_children(entity, ui_tree.iter_children(entity));
         }
     });
 
@@ -298,7 +298,7 @@ with UI components as a child of an entity without UI components, your UI layout
                 &ui_surface,
                 None,
                 &mut node_transform_query,
-                &ui_children,
+                &ui_tree,
                 inverse_target_scale_factor,
                 Vec2::ZERO,
                 Vec2::ZERO,
@@ -324,7 +324,7 @@ with UI components as a child of an entity without UI components, your UI layout
             Option<&Outline>,
             Option<&ScrollPosition>,
         )>,
-        ui_children: &UiChildren,
+        ui_tree: &UiTree,
         inverse_target_scale_factor: f32,
         parent_size: Vec2,
         parent_scroll_position: Vec2,
@@ -435,14 +435,14 @@ with UI components as a child of an entity without UI components, your UI layout
                     .insert(ScrollPosition::from(&clamped_scroll_position));
             }
 
-            for child_uinode in ui_children.iter_children(entity) {
+            for child_uinode in ui_tree.iter_children(entity) {
                 update_uinode_geometry_recursive(
                     commands,
                     child_uinode,
                     ui_surface,
                     Some(viewport_size),
                     node_transform_query,
-                    ui_children,
+                    ui_tree,
                     inverse_target_scale_factor,
                     rounded_size,
                     clamped_scroll_position,
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index 81b627fba342d..39cc4d96cee73 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_utils::HashSet;
 
-use crate::{GlobalZIndex, Node, UiChildren, UiRootNodes, ZIndex};
+use crate::{GlobalZIndex, Node, UiRootNodes, UiTree, ZIndex};
 
 /// The current UI stack, which contains all UI nodes ordered by their depth (back-to-front).
 ///
@@ -44,7 +44,7 @@ pub fn ui_stack_system(
     ui_root_nodes: UiRootNodes,
     root_node_query: Query<(Entity, Option<&GlobalZIndex>, Option<&ZIndex>)>,
     zindex_global_node_query: Query<(Entity, &GlobalZIndex, Option<&ZIndex>), With<Node>>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
     zindex_query: Query<Option<&ZIndex>, (With<Node>, Without<GlobalZIndex>)>,
     mut update_query: Query<&mut Node>,
 ) {
@@ -82,7 +82,7 @@ pub fn ui_stack_system(
         update_uistack_recursive(
             &mut cache,
             root_entity,
-            &ui_children,
+            &ui_tree,
             &zindex_query,
             &mut ui_stack.uinodes,
         );
@@ -98,7 +98,7 @@ pub fn ui_stack_system(
 fn update_uistack_recursive(
     cache: &mut ChildBufferCache,
     node_entity: Entity,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     zindex_query: &Query<Option<&ZIndex>, (With<Node>, Without<GlobalZIndex>)>,
     ui_stack: &mut Vec<Entity>,
 ) {
@@ -106,7 +106,7 @@ fn update_uistack_recursive(
 
     let mut child_buffer = cache.pop();
     child_buffer.extend(
-        ui_children
+        ui_tree
             .iter_children(node_entity)
             .filter_map(|child_entity| {
                 zindex_query
@@ -117,7 +117,7 @@ fn update_uistack_recursive(
     );
     child_buffer.sort_by_key(|k| k.1);
     for (child_entity, _) in child_buffer.drain(..) {
-        update_uistack_recursive(cache, child_entity, ui_children, zindex_query, ui_stack);
+        update_uistack_recursive(cache, child_entity, ui_tree, zindex_query, ui_stack);
     }
     cache.push(child_buffer);
 }
diff --git a/crates/bevy_ui/src/ui_tree.rs b/crates/bevy_ui/src/ui_tree.rs
index e993551378266..ec203c23e2bf3 100644
--- a/crates/bevy_ui/src/ui_tree.rs
+++ b/crates/bevy_ui/src/ui_tree.rs
@@ -27,7 +27,7 @@ pub struct UiRootNodes<'w, 's> {
     root_node_query: Query<'w, 's, Entity, (With<Node>, Without<Parent>)>,
     root_ghost_node_query: Query<'w, 's, Entity, (With<GhostNode>, Without<Parent>)>,
     all_nodes_query: Query<'w, 's, Entity, With<Node>>,
-    ui_children: UiChildren<'w, 's>,
+    ui_tree: UiTree<'w, 's>,
 }
 
 impl<'w, 's> UiRootNodes<'w, 's> {
@@ -36,14 +36,14 @@ impl<'w, 's> UiRootNodes<'w, 's> {
             .iter()
             .chain(self.root_ghost_node_query.iter().flat_map(|root_ghost| {
                 self.all_nodes_query
-                    .iter_many(self.ui_children.iter_children(root_ghost))
+                    .iter_many(self.ui_tree.iter_children(root_ghost))
             }))
     }
 }
 
-/// System param that gives access to UI children utilities, skipping over [`GhostNode`].
+/// System param that gives access to UI tree utilities, skipping over [`GhostNode`] and stopping traversal at non-UI entities.
 #[derive(SystemParam)]
-pub struct UiChildren<'w, 's> {
+pub struct UiTree<'w, 's> {
     ui_children_query: Query<
         'w,
         's,
@@ -56,7 +56,7 @@ pub struct UiChildren<'w, 's> {
     parents_query: Query<'w, 's, &'static Parent>,
 }
 
-impl<'w, 's> UiChildren<'w, 's> {
+impl<'w, 's> UiTree<'w, 's> {
     /// Iterates the [`Node`] children of `entity`, skipping over [`GhostNode`].
     ///
     /// Traverses the hierarchy depth-first to ensure child order.
@@ -149,7 +149,7 @@ mod tests {
     };
     use bevy_hierarchy::{BuildChildren, ChildBuild};
 
-    use super::{GhostNode, UiChildren, UiRootNodes};
+    use super::{GhostNode, UiRootNodes, UiTree};
     use crate::prelude::NodeBundle;
 
     #[derive(Component, PartialEq, Debug)]
@@ -211,7 +211,7 @@ mod tests {
         world.entity_mut(n7).add_children(&[n8]);
         world.entity_mut(n9).add_children(&[n10]);
 
-        let mut system_state = SystemState::<(UiChildren, Query<&A>)>::new(world);
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
         let (ui_children, a_query) = system_state.get(world);
 
         let result: Vec<_> = a_query.iter_many(ui_children.iter_children(n1)).collect();
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index f47e808acd1de..03f07fa4e2597 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -1,6 +1,6 @@
 //! This module contains systems that update the UI when something changes
 
-use crate::{CalculatedClip, Display, OverflowAxis, Style, TargetCamera, UiChildren, UiRootNodes};
+use crate::{CalculatedClip, Display, OverflowAxis, Style, TargetCamera, UiRootNodes, UiTree};
 
 use super::Node;
 use bevy_ecs::{
@@ -17,22 +17,16 @@ pub fn update_clipping_system(
     mut commands: Commands,
     root_nodes: UiRootNodes,
     mut node_query: Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
 ) {
     for root_node in root_nodes.iter() {
-        update_clipping(
-            &mut commands,
-            &ui_children,
-            &mut node_query,
-            root_node,
-            None,
-        );
+        update_clipping(&mut commands, &ui_tree, &mut node_query, root_node, None);
     }
 }
 
 fn update_clipping(
     commands: &mut Commands,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     node_query: &mut Query<(&Node, &GlobalTransform, &Style, Option<&mut CalculatedClip>)>,
     entity: Entity,
     mut maybe_inherited_clip: Option<Rect>,
@@ -105,8 +99,8 @@ fn update_clipping(
         Some(maybe_inherited_clip.map_or(node_rect, |c| c.intersect(node_rect)))
     };
 
-    for child in ui_children.iter_children(entity) {
-        update_clipping(commands, ui_children, node_query, child, children_clip);
+    for child in ui_tree.iter_children(entity) {
+        update_clipping(commands, ui_tree, node_query, child, children_clip);
     }
 }
 
@@ -118,7 +112,7 @@ pub fn update_target_camera_system(
     >,
     node_query: Query<(Entity, Option<&TargetCamera>), With<Node>>,
     ui_root_nodes: UiRootNodes,
-    ui_children: UiChildren,
+    ui_tree: UiTree,
 ) {
     // Track updated entities to prevent redundant updates, as `Commands` changes are deferred,
     // and updates done for changed_children_query can overlap with itself or with root_node_query
@@ -131,7 +125,7 @@ pub fn update_target_camera_system(
             root_node,
             target_camera,
             &node_query,
-            &ui_children,
+            &ui_tree,
             &mut commands,
             &mut updated_entities,
         );
@@ -141,7 +135,7 @@ pub fn update_target_camera_system(
     // by this point, and iteration will be skipped.
     // Otherwise, update changed children
     for (parent, target_camera) in &node_query {
-        if !ui_children.children_is_changed(parent) {
+        if !ui_tree.children_is_changed(parent) {
             continue;
         }
 
@@ -149,7 +143,7 @@ pub fn update_target_camera_system(
             parent,
             target_camera,
             &node_query,
-            &ui_children,
+            &ui_tree,
             &mut commands,
             &mut updated_entities,
         );
@@ -160,11 +154,11 @@ fn update_children_target_camera(
     entity: Entity,
     camera_to_set: Option<&TargetCamera>,
     node_query: &Query<(Entity, Option<&TargetCamera>), With<Node>>,
-    ui_children: &UiChildren,
+    ui_tree: &UiTree,
     commands: &mut Commands,
     updated_entities: &mut HashSet<Entity>,
 ) {
-    for child in ui_children.iter_children(entity) {
+    for child in ui_tree.iter_children(entity) {
         // Skip if the child has already been updated or update is not needed
         if updated_entities.contains(&child)
             || camera_to_set == node_query.get(child).ok().and_then(|(_, camera)| camera)
@@ -186,7 +180,7 @@ fn update_children_target_camera(
             child,
             camera_to_set,
             node_query,
-            ui_children,
+            ui_tree,
             commands,
             updated_entities,
         );

From 9b70916198540c3ed20e03694ac223f916ed2d05 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 14 Oct 2024 19:15:19 +0200
Subject: [PATCH 07/18] Add root_ancestor

---
 crates/bevy_ui/src/ui_tree.rs | 47 ++++++++++++++++++++++++++++++++---
 1 file changed, 43 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ui/src/ui_tree.rs b/crates/bevy_ui/src/ui_tree.rs
index ec203c23e2bf3..2ae65219eb769 100644
--- a/crates/bevy_ui/src/ui_tree.rs
+++ b/crates/bevy_ui/src/ui_tree.rs
@@ -53,7 +53,7 @@ pub struct UiTree<'w, 's> {
     changed_children_query: Query<'w, 's, Entity, Changed<Children>>,
     children_query: Query<'w, 's, &'static Children>,
     ghost_nodes_query: Query<'w, 's, Entity, With<GhostNode>>,
-    parents_query: Query<'w, 's, &'static Parent>,
+    parents_query: Query<'w, 's, &'static Parent, Or<(With<Node>, With<GhostNode>)>>,
 }
 
 impl<'w, 's> UiTree<'w, 's> {
@@ -76,13 +76,24 @@ impl<'w, 's> UiTree<'w, 's> {
         }
     }
 
-    /// Returns the UI parent of the provided entity, skipping over [`GhostNode`].
+    /// Returns the [`Node`] parent of the provided entity, skipping over [`GhostNode`].
     pub fn parent(&'s self, entity: Entity) -> Option<Entity> {
         self.parents_query
             .iter_ancestors(entity)
             .find(|entity| !self.ghost_nodes_query.contains(*entity))
     }
 
+    /// Returns the topmost [`Node`] ancestor of the given `entity`.
+    ///
+    /// This may be the entity itself if it has no parent or if it isn't part of a UI tree.
+    pub fn root_ancestor(&'s self, entity: Entity) -> Entity {
+        // Recursively search up the tree until we're out of parents
+        match self.parent(entity) {
+            Some(parent) => self.root_ancestor(parent),
+            None => entity,
+        }
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(
@@ -212,10 +223,38 @@ mod tests {
         world.entity_mut(n9).add_children(&[n10]);
 
         let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
-        let (ui_children, a_query) = system_state.get(world);
+        let (ui_tree, a_query) = system_state.get(world);
 
-        let result: Vec<_> = a_query.iter_many(ui_children.iter_children(n1)).collect();
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_children(n1)).collect();
 
         assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
     }
+
+    #[test]
+    fn root_ancestor() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), NodeBundle::default())).id();
+        let n2 = world.spawn((A(2), GhostNode)).id();
+        let n3 = world.spawn((A(3), GhostNode)).id();
+        let n4 = world.spawn((A(4), NodeBundle::default())).id();
+
+        let n6 = world.spawn((A(6), GhostNode)).id();
+        let n7 = world.spawn((A(7), GhostNode)).id();
+        let n8 = world.spawn((A(8), NodeBundle::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n3).add_children(&[n4]);
+
+        world.entity_mut(n6).add_children(&[n7]);
+        world.entity_mut(n7).add_children(&[n8]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n1)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n2)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n4)).unwrap());
+        assert_eq!(&A(8), a_query.get(ui_tree.root_ancestor(n8)).unwrap());
+    }
 }

From 2b8111600f693a24143ecdc03bcaeb02f299af6b Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 15 Oct 2024 11:34:54 +0200
Subject: [PATCH 08/18] Add iter_ancestors

---
 crates/bevy_ui/src/ui_tree.rs | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/ui_tree.rs b/crates/bevy_ui/src/ui_tree.rs
index 2ae65219eb769..7d0664b6681d0 100644
--- a/crates/bevy_ui/src/ui_tree.rs
+++ b/crates/bevy_ui/src/ui_tree.rs
@@ -94,6 +94,15 @@ impl<'w, 's> UiTree<'w, 's> {
         }
     }
 
+    /// Returns an [`Iterator`] of [`Node`] entities over all `entity`s ancestors within the current UI tree.
+    ///
+    /// Does not include the entity itself.
+    pub fn iter_ancestors(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.parents_query
+            .iter_ancestors(entity)
+            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(
@@ -231,13 +240,14 @@ mod tests {
     }
 
     #[test]
-    fn root_ancestor() {
+    fn ancestors() {
         let world = &mut World::new();
 
         let n1 = world.spawn((A(1), NodeBundle::default())).id();
         let n2 = world.spawn((A(2), GhostNode)).id();
         let n3 = world.spawn((A(3), GhostNode)).id();
         let n4 = world.spawn((A(4), NodeBundle::default())).id();
+        let n5 = world.spawn((A(5), NodeBundle::default())).id();
 
         let n6 = world.spawn((A(6), GhostNode)).id();
         let n7 = world.spawn((A(7), GhostNode)).id();
@@ -245,6 +255,7 @@ mod tests {
 
         world.entity_mut(n1).add_children(&[n2, n3]);
         world.entity_mut(n3).add_children(&[n4]);
+        world.entity_mut(n4).add_children(&[n5]);
 
         world.entity_mut(n6).add_children(&[n7]);
         world.entity_mut(n7).add_children(&[n8]);
@@ -255,6 +266,25 @@ mod tests {
         assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n1)).unwrap());
         assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n2)).unwrap());
         assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n4)).unwrap());
+        assert_eq!(&A(1), a_query.get(ui_tree.root_ancestor(n5)).unwrap());
         assert_eq!(&A(8), a_query.get(ui_tree.root_ancestor(n8)).unwrap());
+
+        assert_eq!(
+            [&A(1)],
+            a_query
+                .iter_many(ui_tree.iter_ancestors(n4))
+                .collect::<Vec<_>>()
+                .as_slice()
+        );
+
+        assert_eq!(
+            [&A(4), &A(1)],
+            a_query
+                .iter_many(ui_tree.iter_ancestors(n5))
+                .collect::<Vec<_>>()
+                .as_slice()
+        );
+
+        assert!(ui_tree.iter_ancestors(n8).next().is_none());
     }
 }

From f092d6ce85169fd1c8ffb9d3cd248e572da716da Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 15 Oct 2024 20:02:30 +0200
Subject: [PATCH 09/18] Add iter_descendants and iter_descendants_depth_first

---
 crates/bevy_ui/src/ui_tree.rs | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/ui_tree.rs b/crates/bevy_ui/src/ui_tree.rs
index 7d0664b6681d0..d0e37e8265f04 100644
--- a/crates/bevy_ui/src/ui_tree.rs
+++ b/crates/bevy_ui/src/ui_tree.rs
@@ -51,8 +51,8 @@ pub struct UiTree<'w, 's> {
         Or<(With<Node>, With<GhostNode>)>,
     >,
     changed_children_query: Query<'w, 's, Entity, Changed<Children>>,
-    children_query: Query<'w, 's, &'static Children>,
     ghost_nodes_query: Query<'w, 's, Entity, With<GhostNode>>,
+    children_query: Query<'w, 's, &'static Children, Or<(With<Node>, With<GhostNode>)>>,
     parents_query: Query<'w, 's, &'static Parent, Or<(With<Node>, With<GhostNode>)>>,
 }
 
@@ -103,6 +103,27 @@ impl<'w, 's> UiTree<'w, 's> {
             .filter(|entity| !self.ghost_nodes_query.contains(*entity))
     }
 
+    /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
+    ///
+    /// Traverses the hierarchy breadth-first and does not include the entity itself.
+    pub fn iter_descendants(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.children_query
+            .iter_descendants(entity)
+            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+    }
+
+    /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
+    ///
+    /// Traverses the hierarchy depth-first and does not include the entity itself.
+    pub fn iter_descendants_depth_first(
+        &'s self,
+        entity: Entity,
+    ) -> impl Iterator<Item = Entity> + 's {
+        self.children_query
+            .iter_descendants_depth_first(entity)
+            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(
@@ -221,6 +242,7 @@ mod tests {
         let n8 = world.spawn((A(8), NodeBundle::default())).id();
         let n9 = world.spawn((A(9), GhostNode)).id();
         let n10 = world.spawn((A(10), NodeBundle::default())).id();
+        let n11 = world.spawn((A(11), NodeBundle::default())).id();
 
         let no_ui = world.spawn_empty().id();
 
@@ -230,13 +252,21 @@ mod tests {
         world.entity_mut(n6).add_children(&[n7, no_ui, n9]);
         world.entity_mut(n7).add_children(&[n8]);
         world.entity_mut(n9).add_children(&[n10]);
+        world.entity_mut(n10).add_children(&[n11]);
 
         let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
         let (ui_tree, a_query) = system_state.get(world);
 
         let result: Vec<_> = a_query.iter_many(ui_tree.iter_children(n1)).collect();
-
         assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_descendants(n1)).collect();
+        assert_eq!([&A(4), &A(5), &A(8), &A(10), &A(11)], result.as_slice());
+
+        let result: Vec<_> = a_query
+            .iter_many(ui_tree.iter_descendants_depth_first(n1))
+            .collect();
+        assert_eq!([&A(5), &A(4), &A(8), &A(10), &A(11)], result.as_slice());
     }
 
     #[test]

From bba3e095ac89d6c28579e9d60c7278a7d1e20b75 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Mon, 21 Oct 2024 18:59:19 +0200
Subject: [PATCH 10/18] Add iter_leaves stub

---
 crates/bevy_ui/src/ui_tree.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/crates/bevy_ui/src/ui_tree.rs b/crates/bevy_ui/src/ui_tree.rs
index d0e37e8265f04..70b641ad54826 100644
--- a/crates/bevy_ui/src/ui_tree.rs
+++ b/crates/bevy_ui/src/ui_tree.rs
@@ -124,6 +124,25 @@ impl<'w, 's> UiTree<'w, 's> {
             .filter(|entity| !self.ghost_nodes_query.contains(*entity))
     }
 
+    /// Returns an [`Iterator`] of [`Node`] entities over the leaves of the UI tree underneath this `entity`.
+    ///
+    /// Only entities which have no [`Node`] descendants are considered leaves.
+    /// This will not include the entity itself, and will not include any entities which are not descendants of the entity,
+    /// even if they are leaves in the same hierarchical tree.
+    ///
+    /// Traverses the hierarchy depth-first.
+    pub fn iter_leaves(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.iter_descendants_depth_first(entity).filter(|entity| {
+            // FIXME: This will not include Nodes with only GhostNode descendants
+            self.children_query
+                .get(*entity)
+                // These are leaf nodes if they have the `Children` component but it's empty
+                .map(|children| children.is_empty())
+                // Or if they don't have the `Children` component at all
+                .unwrap_or(true)
+        })
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(

From 303ad8f41993255c63febc00978ad8451e7a8a2b Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 22 Oct 2024 12:18:33 +0200
Subject: [PATCH 11/18] Fix iter_leaves implementation and add test

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 79 +++++++++++++++++++---
 1 file changed, 70 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index bee4a081bb5ba..26958e66cd52a 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -153,15 +153,16 @@ impl<'w, 's> UiTree<'w, 's> {
     ///
     /// Traverses the hierarchy depth-first.
     pub fn iter_leaves(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
-        self.iter_descendants_depth_first(entity).filter(|entity| {
-            // FIXME: This will not include Nodes with only GhostNode descendants
-            self.children_query
-                .get(*entity)
-                // These are leaf nodes if they have the `Children` component but it's empty
-                .map(|children| children.is_empty())
-                // Or if they don't have the `Children` component at all
-                .unwrap_or(true)
-        })
+        UiLeavesIter {
+            stack: self
+                .ui_children_query
+                .get(entity)
+                .map_or(SmallVec::new(), |(children, _)| {
+                    children.into_iter().flatten().rev().copied().collect()
+                }),
+            query: &self.ui_children_query,
+            potential_leaf: None,
+        }
     }
 
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
@@ -221,6 +222,43 @@ impl<'w, 's> Iterator for UiChildrenIter<'w, 's> {
     }
 }
 
+pub struct UiLeavesIter<'w, 's> {
+    stack: SmallVec<[Entity; 8]>,
+    query: &'s Query<
+        'w,
+        's,
+        (Option<&'static Children>, Has<GhostNode>),
+        Or<(With<Node>, With<GhostNode>)>,
+    >,
+    potential_leaf: Option<(usize, Entity)>,
+}
+
+impl<'w, 's> Iterator for UiLeavesIter<'w, 's> {
+    type Item = Entity;
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if let Some((stack_length, node_entity)) = self.potential_leaf {
+                if stack_length == self.stack.len() {
+                    // Confirmed leaf Node since no entities below it were Nodes
+                    self.potential_leaf = None;
+                    return Some(node_entity);
+                }
+            }
+
+            let entity = self.stack.pop()?;
+            if let Ok((children, has_ghost_node)) = self.query.get(entity) {
+                if !has_ghost_node {
+                    // This is a Node, store as potential leaf and continue traversing.
+                    self.potential_leaf = Some((self.stack.len(), entity));
+                }
+                if let Some(children) = children {
+                    self.stack.extend(children.iter().rev().copied());
+                }
+            }
+        }
+    }
+}
+
 #[cfg(all(test, feature = "ghost_nodes"))]
 mod tests {
     use bevy_ecs::{
@@ -358,4 +396,27 @@ mod tests {
 
         assert!(ui_tree.iter_ancestors(n8).next().is_none());
     }
+
+    #[test]
+    fn iter_leaves() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+        let n6 = world.spawn((A(6), GhostNode::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n2).add_children(&[n4]);
+        world.entity_mut(n3).add_children(&[n5]);
+        world.entity_mut(n5).add_children(&[n6]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_leaves(n1)).collect();
+        assert_eq!([&A(4), &A(5)], result.as_slice());
+    }
 }

From 09ea2da66305b09366d75919673a2c32bab613f8 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 22 Oct 2024 23:16:42 +0200
Subject: [PATCH 12/18] Add iter_siblings

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 30 ++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 26958e66cd52a..17d3059c2407e 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -165,6 +165,16 @@ impl<'w, 's> UiTree<'w, 's> {
         }
     }
 
+    /// Returns an [`Iterator`] of [`Node`] entities over the `entity`s immediate siblings, who share the same first [`Node`] ancestor within the UI tree.
+    ///
+    /// The entity itself is not included in the iterator.
+    pub fn iter_siblings(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
+        self.parent(entity).into_iter().flat_map(move |parent| {
+            self.iter_children(parent)
+                .filter(move |child| *child != entity)
+        })
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(
@@ -419,4 +429,24 @@ mod tests {
         let result: Vec<_> = a_query.iter_many(ui_tree.iter_leaves(n1)).collect();
         assert_eq!([&A(4), &A(5)], result.as_slice());
     }
+
+    #[test]
+    fn iter_siblings() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+        let n4 = world.spawn((A(4), Node::default())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n2).add_children(&[n4, n5]);
+
+        let mut system_state = SystemState::<(UiTree, Query<&A>)>::new(world);
+        let (ui_tree, a_query) = system_state.get(world);
+
+        let result: Vec<_> = a_query.iter_many(ui_tree.iter_siblings(n5)).collect();
+        assert_eq!([&A(4), &A(3)], result.as_slice());
+    }
 }

From e86cff022bdbc1a122a98789d7abe3e9d7656846 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 22 Oct 2024 23:26:57 +0200
Subject: [PATCH 13/18] Add is_root

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 17d3059c2407e..8ae01337d18f3 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -191,7 +191,7 @@ impl<'w, 's> UiTree<'w, 's> {
         )
     }
 
-    /// Given an entity in the UI hierarchy, check if its set of children has changed, e.g if children has been added/removed or if the order has changed.
+    /// Given an entity in the UI tree, check if its parent has changed, e.g if children has been added/removed or if the order has changed.
     pub fn children_is_changed(&'s self, entity: Entity) -> bool {
         self.changed_children_query.contains(entity)
             || self
@@ -203,6 +203,15 @@ impl<'w, 's> UiTree<'w, 's> {
     pub fn is_ui_entity(&'s self, entity: Entity) -> bool {
         self.ui_children_query.contains(entity)
     }
+
+    /// Returns `true` if the given entity is a root in the UI tree.
+    ///
+    /// A [`Node`] is a root node if it has no parent, or if all ancestors are ghost nodes.
+    ///
+    /// A [`GhostNode`] is a root node if it has no parent.
+    pub fn is_root(&'s self, entity: Entity) -> bool {
+        self.parent(entity).is_none()
+    }
 }
 
 pub struct UiChildrenIter<'w, 's> {

From dc0e700288ec7f25981e14bd3f4af01eb9a494b3 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Tue, 22 Oct 2024 23:56:32 +0200
Subject: [PATCH 14/18] Add is_leaf and is_root_or_leaf testcase

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 54 +++++++++++++++++++++-
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 8ae01337d18f3..30af7b8d15488 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -72,6 +72,7 @@ pub struct UiTree<'w, 's> {
         Or<(With<Node>, With<GhostNode>)>,
     >,
     changed_children_query: Query<'w, 's, Entity, Changed<Children>>,
+    nodes_query: Query<'w, 's, Entity, With<Node>>,
     ghost_nodes_query: Query<'w, 's, Entity, With<GhostNode>>,
     children_query: Query<'w, 's, &'static Children, Or<(With<Node>, With<GhostNode>)>>,
     parents_query: Query<'w, 's, &'static Parent, Or<(With<Node>, With<GhostNode>)>>,
@@ -206,12 +207,31 @@ impl<'w, 's> UiTree<'w, 's> {
 
     /// Returns `true` if the given entity is a root in the UI tree.
     ///
-    /// A [`Node`] is a root node if it has no parent, or if all ancestors are ghost nodes.
+    /// A [`Node`] is a root if it has no parent, or if all ancestors are ghost nodes.
     ///
-    /// A [`GhostNode`] is a root node if it has no parent.
+    /// A [`GhostNode`] is a root if it has no parent.
     pub fn is_root(&'s self, entity: Entity) -> bool {
         self.parent(entity).is_none()
     }
+
+    /// Returns `true` if the given entity is a leaf in the UI tree.
+    ///
+    /// A [`Node`] is a leaf if it has no [`Node`] descendants.
+    ///
+    /// A [`GhostNode`] is a leaf if it has no [`Node`] or [`GhostNode`] children.
+    pub fn is_leaf(&'s self, entity: Entity) -> bool {
+        if self.ghost_nodes_query.contains(entity) {
+            if let Ok(children) = self.children_query.get(entity) {
+                !children.iter().any(|child| {
+                    self.ghost_nodes_query.contains(*child) || self.nodes_query.contains(*child)
+                })
+            } else {
+                true
+            }
+        } else {
+            self.iter_descendants(entity).next().is_none()
+        }
+    }
 }
 
 pub struct UiChildrenIter<'w, 's> {
@@ -458,4 +478,34 @@ mod tests {
         let result: Vec<_> = a_query.iter_many(ui_tree.iter_siblings(n5)).collect();
         assert_eq!([&A(4), &A(3)], result.as_slice());
     }
+
+    #[test]
+    fn is_root_or_leaf() {
+        let world = &mut World::new();
+
+        let n1 = world.spawn((A(1), Node::default())).id();
+        let n2 = world.spawn((A(2), GhostNode::new())).id();
+        let n3 = world.spawn((A(3), Node::default())).id();
+
+        let n4 = world.spawn((A(4), GhostNode::new())).id();
+        let n5 = world.spawn((A(5), Node::default())).id();
+
+        world.entity_mut(n1).add_children(&[n2, n3]);
+        world.entity_mut(n4).add_children(&[n5]);
+
+        let mut system_state = SystemState::<UiTree>::new(world);
+        let ui_tree = system_state.get(world);
+
+        assert_eq!(true, ui_tree.is_root(n1));
+        assert_eq!(false, ui_tree.is_root(n2));
+        assert_eq!(false, ui_tree.is_root(n3));
+        assert_eq!(true, ui_tree.is_root(n4));
+        assert_eq!(true, ui_tree.is_root(n5));
+
+        assert_eq!(false, ui_tree.is_leaf(n1));
+        assert_eq!(true, ui_tree.is_leaf(n2));
+        assert_eq!(true, ui_tree.is_leaf(n3));
+        assert_eq!(false, ui_tree.is_leaf(n4));
+        assert_eq!(true, ui_tree.is_leaf(n5));
+    }
 }

From 0e2f1c4203db9195152a30edf4230ef2e07bdc5b Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Wed, 23 Oct 2024 00:00:27 +0200
Subject: [PATCH 15/18] Use nodes_query instead of ghost_nodes_query where
 applicable

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

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 30af7b8d15488..2dc12a1ee14d7 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -102,7 +102,7 @@ impl<'w, 's> UiTree<'w, 's> {
     pub fn parent(&'s self, entity: Entity) -> Option<Entity> {
         self.parents_query
             .iter_ancestors(entity)
-            .find(|entity| !self.ghost_nodes_query.contains(*entity))
+            .find(|entity| self.nodes_query.contains(*entity))
     }
 
     /// Returns the topmost [`Node`] ancestor of the given `entity`.
@@ -122,7 +122,7 @@ impl<'w, 's> UiTree<'w, 's> {
     pub fn iter_ancestors(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
         self.parents_query
             .iter_ancestors(entity)
-            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+            .filter(|entity| self.nodes_query.contains(*entity))
     }
 
     /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
@@ -131,7 +131,7 @@ impl<'w, 's> UiTree<'w, 's> {
     pub fn iter_descendants(&'s self, entity: Entity) -> impl Iterator<Item = Entity> + 's {
         self.children_query
             .iter_descendants(entity)
-            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+            .filter(|entity| self.nodes_query.contains(*entity))
     }
 
     /// Returns an [`Iterator`] of [`Node`] entities over all of `entity`s descendants within the current UI tree.
@@ -143,7 +143,7 @@ impl<'w, 's> UiTree<'w, 's> {
     ) -> impl Iterator<Item = Entity> + 's {
         self.children_query
             .iter_descendants_depth_first(entity)
-            .filter(|entity| !self.ghost_nodes_query.contains(*entity))
+            .filter(|entity| self.nodes_query.contains(*entity))
     }
 
     /// Returns an [`Iterator`] of [`Node`] entities over the leaves of the UI tree underneath this `entity`.

From e9b647f62e009c217aff746866950b170d8f21d4 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Wed, 23 Oct 2024 00:09:39 +0200
Subject: [PATCH 16/18] Add child_index

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 2dc12a1ee14d7..79f41cbaf84e0 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -176,6 +176,12 @@ impl<'w, 's> UiTree<'w, 's> {
         })
     }
 
+    /// Returns the index of a [`Node`] among its siblings, or [`None`] if it does not have a parent.
+    pub fn child_index(&'s self, entity: Entity) -> Option<usize> {
+        self.parent(entity)
+            .and_then(|parent| self.iter_children(parent).position(|child| child == entity))
+    }
+
     /// Iterates the [`GhostNode`]s between this entity and its UI children.
     pub fn iter_ghost_nodes(&'s self, entity: Entity) -> Box<dyn Iterator<Item = Entity> + 's> {
         Box::new(
@@ -378,6 +384,12 @@ mod tests {
         let result: Vec<_> = a_query.iter_many(ui_tree.iter_children(n1)).collect();
         assert_eq!([&A(5), &A(4), &A(8), &A(10)], result.as_slice());
 
+        assert_eq!(None, ui_tree.child_index(n1));
+        assert_eq!(Some(0), ui_tree.child_index(n5));
+        assert_eq!(Some(1), ui_tree.child_index(n4));
+        assert_eq!(Some(2), ui_tree.child_index(n8));
+        assert_eq!(Some(3), ui_tree.child_index(n10));
+
         let result: Vec<_> = a_query.iter_many(ui_tree.iter_descendants(n1)).collect();
         assert_eq!([&A(4), &A(5), &A(8), &A(10), &A(11)], result.as_slice());
 

From 9ddb2c725c414a1e7e3b307739523741313da87b Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Wed, 23 Oct 2024 00:12:14 +0200
Subject: [PATCH 17/18] Fix bad doc comment

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

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 79f41cbaf84e0..30fc45d501aa0 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -198,7 +198,7 @@ impl<'w, 's> UiTree<'w, 's> {
         )
     }
 
-    /// Given an entity in the UI tree, check if its parent has changed, e.g if children has been added/removed or if the order has changed.
+    /// Given an entity in the UI tree, check if its children has changed, e.g if children has been added/removed or if the order has changed.
     pub fn children_is_changed(&'s self, entity: Entity) -> bool {
         self.changed_children_query.contains(entity)
             || self

From a89ee94cd6426efc3cf6ac3024acbbfa96639a13 Mon Sep 17 00:00:00 2001
From: Viktor Gustavsson <villor94@gmail.com>
Date: Wed, 23 Oct 2024 00:43:59 +0200
Subject: [PATCH 18/18] assert_eq w. literal bool -> assert

---
 crates/bevy_ui/src/experimental/ui_tree.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ui/src/experimental/ui_tree.rs b/crates/bevy_ui/src/experimental/ui_tree.rs
index 30fc45d501aa0..06f325834161c 100644
--- a/crates/bevy_ui/src/experimental/ui_tree.rs
+++ b/crates/bevy_ui/src/experimental/ui_tree.rs
@@ -508,16 +508,16 @@ mod tests {
         let mut system_state = SystemState::<UiTree>::new(world);
         let ui_tree = system_state.get(world);
 
-        assert_eq!(true, ui_tree.is_root(n1));
-        assert_eq!(false, ui_tree.is_root(n2));
-        assert_eq!(false, ui_tree.is_root(n3));
-        assert_eq!(true, ui_tree.is_root(n4));
-        assert_eq!(true, ui_tree.is_root(n5));
-
-        assert_eq!(false, ui_tree.is_leaf(n1));
-        assert_eq!(true, ui_tree.is_leaf(n2));
-        assert_eq!(true, ui_tree.is_leaf(n3));
-        assert_eq!(false, ui_tree.is_leaf(n4));
-        assert_eq!(true, ui_tree.is_leaf(n5));
+        assert!(ui_tree.is_root(n1));
+        assert!(!ui_tree.is_root(n2));
+        assert!(!ui_tree.is_root(n3));
+        assert!(ui_tree.is_root(n4));
+        assert!(ui_tree.is_root(n5));
+
+        assert!(!ui_tree.is_leaf(n1));
+        assert!(ui_tree.is_leaf(n2));
+        assert!(ui_tree.is_leaf(n3));
+        assert!(!ui_tree.is_leaf(n4));
+        assert!(ui_tree.is_leaf(n5));
     }
 }