From 9abf5b4fbbb5eee8fb385c308a9c2cf29caa0d55 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Wed, 8 Nov 2023 23:39:33 +0100
Subject: [PATCH 01/36] Update split_screen example; replace `window_roots`
 with `camera_roots`

---
 crates/bevy_render/src/camera/camera.rs |  5 ++
 crates/bevy_ui/src/layout/debug.rs      |  4 +-
 crates/bevy_ui/src/layout/mod.rs        | 63 ++++++++++++------
 crates/bevy_ui/src/ui_node.rs           |  5 +-
 examples/3d/split_screen.rs             | 88 +++++++++++++++++++------
 5 files changed, 121 insertions(+), 44 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index be6349689b7cb..9994e9f15ab5c 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -219,6 +219,11 @@ impl Camera {
         self.computed.target_info.as_ref().map(|t| t.physical_size)
     }
 
+    #[inline]
+    pub fn target_scaling_factor(&self) -> Option<f64> {
+        self.computed.target_info.as_ref().map(|t| t.scale_factor)
+    }
+
     /// The projection matrix computed using this camera's [`CameraProjection`].
     #[inline]
     pub fn projection_matrix(&self) -> Mat4 {
diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index c47b2ca8e802b..37fb5c2b88845 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();
-    for (&entity, roots) in &ui_surface.window_roots {
+    for (&entity, roots) in &ui_surface.camera_roots {
         let mut out = String::new();
         for root in roots {
             print_node(
@@ -25,7 +25,7 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
                 &mut out,
             );
         }
-        bevy_log::info!("Layout tree for window entity: {entity:?}\n{out}");
+        bevy_log::info!("Layout tree for camera entity: {entity:?}\n{out}");
     }
 }
 
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index d404431b1bf26..2fe305ded5b8e 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, Outline, Style, UiScale};
+use crate::{ContentSize, Node, Outline, Style, UiCamera, UiScale};
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
     entity::Entity,
@@ -13,7 +13,8 @@ use bevy_ecs::{
 };
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
-use bevy_math::Vec2;
+use bevy_math::{UVec2, Vec2};
+use bevy_render::camera::Camera;
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
@@ -51,7 +52,7 @@ struct RootNodePair {
 #[derive(Resource)]
 pub struct UiSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    window_roots: HashMap<Entity, Vec<RootNodePair>>,
+    camera_roots: HashMap<Entity, Vec<RootNodePair>>,
     taffy: Taffy,
 }
 
@@ -66,7 +67,7 @@ impl fmt::Debug for UiSurface {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("UiSurface")
             .field("entity_to_taffy", &self.entity_to_taffy)
-            .field("window_nodes", &self.window_roots)
+            .field("camera_roots", &self.camera_roots)
             .finish()
     }
 }
@@ -77,7 +78,7 @@ impl Default for UiSurface {
         taffy.disable_rounding();
         Self {
             entity_to_taffy: Default::default(),
-            window_roots: Default::default(),
+            camera_roots: Default::default(),
             taffy,
         }
     }
@@ -142,9 +143,9 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Set the ui node entities without a [`Parent`] as children to the root node in the taffy layout.
-    pub fn set_window_children(
+    pub fn set_camera_children(
         &mut self,
-        window_id: Entity,
+        camera_id: Entity,
         children: impl Iterator<Item = Entity>,
     ) {
         let viewport_style = taffy::style::Style {
@@ -160,7 +161,7 @@ without UI components as a child of an entity with UI components, results may be
             ..default()
         };
 
-        let existing_roots = self.window_roots.entry(window_id).or_default();
+        let existing_roots = self.camera_roots.entry(camera_id).or_default();
         let mut new_roots = Vec::new();
         for entity in children {
             let node = *self.entity_to_taffy.get(&entity).unwrap();
@@ -185,18 +186,20 @@ without UI components as a child of an entity with UI components, results may be
             }
         }
 
-        self.window_roots.insert(window_id, new_roots);
+        self.camera_roots.insert(camera_id, new_roots);
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.
-    pub fn compute_window_layout(&mut self, window: Entity, window_resolution: &WindowResolution) {
+    pub fn compute_camera_layout(&mut self, camera: Entity, render_target_resolution: UVec2) {
+        let Some(camera_root_nodes) = self.camera_roots.get(&camera) else {
+            return;
+        };
+
         let available_space = taffy::geometry::Size {
-            width: taffy::style::AvailableSpace::Definite(window_resolution.physical_width() as f32),
-            height: taffy::style::AvailableSpace::Definite(
-                window_resolution.physical_height() as f32
-            ),
+            width: taffy::style::AvailableSpace::Definite(render_target_resolution.x as f32),
+            height: taffy::style::AvailableSpace::Definite(render_target_resolution.y as f32),
         };
-        for root_nodes in self.window_roots.entry(window).or_default() {
+        for root_nodes in camera_root_nodes {
             self.taffy
                 .compute_layout(root_nodes.implicit_viewport_node, available_space)
                 .unwrap();
@@ -242,11 +245,12 @@ pub enum LayoutError {
 pub fn ui_layout_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     windows: Query<(Entity, &Window)>,
+    cameras: Query<(Entity, &Camera)>,
     ui_scale: Res<UiScale>,
     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>)>,
+    root_node_query: Query<(Entity, Option<&UiCamera>), (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>>,
@@ -276,6 +280,7 @@ pub fn ui_layout_system(
         .read()
         .any(|resized_window| resized_window.window == primary_window_entity);
 
+    // TODO: Use camera target_scaling_factor instead
     let scale_factor = logical_to_physical_factor * ui_scale.0;
 
     let layout_context = LayoutContext::new(scale_factor, physical_size);
@@ -309,7 +314,23 @@ pub fn ui_layout_system(
     ui_surface.remove_entities(removed_nodes.read());
 
     // 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());
+    // TODO: default camera to a primary one somehow
+    let root_nodes_defaulted = root_node_query
+        .iter()
+        .filter_map(|(entity, camera)| camera.map(|c| (entity, c)));
+
+    let mut root_nodes_grouped_by_camera: HashMap<Entity, Vec<Entity>> = HashMap::new();
+
+    for (entity, camera) in root_nodes_defaulted {
+        root_nodes_grouped_by_camera
+            .entry(camera.0)
+            .or_insert_with(Vec::new)
+            .push(entity);
+    }
+
+    for (camera_id, group) in &root_nodes_grouped_by_camera {
+        ui_surface.set_camera_children(*camera_id, group.into_iter().cloned());
+    }
 
     // update and remove children
     for entity in removed_children.read() {
@@ -322,8 +343,10 @@ pub fn ui_layout_system(
     }
 
     // compute layouts
-    for (entity, window) in windows.iter() {
-        ui_surface.compute_window_layout(entity, &window.resolution);
+    for (entity, camera) in cameras.iter() {
+        if let Some(rect) = camera.physical_viewport_rect() {
+            ui_surface.compute_camera_layout(entity, rect.size());
+        }
     }
 
     let inverse_target_scale_factor = 1. / scale_factor;
@@ -376,7 +399,7 @@ pub fn ui_layout_system(
         }
     }
 
-    for entity in root_node_query.iter() {
+    for (entity, _camera) in root_node_query.iter() {
         update_uinode_geometry_recursive(
             entity,
             &ui_surface,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index a02308566b446..7f5e95f36fefb 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,6 +1,6 @@
 use crate::{UiRect, Val};
 use bevy_asset::Handle;
-use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
+use bevy_ecs::{entity::Entity, prelude::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
 use bevy_reflect::prelude::*;
 use bevy_render::{color::Color, texture::Image};
@@ -1713,3 +1713,6 @@ mod tests {
         assert_eq!(GridPlacement::end_span(-4, 12).get_start(), None);
     }
 }
+
+#[derive(Component, Clone, Debug, Reflect)]
+pub struct UiCamera(pub Entity);
diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 1a0f215d6464f..39aea7eee9f92 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -4,7 +4,7 @@ use std::f32::consts::PI;
 
 use bevy::{
     core_pipeline::clear_color::ClearColorConfig, pbr::CascadeShadowConfigBuilder, prelude::*,
-    render::camera::Viewport, window::WindowResized,
+    render::camera::Viewport, ui::prelude::*, window::WindowResized,
 };
 
 fn main() {
@@ -52,32 +52,78 @@ fn setup(
     });
 
     // Left Camera
-    commands.spawn((
-        Camera3dBundle {
-            transform: Transform::from_xyz(0.0, 200.0, -100.0).looking_at(Vec3::ZERO, Vec3::Y),
-            ..default()
-        },
-        LeftCamera,
-    ));
+    let left_camera = commands
+        .spawn((
+            Camera3dBundle {
+                transform: Transform::from_xyz(0.0, 200.0, -100.0).looking_at(Vec3::ZERO, Vec3::Y),
+                ..default()
+            },
+            LeftCamera,
+        ))
+        .id();
 
     // Right Camera
-    commands.spawn((
-        Camera3dBundle {
-            transform: Transform::from_xyz(100.0, 100., 150.0).looking_at(Vec3::ZERO, Vec3::Y),
-            camera: Camera {
-                // Renders the right camera after the left camera, which has a default priority of 0
-                order: 1,
+    let right_camera = commands
+        .spawn((
+            Camera3dBundle {
+                transform: Transform::from_xyz(100.0, 100., 150.0).looking_at(Vec3::ZERO, Vec3::Y),
+                camera: Camera {
+                    // Renders the right camera after the left camera, which has a default priority of 0
+                    order: 1,
+                    ..default()
+                },
+                camera_3d: Camera3d {
+                    // don't clear on the second camera because the first camera already cleared the window
+                    clear_color: ClearColorConfig::None,
+                    ..default()
+                },
                 ..default()
             },
-            camera_3d: Camera3d {
-                // don't clear on the second camera because the first camera already cleared the window
-                clear_color: ClearColorConfig::None,
+            RightCamera,
+        ))
+        .id();
+
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.0),
+                    height: Val::Percent(100.0),
+                    justify_content: JustifyContent::SpaceBetween,
+                    ..default()
+                },
                 ..default()
             },
-            ..default()
-        },
-        RightCamera,
-    ));
+            UiCamera(left_camera),
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                TextBundle::from_section("Left", TextStyle::default()),
+                // TODO: replace with UiCamera propogation system
+                UiCamera(left_camera),
+            ));
+        });
+
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.0),
+                    height: Val::Percent(100.0),
+                    justify_content: JustifyContent::SpaceBetween,
+                    ..default()
+                },
+                ..default()
+            },
+            UiCamera(right_camera),
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                TextBundle::from_section("Right", TextStyle::default()),
+                // TODO: replace with UiCamera propogation system
+                UiCamera(right_camera),
+            ));
+        });
 }
 
 #[derive(Component)]

From 5d86151ce9768d59c77b4d85bb0ccc4ed3c91c8f Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 10 Nov 2023 21:15:30 +0100
Subject: [PATCH 02/36] Ui is painted to both left and right viewports

---
 crates/bevy_ui/src/layout/mod.rs         | 18 +++++++++++++---
 crates/bevy_ui/src/render/mod.rs         | 26 +++++++++++++++++++-----
 crates/bevy_ui/src/render/render_pass.rs |  8 ++++++--
 3 files changed, 42 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 2fe305ded5b8e..c3f248e49de79 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -14,7 +14,7 @@ use bevy_ecs::{
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
-use bevy_render::camera::Camera;
+use bevy_render::camera::{Camera, RenderTarget};
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
 use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
@@ -314,10 +314,22 @@ pub fn ui_layout_system(
     ui_surface.remove_entities(removed_nodes.read());
 
     // update window children (for now assuming all Nodes live in the primary window)
-    // TODO: default camera to a primary one somehow
+
+    let primary_camera = {
+        let default_render_target = RenderTarget::default().normalize(Some(primary_window_entity));
+        cameras.iter().find_map(|(entity, camera)| {
+            if camera.is_active
+                && camera.target.normalize(Some(primary_window_entity)) == default_render_target
+            {
+                Some(UiCamera(entity))
+            } else {
+                None
+            }
+        })
+    };
     let root_nodes_defaulted = root_node_query
         .iter()
-        .filter_map(|(entity, camera)| camera.map(|c| (entity, c)));
+        .filter_map(|(entity, camera)| camera.or(primary_camera.as_ref()).map(|c| (entity, c)));
 
     let mut root_nodes_grouped_by_camera: HashMap<Entity, Vec<Entity>> = HashMap::new();
 
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index f63fd1a0dc36c..7908541f9e817 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -12,11 +12,11 @@ pub use pipeline::*;
 pub use render_pass::*;
 pub use ui_material_pipeline::*;
 
-use crate::Outline;
 use crate::{
     prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
     Style, UiImage, UiScale, UiTextureAtlasImage, Val,
 };
+use crate::{Outline, UiCamera};
 
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, AssetId, Assets, Handle};
@@ -163,6 +163,7 @@ pub struct ExtractedUiNode {
     pub clip: Option<Rect>,
     pub flip_x: bool,
     pub flip_y: bool,
+    pub camera_entity: Entity,
 }
 
 #[derive(Resource, Default)]
@@ -185,6 +186,7 @@ pub fn extract_atlas_uinodes(
                 Option<&CalculatedClip>,
                 &Handle<TextureAtlas>,
                 &UiTextureAtlasImage,
+                &UiCamera,
             ),
             Without<UiImage>,
         >,
@@ -199,6 +201,7 @@ pub fn extract_atlas_uinodes(
         clip,
         texture_atlas_handle,
         atlas_image,
+        camera,
     ) in uinode_query.iter()
     {
         // Skip invisible and completely transparent nodes
@@ -250,6 +253,7 @@ pub fn extract_atlas_uinodes(
                 atlas_size: Some(atlas_size),
                 flip_x: atlas_image.flip_x,
                 flip_y: atlas_image.flip_y,
+                camera_entity: camera.0,
             },
         );
     }
@@ -282,6 +286,7 @@ pub fn extract_uinode_borders(
                 Option<&Parent>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
+                &UiCamera,
             ),
             Without<ContentSize>,
         >,
@@ -298,7 +303,7 @@ pub fn extract_uinode_borders(
         // so we have to divide by `UiScale` to get the size of the UI viewport.
         / ui_scale.0 as f32;
 
-    for (node, global_transform, style, border_color, parent, view_visibility, clip) in
+    for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
         uinode_query.iter()
     {
         // Skip invisible borders
@@ -374,6 +379,7 @@ pub fn extract_uinode_borders(
                         clip: clip.map(|clip| clip.clip),
                         flip_x: false,
                         flip_y: false,
+                        camera_entity: camera.0,
                     },
                 );
             }
@@ -391,12 +397,15 @@ pub fn extract_uinode_outlines(
             &Outline,
             &ViewVisibility,
             Option<&Parent>,
+            &UiCamera,
         )>,
     >,
     clip_query: Query<&CalculatedClip>,
 ) {
     let image = AssetId::<Image>::default();
-    for (node, global_transform, outline, view_visibility, maybe_parent) in uinode_query.iter() {
+    for (node, global_transform, outline, view_visibility, maybe_parent, camera) in
+        uinode_query.iter()
+    {
         // Skip invisible outlines
         if !view_visibility.get()
             || outline.color.is_fully_transparent()
@@ -463,6 +472,7 @@ pub fn extract_uinode_outlines(
                         clip,
                         flip_x: false,
                         flip_y: false,
+                        camera_entity: camera.0,
                     },
                 );
             }
@@ -483,12 +493,13 @@ pub fn extract_uinodes(
                 Option<&UiImage>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
+                &UiCamera,
             ),
             Without<UiTextureAtlasImage>,
         >,
     >,
 ) {
-    for (entity, uinode, transform, color, maybe_image, view_visibility, clip) in
+    for (entity, uinode, transform, color, maybe_image, view_visibility, clip, camera) in
         uinode_query.iter()
     {
         // Skip invisible and completely transparent nodes
@@ -521,6 +532,7 @@ pub fn extract_uinodes(
                 atlas_size: None,
                 flip_x,
                 flip_y,
+                camera_entity: camera.0,
             },
         );
     }
@@ -614,6 +626,7 @@ pub fn extract_text_uinodes(
             &TextLayoutInfo,
             &ViewVisibility,
             Option<&CalculatedClip>,
+            &UiCamera,
         )>,
     >,
 ) {
@@ -626,7 +639,7 @@ pub fn extract_text_uinodes(
 
     let inverse_scale_factor = (scale_factor as f32).recip();
 
-    for (uinode, global_transform, text, text_layout_info, view_visibility, clip) in
+    for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
         // Skip if not visible or if size is set to zero (e.g. when a parent is set to `Display::None`)
@@ -667,6 +680,7 @@ pub fn extract_text_uinodes(
                     clip: clip.map(|clip| clip.clip),
                     flip_x: false,
                     flip_y: false,
+                    camera_entity: camera.0,
                 },
             );
         }
@@ -710,6 +724,7 @@ pub(crate) const QUAD_INDICES: [usize; 6] = [0, 2, 3, 0, 1, 2];
 pub struct UiBatch {
     pub range: Range<u32>,
     pub image: AssetId<Image>,
+    pub camera: Entity,
 }
 
 const TEXTURED_QUAD: u32 = 0;
@@ -818,6 +833,7 @@ pub fn prepare_uinodes(
                             let new_batch = UiBatch {
                                 range: index..index,
                                 image: extracted_uinode.image,
+                                camera: extracted_uinode.camera_entity,
                             };
 
                             batches.push((item.entity, new_batch));
diff --git a/crates/bevy_ui/src/render/render_pass.rs b/crates/bevy_ui/src/render/render_pass.rs
index bde2898534cac..e1ebbdbc934eb 100644
--- a/crates/bevy_ui/src/render/render_pass.rs
+++ b/crates/bevy_ui/src/render/render_pass.rs
@@ -7,6 +7,7 @@ use bevy_ecs::{
     system::{lifetimeless::*, SystemParamItem},
 };
 use bevy_render::{
+    camera::ExtractedCamera,
     render_graph::*,
     render_phase::*,
     render_resource::{CachedRenderPipelineId, LoadOp, Operations, RenderPassDescriptor},
@@ -20,6 +21,7 @@ pub struct UiPassNode {
         (
             &'static RenderPhase<TransparentUi>,
             &'static ViewTarget,
+            &'static ExtractedCamera,
             Option<&'static UiCameraConfig>,
         ),
         With<ExtractedView>,
@@ -50,7 +52,7 @@ impl Node for UiPassNode {
     ) -> Result<(), NodeRunError> {
         let input_view_entity = graph.view_entity();
 
-        let Ok((transparent_phase, target, camera_ui)) =
+        let Ok((transparent_phase, target, camera, camera_ui)) =
             self.ui_view_query.get_manual(world, input_view_entity)
         else {
             return Ok(());
@@ -80,7 +82,9 @@ impl Node for UiPassNode {
             }))],
             depth_stencil_attachment: None,
         });
-
+        if let Some(viewport) = camera.viewport.as_ref() {
+            render_pass.set_camera_viewport(viewport);
+        }
         transparent_phase.render(&mut render_pass, world, view_entity);
 
         Ok(())

From 310cb62e5e0e9b6d915af8bd46c510ec4b88b9de Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 11 Nov 2023 10:26:09 +0100
Subject: [PATCH 03/36] Independent panels rendering

---
 crates/bevy_ui/src/render/mod.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 7908541f9e817..3f4fb08009953 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -735,12 +735,12 @@ pub fn queue_uinodes(
     extracted_uinodes: Res<ExtractedUiNodes>,
     ui_pipeline: Res<UiPipeline>,
     mut pipelines: ResMut<SpecializedRenderPipelines<UiPipeline>>,
-    mut views: Query<(&ExtractedView, &mut RenderPhase<TransparentUi>)>,
+    mut views: Query<(Entity, &ExtractedView, &mut RenderPhase<TransparentUi>)>,
     pipeline_cache: Res<PipelineCache>,
     draw_functions: Res<DrawFunctions<TransparentUi>>,
 ) {
     let draw_function = draw_functions.read().id::<DrawUi>();
-    for (view, mut transparent_phase) in &mut views {
+    for (view_entity, view, mut transparent_phase) in &mut views {
         let pipeline = pipelines.specialize(
             &pipeline_cache,
             &ui_pipeline,
@@ -751,6 +751,9 @@ pub fn queue_uinodes(
             .reserve(extracted_uinodes.uinodes.len());
 
         for (entity, extracted_uinode) in extracted_uinodes.uinodes.iter() {
+            if view_entity != extracted_uinode.camera_entity {
+                continue;
+            }
             transparent_phase.add(TransparentUi {
                 draw_function,
                 pipeline,
@@ -825,6 +828,8 @@ pub fn prepare_uinodes(
                         || (batch_image_handle != AssetId::default()
                             && extracted_uinode.image != AssetId::default()
                             && batch_image_handle != extracted_uinode.image)
+                        || existing_batch.as_ref().map(|(_, b)| b.camera)
+                            != Some(extracted_uinode.camera_entity)
                     {
                         if let Some(gpu_image) = gpu_images.get(extracted_uinode.image) {
                             batch_item_index = item_index;

From bcd8ee7654e81bf523c72d25a6a9b29db492754d Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 11 Nov 2023 16:37:54 +0100
Subject: [PATCH 04/36] Propagate UiCamera to children

---
 crates/bevy_ui/src/lib.rs    |  3 ++-
 crates/bevy_ui/src/update.rs | 35 +++++++++++++++++++++++++++++++++--
 examples/3d/split_screen.rs  | 12 ++----------
 3 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index e72eb5ea777d2..d0c348e16562b 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -54,7 +54,7 @@ use bevy_render::{extract_component::ExtractComponentPlugin, texture::Image, Ren
 use bevy_transform::TransformSystem;
 use stack::ui_stack_system;
 pub use stack::UiStack;
-use update::update_clipping_system;
+use update::{update_clipping_system, update_ui_camera_system};
 
 /// The basic plugin for Bevy UI
 #[derive(Default)]
@@ -185,6 +185,7 @@ impl Plugin for UiPlugin {
                 ui_layout_system
                     .in_set(UiSystem::Layout)
                     .before(TransformSystem::TransformPropagate),
+                update_ui_camera_system.in_set(UiSystem::Layout),
                 resolve_outlines_system
                     .in_set(UiSystem::Outlines)
                     .after(UiSystem::Layout),
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index dd524be5172e7..f530ec2812528 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -1,11 +1,11 @@
 //! This module contains systems that update the UI when something changes
 
-use crate::{CalculatedClip, OverflowAxis, Style};
+use crate::{CalculatedClip, OverflowAxis, Style, UiCamera};
 
 use super::Node;
 use bevy_ecs::{
     entity::Entity,
-    query::{With, Without},
+    query::{Changed, With, Without},
     system::{Commands, Query},
 };
 use bevy_hierarchy::{Children, Parent};
@@ -92,3 +92,34 @@ fn update_clipping(
         }
     }
 }
+
+pub fn update_ui_camera_system(
+    mut commands: Commands,
+    root_node_query: Query<Entity, (With<Node>, Without<Parent>, Changed<UiCamera>)>,
+    children_query: Query<&Children>,
+    node_query: Query<Option<&UiCamera>, With<Node>>,
+) {
+    for root_node in &root_node_query {
+        update_ui_camera(&mut commands, &children_query, &node_query, root_node, None);
+    }
+}
+
+fn update_ui_camera(
+    commands: &mut Commands,
+    children_query: &Query<&Children>,
+    node_query: &Query<Option<&UiCamera>, With<Node>>,
+    entity: Entity,
+    maybe_inherited_camera: Option<&UiCamera>,
+) {
+    let current_ui_camera = node_query.get(entity).unwrap();
+    let Some(ui_camera) = maybe_inherited_camera.or(current_ui_camera) else {
+        return;
+    };
+
+    if let Ok(children) = children_query.get(entity) {
+        for &child in children {
+            commands.entity(child).insert(ui_camera.clone());
+            update_ui_camera(commands, children_query, node_query, child, Some(ui_camera));
+        }
+    }
+}
diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 39aea7eee9f92..990c56388e41a 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -97,11 +97,7 @@ fn setup(
             UiCamera(left_camera),
         ))
         .with_children(|parent| {
-            parent.spawn((
-                TextBundle::from_section("Left", TextStyle::default()),
-                // TODO: replace with UiCamera propogation system
-                UiCamera(left_camera),
-            ));
+            parent.spawn((TextBundle::from_section("Left", TextStyle::default()),));
         });
 
     commands
@@ -118,11 +114,7 @@ fn setup(
             UiCamera(right_camera),
         ))
         .with_children(|parent| {
-            parent.spawn((
-                TextBundle::from_section("Right", TextStyle::default()),
-                // TODO: replace with UiCamera propogation system
-                UiCamera(right_camera),
-            ));
+            parent.spawn((TextBundle::from_section("Right", TextStyle::default()),));
         });
 }
 

From 19edd49a4ff959d3ab7bdf6157f6395d5f42bbd4 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 11 Nov 2023 18:01:20 +0100
Subject: [PATCH 05/36] Default to any active  primary window camera

---
 crates/bevy_ui/src/layout/mod.rs    |   3 +-
 crates/bevy_ui/src/render/mod.rs    | 133 +++++++++++++++++++---------
 crates/bevy_ui/src/ui_node.rs       |   6 ++
 examples/3d/split_screen.rs         |  32 ++-----
 examples/window/multiple_windows.rs |  35 ++++++--
 5 files changed, 132 insertions(+), 77 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index c3f248e49de79..00d4200f3c8dc 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,7 +17,7 @@ use bevy_math::{UVec2, Vec2};
 use bevy_render::camera::{Camera, RenderTarget};
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
-use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
+use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::Taffy;
 use thiserror::Error;
@@ -244,7 +244,6 @@ pub enum LayoutError {
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
-    windows: Query<(Entity, &Window)>,
     cameras: Query<(Entity, &Camera)>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 3f4fb08009953..8394503f08d5b 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -3,11 +3,13 @@ mod render_pass;
 mod ui_material_pipeline;
 
 use bevy_core_pipeline::{core_2d::Camera2d, core_3d::Camera3d};
+
+use bevy_derive::Deref;
 use bevy_hierarchy::Parent;
 use bevy_render::render_phase::PhaseItem;
 use bevy_render::view::ViewVisibility;
 use bevy_render::{render_resource::BindGroupEntries, ExtractSchedule, Render};
-use bevy_window::{PrimaryWindow, Window};
+use bevy_window::WindowRef;
 pub use pipeline::*;
 pub use render_pass::*;
 pub use ui_material_pipeline::*;
@@ -74,22 +76,28 @@ pub fn build_ui_render(app: &mut App) {
         .init_resource::<UiImageBindGroups>()
         .init_resource::<UiMeta>()
         .init_resource::<ExtractedUiNodes>()
+        .init_resource::<PrimaryWindowCamera>()
         .init_resource::<DrawFunctions<TransparentUi>>()
         .add_render_command::<TransparentUi, DrawUi>()
         .add_systems(
             ExtractSchedule,
             (
-                extract_default_ui_camera_view::<Camera2d>,
-                extract_default_ui_camera_view::<Camera3d>,
-                extract_uinodes.in_set(RenderUiSystem::ExtractNode),
-                extract_atlas_uinodes
-                    .in_set(RenderUiSystem::ExtractAtlasNode)
-                    .after(RenderUiSystem::ExtractNode),
-                extract_uinode_borders.after(RenderUiSystem::ExtractAtlasNode),
-                #[cfg(feature = "bevy_text")]
-                extract_text_uinodes.after(RenderUiSystem::ExtractAtlasNode),
-                extract_uinode_outlines.after(RenderUiSystem::ExtractAtlasNode),
-            ),
+                (
+                    extract_default_ui_camera_view::<Camera2d>,
+                    extract_default_ui_camera_view::<Camera3d>,
+                ),
+                (
+                    extract_uinodes.in_set(RenderUiSystem::ExtractNode),
+                    extract_atlas_uinodes
+                        .in_set(RenderUiSystem::ExtractAtlasNode)
+                        .after(RenderUiSystem::ExtractNode),
+                    extract_uinode_borders.after(RenderUiSystem::ExtractAtlasNode),
+                    #[cfg(feature = "bevy_text")]
+                    extract_text_uinodes.after(RenderUiSystem::ExtractAtlasNode),
+                    extract_uinode_outlines.after(RenderUiSystem::ExtractAtlasNode),
+                ),
+            )
+                .chain(),
         )
         .add_systems(
             Render,
@@ -173,6 +181,7 @@ pub struct ExtractedUiNodes {
 
 pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    primary_window_camera: Res<PrimaryWindowCamera>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     uinode_query: Extract<
@@ -186,7 +195,7 @@ pub fn extract_atlas_uinodes(
                 Option<&CalculatedClip>,
                 &Handle<TextureAtlas>,
                 &UiTextureAtlasImage,
-                &UiCamera,
+                Option<&UiCamera>,
             ),
             Without<UiImage>,
         >,
@@ -209,6 +218,11 @@ pub fn extract_atlas_uinodes(
             continue;
         }
 
+        // Skip if no camera is set
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(primary_window_camera.0) else {
+            continue;
+        };
+
         let (mut atlas_rect, mut atlas_size, image) =
             if let Some(texture_atlas) = texture_atlases.get(texture_atlas_handle) {
                 let atlas_rect = *texture_atlas
@@ -253,7 +267,7 @@ pub fn extract_atlas_uinodes(
                 atlas_size: Some(atlas_size),
                 flip_x: atlas_image.flip_x,
                 flip_y: atlas_image.flip_y,
-                camera_entity: camera.0,
+                camera_entity,
             },
         );
     }
@@ -274,7 +288,8 @@ pub(crate) fn resolve_border_thickness(value: Val, parent_width: f32, viewport_s
 pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    windows: Extract<Query<&Window, With<PrimaryWindow>>>,
+    primary_window_camera: Res<PrimaryWindowCamera>,
+    camera_query: Query<&Camera>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<
@@ -286,7 +301,7 @@ pub fn extract_uinode_borders(
                 Option<&Parent>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                &UiCamera,
+                Option<&UiCamera>,
             ),
             Without<ContentSize>,
         >,
@@ -295,14 +310,6 @@ pub fn extract_uinode_borders(
 ) {
     let image = AssetId::<Image>::default();
 
-    let ui_logical_viewport_size = windows
-        .get_single()
-        .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
-        .unwrap_or(Vec2::ZERO)
-        // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
-        // so we have to divide by `UiScale` to get the size of the UI viewport.
-        / ui_scale.0 as f32;
-
     for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
         uinode_query.iter()
     {
@@ -314,6 +321,18 @@ pub fn extract_uinode_borders(
         {
             continue;
         }
+        // Skip if no camera is set
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
+            continue;
+        };
+        let ui_logical_viewport_size = camera_query
+            .get(camera_entity)
+            .ok()
+            .and_then(|c| c.logical_viewport_size())
+            .unwrap_or(Vec2::ZERO)
+            // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
+            // so we have to divide by `UiScale` to get the size of the UI viewport.
+            / ui_scale.0 as f32;
 
         // Both vertical and horizontal percentage border values are calculated based on the width of the parent node
         // <https://developer.mozilla.org/en-US/docs/Web/CSS/border-width>
@@ -379,7 +398,7 @@ pub fn extract_uinode_borders(
                         clip: clip.map(|clip| clip.clip),
                         flip_x: false,
                         flip_y: false,
-                        camera_entity: camera.0,
+                        camera_entity,
                     },
                 );
             }
@@ -390,6 +409,7 @@ pub fn extract_uinode_borders(
 pub fn extract_uinode_outlines(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    primary_window_camera: Res<PrimaryWindowCamera>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -397,7 +417,7 @@ pub fn extract_uinode_outlines(
             &Outline,
             &ViewVisibility,
             Option<&Parent>,
-            &UiCamera,
+            Option<&UiCamera>,
         )>,
     >,
     clip_query: Query<&CalculatedClip>,
@@ -413,6 +433,10 @@ pub fn extract_uinode_outlines(
         {
             continue;
         }
+        // Skip if no camera is set
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
+            continue;
+        };
 
         // Outline's are drawn outside of a node's borders, so they are clipped using the clipping Rect of their UI node entity's parent.
         let clip =
@@ -472,7 +496,7 @@ pub fn extract_uinode_outlines(
                         clip,
                         flip_x: false,
                         flip_y: false,
-                        camera_entity: camera.0,
+                        camera_entity,
                     },
                 );
             }
@@ -482,6 +506,7 @@ pub fn extract_uinode_outlines(
 
 pub fn extract_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    primary_window_camera: Res<PrimaryWindowCamera>,
     images: Extract<Res<Assets<Image>>>,
     uinode_query: Extract<
         Query<
@@ -493,7 +518,7 @@ pub fn extract_uinodes(
                 Option<&UiImage>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                &UiCamera,
+                Option<&UiCamera>,
             ),
             Without<UiTextureAtlasImage>,
         >,
@@ -506,6 +531,10 @@ pub fn extract_uinodes(
         if !view_visibility.get() || color.0.is_fully_transparent() {
             continue;
         }
+        // Skip if no camera is set
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
+            continue;
+        };
 
         let (image, flip_x, flip_y) = if let Some(image) = maybe_image {
             // Skip loading images
@@ -532,7 +561,7 @@ pub fn extract_uinodes(
                 atlas_size: None,
                 flip_x,
                 flip_y,
-                camera_entity: camera.0,
+                camera_entity,
             },
         );
     }
@@ -549,11 +578,21 @@ const UI_CAMERA_FAR: f32 = 1000.0;
 // TODO: Evaluate if we still need this.
 const UI_CAMERA_TRANSFORM_OFFSET: f32 = -0.1;
 
+#[derive(Resource, Deref, Default)]
+pub struct PrimaryWindowCamera(pub Option<Entity>);
+
+impl From<PrimaryWindowCamera> for Option<Entity> {
+    fn from(camera: PrimaryWindowCamera) -> Self {
+        camera.0
+    }
+}
+
 #[derive(Component)]
 pub struct DefaultCameraView(pub Entity);
 
 pub fn extract_default_ui_camera_view<T: Component>(
     mut commands: Commands,
+    mut primary_window_camera: ResMut<PrimaryWindowCamera>,
     ui_scale: Extract<Res<UiScale>>,
     query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
 ) {
@@ -563,6 +602,14 @@ pub fn extract_default_ui_camera_view<T: Component>(
         if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
             continue;
         }
+
+        match camera.target {
+            bevy_render::camera::RenderTarget::Window(WindowRef::Primary) if camera.is_active => {
+                primary_window_camera.0 = Some(entity);
+            }
+            _ => {}
+        }
+
         if let (
             Some(logical_size),
             Some(URect {
@@ -615,8 +662,9 @@ pub fn extract_default_ui_camera_view<T: Component>(
 pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    primary_window_camera: Res<PrimaryWindowCamera>,
+    camera_query: Query<&Camera>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
-    windows: Extract<Query<&Window, With<PrimaryWindow>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<(
@@ -626,19 +674,10 @@ pub fn extract_text_uinodes(
             &TextLayoutInfo,
             &ViewVisibility,
             Option<&CalculatedClip>,
-            &UiCamera,
+            Option<&UiCamera>,
         )>,
     >,
 ) {
-    // TODO: Support window-independent UI scale: https://github.com/bevyengine/bevy/issues/5621
-    let scale_factor = windows
-        .get_single()
-        .map(|window| window.resolution.scale_factor())
-        .unwrap_or(1.0)
-        * ui_scale.0;
-
-    let inverse_scale_factor = (scale_factor as f32).recip();
-
     for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
@@ -646,6 +685,18 @@ pub fn extract_text_uinodes(
         if !view_visibility.get() || uinode.size().x == 0. || uinode.size().y == 0. {
             continue;
         }
+        // Skip if no camera is set
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
+            continue;
+        };
+        let scale_factor = camera_query
+            .get(camera_entity)
+            .ok()
+            .and_then(|c| c.target_scaling_factor())
+            .unwrap_or(1.0)
+            * ui_scale.0;
+        let inverse_scale_factor = (scale_factor as f32).recip();
+
         let transform = global_transform.compute_matrix()
             * Mat4::from_translation(-0.5 * uinode.size().extend(0.));
 
@@ -680,7 +731,7 @@ pub fn extract_text_uinodes(
                     clip: clip.map(|clip| clip.clip),
                     flip_x: false,
                     flip_y: false,
-                    camera_entity: camera.0,
+                    camera_entity,
                 },
             );
         }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 7f5e95f36fefb..a85824834db0b 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1716,3 +1716,9 @@ mod tests {
 
 #[derive(Component, Clone, Debug, Reflect)]
 pub struct UiCamera(pub Entity);
+
+impl UiCamera {
+    pub fn entity(&self) -> Entity {
+        self.0
+    }
+}
diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 990c56388e41a..f5ac820116631 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -4,7 +4,7 @@ use std::f32::consts::PI;
 
 use bevy::{
     core_pipeline::clear_color::ClearColorConfig, pbr::CascadeShadowConfigBuilder, prelude::*,
-    render::camera::Viewport, ui::prelude::*, window::WindowResized,
+    render::camera::Viewport, window::WindowResized,
 };
 
 fn main() {
@@ -84,37 +84,15 @@ fn setup(
         .id();
 
     commands
-        .spawn((
-            NodeBundle {
-                style: Style {
-                    width: Val::Percent(100.0),
-                    height: Val::Percent(100.0),
-                    justify_content: JustifyContent::SpaceBetween,
-                    ..default()
-                },
-                ..default()
-            },
-            UiCamera(left_camera),
-        ))
+        .spawn((NodeBundle::default(), UiCamera(left_camera)))
         .with_children(|parent| {
-            parent.spawn((TextBundle::from_section("Left", TextStyle::default()),));
+            parent.spawn(TextBundle::from_section("Left", TextStyle::default()));
         });
 
     commands
-        .spawn((
-            NodeBundle {
-                style: Style {
-                    width: Val::Percent(100.0),
-                    height: Val::Percent(100.0),
-                    justify_content: JustifyContent::SpaceBetween,
-                    ..default()
-                },
-                ..default()
-            },
-            UiCamera(right_camera),
-        ))
+        .spawn((NodeBundle::default(), UiCamera(right_camera)))
         .with_children(|parent| {
-            parent.spawn((TextBundle::from_section("Right", TextStyle::default()),));
+            parent.spawn(TextBundle::from_section("Right", TextStyle::default()));
         });
 }
 
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index 8905d76ca9c6a..486be9b6b7361 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -38,12 +38,33 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
         .id();
 
     // second window camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(6.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
-        camera: Camera {
-            target: RenderTarget::Window(WindowRef::Entity(second_window)),
+    let second_window_camera = commands
+        .spawn(Camera3dBundle {
+            transform: Transform::from_xyz(6.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+            camera: Camera {
+                target: RenderTarget::Window(WindowRef::Entity(second_window)),
+                ..default()
+            },
             ..default()
-        },
-        ..default()
-    });
+        })
+        .id();
+
+    // UI defaults to the primary window, no need to explicitly set the UiCamera on the root node
+    commands
+        .spawn(NodeBundle::default())
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "First window",
+                TextStyle::default(),
+            ));
+        });
+
+    commands
+        .spawn((NodeBundle::default(), UiCamera(second_window_camera)))
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "Second window",
+                TextStyle::default(),
+            ));
+        });
 }

From b4546f19d20804220a6fce5622d203b8a2df2348 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 11 Nov 2023 18:53:14 +0100
Subject: [PATCH 06/36] Layout based on camera scale factor

---
 crates/bevy_ui/src/layout/mod.rs | 151 +++++++++++++++----------------
 1 file changed, 73 insertions(+), 78 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 00d4200f3c8dc..aecd5cd09f6c8 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -17,7 +17,7 @@ use bevy_math::{UVec2, Vec2};
 use bevy_render::camera::{Camera, RenderTarget};
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
-use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
+use bevy_window::{PrimaryWindow, Window, WindowRef, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::Taffy;
 use thiserror::Error;
@@ -243,14 +243,14 @@ pub enum LayoutError {
 /// 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>>,
+    primary_window: Query<Entity, With<PrimaryWindow>>,
     cameras: Query<(Entity, &Camera)>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut resize_events: EventReader<bevy_window::WindowResized>,
     mut ui_surface: ResMut<UiSurface>,
     root_node_query: Query<(Entity, Option<&UiCamera>), (With<Node>, Without<Parent>)>,
-    style_query: Query<(Entity, Ref<Style>), With<Node>>,
+    style_query: Query<(Entity, Ref<Style>, Option<&UiCamera>), With<Node>>,
     mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, Ref<Children>), With<Node>>,
     just_children_query: Query<&Children>,
@@ -259,44 +259,84 @@ pub fn ui_layout_system(
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
     mut removed_nodes: RemovedComponents<Node>,
 ) {
-    // 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;
-        };
+    let primary_camera = cameras
+        .iter()
+        .find_map(|(entity, camera)| match camera.target {
+            RenderTarget::Window(bevy_window::WindowRef::Primary) if camera.is_active => {
+                Some(UiCamera(entity))
+            }
+            _ => None,
+        });
+    let root_nodes_defaulted = root_node_query
+        .iter()
+        .filter_map(|(entity, camera)| camera.or(primary_camera.as_ref()).map(|c| (entity, c)));
 
-    let resized = resize_events
-        .read()
-        .any(|resized_window| resized_window.window == primary_window_entity);
+    let mut root_nodes_grouped_by_camera: HashMap<Entity, Vec<Entity>> = HashMap::new();
+    for (entity, camera) in root_nodes_defaulted {
+        root_nodes_grouped_by_camera
+            .entry(camera.0)
+            .or_insert_with(Vec::new)
+            .push(entity);
+    }
 
-    // TODO: Use camera target_scaling_factor instead
-    let scale_factor = logical_to_physical_factor * ui_scale.0;
+    for (camera_id, group) in &root_nodes_grouped_by_camera {
+        let (_, camera) = cameras.get(*camera_id).unwrap();
+        let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
+        let inverse_target_scale_factor = 1. / scale_factor;
+        let physical_size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
+        let resized = resize_events
+            .read()
+            .any(|resized_window| match camera.target {
+                RenderTarget::Window(WindowRef::Primary) => {
+                    resized_window.window == primary_window.single()
+                }
+                RenderTarget::Window(WindowRef::Entity(window)) => resized_window.window == window,
+                _ => false,
+            });
 
-    let layout_context = LayoutContext::new(scale_factor, physical_size);
+        let layout_context = LayoutContext::new(
+            scale_factor,
+            [physical_size.x as f32, physical_size.y as f32].into(),
+        );
 
-    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() {
+        if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
+            // update all nodes
+            for (entity, style, ui_camera) in style_query.iter() {
+                if let Some(ui_camera) = ui_camera.or(primary_camera.as_ref()) {
+                    if ui_camera.entity() != *camera_id {
+                        continue;
+                    }
+                }
                 ui_surface.upsert_node(entity, &style, &layout_context);
             }
+        } else {
+            for (entity, style, ui_camera) in style_query.iter() {
+                if let Some(ui_camera) = ui_camera.or(primary_camera.as_ref()) {
+                    if ui_camera.entity() != *camera_id {
+                        continue;
+                    }
+                }
+                if style.is_changed() {
+                    ui_surface.upsert_node(entity, &style, &layout_context);
+                }
+            }
+        }
+
+        ui_surface.set_camera_children(*camera_id, group.into_iter().cloned());
+
+        for entity in group {
+            update_uinode_geometry_recursive(
+                *entity,
+                &ui_surface,
+                &mut node_transform_query,
+                &just_children_query,
+                inverse_target_scale_factor as f32,
+                Vec2::ZERO,
+                Vec2::ZERO,
+            );
         }
     }
+    scale_factor_events.clear();
 
     // 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.read() {
@@ -312,37 +352,6 @@ pub fn ui_layout_system(
     // clean up removed nodes
     ui_surface.remove_entities(removed_nodes.read());
 
-    // update window children (for now assuming all Nodes live in the primary window)
-
-    let primary_camera = {
-        let default_render_target = RenderTarget::default().normalize(Some(primary_window_entity));
-        cameras.iter().find_map(|(entity, camera)| {
-            if camera.is_active
-                && camera.target.normalize(Some(primary_window_entity)) == default_render_target
-            {
-                Some(UiCamera(entity))
-            } else {
-                None
-            }
-        })
-    };
-    let root_nodes_defaulted = root_node_query
-        .iter()
-        .filter_map(|(entity, camera)| camera.or(primary_camera.as_ref()).map(|c| (entity, c)));
-
-    let mut root_nodes_grouped_by_camera: HashMap<Entity, Vec<Entity>> = HashMap::new();
-
-    for (entity, camera) in root_nodes_defaulted {
-        root_nodes_grouped_by_camera
-            .entry(camera.0)
-            .or_insert_with(Vec::new)
-            .push(entity);
-    }
-
-    for (camera_id, group) in &root_nodes_grouped_by_camera {
-        ui_surface.set_camera_children(*camera_id, group.into_iter().cloned());
-    }
-
     // update and remove children
     for entity in removed_children.read() {
         ui_surface.try_remove_children(entity);
@@ -360,8 +369,6 @@ pub fn ui_layout_system(
         }
     }
 
-    let inverse_target_scale_factor = 1. / scale_factor;
-
     fn update_uinode_geometry_recursive(
         entity: Entity,
         ui_surface: &UiSurface,
@@ -409,18 +416,6 @@ pub fn ui_layout_system(
             }
         }
     }
-
-    for (entity, _camera) in root_node_query.iter() {
-        update_uinode_geometry_recursive(
-            entity,
-            &ui_surface,
-            &mut node_transform_query,
-            &just_children_query,
-            inverse_target_scale_factor as f32,
-            Vec2::ZERO,
-            Vec2::ZERO,
-        );
-    }
 }
 
 /// Resolve and update the widths of Node outlines

From 3bd738e92e4d83b0ac0117dc618a0400149ac317 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 12 Nov 2023 00:00:27 +0100
Subject: [PATCH 07/36] Update camera target scale factor on window change

---
 crates/bevy_render/src/camera/camera.rs | 7 +++++++
 crates/bevy_ui/src/render/mod.rs        | 6 +++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 9994e9f15ab5c..af9fc28a7eaf5 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -26,6 +26,7 @@ use bevy_transform::components::GlobalTransform;
 use bevy_utils::{HashMap, HashSet};
 use bevy_window::{
     NormalizedWindowRef, PrimaryWindow, Window, WindowCreated, WindowRef, WindowResized,
+    WindowScaleFactorChanged,
 };
 use std::{borrow::Cow, ops::Range};
 use wgpu::{BlendState, LoadOp, TextureFormat};
@@ -572,6 +573,7 @@ impl NormalizedRenderTarget {
 pub fn camera_system<T: CameraProjection + Component>(
     mut window_resized_events: EventReader<WindowResized>,
     mut window_created_events: EventReader<WindowCreated>,
+    mut window_scale_factor_changed_events: EventReader<WindowScaleFactorChanged>,
     mut image_asset_events: EventReader<AssetEvent<Image>>,
     primary_window: Query<Entity, With<PrimaryWindow>>,
     windows: Query<(Entity, &Window)>,
@@ -584,6 +586,11 @@ pub fn camera_system<T: CameraProjection + Component>(
     let mut changed_window_ids = HashSet::new();
     changed_window_ids.extend(window_created_events.read().map(|event| event.window));
     changed_window_ids.extend(window_resized_events.read().map(|event| event.window));
+    changed_window_ids.extend(
+        window_scale_factor_changed_events
+            .read()
+            .map(|event| event.window),
+    );
 
     let changed_image_handles: HashSet<&AssetId<Image>> = image_asset_events
         .read()
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 8394503f08d5b..1669f11df6fcb 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -289,7 +289,7 @@ pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     primary_window_camera: Res<PrimaryWindowCamera>,
-    camera_query: Query<&Camera>,
+    camera_query: Extract<Query<&Camera>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<
@@ -578,7 +578,7 @@ const UI_CAMERA_FAR: f32 = 1000.0;
 // TODO: Evaluate if we still need this.
 const UI_CAMERA_TRANSFORM_OFFSET: f32 = -0.1;
 
-#[derive(Resource, Deref, Default)]
+#[derive(Resource, Deref, Default, Debug)]
 pub struct PrimaryWindowCamera(pub Option<Entity>);
 
 impl From<PrimaryWindowCamera> for Option<Entity> {
@@ -663,7 +663,7 @@ pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     primary_window_camera: Res<PrimaryWindowCamera>,
-    camera_query: Query<&Camera>,
+    camera_query: Extract<Query<&Camera>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<

From c94cb9b634e1f034507f70f2c9611d46343e6ecf Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 12 Nov 2023 17:25:46 +0100
Subject: [PATCH 08/36] Propagate UI camera on children change

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

diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index f530ec2812528..76a3c5407c77c 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -96,12 +96,23 @@ fn update_clipping(
 pub fn update_ui_camera_system(
     mut commands: Commands,
     root_node_query: Query<Entity, (With<Node>, Without<Parent>, Changed<UiCamera>)>,
+    changed_children_query: Query<(Entity, &UiCamera), Changed<Children>>,
     children_query: Query<&Children>,
     node_query: Query<Option<&UiCamera>, With<Node>>,
 ) {
     for root_node in &root_node_query {
         update_ui_camera(&mut commands, &children_query, &node_query, root_node, None);
     }
+
+    for (parent, camera) in &changed_children_query {
+        update_ui_camera(
+            &mut commands,
+            &children_query,
+            &node_query,
+            parent,
+            Some(camera),
+        );
+    }
 }
 
 fn update_ui_camera(

From 5f1db01ead2e6caff8b8a600e5f1dd737967b40a Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 12 Nov 2023 20:39:51 +0100
Subject: [PATCH 09/36] Relative cursor position

---
 crates/bevy_render/src/camera/camera.rs |  7 ++++
 crates/bevy_ui/src/focus.rs             | 50 ++++++++++++++++++++-----
 crates/bevy_ui/src/layout/mod.rs        | 17 ++++-----
 crates/bevy_ui/src/render/mod.rs        |  8 +---
 examples/ui/button.rs                   | 13 ++++++-
 examples/ui/relative_cursor_position.rs | 13 ++++++-
 6 files changed, 82 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index af9fc28a7eaf5..d6ea5db2f55ce 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -363,6 +363,13 @@ impl Camera {
 
         (!world_space_coords.is_nan()).then_some(world_space_coords)
     }
+
+    pub fn is_primary(&self) -> bool {
+        match self.target {
+            RenderTarget::Window(WindowRef::Primary) => self.is_active,
+            _ => false,
+        }
+    }
 }
 
 /// Control how this camera outputs once rendering is completed.
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 91454adeeaada..d464535b28e0c 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, UiScale, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiCamera, UiScale, UiStack};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -126,6 +126,7 @@ pub struct NodeQuery {
     focus_policy: Option<&'static FocusPolicy>,
     calculated_clip: Option<&'static CalculatedClip>,
     view_visibility: Option<&'static ViewVisibility>,
+    ui_camera: Option<&'static UiCamera>,
 }
 
 /// The system that sets Interaction for all UI elements based on the mouse cursor activity
@@ -134,7 +135,7 @@ pub struct NodeQuery {
 #[allow(clippy::too_many_arguments)]
 pub fn ui_focus_system(
     mut state: Local<State>,
-    camera: Query<(&Camera, Option<&UiCameraConfig>)>,
+    camera_query: Query<(Entity, &Camera, Option<&UiCameraConfig>)>,
     windows: Query<&Window>,
     mouse_button_input: Res<Input<MouseButton>>,
     touches_input: Res<Touches>,
@@ -170,28 +171,43 @@ pub fn ui_focus_system(
     let is_ui_disabled =
         |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
 
-    let cursor_position = camera
+    let primary_camera = camera_query.iter().find_map(|(entity, camera, _)| {
+        if camera.is_primary() {
+            Some(entity)
+        } else {
+            None
+        }
+    });
+
+    let camera_cursor_positions: Vec<(Entity, Vec2)> = camera_query
         .iter()
-        .filter(|(_, camera_ui)| !is_ui_disabled(*camera_ui))
-        .filter_map(|(camera, _)| {
+        .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
+        .filter_map(|(entity, camera, _)| {
             if let Some(NormalizedRenderTarget::Window(window_ref)) =
                 camera.target.normalize(primary_window)
             {
-                Some(window_ref)
+                Some((entity, camera, window_ref))
             } else {
                 None
             }
         })
-        .find_map(|window_ref| {
+        .filter_map(|(entity, camera, window_ref)| {
+            let viewport_position = camera
+                .logical_viewport_rect()
+                .map(|rect| rect.min)
+                .unwrap_or_default();
+
             windows
                 .get(window_ref.entity())
                 .ok()
                 .and_then(|window| window.cursor_position())
+                .or_else(|| touches_input.first_pressed_position())
+                .map(|cursor_position| (entity, cursor_position - viewport_position))
         })
-        .or_else(|| touches_input.first_pressed_position())
         // The cursor position returned by `Window` only takes into account the window scale factor and not `UiScale`.
         // To convert the cursor position to logical UI viewport coordinates we have to divide it by `UiScale`.
-        .map(|cursor_position| cursor_position / ui_scale.0 as f32);
+        .map(|(entity, cursor_position)| (entity, cursor_position / ui_scale.0 as f32))
+        .collect();
 
     // prepare an iterator that contains all the nodes that have the cursor in their rect,
     // from the top node to the bottom one. this will also reset the interaction to `None`
@@ -216,6 +232,22 @@ pub fn ui_focus_system(
                     }
                 }
 
+                let Some(ui_camera_entity) =
+                    node.ui_camera.map(UiCamera::entity).or(primary_camera)
+                else {
+                    return None;
+                };
+                let cursor_position =
+                    camera_cursor_positions
+                        .iter()
+                        .find_map(|(camera_entity, position)| {
+                            if *camera_entity == ui_camera_entity {
+                                Some(*position)
+                            } else {
+                                None
+                            }
+                        });
+
                 let position = node.global_transform.translation();
                 let ui_position = position.truncate();
                 let extents = node.node.size() / 2.0;
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index aecd5cd09f6c8..eb7f89f9708f6 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -14,10 +14,10 @@ use bevy_ecs::{
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
-use bevy_render::camera::{Camera, RenderTarget};
+use bevy_render::camera::{Camera, NormalizedRenderTarget, RenderTarget};
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
-use bevy_window::{PrimaryWindow, Window, WindowRef, WindowScaleFactorChanged};
+use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::Taffy;
 use thiserror::Error;
@@ -284,15 +284,14 @@ pub fn ui_layout_system(
         let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
         let inverse_target_scale_factor = 1. / scale_factor;
         let physical_size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
-        let resized = resize_events
-            .read()
-            .any(|resized_window| match camera.target {
-                RenderTarget::Window(WindowRef::Primary) => {
-                    resized_window.window == primary_window.single()
+        let resized = resize_events.read().any(|resized_window| {
+            match camera.target.normalize(primary_window.get_single().ok()) {
+                Some(NormalizedRenderTarget::Window(window_ref)) => {
+                    resized_window.window == window_ref.entity()
                 }
-                RenderTarget::Window(WindowRef::Entity(window)) => resized_window.window == window,
                 _ => false,
-            });
+            }
+        });
 
         let layout_context = LayoutContext::new(
             scale_factor,
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 1669f11df6fcb..dfddb8ff5ffc6 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -9,7 +9,6 @@ use bevy_hierarchy::Parent;
 use bevy_render::render_phase::PhaseItem;
 use bevy_render::view::ViewVisibility;
 use bevy_render::{render_resource::BindGroupEntries, ExtractSchedule, Render};
-use bevy_window::WindowRef;
 pub use pipeline::*;
 pub use render_pass::*;
 pub use ui_material_pipeline::*;
@@ -603,11 +602,8 @@ pub fn extract_default_ui_camera_view<T: Component>(
             continue;
         }
 
-        match camera.target {
-            bevy_render::camera::RenderTarget::Window(WindowRef::Primary) if camera.is_active => {
-                primary_window_camera.0 = Some(entity);
-            }
-            _ => {}
+        if camera.is_primary() {
+            primary_window_camera.0 = Some(entity);
         }
 
         if let (
diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index 5e37068572b6a..d7a7b9282b863 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -6,6 +6,7 @@
 #![allow(clippy::type_complexity)]
 
 use bevy::{prelude::*, winit::WinitSettings};
+use bevy_internal::render::camera::Viewport;
 
 fn main() {
     App::new()
@@ -57,7 +58,17 @@ fn button_system(
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // ui camera
-    commands.spawn(Camera2dBundle::default());
+    commands.spawn(Camera2dBundle {
+        camera: Camera {
+            viewport: Some(Viewport {
+                physical_position: [200, 100].into(),
+                physical_size: [600, 600].into(),
+                ..default()
+            }),
+            ..default()
+        },
+        ..default()
+    });
     commands
         .spawn(NodeBundle {
             style: Style {
diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 84b9fa2fe19d4..23d814b6521a1 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -1,6 +1,7 @@
 //! Showcases the [`RelativeCursorPosition`] component, used to check the position of the cursor relative to a UI node.
 
 use bevy::{prelude::*, ui::RelativeCursorPosition, winit::WinitSettings};
+use bevy_internal::render::camera::Viewport;
 
 fn main() {
     App::new()
@@ -13,7 +14,17 @@ fn main() {
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
-    commands.spawn(Camera2dBundle::default());
+    commands.spawn(Camera2dBundle {
+        camera: Camera {
+            viewport: Some(Viewport {
+                physical_position: [200, 100].into(),
+                physical_size: [600, 600].into(),
+                ..default()
+            }),
+            ..default()
+        },
+        ..default()
+    });
 
     commands
         .spawn(NodeBundle {

From 79a2ed98667230c3a10cf761ca0406caf1ed83d1 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Mon, 13 Nov 2023 18:54:33 +0100
Subject: [PATCH 10/36] Resize viewport on scale factor change

---
 crates/bevy_render/src/camera/camera.rs | 47 +++++++++++++++++++------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index d6ea5db2f55ce..13623e5f7bff9 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -75,7 +75,7 @@ pub struct RenderTargetInfo {
 pub struct ComputedCameraValues {
     projection_matrix: Mat4,
     target_info: Option<RenderTargetInfo>,
-    // position and size of the `Viewport`
+    // size of the `Viewport`
     old_viewport_size: Option<UVec2>,
 }
 
@@ -559,9 +559,9 @@ impl NormalizedRenderTarget {
 
 /// System in charge of updating a [`Camera`] when its window or projection changes.
 ///
-/// The system detects window creation and resize events to update the camera projection if
-/// needed. It also queries any [`CameraProjection`] component associated with the same entity
-/// as the [`Camera`] one, to automatically update the camera projection matrix.
+/// The system detects window creation, resize, and scale factor change events to update the camera
+/// projection if needed. It also queries any [`CameraProjection`] component associated with the same
+/// entity as the [`Camera`] one, to automatically update the camera projection matrix.
 ///
 /// The system function is generic over the camera projection type, and only instances of
 /// [`OrthographicProjection`] and [`PerspectiveProjection`] are automatically added to
@@ -593,11 +593,11 @@ pub fn camera_system<T: CameraProjection + Component>(
     let mut changed_window_ids = HashSet::new();
     changed_window_ids.extend(window_created_events.read().map(|event| event.window));
     changed_window_ids.extend(window_resized_events.read().map(|event| event.window));
-    changed_window_ids.extend(
-        window_scale_factor_changed_events
-            .read()
-            .map(|event| event.window),
-    );
+    let scale_factor_changed_window_ids: HashSet<_> = window_scale_factor_changed_events
+        .read()
+        .map(|event| event.window)
+        .collect();
+    changed_window_ids.extend(scale_factor_changed_window_ids.clone());
 
     let changed_image_handles: HashSet<&AssetId<Image>> = image_asset_events
         .read()
@@ -611,7 +611,7 @@ pub fn camera_system<T: CameraProjection + Component>(
         .collect();
 
     for (mut camera, mut camera_projection) in &mut cameras {
-        let viewport_size = camera
+        let mut viewport_size = camera
             .viewport
             .as_ref()
             .map(|viewport| viewport.physical_size);
@@ -622,11 +622,36 @@ pub fn camera_system<T: CameraProjection + Component>(
                 || camera_projection.is_changed()
                 || camera.computed.old_viewport_size != viewport_size
             {
-                camera.computed.target_info = normalized_target.get_render_target_info(
+                let new_computed_target_info = normalized_target.get_render_target_info(
                     &windows,
                     &images,
                     &manual_texture_views,
                 );
+                // Check for the scale factor changing, and resize the viewport if needed.
+                // This can happen when the window is moved between monitors with different DPIs.
+                // Without this, the viewport will take a smaller portion of the window moved to
+                // a higher DPI monitor.
+                if normalized_target.is_changed(&scale_factor_changed_window_ids, &HashSet::new()) {
+                    if let (Some(new_scale_factor), Some(old_scale_factor)) = (
+                        new_computed_target_info
+                            .as_ref()
+                            .map(|info| info.scale_factor),
+                        camera
+                            .computed
+                            .target_info
+                            .as_ref()
+                            .map(|info| info.scale_factor),
+                    ) {
+                        let resize_factor = new_scale_factor / old_scale_factor;
+                        if let Some(ref mut viewport) = camera.viewport {
+                            let resize = |vec: UVec2| (vec.as_dvec2() * resize_factor).as_uvec2();
+                            viewport.physical_position = resize(viewport.physical_position);
+                            viewport.physical_size = resize(viewport.physical_size);
+                            viewport_size = Some(viewport.physical_size);
+                        }
+                    }
+                }
+                camera.computed.target_info = new_computed_target_info;
                 if let Some(size) = camera.logical_viewport_size() {
                     camera_projection.update(size.x, size.y);
                     camera.computed.projection_matrix = camera_projection.get_projection_matrix();

From b80b6c173ddea374439b894f3d2d9844af2fb89a Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Tue, 14 Nov 2023 21:11:25 +0100
Subject: [PATCH 11/36] Restore initial ui_layout_system order

---
 crates/bevy_ui/src/layout/mod.rs | 97 ++++++++++++++++----------------
 1 file changed, 49 insertions(+), 48 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index eb7f89f9708f6..02dc218c6e2a7 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -14,7 +14,7 @@ use bevy_ecs::{
 use bevy_hierarchy::{Children, Parent};
 use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
-use bevy_render::camera::{Camera, NormalizedRenderTarget, RenderTarget};
+use bevy_render::camera::{Camera, NormalizedRenderTarget};
 use bevy_transform::components::Transform;
 use bevy_utils::{default, HashMap};
 use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
@@ -256,35 +256,46 @@ pub fn ui_layout_system(
     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>,
+    mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
-    let primary_camera = cameras
-        .iter()
-        .find_map(|(entity, camera)| match camera.target {
-            RenderTarget::Window(bevy_window::WindowRef::Primary) if camera.is_active => {
-                Some(UiCamera(entity))
-            }
-            _ => None,
-        });
+    let primary_camera = cameras.iter().find_map(|(entity, camera)| {
+        if camera.is_primary() {
+            Some(UiCamera(entity))
+        } else {
+            None
+        }
+    });
     let root_nodes_defaulted = root_node_query
         .iter()
         .filter_map(|(entity, camera)| camera.or(primary_camera.as_ref()).map(|c| (entity, c)));
 
-    let mut root_nodes_grouped_by_camera: HashMap<Entity, Vec<Entity>> = HashMap::new();
+    let mut camera_root_nodes: HashMap<Entity, Vec<Entity>> = HashMap::new();
     for (entity, camera) in root_nodes_defaulted {
-        root_nodes_grouped_by_camera
+        camera_root_nodes
             .entry(camera.0)
             .or_insert_with(Vec::new)
             .push(entity);
     }
-
-    for (camera_id, group) in &root_nodes_grouped_by_camera {
-        let (_, camera) = cameras.get(*camera_id).unwrap();
+    let get_camera = |camera_id: Entity| {
+        let (_, camera) = cameras.get(camera_id).unwrap();
         let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
-        let inverse_target_scale_factor = 1. / scale_factor;
+        (camera, scale_factor)
+    };
+    let belongs_to_camera = |camera_id: &Entity, ui_camera: &Option<&UiCamera>| match *ui_camera {
+        Some(ui_camera) => ui_camera.0 == *camera_id,
+        None => match &primary_camera {
+            Some(ui_camera) => ui_camera.0 == *camera_id,
+            None => false,
+        },
+    };
+
+    // Resize nodes
+    let resize_events = resize_events.read().collect::<Vec<_>>();
+    for (camera_id, roots) in &camera_root_nodes {
+        let (camera, scale_factor) = get_camera(*camera_id);
         let physical_size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
-        let resized = resize_events.read().any(|resized_window| {
+        let resized = resize_events.iter().any(|resized_window| {
             match camera.target.normalize(primary_window.get_single().ok()) {
                 Some(NormalizedRenderTarget::Window(window_ref)) => {
                     resized_window.window == window_ref.entity()
@@ -301,39 +312,19 @@ pub fn ui_layout_system(
         if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
             // update all nodes
             for (entity, style, ui_camera) in style_query.iter() {
-                if let Some(ui_camera) = ui_camera.or(primary_camera.as_ref()) {
-                    if ui_camera.entity() != *camera_id {
-                        continue;
-                    }
+                if belongs_to_camera(camera_id, &ui_camera) {
+                    ui_surface.upsert_node(entity, &style, &layout_context);
                 }
-                ui_surface.upsert_node(entity, &style, &layout_context);
             }
         } else {
             for (entity, style, ui_camera) in style_query.iter() {
-                if let Some(ui_camera) = ui_camera.or(primary_camera.as_ref()) {
-                    if ui_camera.entity() != *camera_id {
-                        continue;
-                    }
-                }
-                if style.is_changed() {
+                if belongs_to_camera(camera_id, &ui_camera) && style.is_changed() {
                     ui_surface.upsert_node(entity, &style, &layout_context);
                 }
             }
         }
 
-        ui_surface.set_camera_children(*camera_id, group.into_iter().cloned());
-
-        for entity in group {
-            update_uinode_geometry_recursive(
-                *entity,
-                &ui_surface,
-                &mut node_transform_query,
-                &just_children_query,
-                inverse_target_scale_factor as f32,
-                Vec2::ZERO,
-                Vec2::ZERO,
-            );
-        }
+        ui_surface.set_camera_children(*camera_id, roots.iter().cloned());
     }
     scale_factor_events.clear();
 
@@ -341,7 +332,6 @@ pub fn ui_layout_system(
     for entity in removed_content_sizes.read() {
         ui_surface.try_remove_measure(entity);
     }
-
     for (entity, mut content_size) in &mut measure_query {
         if let Some(measure_func) = content_size.measure_func.take() {
             ui_surface.update_measure(entity, measure_func);
@@ -356,15 +346,26 @@ pub fn ui_layout_system(
         ui_surface.try_remove_children(entity);
     }
     for (entity, children) in &children_query {
-        if children.is_changed() {
-            ui_surface.update_children(entity, &children);
-        }
+        ui_surface.update_children(entity, &children);
     }
 
-    // compute layouts
-    for (entity, camera) in cameras.iter() {
+    for (camera_id, root_nodes) in &camera_root_nodes {
+        let (camera, scale_factor) = get_camera(*camera_id);
+        let inverse_target_scale_factor = 1. / scale_factor;
         if let Some(rect) = camera.physical_viewport_rect() {
-            ui_surface.compute_camera_layout(entity, rect.size());
+            ui_surface.compute_camera_layout(*camera_id, rect.size());
+        }
+
+        for root in root_nodes {
+            update_uinode_geometry_recursive(
+                *root,
+                &ui_surface,
+                &mut node_transform_query,
+                &just_children_query,
+                inverse_target_scale_factor as f32,
+                Vec2::ZERO,
+                Vec2::ZERO,
+            );
         }
     }
 

From 2a2d254b625810f9228be09e2f0e70e162fea18a Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Tue, 14 Nov 2023 22:18:05 +0100
Subject: [PATCH 12/36] Post-merge formatting

---
 crates/bevy_ui/src/layout/mod.rs | 2 +-
 crates/bevy_ui/src/render/mod.rs | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 02dc218c6e2a7..7e171d0b41106 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -351,7 +351,7 @@ pub fn ui_layout_system(
 
     for (camera_id, root_nodes) in &camera_root_nodes {
         let (camera, scale_factor) = get_camera(*camera_id);
-        let inverse_target_scale_factor = 1. / scale_factor;
+        let inverse_target_scale_factor = scale_factor.recip();
         if let Some(rect) = camera.physical_viewport_rect() {
             ui_surface.compute_camera_layout(*camera_id, rect.size());
         }
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index e2aaf19976937..9aedd9beee11b 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -607,7 +607,7 @@ pub fn extract_default_ui_camera_view<T: Component>(
         if !camera.is_active {
             continue;
         }
-      
+
         if camera.is_primary() {
             primary_window_camera.0 = Some(entity);
         }
@@ -680,7 +680,6 @@ pub fn extract_text_uinodes(
         )>,
     >,
 ) {
-
     for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
@@ -692,13 +691,13 @@ pub fn extract_text_uinodes(
         let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
             continue;
         };
-        let scale_factor = camera_query
+        let scale_factor = (camera_query
             .get(camera_entity)
             .ok()
             .and_then(|c| c.target_scaling_factor())
             .unwrap_or(1.0)
-            * ui_scale.0;
-        let inverse_scale_factor = (scale_factor as f32).recip();
+            * ui_scale.0) as f32;
+        let inverse_scale_factor = scale_factor.recip();
 
         let mut affine = global_transform.affine();
 

From 4ea0fb6444d8c8b81e77c21402c8ba5a4157d518 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Wed, 15 Nov 2023 22:44:03 +0100
Subject: [PATCH 13/36] Interactive UI in split screen example

---
 examples/3d/split_screen.rs | 130 ++++++++++++++++++++++++++++++++++--
 1 file changed, 125 insertions(+), 5 deletions(-)

diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index f5ac820116631..7592395ede696 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -11,7 +11,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_systems(Update, set_camera_viewports)
+        .add_systems(Update, (set_camera_viewports, button_system))
         .run();
 }
 
@@ -83,17 +83,103 @@ fn setup(
         ))
         .id();
 
+    // Set up UI
     commands
-        .spawn((NodeBundle::default(), UiCamera(left_camera)))
+        .spawn((
+            UiCamera(left_camera),
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.),
+                    ..default()
+                },
+                ..default()
+            },
+        ))
         .with_children(|parent| {
-            parent.spawn(TextBundle::from_section("Left", TextStyle::default()));
+            parent.spawn(TextBundle::from_section(
+                "Left",
+                TextStyle {
+                    font_size: 20.,
+                    ..default()
+                },
+            ));
+            buttons_panel(parent);
         });
 
     commands
-        .spawn((NodeBundle::default(), UiCamera(right_camera)))
+        .spawn((
+            UiCamera(right_camera),
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.),
+                    ..default()
+                },
+                ..default()
+            },
+        ))
         .with_children(|parent| {
-            parent.spawn(TextBundle::from_section("Right", TextStyle::default()));
+            parent.spawn(TextBundle::from_section(
+                "Right",
+                TextStyle {
+                    font_size: 20.,
+                    ..default()
+                },
+            ));
+            buttons_panel(parent);
         });
+
+    fn buttons_panel(parent: &mut ChildBuilder) {
+        parent
+            .spawn(NodeBundle {
+                style: Style {
+                    position_type: PositionType::Absolute,
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.),
+                    display: Display::Flex,
+                    flex_direction: FlexDirection::Row,
+                    justify_content: JustifyContent::SpaceBetween,
+                    align_items: AlignItems::Center,
+                    padding: UiRect::all(Val::Px(20.)),
+                    ..default()
+                },
+                ..default()
+            })
+            .with_children(|parent| {
+                rotate_button(parent, "<", Direction::Left);
+                rotate_button(parent, ">", Direction::Right);
+            });
+    }
+
+    fn rotate_button(parent: &mut ChildBuilder, caption: &str, direction: Direction) {
+        parent
+            .spawn((
+                RotateCamera(direction),
+                ButtonBundle {
+                    style: Style {
+                        width: Val::Px(40.),
+                        height: Val::Px(40.),
+                        border: UiRect::all(Val::Px(2.)),
+                        justify_content: JustifyContent::Center,
+                        align_items: AlignItems::Center,
+                        ..default()
+                    },
+                    border_color: Color::WHITE.into(),
+                    background_color: Color::DARK_GRAY.into(),
+                    ..default()
+                },
+            ))
+            .with_children(|parent| {
+                parent.spawn(TextBundle::from_section(
+                    caption,
+                    TextStyle {
+                        font_size: 20.,
+                        ..default()
+                    },
+                ));
+            });
+    }
 }
 
 #[derive(Component)]
@@ -102,6 +188,14 @@ struct LeftCamera;
 #[derive(Component)]
 struct RightCamera;
 
+#[derive(Component)]
+struct RotateCamera(Direction);
+
+enum Direction {
+    Left,
+    Right,
+}
+
 fn set_camera_viewports(
     windows: Query<&Window>,
     mut resize_events: EventReader<WindowResized>,
@@ -134,3 +228,29 @@ fn set_camera_viewports(
         });
     }
 }
+
+fn button_system(
+    interaction_query: Query<
+        (&Interaction, &UiCamera, &RotateCamera),
+        (Changed<Interaction>, With<Button>),
+    >,
+    mut camera_query: Query<&mut Transform, With<Camera>>,
+) {
+    for (interaction, ui_camera, RotateCamera(direction)) in &interaction_query {
+        match *interaction {
+            Interaction::Pressed => {
+                // Since UiCamera propagates to the children, we can use it to find
+                // which side of the screen the button is on.
+                if let Ok(mut camera_transform) = camera_query.get_mut(ui_camera.entity()) {
+                    let angle = match direction {
+                        Direction::Left => -0.1,
+                        Direction::Right => 0.1,
+                    };
+                    camera_transform
+                        .rotate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, angle));
+                }
+            }
+            _ => {}
+        }
+    }
+}

From 7bc0a5e17556dbdd074c466e32e0f21ec70142e7 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Thu, 16 Nov 2023 00:36:03 +0100
Subject: [PATCH 14/36] Revers button example, update cursor position example

---
 examples/ui/button.rs                   | 13 +------------
 examples/ui/relative_cursor_position.rs |  5 +++--
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index d7a7b9282b863..5e37068572b6a 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -6,7 +6,6 @@
 #![allow(clippy::type_complexity)]
 
 use bevy::{prelude::*, winit::WinitSettings};
-use bevy_internal::render::camera::Viewport;
 
 fn main() {
     App::new()
@@ -58,17 +57,7 @@ fn button_system(
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // ui camera
-    commands.spawn(Camera2dBundle {
-        camera: Camera {
-            viewport: Some(Viewport {
-                physical_position: [200, 100].into(),
-                physical_size: [600, 600].into(),
-                ..default()
-            }),
-            ..default()
-        },
-        ..default()
-    });
+    commands.spawn(Camera2dBundle::default());
     commands
         .spawn(NodeBundle {
             style: Style {
diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 23d814b6521a1..39b81e3024ad6 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -1,7 +1,8 @@
 //! Showcases the [`RelativeCursorPosition`] component, used to check the position of the cursor relative to a UI node.
 
-use bevy::{prelude::*, ui::RelativeCursorPosition, winit::WinitSettings};
-use bevy_internal::render::camera::Viewport;
+use bevy::{
+    prelude::*, render::camera::Viewport, ui::RelativeCursorPosition, winit::WinitSettings,
+};
 
 fn main() {
     App::new()

From 3f6b606cdc9dd5f9dd169e8a65cd9b72431af58b Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Thu, 16 Nov 2023 01:22:49 +0100
Subject: [PATCH 15/36] Can layout without a camera

---
 crates/bevy_ui/src/layout/debug.rs |   4 +-
 crates/bevy_ui/src/layout/mod.rs   | 102 ++++++++++++++++-------------
 crates/bevy_ui/src/ui_node.rs      |   2 +-
 3 files changed, 59 insertions(+), 49 deletions(-)

diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index 37fb5c2b88845..22e9ca80ca0b7 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -33,7 +33,7 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
 fn print_node(
     ui_surface: &UiSurface,
     taffy_to_entity: &HashMap<Node, Entity>,
-    entity: Entity,
+    entity: Option<Entity>,
     node: Node,
     has_sibling: bool,
     lines_string: String,
@@ -79,7 +79,7 @@ fn print_node(
         print_node(
             ui_surface,
             taffy_to_entity,
-            *child_entity,
+            Some(*child_entity),
             *child_node,
             has_sibling,
             new_string.clone(),
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 7e171d0b41106..3859c9c9f5a27 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -52,7 +52,7 @@ struct RootNodePair {
 #[derive(Resource)]
 pub struct UiSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    camera_roots: HashMap<Entity, Vec<RootNodePair>>,
+    camera_roots: HashMap<Option<Entity>, Vec<RootNodePair>>,
     taffy: Taffy,
 }
 
@@ -145,7 +145,7 @@ without UI components as a child of an entity with UI components, results may be
     /// Set the ui node entities without a [`Parent`] as children to the root node in the taffy layout.
     pub fn set_camera_children(
         &mut self,
-        camera_id: Entity,
+        camera_id: Option<Entity>,
         children: impl Iterator<Item = Entity>,
     ) {
         let viewport_style = taffy::style::Style {
@@ -190,7 +190,11 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.
-    pub fn compute_camera_layout(&mut self, camera: Entity, render_target_resolution: UVec2) {
+    pub fn compute_camera_layout(
+        &mut self,
+        camera: Option<Entity>,
+        render_target_resolution: UVec2,
+    ) {
         let Some(camera_root_nodes) = self.camera_roots.get(&camera) else {
             return;
         };
@@ -243,8 +247,8 @@ pub enum LayoutError {
 /// 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, With<PrimaryWindow>>,
-    cameras: Query<(Entity, &Camera)>,
+    primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
+    cameras: Query<&Camera>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut resize_events: EventReader<bevy_window::WindowResized>,
@@ -259,66 +263,74 @@ pub fn ui_layout_system(
     mut removed_nodes: RemovedComponents<Node>,
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
-    let primary_camera = cameras.iter().find_map(|(entity, camera)| {
-        if camera.is_primary() {
-            Some(UiCamera(entity))
-        } else {
-            None
-        }
-    });
-    let root_nodes_defaulted = root_node_query
-        .iter()
-        .filter_map(|(entity, camera)| camera.or(primary_camera.as_ref()).map(|c| (entity, c)));
-
-    let mut camera_root_nodes: HashMap<Entity, Vec<Entity>> = HashMap::new();
-    for (entity, camera) in root_nodes_defaulted {
+    let mut camera_root_nodes: HashMap<Option<Entity>, Vec<Entity>> = HashMap::new();
+    for (entity, camera) in &root_node_query {
         camera_root_nodes
-            .entry(camera.0)
+            .entry(camera.map(UiCamera::entity))
             .or_insert_with(Vec::new)
             .push(entity);
     }
-    let get_camera = |camera_id: Entity| {
-        let (_, camera) = cameras.get(camera_id).unwrap();
-        let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
-        (camera, scale_factor)
-    };
-    let belongs_to_camera = |camera_id: &Entity, ui_camera: &Option<&UiCamera>| match *ui_camera {
-        Some(ui_camera) => ui_camera.0 == *camera_id,
-        None => match &primary_camera {
-            Some(ui_camera) => ui_camera.0 == *camera_id,
-            None => false,
-        },
+    let get_viewport_properties = |camera_id: Option<Entity>| {
+        if let Some(camera_id) = camera_id {
+            let camera = cameras.get(camera_id).unwrap();
+            let size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
+            let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
+            (size, scale_factor)
+        } else {
+            let size = primary_window
+                .get_single()
+                .map(|(_, window)| [window.physical_width(), window.physical_height()].into())
+                .unwrap_or(UVec2::ZERO);
+            let scale_factor = primary_window
+                .get_single()
+                .map(|(_, window)| window.scale_factor())
+                .unwrap_or(1.0)
+                * ui_scale.0;
+            (size, scale_factor)
+        }
     };
 
     // Resize nodes
     let resize_events = resize_events.read().collect::<Vec<_>>();
     for (camera_id, roots) in &camera_root_nodes {
-        let (camera, scale_factor) = get_camera(*camera_id);
-        let physical_size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
+        let (size, scale_factor) = get_viewport_properties(*camera_id);
         let resized = resize_events.iter().any(|resized_window| {
-            match camera.target.normalize(primary_window.get_single().ok()) {
-                Some(NormalizedRenderTarget::Window(window_ref)) => {
-                    resized_window.window == window_ref.entity()
+            let primary_window = primary_window.get_single().map(|(e, _)| e).ok();
+            match camera_id {
+                Some(camera_id) => {
+                    if let Some(NormalizedRenderTarget::Window(window_ref)) = cameras
+                        .get(*camera_id)
+                        .ok()
+                        .and_then(|camera| camera.target.normalize(primary_window))
+                    {
+                        resized_window.window == window_ref.entity()
+                    } else {
+                        false
+                    }
+                }
+                None => {
+                    // Camera if not specified, use primary window
+                    match primary_window {
+                        Some(primary_window) => resized_window.window == primary_window,
+                        None => false,
+                    }
                 }
-                _ => false,
             }
         });
 
-        let layout_context = LayoutContext::new(
-            scale_factor,
-            [physical_size.x as f32, physical_size.y as f32].into(),
-        );
+        let layout_context =
+            LayoutContext::new(scale_factor, [size.x as f32, size.y as f32].into());
 
         if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
             // update all nodes
             for (entity, style, ui_camera) in style_query.iter() {
-                if belongs_to_camera(camera_id, &ui_camera) {
+                if ui_camera.map(UiCamera::entity) == *camera_id {
                     ui_surface.upsert_node(entity, &style, &layout_context);
                 }
             }
         } else {
             for (entity, style, ui_camera) in style_query.iter() {
-                if belongs_to_camera(camera_id, &ui_camera) && style.is_changed() {
+                if ui_camera.map(UiCamera::entity) == *camera_id && style.is_changed() {
                     ui_surface.upsert_node(entity, &style, &layout_context);
                 }
             }
@@ -350,12 +362,10 @@ pub fn ui_layout_system(
     }
 
     for (camera_id, root_nodes) in &camera_root_nodes {
-        let (camera, scale_factor) = get_camera(*camera_id);
+        let (size, scale_factor) = get_viewport_properties(*camera_id);
         let inverse_target_scale_factor = scale_factor.recip();
-        if let Some(rect) = camera.physical_viewport_rect() {
-            ui_surface.compute_camera_layout(*camera_id, rect.size());
-        }
 
+        ui_surface.compute_camera_layout(*camera_id, size);
         for root in root_nodes {
             update_uinode_geometry_recursive(
                 *root,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index a85824834db0b..1c4ed2380ef0c 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1714,7 +1714,7 @@ mod tests {
     }
 }
 
-#[derive(Component, Clone, Debug, Reflect)]
+#[derive(Component, Clone, Debug, Reflect, Eq, PartialEq)]
 pub struct UiCamera(pub Entity);
 
 impl UiCamera {

From d2889f15cb8d06d8c72225df56711984e3e8d414 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 17 Nov 2023 19:34:49 +0100
Subject: [PATCH 16/36] Default to primary window itself, not a camera

---
 crates/bevy_render/src/camera/camera.rs |   7 --
 crates/bevy_ui/src/focus.rs             |  47 +++++----
 crates/bevy_ui/src/layout/mod.rs        |  38 ++++---
 crates/bevy_ui/src/lib.rs               |  10 +-
 crates/bevy_ui/src/render/mod.rs        | 126 ++++++++++++------------
 crates/bevy_ui/src/update.rs            |  16 ++-
 6 files changed, 123 insertions(+), 121 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 13623e5f7bff9..8527ed5bfd9c5 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -363,13 +363,6 @@ impl Camera {
 
         (!world_space_coords.is_nan()).then_some(world_space_coords)
     }
-
-    pub fn is_primary(&self) -> bool {
-        match self.target {
-            RenderTarget::Window(WindowRef::Primary) => self.is_active,
-            _ => false,
-        }
-    }
 }
 
 /// Control how this camera outputs once rendering is completed.
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index d464535b28e0c..b3d37479dbbc2 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -136,13 +136,13 @@ pub struct NodeQuery {
 pub fn ui_focus_system(
     mut state: Local<State>,
     camera_query: Query<(Entity, &Camera, Option<&UiCameraConfig>)>,
+    primary_window: Query<Entity, With<PrimaryWindow>>,
     windows: Query<&Window>,
     mouse_button_input: Res<Input<MouseButton>>,
     touches_input: Res<Touches>,
     ui_scale: Res<UiScale>,
     ui_stack: Res<UiStack>,
     mut node_query: Query<NodeQuery>,
-    primary_window: Query<Entity, With<PrimaryWindow>>,
 ) {
     let primary_window = primary_window.iter().next();
 
@@ -171,14 +171,6 @@ pub fn ui_focus_system(
     let is_ui_disabled =
         |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
 
-    let primary_camera = camera_query.iter().find_map(|(entity, camera, _)| {
-        if camera.is_primary() {
-            Some(entity)
-        } else {
-            None
-        }
-    });
-
     let camera_cursor_positions: Vec<(Entity, Vec2)> = camera_query
         .iter()
         .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
@@ -230,23 +222,30 @@ pub fn ui_focus_system(
 
                         return None;
                     }
-                }
-
-                let Some(ui_camera_entity) =
-                    node.ui_camera.map(UiCamera::entity).or(primary_camera)
-                else {
+                } else {
                     return None;
                 };
-                let cursor_position =
-                    camera_cursor_positions
-                        .iter()
-                        .find_map(|(camera_entity, position)| {
-                            if *camera_entity == ui_camera_entity {
-                                Some(*position)
-                            } else {
-                                None
-                            }
-                        });
+                let cursor_position = match node.ui_camera.map(UiCamera::entity) {
+                    Some(ui_camera_entity) => {
+                        camera_cursor_positions
+                            .iter()
+                            .find_map(|(camera_entity, position)| {
+                                if *camera_entity == ui_camera_entity {
+                                    Some(*position)
+                                } else {
+                                    None
+                                }
+                            })
+                    }
+                    None =>
+                    // UiCamera is not set, so we use the primary window
+                    {
+                        primary_window
+                            .and_then(|entity| windows.get(entity).ok())
+                            .and_then(|window| window.cursor_position())
+                            .or_else(|| touches_input.first_pressed_position())
+                    }
+                };
 
                 let position = node.global_transform.translation();
                 let ui_position = position.truncate();
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 3859c9c9f5a27..8b266893925c0 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -263,9 +263,9 @@ pub fn ui_layout_system(
     mut removed_nodes: RemovedComponents<Node>,
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
-    let mut camera_root_nodes: HashMap<Option<Entity>, Vec<Entity>> = HashMap::new();
+    let mut camera_to_root_nodes_map: HashMap<Option<Entity>, Vec<Entity>> = HashMap::new();
     for (entity, camera) in &root_node_query {
-        camera_root_nodes
+        camera_to_root_nodes_map
             .entry(camera.map(UiCamera::entity))
             .or_insert_with(Vec::new)
             .push(entity);
@@ -292,7 +292,7 @@ pub fn ui_layout_system(
 
     // Resize nodes
     let resize_events = resize_events.read().collect::<Vec<_>>();
-    for (camera_id, roots) in &camera_root_nodes {
+    for (camera_id, root_nodes) in &camera_to_root_nodes_map {
         let (size, scale_factor) = get_viewport_properties(*camera_id);
         let resized = resize_events.iter().any(|resized_window| {
             let primary_window = primary_window.get_single().map(|(e, _)| e).ok();
@@ -309,7 +309,7 @@ pub fn ui_layout_system(
                     }
                 }
                 None => {
-                    // Camera if not specified, use primary window
+                    // If no camera specified, default to primary window
                     match primary_window {
                         Some(primary_window) => resized_window.window == primary_window,
                         None => false,
@@ -321,34 +321,32 @@ pub fn ui_layout_system(
         let layout_context =
             LayoutContext::new(scale_factor, [size.x as f32, size.y as f32].into());
 
-        if !scale_factor_events.is_empty() || ui_scale.is_changed() || resized {
-            // update all nodes
-            for (entity, style, ui_camera) in style_query.iter() {
-                if ui_camera.map(UiCamera::entity) == *camera_id {
-                    ui_surface.upsert_node(entity, &style, &layout_context);
-                }
-            }
-        } else {
-            for (entity, style, ui_camera) in style_query.iter() {
-                if ui_camera.map(UiCamera::entity) == *camera_id && style.is_changed() {
+        // update all nodes
+        for (entity, style, ui_camera) in style_query.iter() {
+            if ui_camera.map(UiCamera::entity) == *camera_id {
+                if resized
+                    || !scale_factor_events.is_empty()
+                    || ui_scale.is_changed()
+                    || style.is_changed()
+                {
                     ui_surface.upsert_node(entity, &style, &layout_context);
                 }
             }
         }
 
-        ui_surface.set_camera_children(*camera_id, roots.iter().cloned());
+        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
     }
     scale_factor_events.clear();
 
-    // 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.read() {
-        ui_surface.try_remove_measure(entity);
-    }
     for (entity, mut content_size) in &mut measure_query {
         if let Some(measure_func) = content_size.measure_func.take() {
             ui_surface.update_measure(entity, measure_func);
         }
     }
+    // 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.read() {
+        ui_surface.try_remove_measure(entity);
+    }
 
     // clean up removed nodes
     ui_surface.remove_entities(removed_nodes.read());
@@ -361,7 +359,7 @@ pub fn ui_layout_system(
         ui_surface.update_children(entity, &children);
     }
 
-    for (camera_id, root_nodes) in &camera_root_nodes {
+    for (camera_id, root_nodes) in &camera_to_root_nodes_map {
         let (size, scale_factor) = get_viewport_properties(*camera_id);
         let inverse_target_scale_factor = scale_factor.recip();
 
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index d0c348e16562b..4203330a82a2b 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -175,17 +175,17 @@ impl Plugin for UiPlugin {
 
             system
         });
-        app.add_systems(
-            PostUpdate,
-            widget::update_atlas_content_size_system.before(UiSystem::Layout),
-        );
+
         app.add_systems(
             PostUpdate,
             (
+                widget::update_atlas_content_size_system.before(UiSystem::Layout),
+                update_ui_camera_system
+                    .in_set(UiSystem::Layout)
+                    .before(ui_layout_system),
                 ui_layout_system
                     .in_set(UiSystem::Layout)
                     .before(TransformSystem::TransformPropagate),
-                update_ui_camera_system.in_set(UiSystem::Layout),
                 resolve_outlines_system
                     .in_set(UiSystem::Outlines)
                     .after(UiSystem::Layout),
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 9aedd9beee11b..186e7c9373836 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -4,10 +4,10 @@ mod ui_material_pipeline;
 
 use bevy_core_pipeline::{core_2d::Camera2d, core_3d::Camera3d};
 
-use bevy_derive::Deref;
 use bevy_hierarchy::Parent;
+use bevy_render::camera::{ExtractedCamera, NormalizedRenderTarget};
 use bevy_render::render_phase::PhaseItem;
-use bevy_render::view::ViewVisibility;
+use bevy_render::view::{ExtractedWindows, ViewVisibility};
 use bevy_render::{render_resource::BindGroupEntries, ExtractSchedule, Render};
 pub use pipeline::*;
 pub use render_pass::*;
@@ -41,6 +41,7 @@ use bevy_sprite::{SpriteAssetEvents, TextureAtlas};
 use bevy_text::{PositionedGlyph, Text, TextLayoutInfo};
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::{EntityHashMap, FloatOrd, HashMap};
+use bevy_window::{PrimaryWindow, Window};
 use bytemuck::{Pod, Zeroable};
 use std::ops::Range;
 
@@ -76,7 +77,6 @@ pub fn build_ui_render(app: &mut App) {
         .init_resource::<UiImageBindGroups>()
         .init_resource::<UiMeta>()
         .init_resource::<ExtractedUiNodes>()
-        .init_resource::<PrimaryWindowCamera>()
         .init_resource::<DrawFunctions<TransparentUi>>()
         .add_render_command::<TransparentUi, DrawUi>()
         .add_systems(
@@ -171,7 +171,7 @@ pub struct ExtractedUiNode {
     pub clip: Option<Rect>,
     pub flip_x: bool,
     pub flip_y: bool,
-    pub camera_entity: Entity,
+    pub camera_entity: Option<Entity>,
 }
 
 #[derive(Resource, Default)]
@@ -181,7 +181,6 @@ pub struct ExtractedUiNodes {
 
 pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window_camera: Res<PrimaryWindowCamera>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     uinode_query: Extract<
@@ -218,11 +217,6 @@ pub fn extract_atlas_uinodes(
             continue;
         }
 
-        // Skip if no camera is set
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(primary_window_camera.0) else {
-            continue;
-        };
-
         let (mut atlas_rect, mut atlas_size, image) =
             if let Some(texture_atlas) = texture_atlases.get(texture_atlas_handle) {
                 let atlas_rect = *texture_atlas
@@ -267,7 +261,7 @@ pub fn extract_atlas_uinodes(
                 atlas_size: Some(atlas_size),
                 flip_x: atlas_image.flip_x,
                 flip_y: atlas_image.flip_y,
-                camera_entity,
+                camera_entity: camera.map(UiCamera::entity),
             },
         );
     }
@@ -288,7 +282,7 @@ pub(crate) fn resolve_border_thickness(value: Val, parent_width: f32, viewport_s
 pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window_camera: Res<PrimaryWindowCamera>,
+    primary_window: Extract<Query<&Window, With<PrimaryWindow>>>,
     camera_query: Extract<Query<&Camera>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
@@ -321,14 +315,18 @@ pub fn extract_uinode_borders(
         {
             continue;
         }
-        // Skip if no camera is set
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
-            continue;
+
+        let target_logical_viewport_size = match camera {
+            Some(UiCamera(camera_entity)) => camera_query
+                .get(*camera_entity)
+                .ok()
+                .and_then(|c| c.logical_viewport_size()),
+            None => primary_window
+                .get_single()
+                .map(|w| [w.resolution.width(), w.resolution.height()].into())
+                .ok(),
         };
-        let ui_logical_viewport_size = camera_query
-            .get(camera_entity)
-            .ok()
-            .and_then(|c| c.logical_viewport_size())
+        let ui_logical_viewport_size = target_logical_viewport_size
             .unwrap_or(Vec2::ZERO)
             // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
             // so we have to divide by `UiScale` to get the size of the UI viewport.
@@ -398,7 +396,7 @@ pub fn extract_uinode_borders(
                         clip: clip.map(|clip| clip.clip),
                         flip_x: false,
                         flip_y: false,
-                        camera_entity,
+                        camera_entity: camera.map(UiCamera::entity),
                     },
                 );
             }
@@ -409,7 +407,6 @@ pub fn extract_uinode_borders(
 pub fn extract_uinode_outlines(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window_camera: Res<PrimaryWindowCamera>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -433,10 +430,6 @@ pub fn extract_uinode_outlines(
         {
             continue;
         }
-        // Skip if no camera is set
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
-            continue;
-        };
 
         // Outline's are drawn outside of a node's borders, so they are clipped using the clipping Rect of their UI node entity's parent.
         let clip =
@@ -496,7 +489,7 @@ pub fn extract_uinode_outlines(
                         clip,
                         flip_x: false,
                         flip_y: false,
-                        camera_entity,
+                        camera_entity: camera.map(UiCamera::entity),
                     },
                 );
             }
@@ -506,7 +499,6 @@ pub fn extract_uinode_outlines(
 
 pub fn extract_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window_camera: Res<PrimaryWindowCamera>,
     images: Extract<Res<Assets<Image>>>,
     uinode_query: Extract<
         Query<
@@ -531,10 +523,6 @@ pub fn extract_uinodes(
         if !view_visibility.get() || color.0.is_fully_transparent() {
             continue;
         }
-        // Skip if no camera is set
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
-            continue;
-        };
 
         let (image, flip_x, flip_y) = if let Some(image) = maybe_image {
             // Skip loading images
@@ -561,7 +549,7 @@ pub fn extract_uinodes(
                 atlas_size: None,
                 flip_x,
                 flip_y,
-                camera_entity,
+                camera_entity: camera.map(UiCamera::entity),
             },
         );
     }
@@ -578,21 +566,11 @@ const UI_CAMERA_FAR: f32 = 1000.0;
 // TODO: Evaluate if we still need this.
 const UI_CAMERA_TRANSFORM_OFFSET: f32 = -0.1;
 
-#[derive(Resource, Deref, Default, Debug)]
-pub struct PrimaryWindowCamera(pub Option<Entity>);
-
-impl From<PrimaryWindowCamera> for Option<Entity> {
-    fn from(camera: PrimaryWindowCamera) -> Self {
-        camera.0
-    }
-}
-
 #[derive(Component)]
 pub struct DefaultCameraView(pub Entity);
 
 pub fn extract_default_ui_camera_view<T: Component>(
     mut commands: Commands,
-    mut primary_window_camera: ResMut<PrimaryWindowCamera>,
     ui_scale: Extract<Res<UiScale>>,
     query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
 ) {
@@ -608,10 +586,6 @@ pub fn extract_default_ui_camera_view<T: Component>(
             continue;
         }
 
-        if camera.is_primary() {
-            primary_window_camera.0 = Some(entity);
-        }
-
         if let (
             Some(logical_size),
             Some(URect {
@@ -664,8 +638,8 @@ pub fn extract_default_ui_camera_view<T: Component>(
 pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window_camera: Res<PrimaryWindowCamera>,
     camera_query: Extract<Query<&Camera>>,
+    primary_window: Extract<Query<&Window, With<PrimaryWindow>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
@@ -687,16 +661,18 @@ pub fn extract_text_uinodes(
         if !view_visibility.get() || uinode.size().x == 0. || uinode.size().y == 0. {
             continue;
         }
-        // Skip if no camera is set
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(**primary_window_camera) else {
-            continue;
+        let target_scale_factor = match camera {
+            Some(UiCamera(camera_entity)) => camera_query
+                .get(*camera_entity)
+                .ok()
+                .and_then(|c| c.target_scaling_factor()),
+
+            None => {
+                // No camera is set, so we use the primary window scale factor
+                primary_window.get_single().map(|w| w.scale_factor()).ok()
+            }
         };
-        let scale_factor = (camera_query
-            .get(camera_entity)
-            .ok()
-            .and_then(|c| c.target_scaling_factor())
-            .unwrap_or(1.0)
-            * ui_scale.0) as f32;
+        let scale_factor = (target_scale_factor.unwrap_or(1.0) * ui_scale.0) as f32;
         let inverse_scale_factor = scale_factor.recip();
 
         let mut affine = global_transform.affine();
@@ -744,7 +720,7 @@ pub fn extract_text_uinodes(
                     clip: clip.map(|clip| clip.clip),
                     flip_x: false,
                     flip_y: false,
-                    camera_entity,
+                    camera_entity: camera.map(UiCamera::entity),
                 },
             );
         }
@@ -788,7 +764,7 @@ pub(crate) const QUAD_INDICES: [usize; 6] = [0, 2, 3, 0, 1, 2];
 pub struct UiBatch {
     pub range: Range<u32>,
     pub image: AssetId<Image>,
-    pub camera: Entity,
+    pub camera: Option<Entity>,
 }
 
 const TEXTURED_QUAD: u32 = 0;
@@ -796,15 +772,21 @@ const UNTEXTURED_QUAD: u32 = 1;
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_uinodes(
+    extracted_windows: Res<ExtractedWindows>,
     extracted_uinodes: Res<ExtractedUiNodes>,
     ui_pipeline: Res<UiPipeline>,
     mut pipelines: ResMut<SpecializedRenderPipelines<UiPipeline>>,
-    mut views: Query<(Entity, &ExtractedView, &mut RenderPhase<TransparentUi>)>,
+    mut views: Query<(
+        Entity,
+        &ExtractedView,
+        Option<&ExtractedCamera>,
+        &mut RenderPhase<TransparentUi>,
+    )>,
     pipeline_cache: Res<PipelineCache>,
     draw_functions: Res<DrawFunctions<TransparentUi>>,
 ) {
     let draw_function = draw_functions.read().id::<DrawUi>();
-    for (view_entity, view, mut transparent_phase) in &mut views {
+    for (view_entity, view, camera, mut transparent_phase) in &mut views {
         let pipeline = pipelines.specialize(
             &pipeline_cache,
             &ui_pipeline,
@@ -815,9 +797,29 @@ pub fn queue_uinodes(
             .reserve(extracted_uinodes.uinodes.len());
 
         for (entity, extracted_uinode) in extracted_uinodes.uinodes.iter() {
-            if view_entity != extracted_uinode.camera_entity {
-                continue;
+            // Skip if the node is not in the current view
+            match extracted_uinode.camera_entity {
+                Some(camera_entity) => {
+                    if view_entity != camera_entity {
+                        continue;
+                    }
+                }
+                None => {
+                    // Compare view with primary window if no camera is explicitly set for the node
+                    if let (
+                        Some(NormalizedRenderTarget::Window(window_ref)),
+                        Some(primary_window),
+                    ) = (
+                        camera.and_then(|c| c.target.as_ref()),
+                        extracted_windows.primary,
+                    ) {
+                        if window_ref.entity() != primary_window {
+                            continue;
+                        }
+                    }
+                }
             }
+
             transparent_phase.add(TransparentUi {
                 draw_function,
                 pipeline,
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 76a3c5407c77c..dfe00b545bf88 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -95,16 +95,26 @@ fn update_clipping(
 
 pub fn update_ui_camera_system(
     mut commands: Commands,
-    root_node_query: Query<Entity, (With<Node>, Without<Parent>, Changed<UiCamera>)>,
+    root_node_query: Query<
+        (Entity, Option<&UiCamera>),
+        (With<Node>, Without<Parent>, Changed<UiCamera>),
+    >,
     changed_children_query: Query<(Entity, &UiCamera), Changed<Children>>,
     children_query: Query<&Children>,
     node_query: Query<Option<&UiCamera>, With<Node>>,
 ) {
-    for root_node in &root_node_query {
-        update_ui_camera(&mut commands, &children_query, &node_query, root_node, None);
+    for (root_node, camera) in &root_node_query {
+        update_ui_camera(
+            &mut commands,
+            &children_query,
+            &node_query,
+            root_node,
+            camera,
+        );
     }
 
     for (parent, camera) in &changed_children_query {
+        // Recursively update all children
         update_ui_camera(
             &mut commands,
             &children_query,

From 436e1d8fe5de88ac3bb89515e2ff4ee7eb5cc1eb Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 17 Nov 2023 20:05:02 +0100
Subject: [PATCH 17/36] Improve code formatting

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

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 8b266893925c0..e0318ea9243c6 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -323,14 +323,13 @@ pub fn ui_layout_system(
 
         // update all nodes
         for (entity, style, ui_camera) in style_query.iter() {
-            if ui_camera.map(UiCamera::entity) == *camera_id {
-                if resized
+            if ui_camera.map(UiCamera::entity) == *camera_id
+                && (resized
                     || !scale_factor_events.is_empty()
                     || ui_scale.is_changed()
-                    || style.is_changed()
-                {
-                    ui_surface.upsert_node(entity, &style, &layout_context);
-                }
+                    || style.is_changed())
+            {
+                ui_surface.upsert_node(entity, &style, &layout_context);
             }
         }
 

From 94e0c3b108853ce95291109f88f38bf4d36877d7 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 18 Nov 2023 16:34:18 +0100
Subject: [PATCH 18/36] Code formatting in examples

---
 examples/3d/split_screen.rs | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 7592395ede696..3c3603e8245a6 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -229,6 +229,7 @@ fn set_camera_viewports(
     }
 }
 
+#[allow(clippy::type_complexity)]
 fn button_system(
     interaction_query: Query<
         (&Interaction, &UiCamera, &RotateCamera),
@@ -237,20 +238,16 @@ fn button_system(
     mut camera_query: Query<&mut Transform, With<Camera>>,
 ) {
     for (interaction, ui_camera, RotateCamera(direction)) in &interaction_query {
-        match *interaction {
-            Interaction::Pressed => {
-                // Since UiCamera propagates to the children, we can use it to find
-                // which side of the screen the button is on.
-                if let Ok(mut camera_transform) = camera_query.get_mut(ui_camera.entity()) {
-                    let angle = match direction {
-                        Direction::Left => -0.1,
-                        Direction::Right => 0.1,
-                    };
-                    camera_transform
-                        .rotate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, angle));
-                }
+        if let Interaction::Pressed = *interaction {
+            // Since UiCamera propagates to the children, we can use it to find
+            // which side of the screen the button is on.
+            if let Ok(mut camera_transform) = camera_query.get_mut(ui_camera.entity()) {
+                let angle = match direction {
+                    Direction::Left => -0.1,
+                    Direction::Right => 0.1,
+                };
+                camera_transform.rotate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, angle));
             }
-            _ => {}
         }
     }
 }

From f5c2aff6f1b5c713ce266fae0e3f810d9c450274 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sat, 18 Nov 2023 16:45:37 +0100
Subject: [PATCH 19/36] Remove redundant explicit ordering

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

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 186e7c9373836..c2e35e50a1c6a 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -82,22 +82,17 @@ pub fn build_ui_render(app: &mut App) {
         .add_systems(
             ExtractSchedule,
             (
-                (
-                    extract_default_ui_camera_view::<Camera2d>,
-                    extract_default_ui_camera_view::<Camera3d>,
-                ),
-                (
-                    extract_uinodes.in_set(RenderUiSystem::ExtractNode),
-                    extract_atlas_uinodes
-                        .in_set(RenderUiSystem::ExtractAtlasNode)
-                        .after(RenderUiSystem::ExtractNode),
-                    extract_uinode_borders.after(RenderUiSystem::ExtractAtlasNode),
-                    #[cfg(feature = "bevy_text")]
-                    extract_text_uinodes.after(RenderUiSystem::ExtractAtlasNode),
-                    extract_uinode_outlines.after(RenderUiSystem::ExtractAtlasNode),
-                ),
-            )
-                .chain(),
+                extract_default_ui_camera_view::<Camera2d>,
+                extract_default_ui_camera_view::<Camera3d>,
+                extract_uinodes.in_set(RenderUiSystem::ExtractNode),
+                extract_atlas_uinodes
+                    .in_set(RenderUiSystem::ExtractAtlasNode)
+                    .after(RenderUiSystem::ExtractNode),
+                extract_uinode_borders.after(RenderUiSystem::ExtractAtlasNode),
+                #[cfg(feature = "bevy_text")]
+                extract_text_uinodes.after(RenderUiSystem::ExtractAtlasNode),
+                extract_uinode_outlines.after(RenderUiSystem::ExtractAtlasNode),
+            ),
         )
         .add_systems(
             Render,

From febd33c15741b28e50c7f2d9a07a5185a23b2ec5 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 24 Nov 2023 20:43:32 +0100
Subject: [PATCH 20/36] Example of rendering UI to a texture

---
 Cargo.toml                          |  11 +++
 examples/README.md                  |   1 +
 examples/ui/render_ui_to_texture.rs | 145 ++++++++++++++++++++++++++++
 3 files changed, 157 insertions(+)
 create mode 100644 examples/ui/render_ui_to_texture.rs

diff --git a/Cargo.toml b/Cargo.toml
index 5fe0449660fe0..1febdc5a4927b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2177,6 +2177,17 @@ description = "Showcases the RelativeCursorPosition component"
 category = "UI (User Interface)"
 wasm = true
 
+[[example]]
+name = "render_ui_to_texture"
+path = "examples/ui/render_ui_to_texture.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.render_ui_to_texture]
+name = "Render UI to Texture"
+description = "An example of rendering UI as a part of a 3D world"
+category = "UI (User Interface)"
+wasm = true
+
 [[example]]
 name = "size_constraints"
 path = "examples/ui/size_constraints.rs"
diff --git a/examples/README.md b/examples/README.md
index 70b1842643858..d8ef7200c1c69 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -364,6 +364,7 @@ Example | Description
 [Overflow](../examples/ui/overflow.rs) | Simple example demonstrating overflow behavior
 [Overflow and Clipping Debug](../examples/ui/overflow_debug.rs) | An example to debug overflow and clipping behavior
 [Relative Cursor Position](../examples/ui/relative_cursor_position.rs) | Showcases the RelativeCursorPosition component
+[Render UI to Texture](../examples/ui/render_ui_to_texture.rs) | An example of rendering UI as a part of a 3D world
 [Size Constraints](../examples/ui/size_constraints.rs) | Demonstrates how the to use the size constraints to control the size of a UI node.
 [Text](../examples/ui/text.rs) | Illustrates creating and updating text
 [Text Debug](../examples/ui/text_debug.rs) | An example for debugging text layout
diff --git a/examples/ui/render_ui_to_texture.rs b/examples/ui/render_ui_to_texture.rs
new file mode 100644
index 0000000000000..4084ef6178959
--- /dev/null
+++ b/examples/ui/render_ui_to_texture.rs
@@ -0,0 +1,145 @@
+//! Shows how to render UI to a texture. Useful for displaying UI in 3D space.
+
+use std::f32::consts::PI;
+
+use bevy::{
+    prelude::*,
+    render::{
+        camera::RenderTarget,
+        render_resource::{
+            Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
+        },
+    },
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, rotator_system)
+        .run();
+}
+
+// Marks the cube, to which the UI texture is applied.
+#[derive(Component)]
+struct Cube;
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    let size = Extent3d {
+        width: 512,
+        height: 512,
+        ..default()
+    };
+
+    // This is the texture that will be rendered to.
+    let mut image = Image {
+        texture_descriptor: TextureDescriptor {
+            label: None,
+            size,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Bgra8UnormSrgb,
+            mip_level_count: 1,
+            sample_count: 1,
+            usage: TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_DST
+                | TextureUsages::RENDER_ATTACHMENT,
+            view_formats: &[],
+        },
+        ..default()
+    };
+
+    // fill image.data with zeroes
+    image.resize(size);
+
+    let image_handle = images.add(image);
+
+    // Light
+    commands.spawn(PointLightBundle {
+        transform: Transform::from_translation(Vec3::new(0.0, 0.0, 10.0)),
+        ..default()
+    });
+
+    let texture_camera = commands
+        .spawn(Camera3dBundle {
+            camera: Camera {
+                // render before the "main pass" camera
+                order: -1,
+                target: RenderTarget::Image(image_handle.clone()),
+                ..default()
+            },
+            ..default()
+        })
+        .id();
+
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    // Cover the whole image
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.),
+                    flex_direction: FlexDirection::Column,
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    ..default()
+                },
+                background_color: Color::GOLD.into(),
+                ..default()
+            },
+            UiCamera(texture_camera),
+        ))
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "This is a cube",
+                TextStyle {
+                    font_size: 40.0,
+                    color: Color::BLACK,
+                    ..default()
+                },
+            ));
+        });
+
+    let cube_size = 4.0;
+    let cube_handle = meshes.add(Mesh::from(shape::Box::new(cube_size, cube_size, cube_size)));
+
+    // This material has the texture that has been rendered.
+    let material_handle = materials.add(StandardMaterial {
+        base_color_texture: Some(image_handle),
+        reflectance: 0.02,
+        unlit: false,
+
+        ..default()
+    });
+
+    // Cube with material containing the rendered UI texture.
+    commands.spawn((
+        PbrBundle {
+            mesh: cube_handle,
+            material: material_handle,
+            transform: Transform::from_xyz(0.0, 0.0, 1.5)
+                .with_rotation(Quat::from_rotation_x(-PI / 5.0)),
+            ..default()
+        },
+        Cube,
+    ));
+
+    // The main pass camera.
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 15.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
+}
+
+const ROTATION_SPEED: f32 = 0.5;
+
+fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Cube>>) {
+    for mut transform in &mut query {
+        transform.rotate_x(1.0 * time.delta_seconds() * ROTATION_SPEED);
+        transform.rotate_y(0.7 * time.delta_seconds() * ROTATION_SPEED);
+    }
+}

From 7676e63befd8df9b79dacefdd3b92fd2a42d15ab Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Tue, 28 Nov 2023 21:38:55 +0100
Subject: [PATCH 21/36] Pre-calculate camera layout into

---
 crates/bevy_ui/src/layout/mod.rs | 165 +++++++++++++++++--------------
 1 file changed, 90 insertions(+), 75 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index e0318ea9243c6..0bb7e6a026e5e 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -16,7 +16,7 @@ use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
 use bevy_render::camera::{Camera, NormalizedRenderTarget};
 use bevy_transform::components::Transform;
-use bevy_utils::{default, HashMap};
+use bevy_utils::{default, HashMap, HashSet};
 use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::Taffy;
@@ -263,89 +263,103 @@ pub fn ui_layout_system(
     mut removed_nodes: RemovedComponents<Node>,
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
-    let mut camera_to_root_nodes_map: HashMap<Option<Entity>, Vec<Entity>> = HashMap::new();
-    for (entity, camera) in &root_node_query {
-        camera_to_root_nodes_map
-            .entry(camera.map(UiCamera::entity))
-            .or_insert_with(Vec::new)
-            .push(entity);
-    }
-    let get_viewport_properties = |camera_id: Option<Entity>| {
-        if let Some(camera_id) = camera_id {
-            let camera = cameras.get(camera_id).unwrap();
-            let size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
-            let scale_factor = camera.target_scaling_factor().unwrap_or(1.0) * ui_scale.0;
-            (size, scale_factor)
-        } else {
-            let size = primary_window
-                .get_single()
-                .map(|(_, window)| [window.physical_width(), window.physical_height()].into())
-                .unwrap_or(UVec2::ZERO);
-            let scale_factor = primary_window
-                .get_single()
-                .map(|(_, window)| window.scale_factor())
-                .unwrap_or(1.0)
-                * ui_scale.0;
-            (size, scale_factor)
+    struct CameraLayoutInfo {
+        root_nodes: Vec<Entity>,
+        size: UVec2,
+        scale_factor: f64,
+        resized: bool,
+    }
+
+    let resized_windows: HashSet<Entity> = resize_events.read().map(|event| event.window).collect();
+    let default_camera_layout_into = || {
+        let (size, scale_factor, resized) = primary_window
+            .get_single()
+            .map(|(entity, window)| {
+                (
+                    [window.physical_width(), window.physical_height()].into(),
+                    window.scale_factor(),
+                    resized_windows.contains(&entity),
+                )
+            })
+            .unwrap_or((UVec2::ZERO, 1.0, false));
+        CameraLayoutInfo {
+            root_nodes: Vec::new(),
+            size,
+            scale_factor: scale_factor * ui_scale.0,
+            resized,
         }
     };
+    let calculate_camera_layout_info = |ui_camera: &Option<Entity>| match ui_camera {
+        Some(camera_id) => {
+            let Ok(camera) = cameras.get(*camera_id) else {
+                warn!(
+                    "UiCamera is pointing to a camera {:?} which doesn't exist",
+                    camera_id
+                );
+                return default_camera_layout_into();
+            };
 
-    // Resize nodes
-    let resize_events = resize_events.read().collect::<Vec<_>>();
-    for (camera_id, root_nodes) in &camera_to_root_nodes_map {
-        let (size, scale_factor) = get_viewport_properties(*camera_id);
-        let resized = resize_events.iter().any(|resized_window| {
-            let primary_window = primary_window.get_single().map(|(e, _)| e).ok();
-            match camera_id {
-                Some(camera_id) => {
-                    if let Some(NormalizedRenderTarget::Window(window_ref)) = cameras
-                        .get(*camera_id)
-                        .ok()
-                        .and_then(|camera| camera.target.normalize(primary_window))
-                    {
-                        resized_window.window == window_ref.entity()
-                    } else {
-                        false
-                    }
-                }
-                None => {
-                    // If no camera specified, default to primary window
-                    match primary_window {
-                        Some(primary_window) => resized_window.window == primary_window,
-                        None => false,
-                    }
-                }
-            }
-        });
+            let size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
+            let scale_factor = camera.target_scaling_factor().unwrap_or(1.0);
+            let camera_target = camera
+                .target
+                .normalize(primary_window.get_single().map(|(e, _)| e).ok());
+            let resized = matches!(camera_target,
+              Some(NormalizedRenderTarget::Window(window_ref)) if resized_windows.contains(&window_ref.entity())
+            );
 
-        let layout_context =
-            LayoutContext::new(scale_factor, [size.x as f32, size.y as f32].into());
-
-        // update all nodes
-        for (entity, style, ui_camera) in style_query.iter() {
-            if ui_camera.map(UiCamera::entity) == *camera_id
-                && (resized
-                    || !scale_factor_events.is_empty()
-                    || ui_scale.is_changed()
-                    || style.is_changed())
-            {
-                ui_surface.upsert_node(entity, &style, &layout_context);
+            CameraLayoutInfo {
+                root_nodes: Vec::new(),
+                size,
+                scale_factor: scale_factor * ui_scale.0,
+                resized,
             }
         }
+        None => default_camera_layout_into(),
+    };
 
-        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
+    // Precalculate the layout info for each camera, so we have fast access to it for each node
+    let mut camera_layout_info: HashMap<Option<Entity>, CameraLayoutInfo> = HashMap::new();
+    for (entity, camera) in &root_node_query {
+        let camera_entity = camera.map(UiCamera::entity);
+        let layout_into = camera_layout_info
+            .entry(camera_entity)
+            .or_insert_with(|| calculate_camera_layout_info(&camera_entity));
+        layout_into.root_nodes.push(entity);
     }
-    scale_factor_events.clear();
 
-    for (entity, mut content_size) in &mut measure_query {
-        if let Some(measure_func) = content_size.measure_func.take() {
-            ui_surface.update_measure(entity, measure_func);
+    // Resize all nodes
+    for (entity, style, ui_camera) in style_query.iter() {
+        let camera = camera_layout_info
+            .get(&ui_camera.map(UiCamera::entity))
+            .unwrap();
+        if camera.resized
+            || !scale_factor_events.is_empty()
+            || ui_scale.is_changed()
+            || style.is_changed()
+        {
+            let layout_context = LayoutContext::new(
+                camera.scale_factor,
+                [camera.size.x as f32, camera.size.y as f32].into(),
+            );
+            ui_surface.upsert_node(entity, &style, &layout_context);
         }
     }
+    scale_factor_events.clear();
+
+    for (camera_id, CameraLayoutInfo { root_nodes, .. }) in &camera_layout_info {
+        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
+    }
+
     // 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.read() {
         ui_surface.try_remove_measure(entity);
     }
+    for (entity, mut content_size) in &mut measure_query {
+        if let Some(measure_func) = content_size.measure_func.take() {
+            ui_surface.update_measure(entity, measure_func);
+        }
+    }
 
     // clean up removed nodes
     ui_surface.remove_entities(removed_nodes.read());
@@ -355,15 +369,16 @@ pub fn ui_layout_system(
         ui_surface.try_remove_children(entity);
     }
     for (entity, children) in &children_query {
-        ui_surface.update_children(entity, &children);
+        if children.is_changed() {
+            ui_surface.update_children(entity, &children);
+        }
     }
 
-    for (camera_id, root_nodes) in &camera_to_root_nodes_map {
-        let (size, scale_factor) = get_viewport_properties(*camera_id);
-        let inverse_target_scale_factor = scale_factor.recip();
+    for (camera_id, camera) in &camera_layout_info {
+        let inverse_target_scale_factor = camera.scale_factor.recip();
 
-        ui_surface.compute_camera_layout(*camera_id, size);
-        for root in root_nodes {
+        ui_surface.compute_camera_layout(*camera_id, camera.size);
+        for root in &camera.root_nodes {
             update_uinode_geometry_recursive(
                 *root,
                 &ui_surface,

From 441542cf9a0d44f607cd780e01e0c26e01dc067c Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Tue, 28 Nov 2023 21:48:49 +0100
Subject: [PATCH 22/36] Make layout system execution order closer to original

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

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 0bb7e6a026e5e..730ddeba7a661 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -347,10 +347,6 @@ pub fn ui_layout_system(
     }
     scale_factor_events.clear();
 
-    for (camera_id, CameraLayoutInfo { root_nodes, .. }) in &camera_layout_info {
-        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
-    }
-
     // 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.read() {
         ui_surface.try_remove_measure(entity);
@@ -364,6 +360,11 @@ pub fn ui_layout_system(
     // clean up removed nodes
     ui_surface.remove_entities(removed_nodes.read());
 
+    // update camera children
+    for (camera_id, CameraLayoutInfo { root_nodes, .. }) in &camera_layout_info {
+        ui_surface.set_camera_children(*camera_id, root_nodes.iter().cloned());
+    }
+
     // update and remove children
     for entity in removed_children.read() {
         ui_surface.try_remove_children(entity);

From 0b45e1e8c07337dd441def4b02a5bf0388ae7949 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Wed, 29 Nov 2023 23:06:03 +0100
Subject: [PATCH 23/36] Optimize UiCamera popagation

---
 crates/bevy_ui/src/lib.rs    | 13 ++++--
 crates/bevy_ui/src/update.rs | 80 +++++++++++++++++++++++++-----------
 2 files changed, 64 insertions(+), 29 deletions(-)

diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index babe1c542ce48..91c72debc8dbc 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -117,6 +117,7 @@ impl Plugin for UiPlugin {
             .register_type::<RelativeCursorPosition>()
             .register_type::<RepeatedGridTrack>()
             .register_type::<Style>()
+            .register_type::<UiCamera>()
             .register_type::<UiCameraConfig>()
             .register_type::<UiImage>()
             .register_type::<UiImageSize>()
@@ -177,10 +178,14 @@ impl Plugin for UiPlugin {
         app.add_systems(
             PostUpdate,
             (
-                widget::update_atlas_content_size_system.before(UiSystem::Layout),
-                update_ui_camera_system
-                    .in_set(UiSystem::Layout)
-                    .before(ui_layout_system),
+                (
+                    widget::update_atlas_content_size_system,
+                    update_ui_camera_system,
+                )
+                    .before(UiSystem::Layout),
+                apply_deferred
+                    .after(update_ui_camera_system)
+                    .before(UiSystem::Layout),
                 ui_layout_system
                     .in_set(UiSystem::Layout)
                     .before(TransformSystem::TransformPropagate),
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index dfe00b545bf88..6de1ce052ac08 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -11,6 +11,7 @@ use bevy_ecs::{
 use bevy_hierarchy::{Children, Parent};
 use bevy_math::Rect;
 use bevy_transform::components::GlobalTransform;
+use bevy_utils::HashSet;
 
 /// Updates clipping for all nodes
 pub fn update_clipping_system(
@@ -95,52 +96,81 @@ fn update_clipping(
 
 pub fn update_ui_camera_system(
     mut commands: Commands,
-    root_node_query: Query<
+    changed_root_nodes_query: Query<
         (Entity, Option<&UiCamera>),
         (With<Node>, Without<Parent>, Changed<UiCamera>),
     >,
-    changed_children_query: Query<(Entity, &UiCamera), Changed<Children>>,
-    children_query: Query<&Children>,
+    changed_children_query: Query<(Entity, Option<&UiCamera>), (With<Node>, Changed<Children>)>,
+    children_query: Query<&Children, With<Node>>,
     node_query: Query<Option<&UiCamera>, With<Node>>,
 ) {
-    for (root_node, camera) in &root_node_query {
-        update_ui_camera(
-            &mut commands,
-            &children_query,
-            &node_query,
+    // 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
+    let mut updated_entities = HashSet::new();
+
+    // Assuming that UiCamera is manually set on the root node only,
+    // update root nodes first, since it implies the biggest change
+    for (root_node, camera) in &changed_root_nodes_query {
+        update_children_ui_camera(
             root_node,
             camera,
+            &node_query,
+            &children_query,
+            &mut commands,
+            &mut updated_entities,
         );
     }
 
+    // If the root node UiCamera was changed, then every child is updated
+    // by this point, and iteration will be skipped.
+    // Otherwise, update changed children
     for (parent, camera) in &changed_children_query {
-        // Recursively update all children
-        update_ui_camera(
-            &mut commands,
-            &children_query,
-            &node_query,
+        update_children_ui_camera(
             parent,
-            Some(camera),
+            camera,
+            &node_query,
+            &children_query,
+            &mut commands,
+            &mut updated_entities,
         );
     }
 }
 
-fn update_ui_camera(
-    commands: &mut Commands,
-    children_query: &Query<&Children>,
-    node_query: &Query<Option<&UiCamera>, With<Node>>,
+fn update_children_ui_camera(
     entity: Entity,
-    maybe_inherited_camera: Option<&UiCamera>,
+    camera_to_set: Option<&UiCamera>,
+    node_query: &Query<Option<&UiCamera>, With<Node>>,
+    children_query: &Query<&Children, With<Node>>,
+    commands: &mut Commands,
+    updated_entities: &mut HashSet<Entity>,
 ) {
-    let current_ui_camera = node_query.get(entity).unwrap();
-    let Some(ui_camera) = maybe_inherited_camera.or(current_ui_camera) else {
+    let Ok(children) = children_query.get(entity) else {
         return;
     };
 
-    if let Ok(children) = children_query.get(entity) {
-        for &child in children {
-            commands.entity(child).insert(ui_camera.clone());
-            update_ui_camera(commands, children_query, node_query, child, Some(ui_camera));
+    for &child in children {
+        // 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).unwrap() {
+            continue;
         }
+
+        match camera_to_set {
+            Some(camera) => {
+                commands.entity(child).insert(camera.clone());
+            }
+            None => {
+                commands.entity(child).remove::<UiCamera>();
+            }
+        }
+        updated_entities.insert(child);
+
+        update_children_ui_camera(
+            child,
+            camera_to_set,
+            node_query,
+            children_query,
+            commands,
+            updated_entities,
+        );
     }
 }

From 54e8e6c7fcff6095f19fee9d298c2544836747fd Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Wed, 29 Nov 2023 23:28:08 +0100
Subject: [PATCH 24/36] Fix `relative_cursor_position` example

---
 examples/ui/relative_cursor_position.rs | 41 ++++++++++++++-----------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 39b81e3024ad6..80712e5b8bae4 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -15,30 +15,35 @@ fn main() {
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
-    commands.spawn(Camera2dBundle {
-        camera: Camera {
-            viewport: Some(Viewport {
-                physical_position: [200, 100].into(),
-                physical_size: [600, 600].into(),
+    let camera = commands
+        .spawn(Camera2dBundle {
+            camera: Camera {
+                viewport: Some(Viewport {
+                    physical_position: [200, 100].into(),
+                    physical_size: [600, 600].into(),
+                    ..default()
+                }),
                 ..default()
-            }),
+            },
             ..default()
-        },
-        ..default()
-    });
+        })
+        .id();
 
     commands
-        .spawn(NodeBundle {
-            style: Style {
-                width: Val::Percent(100.),
-                height: Val::Percent(100.0),
-                align_items: AlignItems::Center,
-                justify_content: JustifyContent::Center,
-                flex_direction: FlexDirection::Column,
+        .spawn((
+            UiCamera(camera),
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.0),
+                    align_items: AlignItems::Center,
+                    justify_content: JustifyContent::Center,
+                    flex_direction: FlexDirection::Column,
+                    ..default()
+                },
                 ..default()
             },
-            ..default()
-        })
+        ))
         .with_children(|parent| {
             parent
                 .spawn(NodeBundle {

From 468da45ea2870e3dec58bd44e6cec04f3c6a7c7d Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 3 Dec 2023 20:53:45 +0100
Subject: [PATCH 25/36] Update examples/ui/render_ui_to_texture.rs

Co-authored-by: davier <bricedavier@gmail.com>
---
 examples/ui/render_ui_to_texture.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/ui/render_ui_to_texture.rs b/examples/ui/render_ui_to_texture.rs
index 4084ef6178959..490b057b19fbb 100644
--- a/examples/ui/render_ui_to_texture.rs
+++ b/examples/ui/render_ui_to_texture.rs
@@ -65,7 +65,7 @@ fn setup(
     });
 
     let texture_camera = commands
-        .spawn(Camera3dBundle {
+        .spawn(Camera2dBundle {
             camera: Camera {
                 // render before the "main pass" camera
                 order: -1,

From 402109beba0c3179df0a0af9b27c309b3a406cc4 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 3 Dec 2023 20:51:56 +0100
Subject: [PATCH 26/36] Default to a single camera if only one exists

---
 crates/bevy_ui/src/focus.rs             | 144 ++++++++++-----------
 crates/bevy_ui/src/layout/debug.rs      |   4 +-
 crates/bevy_ui/src/layout/mod.rs        | 163 +++++++++++++-----------
 crates/bevy_ui/src/render/mod.rs        | 133 +++++++++----------
 examples/ui/relative_cursor_position.rs |  45 ++++---
 5 files changed, 245 insertions(+), 244 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 21cbb673b719b..d3c3e56a45f36 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -161,24 +161,23 @@ pub fn ui_focus_system(
     let is_ui_disabled =
         |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
 
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok().map(|(entity, _, _)| entity);
     let camera_cursor_positions: Vec<(Entity, Vec2)> = camera_query
         .iter()
         .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
         .filter_map(|(entity, camera, _)| {
-            if let Some(NormalizedRenderTarget::Window(window_ref)) =
+            // Interactions are only supported for cameras rendering to a window.
+            let Some(NormalizedRenderTarget::Window(window_ref)) =
                 camera.target.normalize(primary_window)
-            {
-                Some((entity, camera, window_ref))
-            } else {
-                None
-            }
-        })
-        .filter_map(|(entity, camera, window_ref)| {
+            else {
+                return None;
+            };
+
             let viewport_position = camera
                 .logical_viewport_rect()
                 .map(|rect| rect.min)
                 .unwrap_or_default();
-
             windows
                 .get(window_ref.entity())
                 .ok()
@@ -200,84 +199,77 @@ pub fn ui_focus_system(
         // reverse the iterator to traverse the tree from closest nodes to furthest
         .rev()
         .filter_map(|entity| {
-            if let Ok(node) = node_query.get_mut(*entity) {
-                // Nodes that are not rendered should not be interactable
-                if let Some(view_visibility) = node.view_visibility {
-                    if !view_visibility.get() {
-                        // Reset their interaction to None to avoid strange stuck state
-                        if let Some(mut interaction) = node.interaction {
-                            // We cannot simply set the interaction to None, as that will trigger change detection repeatedly
-                            interaction.set_if_neq(Interaction::None);
-                        }
+            let Ok(node) = node_query.get_mut(*entity) else {
+                return None;
+            };
 
-                        return None;
-                    }
-                } else {
-                    return None;
-                };
-                let cursor_position = match node.ui_camera.map(UiCamera::entity) {
-                    Some(ui_camera_entity) => {
-                        camera_cursor_positions
-                            .iter()
-                            .find_map(|(camera_entity, position)| {
-                                if *camera_entity == ui_camera_entity {
-                                    Some(*position)
-                                } else {
-                                    None
-                                }
-                            })
-                    }
-                    None =>
-                    // UiCamera is not set, so we use the primary window
-                    {
-                        primary_window
-                            .and_then(|entity| windows.get(entity).ok())
-                            .and_then(|window| window.cursor_position())
-                            .or_else(|| touches_input.first_pressed_position())
+            let Some(view_visibility) = node.view_visibility else {
+                return None;
+            };
+            // Nodes that are not rendered should not be interactable
+            if !view_visibility.get() {
+                // Reset their interaction to None to avoid strange stuck state
+                if let Some(mut interaction) = node.interaction {
+                    // We cannot simply set the interaction to None, as that will trigger change detection repeatedly
+                    interaction.set_if_neq(Interaction::None);
+                }
+                return None;
+            }
+            let Some(camera_entity) = node
+                .ui_camera
+                .map(UiCamera::entity)
+                .or(default_single_camera)
+            else {
+                return None;
+            };
+
+            let cursor_position = camera_cursor_positions
+                .iter()
+                .find_map(|(entity, position)| {
+                    if *entity == camera_entity {
+                        Some(*position)
+                    } else {
+                        None
                     }
-                };
+                });
 
-                let node_rect = node.node.logical_rect(node.global_transform);
+            let node_rect = node.node.logical_rect(node.global_transform);
 
-                // Intersect with the calculated clip rect to find the bounds of the visible region of the node
-                let visible_rect = node
-                    .calculated_clip
-                    .map(|clip| node_rect.intersect(clip.clip))
-                    .unwrap_or(node_rect);
+            // Intersect with the calculated clip rect to find the bounds of the visible region of the node
+            let visible_rect = node
+                .calculated_clip
+                .map(|clip| node_rect.intersect(clip.clip))
+                .unwrap_or(node_rect);
 
-                // The mouse position relative to the node
-                // (0., 0.) is the top-left corner, (1., 1.) is the bottom-right corner
-                // Coordinates are relative to the entire node, not just the visible region.
-                let relative_cursor_position = cursor_position
-                    .map(|cursor_position| (cursor_position - node_rect.min) / node_rect.size());
+            // The mouse position relative to the node
+            // (0., 0.) is the top-left corner, (1., 1.) is the bottom-right corner
+            // Coordinates are relative to the entire node, not just the visible region.
+            let relative_cursor_position = cursor_position
+                .map(|cursor_position| (cursor_position - node_rect.min) / node_rect.size());
 
-                // If the current cursor position is within the bounds of the node's visible area, consider it for
-                // clicking
-                let relative_cursor_position_component = RelativeCursorPosition {
-                    normalized_visible_node_rect: visible_rect.normalize(node_rect),
-                    normalized: relative_cursor_position,
-                };
+            // If the current cursor position is within the bounds of the node's visible area, consider it for
+            // clicking
+            let relative_cursor_position_component = RelativeCursorPosition {
+                normalized_visible_node_rect: visible_rect.normalize(node_rect),
+                normalized: relative_cursor_position,
+            };
 
-                let contains_cursor = relative_cursor_position_component.mouse_over();
+            let contains_cursor = relative_cursor_position_component.mouse_over();
 
-                // Save the relative cursor position to the correct component
-                if let Some(mut node_relative_cursor_position_component) =
-                    node.relative_cursor_position
-                {
-                    *node_relative_cursor_position_component = relative_cursor_position_component;
-                }
+            // Save the relative cursor position to the correct component
+            if let Some(mut node_relative_cursor_position_component) = node.relative_cursor_position
+            {
+                *node_relative_cursor_position_component = relative_cursor_position_component;
+            }
 
-                if contains_cursor {
-                    Some(*entity)
-                } else {
-                    if let Some(mut interaction) = node.interaction {
-                        if *interaction == Interaction::Hovered || (cursor_position.is_none()) {
-                            interaction.set_if_neq(Interaction::None);
-                        }
+            if contains_cursor {
+                Some(*entity)
+            } else {
+                if let Some(mut interaction) = node.interaction {
+                    if *interaction == Interaction::Hovered || (cursor_position.is_none()) {
+                        interaction.set_if_neq(Interaction::None);
                     }
-                    None
                 }
-            } else {
                 None
             }
         })
diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index 22e9ca80ca0b7..37fb5c2b88845 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -33,7 +33,7 @@ pub fn print_ui_layout_tree(ui_surface: &UiSurface) {
 fn print_node(
     ui_surface: &UiSurface,
     taffy_to_entity: &HashMap<Node, Entity>,
-    entity: Option<Entity>,
+    entity: Entity,
     node: Node,
     has_sibling: bool,
     lines_string: String,
@@ -79,7 +79,7 @@ fn print_node(
         print_node(
             ui_surface,
             taffy_to_entity,
-            Some(*child_entity),
+            *child_entity,
             *child_node,
             has_sibling,
             new_string.clone(),
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 730ddeba7a661..eed33ffda69c1 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -52,7 +52,7 @@ struct RootNodePair {
 #[derive(Resource)]
 pub struct UiSurface {
     entity_to_taffy: HashMap<Entity, taffy::node::Node>,
-    camera_roots: HashMap<Option<Entity>, Vec<RootNodePair>>,
+    camera_roots: HashMap<Entity, Vec<RootNodePair>>,
     taffy: Taffy,
 }
 
@@ -145,7 +145,7 @@ without UI components as a child of an entity with UI components, results may be
     /// Set the ui node entities without a [`Parent`] as children to the root node in the taffy layout.
     pub fn set_camera_children(
         &mut self,
-        camera_id: Option<Entity>,
+        camera_id: Entity,
         children: impl Iterator<Item = Entity>,
     ) {
         let viewport_style = taffy::style::Style {
@@ -190,11 +190,7 @@ without UI components as a child of an entity with UI components, results may be
     }
 
     /// Compute the layout for each window entity's corresponding root node in the layout.
-    pub fn compute_camera_layout(
-        &mut self,
-        camera: Option<Entity>,
-        render_target_resolution: UVec2,
-    ) {
+    pub fn compute_camera_layout(&mut self, camera: Entity, render_target_resolution: UVec2) {
         let Some(camera_root_nodes) = self.camera_roots.get(&camera) else {
             return;
         };
@@ -248,7 +244,7 @@ pub enum LayoutError {
 #[allow(clippy::too_many_arguments)]
 pub fn ui_layout_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
-    cameras: Query<&Camera>,
+    cameras: Query<(Entity, &Camera)>,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut resize_events: EventReader<bevy_window::WindowResized>,
@@ -264,85 +260,85 @@ pub fn ui_layout_system(
     mut node_transform_query: Query<(&mut Node, &mut Transform)>,
 ) {
     struct CameraLayoutInfo {
-        root_nodes: Vec<Entity>,
         size: UVec2,
-        scale_factor: f64,
         resized: bool,
+        scale_factor: f64,
+        root_nodes: Vec<Entity>,
     }
 
+    // If there is only one camera, we use it as default
+    let default_single_camera = cameras.get_single().ok().map(|(entity, _)| entity);
+    let camera_with_default =
+        |ui_camera: Option<&UiCamera>| ui_camera.map(UiCamera::entity).or(default_single_camera);
+
     let resized_windows: HashSet<Entity> = resize_events.read().map(|event| event.window).collect();
-    let default_camera_layout_into = || {
-        let (size, scale_factor, resized) = primary_window
-            .get_single()
-            .map(|(entity, window)| {
-                (
-                    [window.physical_width(), window.physical_height()].into(),
-                    window.scale_factor(),
-                    resized_windows.contains(&entity),
-                )
-            })
-            .unwrap_or((UVec2::ZERO, 1.0, false));
+    let calculate_camera_layout_info = |camera: &Camera| {
+        let size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
+        let scale_factor = camera.target_scaling_factor().unwrap_or(1.0);
+        let camera_target = camera
+            .target
+            .normalize(primary_window.get_single().map(|(e, _)| e).ok());
+        let resized = matches!(camera_target,
+          Some(NormalizedRenderTarget::Window(window_ref)) if resized_windows.contains(&window_ref.entity())
+        );
         CameraLayoutInfo {
-            root_nodes: Vec::new(),
             size,
-            scale_factor: scale_factor * ui_scale.0,
             resized,
+            scale_factor: scale_factor * ui_scale.0,
+            root_nodes: Vec::new(),
         }
     };
-    let calculate_camera_layout_info = |ui_camera: &Option<Entity>| match ui_camera {
-        Some(camera_id) => {
-            let Ok(camera) = cameras.get(*camera_id) else {
-                warn!(
-                    "UiCamera is pointing to a camera {:?} which doesn't exist",
-                    camera_id
-                );
-                return default_camera_layout_into();
-            };
-
-            let size = camera.physical_viewport_size().unwrap_or(UVec2::ZERO);
-            let scale_factor = camera.target_scaling_factor().unwrap_or(1.0);
-            let camera_target = camera
-                .target
-                .normalize(primary_window.get_single().map(|(e, _)| e).ok());
-            let resized = matches!(camera_target,
-              Some(NormalizedRenderTarget::Window(window_ref)) if resized_windows.contains(&window_ref.entity())
-            );
 
-            CameraLayoutInfo {
-                root_nodes: Vec::new(),
-                size,
-                scale_factor: scale_factor * ui_scale.0,
-                resized,
+    // Precalculate the layout info for each camera, so we have fast access to it for each node
+    let mut camera_layout_info: HashMap<Entity, CameraLayoutInfo> = HashMap::new();
+    for (entity, ui_camera) in &root_node_query {
+        match camera_with_default(ui_camera) {
+            Some(camera_entity) => {
+                let Ok((_, camera)) = cameras.get(camera_entity) else {
+                    warn!(
+                        "UiCamera is pointing to a camera {:?} which doesn't exist",
+                        camera_entity
+                    );
+                    continue;
+                };
+                let layout_info = camera_layout_info
+                    .entry(camera_entity)
+                    .or_insert_with(|| calculate_camera_layout_info(&camera));
+                layout_info.root_nodes.push(entity);
+            }
+            None => {
+                if cameras.is_empty() {
+                    warn!("No camera found to render UI to. To fix this, add at least one camera to the scene.");
+                } else {
+                    warn!(
+                        "Multiple cameras found, causing UI target ambiguity. \
+                        To fix this, add an explicit `UiCamera` component to root UI node {:?}",
+                        entity
+                    );
+                }
+                continue;
             }
         }
-        None => default_camera_layout_into(),
-    };
-
-    // Precalculate the layout info for each camera, so we have fast access to it for each node
-    let mut camera_layout_info: HashMap<Option<Entity>, CameraLayoutInfo> = HashMap::new();
-    for (entity, camera) in &root_node_query {
-        let camera_entity = camera.map(UiCamera::entity);
-        let layout_into = camera_layout_info
-            .entry(camera_entity)
-            .or_insert_with(|| calculate_camera_layout_info(&camera_entity));
-        layout_into.root_nodes.push(entity);
     }
 
     // Resize all nodes
     for (entity, style, ui_camera) in style_query.iter() {
-        let camera = camera_layout_info
-            .get(&ui_camera.map(UiCamera::entity))
-            .unwrap();
-        if camera.resized
-            || !scale_factor_events.is_empty()
-            || ui_scale.is_changed()
-            || style.is_changed()
+        if let Some(camera) =
+            camera_with_default(ui_camera).and_then(|c| camera_layout_info.get(&c))
         {
-            let layout_context = LayoutContext::new(
-                camera.scale_factor,
-                [camera.size.x as f32, camera.size.y as f32].into(),
-            );
-            ui_surface.upsert_node(entity, &style, &layout_context);
+            if camera.resized
+                || !scale_factor_events.is_empty()
+                || ui_scale.is_changed()
+                || style.is_changed()
+            {
+                let layout_context = LayoutContext::new(
+                    camera.scale_factor,
+                    [camera.size.x as f32, camera.size.y as f32].into(),
+                );
+                ui_surface.upsert_node(entity, &style, &layout_context);
+            }
+        } else {
+            continue;
         }
     }
     scale_factor_events.clear();
@@ -502,10 +498,16 @@ mod tests {
     use crate::layout::round_layout_coords;
     use crate::prelude::*;
     use crate::ui_layout_system;
+    use crate::update::update_ui_camera_system;
     use crate::ContentSize;
     use crate::UiSurface;
+    use bevy_asset::AssetEvent;
+    use bevy_asset::Assets;
+    use bevy_core_pipeline::core_2d::Camera2dBundle;
     use bevy_ecs::entity::Entity;
     use bevy_ecs::event::Events;
+    use bevy_ecs::schedule::apply_deferred;
+    use bevy_ecs::schedule::IntoSystemConfigs;
     use bevy_ecs::schedule::Schedule;
     use bevy_ecs::world::World;
     use bevy_hierarchy::despawn_with_children_recursive;
@@ -513,10 +515,14 @@ mod tests {
     use bevy_hierarchy::Children;
     use bevy_math::vec2;
     use bevy_math::Vec2;
+    use bevy_render::camera::ManualTextureViews;
+    use bevy_render::camera::OrthographicProjection;
+    use bevy_render::texture::Image;
     use bevy_utils::prelude::default;
     use bevy_utils::HashMap;
     use bevy_window::PrimaryWindow;
     use bevy_window::Window;
+    use bevy_window::WindowCreated;
     use bevy_window::WindowResized;
     use bevy_window::WindowResolution;
     use bevy_window::WindowScaleFactorChanged;
@@ -537,8 +543,13 @@ mod tests {
         world.init_resource::<UiSurface>();
         world.init_resource::<Events<WindowScaleFactorChanged>>();
         world.init_resource::<Events<WindowResized>>();
+        // Required for the camera system
+        world.init_resource::<Events<WindowCreated>>();
+        world.init_resource::<Events<AssetEvent<Image>>>();
+        world.init_resource::<Assets<Image>>();
+        world.init_resource::<ManualTextureViews>();
 
-        // spawn a dummy primary window
+        // spawn a dummy primary window and camera
         world.spawn((
             Window {
                 resolution: WindowResolution::new(WINDOW_WIDTH, WINDOW_HEIGHT),
@@ -546,9 +557,19 @@ mod tests {
             },
             PrimaryWindow,
         ));
+        world.spawn(Camera2dBundle::default());
 
         let mut ui_schedule = Schedule::default();
-        ui_schedule.add_systems(ui_layout_system);
+        ui_schedule.add_systems(
+            (
+                // UI is driven by calculated camera target info, so we need to run the camera system first
+                bevy_render::camera::camera_system::<OrthographicProjection>,
+                update_ui_camera_system,
+                apply_deferred,
+                ui_layout_system,
+            )
+                .chain(),
+        );
 
         (world, ui_schedule)
     }
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index c2e35e50a1c6a..20504d23298bc 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -3,12 +3,11 @@ mod render_pass;
 mod ui_material_pipeline;
 
 use bevy_core_pipeline::{core_2d::Camera2d, core_3d::Camera3d};
-
 use bevy_hierarchy::Parent;
-use bevy_render::camera::{ExtractedCamera, NormalizedRenderTarget};
-use bevy_render::render_phase::PhaseItem;
-use bevy_render::view::{ExtractedWindows, ViewVisibility};
-use bevy_render::{render_resource::BindGroupEntries, ExtractSchedule, Render};
+use bevy_render::{
+    render_phase::PhaseItem, render_resource::BindGroupEntries, view::ViewVisibility,
+    ExtractSchedule, Render,
+};
 pub use pipeline::*;
 pub use render_pass::*;
 pub use ui_material_pipeline::*;
@@ -41,7 +40,6 @@ use bevy_sprite::{SpriteAssetEvents, TextureAtlas};
 use bevy_text::{PositionedGlyph, Text, TextLayoutInfo};
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::{EntityHashMap, FloatOrd, HashMap};
-use bevy_window::{PrimaryWindow, Window};
 use bytemuck::{Pod, Zeroable};
 use std::ops::Range;
 
@@ -166,7 +164,10 @@ pub struct ExtractedUiNode {
     pub clip: Option<Rect>,
     pub flip_x: bool,
     pub flip_y: bool,
-    pub camera_entity: Option<Entity>,
+    // Camera to render this UI node to. By the time it is extracted,
+    // it is defaulted to a single camera if only one exists.
+    // Nodes with ambiguous camera will be ignored.
+    pub camera_entity: Entity,
 }
 
 #[derive(Resource, Default)]
@@ -178,6 +179,7 @@ pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
+    camera_query: Extract<Query<Entity, With<Camera>>>,
     uinode_query: Extract<
         Query<
             (
@@ -195,6 +197,8 @@ pub fn extract_atlas_uinodes(
         >,
     >,
 ) {
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok();
     for (
         entity,
         uinode,
@@ -207,6 +211,9 @@ pub fn extract_atlas_uinodes(
         camera,
     ) in uinode_query.iter()
     {
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+            continue;
+        };
         // Skip invisible and completely transparent nodes
         if !view_visibility.get() || color.0.is_fully_transparent() {
             continue;
@@ -256,7 +263,7 @@ pub fn extract_atlas_uinodes(
                 atlas_size: Some(atlas_size),
                 flip_x: atlas_image.flip_x,
                 flip_y: atlas_image.flip_y,
-                camera_entity: camera.map(UiCamera::entity),
+                camera_entity,
             },
         );
     }
@@ -277,8 +284,7 @@ pub(crate) fn resolve_border_thickness(value: Val, parent_width: f32, viewport_s
 pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    primary_window: Extract<Query<&Window, With<PrimaryWindow>>>,
-    camera_query: Extract<Query<&Camera>>,
+    camera_query: Extract<Query<(Entity, &Camera)>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<
@@ -297,11 +303,16 @@ pub fn extract_uinode_borders(
     >,
     node_query: Extract<Query<&Node>>,
 ) {
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok().map(|(entity, _)| entity);
     let image = AssetId::<Image>::default();
 
     for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
-        uinode_query.iter()
+        &uinode_query
     {
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+            continue;
+        };
         // Skip invisible borders
         if !view_visibility.get()
             || border_color.0.is_fully_transparent()
@@ -311,17 +322,10 @@ pub fn extract_uinode_borders(
             continue;
         }
 
-        let target_logical_viewport_size = match camera {
-            Some(UiCamera(camera_entity)) => camera_query
-                .get(*camera_entity)
-                .ok()
-                .and_then(|c| c.logical_viewport_size()),
-            None => primary_window
-                .get_single()
-                .map(|w| [w.resolution.width(), w.resolution.height()].into())
-                .ok(),
-        };
-        let ui_logical_viewport_size = target_logical_viewport_size
+        let ui_logical_viewport_size = camera_query
+            .get(camera_entity)
+            .ok()
+            .and_then(|(_, c)| c.logical_viewport_size())
             .unwrap_or(Vec2::ZERO)
             // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
             // so we have to divide by `UiScale` to get the size of the UI viewport.
@@ -391,7 +395,7 @@ pub fn extract_uinode_borders(
                         clip: clip.map(|clip| clip.clip),
                         flip_x: false,
                         flip_y: false,
-                        camera_entity: camera.map(UiCamera::entity),
+                        camera_entity,
                     },
                 );
             }
@@ -402,6 +406,7 @@ pub fn extract_uinode_borders(
 pub fn extract_uinode_outlines(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
+    camera_query: Extract<Query<Entity, With<Camera>>>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -414,10 +419,13 @@ pub fn extract_uinode_outlines(
     >,
     clip_query: Query<&CalculatedClip>,
 ) {
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok();
     let image = AssetId::<Image>::default();
-    for (node, global_transform, outline, view_visibility, maybe_parent, camera) in
-        uinode_query.iter()
-    {
+    for (node, global_transform, outline, view_visibility, maybe_parent, camera) in &uinode_query {
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+            continue;
+        };
         // Skip invisible outlines
         if !view_visibility.get()
             || outline.color.is_fully_transparent()
@@ -484,7 +492,7 @@ pub fn extract_uinode_outlines(
                         clip,
                         flip_x: false,
                         flip_y: false,
-                        camera_entity: camera.map(UiCamera::entity),
+                        camera_entity,
                     },
                 );
             }
@@ -495,6 +503,7 @@ pub fn extract_uinode_outlines(
 pub fn extract_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
+    camera_query: Extract<Query<Entity, With<Camera>>>,
     uinode_query: Extract<
         Query<
             (
@@ -511,9 +520,14 @@ pub fn extract_uinodes(
         >,
     >,
 ) {
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok();
     for (entity, uinode, transform, color, maybe_image, view_visibility, clip, camera) in
         uinode_query.iter()
     {
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+            continue;
+        };
         // Skip invisible and completely transparent nodes
         if !view_visibility.get() || color.0.is_fully_transparent() {
             continue;
@@ -544,7 +558,7 @@ pub fn extract_uinodes(
                 atlas_size: None,
                 flip_x,
                 flip_y,
-                camera_entity: camera.map(UiCamera::entity),
+                camera_entity,
             },
         );
     }
@@ -633,8 +647,7 @@ pub fn extract_default_ui_camera_view<T: Component>(
 pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    camera_query: Extract<Query<&Camera>>,
-    primary_window: Extract<Query<&Window, With<PrimaryWindow>>>,
+    camera_query: Extract<Query<(Entity, &Camera)>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
@@ -649,25 +662,25 @@ pub fn extract_text_uinodes(
         )>,
     >,
 ) {
+    // If there is only one camera, we use it as default
+    let default_single_camera = camera_query.get_single().ok().map(|(entity, _)| entity);
     for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
+        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+            continue;
+        };
         // Skip if not visible or if size is set to zero (e.g. when a parent is set to `Display::None`)
         if !view_visibility.get() || uinode.size().x == 0. || uinode.size().y == 0. {
             continue;
         }
-        let target_scale_factor = match camera {
-            Some(UiCamera(camera_entity)) => camera_query
-                .get(*camera_entity)
-                .ok()
-                .and_then(|c| c.target_scaling_factor()),
-
-            None => {
-                // No camera is set, so we use the primary window scale factor
-                primary_window.get_single().map(|w| w.scale_factor()).ok()
-            }
-        };
-        let scale_factor = (target_scale_factor.unwrap_or(1.0) * ui_scale.0) as f32;
+
+        let scale_factor = (camera_query
+            .get(camera_entity)
+            .ok()
+            .and_then(|(_, c)| c.target_scaling_factor())
+            .unwrap_or(1.0)
+            * ui_scale.0) as f32;
         let inverse_scale_factor = scale_factor.recip();
 
         let mut affine = global_transform.affine();
@@ -715,7 +728,7 @@ pub fn extract_text_uinodes(
                     clip: clip.map(|clip| clip.clip),
                     flip_x: false,
                     flip_y: false,
-                    camera_entity: camera.map(UiCamera::entity),
+                    camera_entity,
                 },
             );
         }
@@ -759,7 +772,7 @@ pub(crate) const QUAD_INDICES: [usize; 6] = [0, 2, 3, 0, 1, 2];
 pub struct UiBatch {
     pub range: Range<u32>,
     pub image: AssetId<Image>,
-    pub camera: Option<Entity>,
+    pub camera: Entity,
 }
 
 const TEXTURED_QUAD: u32 = 0;
@@ -767,21 +780,15 @@ const UNTEXTURED_QUAD: u32 = 1;
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_uinodes(
-    extracted_windows: Res<ExtractedWindows>,
     extracted_uinodes: Res<ExtractedUiNodes>,
     ui_pipeline: Res<UiPipeline>,
     mut pipelines: ResMut<SpecializedRenderPipelines<UiPipeline>>,
-    mut views: Query<(
-        Entity,
-        &ExtractedView,
-        Option<&ExtractedCamera>,
-        &mut RenderPhase<TransparentUi>,
-    )>,
+    mut views: Query<(Entity, &ExtractedView, &mut RenderPhase<TransparentUi>)>,
     pipeline_cache: Res<PipelineCache>,
     draw_functions: Res<DrawFunctions<TransparentUi>>,
 ) {
     let draw_function = draw_functions.read().id::<DrawUi>();
-    for (view_entity, view, camera, mut transparent_phase) in &mut views {
+    for (view_entity, view, mut transparent_phase) in &mut views {
         let pipeline = pipelines.specialize(
             &pipeline_cache,
             &ui_pipeline,
@@ -793,26 +800,8 @@ pub fn queue_uinodes(
 
         for (entity, extracted_uinode) in extracted_uinodes.uinodes.iter() {
             // Skip if the node is not in the current view
-            match extracted_uinode.camera_entity {
-                Some(camera_entity) => {
-                    if view_entity != camera_entity {
-                        continue;
-                    }
-                }
-                None => {
-                    // Compare view with primary window if no camera is explicitly set for the node
-                    if let (
-                        Some(NormalizedRenderTarget::Window(window_ref)),
-                        Some(primary_window),
-                    ) = (
-                        camera.and_then(|c| c.target.as_ref()),
-                        extracted_windows.primary,
-                    ) {
-                        if window_ref.entity() != primary_window {
-                            continue;
-                        }
-                    }
-                }
+            if view_entity != extracted_uinode.camera_entity {
+                continue;
             }
 
             transparent_phase.add(TransparentUi {
diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 80712e5b8bae4..9fadcce967fe2 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -3,6 +3,7 @@
 use bevy::{
     prelude::*, render::camera::Viewport, ui::RelativeCursorPosition, winit::WinitSettings,
 };
+use bevy_internal::core_pipeline::clear_color::ClearColorConfig;
 
 fn main() {
     App::new()
@@ -15,35 +16,33 @@ fn main() {
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let camera = commands
-        .spawn(Camera2dBundle {
-            camera: Camera {
-                viewport: Some(Viewport {
-                    physical_position: [200, 100].into(),
-                    physical_size: [600, 600].into(),
-                    ..default()
-                }),
+    commands.spawn(Camera2dBundle {
+        camera_2d: Camera2d {
+            clear_color: ClearColorConfig::None,
+        },
+        camera: Camera {
+            viewport: Some(Viewport {
+                physical_position: [200, 100].into(),
+                physical_size: [600, 600].into(),
                 ..default()
-            },
+            }),
             ..default()
-        })
-        .id();
+        },
+        ..default()
+    });
 
     commands
-        .spawn((
-            UiCamera(camera),
-            NodeBundle {
-                style: Style {
-                    width: Val::Percent(100.),
-                    height: Val::Percent(100.0),
-                    align_items: AlignItems::Center,
-                    justify_content: JustifyContent::Center,
-                    flex_direction: FlexDirection::Column,
-                    ..default()
-                },
+        .spawn((NodeBundle {
+            style: Style {
+                width: Val::Percent(100.),
+                height: Val::Percent(100.0),
+                align_items: AlignItems::Center,
+                justify_content: JustifyContent::Center,
+                flex_direction: FlexDirection::Column,
                 ..default()
             },
-        ))
+            ..default()
+        },))
         .with_children(|parent| {
             parent
                 .spawn(NodeBundle {

From 1d36e126fdf2896dc02f8904af90ce683e00c47d Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 3 Dec 2023 21:00:29 +0100
Subject: [PATCH 27/36] Reduce number of iterations over nodes

---
 crates/bevy_ui/src/render/mod.rs | 44 ++++++++++++++------------------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 20504d23298bc..23434555351e2 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -783,40 +783,34 @@ pub fn queue_uinodes(
     extracted_uinodes: Res<ExtractedUiNodes>,
     ui_pipeline: Res<UiPipeline>,
     mut pipelines: ResMut<SpecializedRenderPipelines<UiPipeline>>,
-    mut views: Query<(Entity, &ExtractedView, &mut RenderPhase<TransparentUi>)>,
+    mut views: Query<(&ExtractedView, &mut RenderPhase<TransparentUi>)>,
     pipeline_cache: Res<PipelineCache>,
     draw_functions: Res<DrawFunctions<TransparentUi>>,
 ) {
     let draw_function = draw_functions.read().id::<DrawUi>();
-    for (view_entity, view, mut transparent_phase) in &mut views {
+    for (entity, extracted_uinode) in extracted_uinodes.uinodes.iter() {
+        let Ok((view, mut transparent_phase)) = views.get_mut(extracted_uinode.camera_entity)
+        else {
+            continue;
+        };
+
         let pipeline = pipelines.specialize(
             &pipeline_cache,
             &ui_pipeline,
             UiPipelineKey { hdr: view.hdr },
         );
-        transparent_phase
-            .items
-            .reserve(extracted_uinodes.uinodes.len());
-
-        for (entity, extracted_uinode) in extracted_uinodes.uinodes.iter() {
-            // Skip if the node is not in the current view
-            if view_entity != extracted_uinode.camera_entity {
-                continue;
-            }
-
-            transparent_phase.add(TransparentUi {
-                draw_function,
-                pipeline,
-                entity: *entity,
-                sort_key: (
-                    FloatOrd(extracted_uinode.stack_index as f32),
-                    entity.index(),
-                ),
-                // batch_range will be calculated in prepare_uinodes
-                batch_range: 0..0,
-                dynamic_offset: None,
-            });
-        }
+        transparent_phase.add(TransparentUi {
+            draw_function,
+            pipeline,
+            entity: *entity,
+            sort_key: (
+                FloatOrd(extracted_uinode.stack_index as f32),
+                entity.index(),
+            ),
+            // batch_range will be calculated in prepare_uinodes
+            batch_range: 0..0,
+            dynamic_offset: None,
+        });
     }
 }
 

From 3116a58973b1e7eb2ce5c8611f8770c6b2616af1 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 3 Dec 2023 21:05:03 +0100
Subject: [PATCH 28/36] Clippy fix

---
 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 eed33ffda69c1..95dc6503319a9 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -303,7 +303,7 @@ pub fn ui_layout_system(
                 };
                 let layout_info = camera_layout_info
                     .entry(camera_entity)
-                    .or_insert_with(|| calculate_camera_layout_info(&camera));
+                    .or_insert_with(|| calculate_camera_layout_info(camera));
                 layout_info.root_nodes.push(entity);
             }
             None => {

From aa3a7149b5ff1ddf76a851c46502b7a47d54f023 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Sun, 3 Dec 2023 21:15:39 +0100
Subject: [PATCH 29/36] Fix imports in example

---
 examples/ui/relative_cursor_position.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 9fadcce967fe2..294d09b4da986 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -3,7 +3,6 @@
 use bevy::{
     prelude::*, render::camera::Viewport, ui::RelativeCursorPosition, winit::WinitSettings,
 };
-use bevy_internal::core_pipeline::clear_color::ClearColorConfig;
 
 fn main() {
     App::new()
@@ -17,10 +16,8 @@ fn main() {
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.spawn(Camera2dBundle {
-        camera_2d: Camera2d {
-            clear_color: ClearColorConfig::None,
-        },
         camera: Camera {
+            // Cursor position will take the viewport offset into account
             viewport: Some(Viewport {
                 physical_position: [200, 100].into(),
                 physical_size: [600, 600].into(),

From 9b06ca2a43e1e8b46aa68ceba04ebebf7edb9d6e Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 15 Dec 2023 20:22:16 +0100
Subject: [PATCH 30/36] Rename UiCamera to TargetCamera

---
 crates/bevy_ui/src/focus.rs             |  8 +++---
 crates/bevy_ui/src/layout/mod.rs        | 33 ++++++++++-----------
 crates/bevy_ui/src/lib.rs               |  8 +++---
 crates/bevy_ui/src/render/mod.rs        | 22 +++++++-------
 crates/bevy_ui/src/ui_node.rs           | 12 ++++++--
 crates/bevy_ui/src/update.rs            | 38 ++++++++++++-------------
 examples/3d/split_screen.rs             | 12 ++++----
 examples/ui/relative_cursor_position.rs |  4 +--
 examples/ui/render_ui_to_texture.rs     |  2 +-
 examples/window/multiple_windows.rs     | 21 +++++++-------
 10 files changed, 84 insertions(+), 76 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index d3c3e56a45f36..efce658aad77e 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, UiCamera, UiScale, UiStack};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, TargetCamera, UiScale, UiStack};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
@@ -116,7 +116,7 @@ pub struct NodeQuery {
     focus_policy: Option<&'static FocusPolicy>,
     calculated_clip: Option<&'static CalculatedClip>,
     view_visibility: Option<&'static ViewVisibility>,
-    ui_camera: Option<&'static UiCamera>,
+    target_camera: Option<&'static TargetCamera>,
 }
 
 /// The system that sets Interaction for all UI elements based on the mouse cursor activity
@@ -216,8 +216,8 @@ pub fn ui_focus_system(
                 return None;
             }
             let Some(camera_entity) = node
-                .ui_camera
-                .map(UiCamera::entity)
+                .target_camera
+                .map(TargetCamera::entity)
                 .or(default_single_camera)
             else {
                 return None;
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 95dc6503319a9..6e7788ed7991d 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, Outline, Style, UiCamera, UiScale};
+use crate::{ContentSize, Node, Outline, Style, TargetCamera, UiScale};
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
     entity::Entity,
@@ -249,8 +249,8 @@ 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, Option<&UiCamera>), (With<Node>, Without<Parent>)>,
-    style_query: Query<(Entity, Ref<Style>, Option<&UiCamera>), With<Node>>,
+    root_node_query: Query<(Entity, Option<&TargetCamera>), (With<Node>, Without<Parent>)>,
+    style_query: Query<(Entity, Ref<Style>, Option<&TargetCamera>), With<Node>>,
     mut measure_query: Query<(Entity, &mut ContentSize)>,
     children_query: Query<(Entity, Ref<Children>), With<Node>>,
     just_children_query: Query<&Children>,
@@ -268,8 +268,11 @@ pub fn ui_layout_system(
 
     // If there is only one camera, we use it as default
     let default_single_camera = cameras.get_single().ok().map(|(entity, _)| entity);
-    let camera_with_default =
-        |ui_camera: Option<&UiCamera>| ui_camera.map(UiCamera::entity).or(default_single_camera);
+    let camera_with_default = |target_camera: Option<&TargetCamera>| {
+        target_camera
+            .map(TargetCamera::entity)
+            .or(default_single_camera)
+    };
 
     let resized_windows: HashSet<Entity> = resize_events.read().map(|event| event.window).collect();
     let calculate_camera_layout_info = |camera: &Camera| {
@@ -291,12 +294,12 @@ pub fn ui_layout_system(
 
     // Precalculate the layout info for each camera, so we have fast access to it for each node
     let mut camera_layout_info: HashMap<Entity, CameraLayoutInfo> = HashMap::new();
-    for (entity, ui_camera) in &root_node_query {
-        match camera_with_default(ui_camera) {
+    for (entity, target_camera) in &root_node_query {
+        match camera_with_default(target_camera) {
             Some(camera_entity) => {
                 let Ok((_, camera)) = cameras.get(camera_entity) else {
                     warn!(
-                        "UiCamera is pointing to a camera {:?} which doesn't exist",
+                        "TargetCamera is pointing to a camera {:?} which doesn't exist",
                         camera_entity
                     );
                     continue;
@@ -312,7 +315,7 @@ pub fn ui_layout_system(
                 } else {
                     warn!(
                         "Multiple cameras found, causing UI target ambiguity. \
-                        To fix this, add an explicit `UiCamera` component to root UI node {:?}",
+                        To fix this, add an explicit `TargetCamera` component to the root UI node {:?}",
                         entity
                     );
                 }
@@ -322,9 +325,9 @@ pub fn ui_layout_system(
     }
 
     // Resize all nodes
-    for (entity, style, ui_camera) in style_query.iter() {
+    for (entity, style, target_camera) in style_query.iter() {
         if let Some(camera) =
-            camera_with_default(ui_camera).and_then(|c| camera_layout_info.get(&c))
+            camera_with_default(target_camera).and_then(|c| camera_layout_info.get(&c))
         {
             if camera.resized
                 || !scale_factor_events.is_empty()
@@ -337,8 +340,6 @@ pub fn ui_layout_system(
                 );
                 ui_surface.upsert_node(entity, &style, &layout_context);
             }
-        } else {
-            continue;
         }
     }
     scale_factor_events.clear();
@@ -498,7 +499,7 @@ mod tests {
     use crate::layout::round_layout_coords;
     use crate::prelude::*;
     use crate::ui_layout_system;
-    use crate::update::update_ui_camera_system;
+    use crate::update::update_target_camera_system;
     use crate::ContentSize;
     use crate::UiSurface;
     use bevy_asset::AssetEvent;
@@ -553,7 +554,7 @@ mod tests {
         world.spawn((
             Window {
                 resolution: WindowResolution::new(WINDOW_WIDTH, WINDOW_HEIGHT),
-                ..Default::default()
+                ..default()
             },
             PrimaryWindow,
         ));
@@ -564,7 +565,7 @@ mod tests {
             (
                 // UI is driven by calculated camera target info, so we need to run the camera system first
                 bevy_render::camera::camera_system::<OrthographicProjection>,
-                update_ui_camera_system,
+                update_target_camera_system,
                 apply_deferred,
                 ui_layout_system,
             )
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 91c72debc8dbc..f12c08b41f1c9 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -52,7 +52,7 @@ use bevy_render::{extract_component::ExtractComponentPlugin, texture::Image, Ren
 use bevy_transform::TransformSystem;
 use stack::ui_stack_system;
 pub use stack::UiStack;
-use update::{update_clipping_system, update_ui_camera_system};
+use update::{update_clipping_system, update_target_camera_system};
 
 /// The basic plugin for Bevy UI
 #[derive(Default)]
@@ -117,7 +117,7 @@ impl Plugin for UiPlugin {
             .register_type::<RelativeCursorPosition>()
             .register_type::<RepeatedGridTrack>()
             .register_type::<Style>()
-            .register_type::<UiCamera>()
+            .register_type::<TargetCamera>()
             .register_type::<UiCameraConfig>()
             .register_type::<UiImage>()
             .register_type::<UiImageSize>()
@@ -180,11 +180,11 @@ impl Plugin for UiPlugin {
             (
                 (
                     widget::update_atlas_content_size_system,
-                    update_ui_camera_system,
+                    update_target_camera_system,
                 )
                     .before(UiSystem::Layout),
                 apply_deferred
-                    .after(update_ui_camera_system)
+                    .after(update_target_camera_system)
                     .before(UiSystem::Layout),
                 ui_layout_system
                     .in_set(UiSystem::Layout)
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 23434555351e2..f7c634118ee14 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -16,7 +16,7 @@ use crate::{
     prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
     Style, UiImage, UiScale, UiTextureAtlasImage, Val,
 };
-use crate::{Outline, UiCamera};
+use crate::{Outline, TargetCamera};
 
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, AssetId, Assets, Handle};
@@ -191,7 +191,7 @@ pub fn extract_atlas_uinodes(
                 Option<&CalculatedClip>,
                 &Handle<TextureAtlas>,
                 &UiTextureAtlasImage,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<UiImage>,
         >,
@@ -211,7 +211,7 @@ pub fn extract_atlas_uinodes(
         camera,
     ) in uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };
         // Skip invisible and completely transparent nodes
@@ -296,7 +296,7 @@ pub fn extract_uinode_borders(
                 Option<&Parent>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<ContentSize>,
         >,
@@ -310,7 +310,7 @@ pub fn extract_uinode_borders(
     for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
         &uinode_query
     {
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };
         // Skip invisible borders
@@ -414,7 +414,7 @@ pub fn extract_uinode_outlines(
             &Outline,
             &ViewVisibility,
             Option<&Parent>,
-            Option<&UiCamera>,
+            Option<&TargetCamera>,
         )>,
     >,
     clip_query: Query<&CalculatedClip>,
@@ -423,7 +423,7 @@ pub fn extract_uinode_outlines(
     let default_single_camera = camera_query.get_single().ok();
     let image = AssetId::<Image>::default();
     for (node, global_transform, outline, view_visibility, maybe_parent, camera) in &uinode_query {
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };
         // Skip invisible outlines
@@ -514,7 +514,7 @@ pub fn extract_uinodes(
                 Option<&UiImage>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<UiTextureAtlasImage>,
         >,
@@ -525,7 +525,7 @@ pub fn extract_uinodes(
     for (entity, uinode, transform, color, maybe_image, view_visibility, clip, camera) in
         uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };
         // Skip invisible and completely transparent nodes
@@ -658,7 +658,7 @@ pub fn extract_text_uinodes(
             &TextLayoutInfo,
             &ViewVisibility,
             Option<&CalculatedClip>,
-            Option<&UiCamera>,
+            Option<&TargetCamera>,
         )>,
     >,
 ) {
@@ -667,7 +667,7 @@ pub fn extract_text_uinodes(
     for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(UiCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };
         // Skip if not visible or if size is set to zero (e.g. when a parent is set to `Display::None`)
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 5f592372ec47f..9d137a435823d 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1715,10 +1715,18 @@ mod tests {
     }
 }
 
+/// Indicates that this root [`Node`] entity should be rendered to a specific camera.
+/// UI then will be layed out respecting the camera's viewport and scale factor, and
+/// rendered to this camera's [`bevy_render::camera::RenderTarget`].
+///
+/// Setting this component on a non-root node will have no effect. It will be overriden
+/// by the root node's component.
+///
+/// Optional if there is only one camera in the world. Required otherwise.
 #[derive(Component, Clone, Debug, Reflect, Eq, PartialEq)]
-pub struct UiCamera(pub Entity);
+pub struct TargetCamera(pub Entity);
 
-impl UiCamera {
+impl TargetCamera {
     pub fn entity(&self) -> Entity {
         self.0
     }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 6de1ce052ac08..7a7909200c64b 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, OverflowAxis, Style, UiCamera};
+use crate::{CalculatedClip, OverflowAxis, Style, TargetCamera};
 
 use super::Node;
 use bevy_ecs::{
@@ -94,26 +94,26 @@ fn update_clipping(
     }
 }
 
-pub fn update_ui_camera_system(
+pub fn update_target_camera_system(
     mut commands: Commands,
     changed_root_nodes_query: Query<
-        (Entity, Option<&UiCamera>),
-        (With<Node>, Without<Parent>, Changed<UiCamera>),
+        (Entity, Option<&TargetCamera>),
+        (With<Node>, Without<Parent>, Changed<TargetCamera>),
     >,
-    changed_children_query: Query<(Entity, Option<&UiCamera>), (With<Node>, Changed<Children>)>,
+    changed_children_query: Query<(Entity, Option<&TargetCamera>), (With<Node>, Changed<Children>)>,
     children_query: Query<&Children, With<Node>>,
-    node_query: Query<Option<&UiCamera>, With<Node>>,
+    node_query: Query<Option<&TargetCamera>, With<Node>>,
 ) {
     // 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
     let mut updated_entities = HashSet::new();
 
-    // Assuming that UiCamera is manually set on the root node only,
+    // Assuming that TargetCamera is manually set on the root node only,
     // update root nodes first, since it implies the biggest change
-    for (root_node, camera) in &changed_root_nodes_query {
-        update_children_ui_camera(
+    for (root_node, target_camera) in &changed_root_nodes_query {
+        update_children_target_camera(
             root_node,
-            camera,
+            target_camera,
             &node_query,
             &children_query,
             &mut commands,
@@ -121,13 +121,13 @@ pub fn update_ui_camera_system(
         );
     }
 
-    // If the root node UiCamera was changed, then every child is updated
+    // If the root node TargetCamera was changed, then every child is updated
     // by this point, and iteration will be skipped.
     // Otherwise, update changed children
-    for (parent, camera) in &changed_children_query {
-        update_children_ui_camera(
+    for (parent, target_camera) in &changed_children_query {
+        update_children_target_camera(
             parent,
-            camera,
+            target_camera,
             &node_query,
             &children_query,
             &mut commands,
@@ -136,10 +136,10 @@ pub fn update_ui_camera_system(
     }
 }
 
-fn update_children_ui_camera(
+fn update_children_target_camera(
     entity: Entity,
-    camera_to_set: Option<&UiCamera>,
-    node_query: &Query<Option<&UiCamera>, With<Node>>,
+    camera_to_set: Option<&TargetCamera>,
+    node_query: &Query<Option<&TargetCamera>, With<Node>>,
     children_query: &Query<&Children, With<Node>>,
     commands: &mut Commands,
     updated_entities: &mut HashSet<Entity>,
@@ -159,12 +159,12 @@ fn update_children_ui_camera(
                 commands.entity(child).insert(camera.clone());
             }
             None => {
-                commands.entity(child).remove::<UiCamera>();
+                commands.entity(child).remove::<TargetCamera>();
             }
         }
         updated_entities.insert(child);
 
-        update_children_ui_camera(
+        update_children_target_camera(
             child,
             camera_to_set,
             node_query,
diff --git a/examples/3d/split_screen.rs b/examples/3d/split_screen.rs
index 3c3603e8245a6..94a9d9f7317b3 100644
--- a/examples/3d/split_screen.rs
+++ b/examples/3d/split_screen.rs
@@ -86,7 +86,7 @@ fn setup(
     // Set up UI
     commands
         .spawn((
-            UiCamera(left_camera),
+            TargetCamera(left_camera),
             NodeBundle {
                 style: Style {
                     width: Val::Percent(100.),
@@ -109,7 +109,7 @@ fn setup(
 
     commands
         .spawn((
-            UiCamera(right_camera),
+            TargetCamera(right_camera),
             NodeBundle {
                 style: Style {
                     width: Val::Percent(100.),
@@ -232,16 +232,16 @@ fn set_camera_viewports(
 #[allow(clippy::type_complexity)]
 fn button_system(
     interaction_query: Query<
-        (&Interaction, &UiCamera, &RotateCamera),
+        (&Interaction, &TargetCamera, &RotateCamera),
         (Changed<Interaction>, With<Button>),
     >,
     mut camera_query: Query<&mut Transform, With<Camera>>,
 ) {
-    for (interaction, ui_camera, RotateCamera(direction)) in &interaction_query {
+    for (interaction, target_camera, RotateCamera(direction)) in &interaction_query {
         if let Interaction::Pressed = *interaction {
-            // Since UiCamera propagates to the children, we can use it to find
+            // Since TargetCamera propagates to the children, we can use it to find
             // which side of the screen the button is on.
-            if let Ok(mut camera_transform) = camera_query.get_mut(ui_camera.entity()) {
+            if let Ok(mut camera_transform) = camera_query.get_mut(target_camera.entity()) {
                 let angle = match direction {
                     Direction::Left => -0.1,
                     Direction::Right => 0.1,
diff --git a/examples/ui/relative_cursor_position.rs b/examples/ui/relative_cursor_position.rs
index 294d09b4da986..d46be399aba82 100644
--- a/examples/ui/relative_cursor_position.rs
+++ b/examples/ui/relative_cursor_position.rs
@@ -29,7 +29,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 
     commands
-        .spawn((NodeBundle {
+        .spawn(NodeBundle {
             style: Style {
                 width: Val::Percent(100.),
                 height: Val::Percent(100.0),
@@ -39,7 +39,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 ..default()
             },
             ..default()
-        },))
+        })
         .with_children(|parent| {
             parent
                 .spawn(NodeBundle {
diff --git a/examples/ui/render_ui_to_texture.rs b/examples/ui/render_ui_to_texture.rs
index 490b057b19fbb..ff97d841703d3 100644
--- a/examples/ui/render_ui_to_texture.rs
+++ b/examples/ui/render_ui_to_texture.rs
@@ -91,7 +91,7 @@ fn setup(
                 background_color: Color::GOLD.into(),
                 ..default()
             },
-            UiCamera(texture_camera),
+            TargetCamera(texture_camera),
         ))
         .with_children(|parent| {
             parent.spawn(TextBundle::from_section(
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index 486be9b6b7361..041787308d039 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -22,12 +22,13 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
         transform: Transform::from_xyz(4.0, 5.0, 4.0),
         ..default()
     });
-    // main camera, cameras default to the primary window
-    // so we don't need to specify that.
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(0.0, 0.0, 6.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
+
+    let first_window_camera = commands
+        .spawn(Camera3dBundle {
+            transform: Transform::from_xyz(0.0, 0.0, 6.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        })
+        .id();
 
     // Spawn a second window
     let second_window = commands
@@ -37,7 +38,6 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
         })
         .id();
 
-    // second window camera
     let second_window_camera = commands
         .spawn(Camera3dBundle {
             transform: Transform::from_xyz(6.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
@@ -49,18 +49,17 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
         })
         .id();
 
-    // UI defaults to the primary window, no need to explicitly set the UiCamera on the root node
+    // Since we are using multiple cameras, we need to specify which camera UI should be rendered to
     commands
-        .spawn(NodeBundle::default())
+        .spawn((NodeBundle::default(), TargetCamera(first_window_camera)))
         .with_children(|parent| {
             parent.spawn(TextBundle::from_section(
                 "First window",
                 TextStyle::default(),
             ));
         });
-
     commands
-        .spawn((NodeBundle::default(), UiCamera(second_window_camera)))
+        .spawn((NodeBundle::default(), TargetCamera(second_window_camera)))
         .with_children(|parent| {
             parent.spawn(TextBundle::from_section(
                 "Second window",

From ccc6b51ec78a6eb1faf8591d139c8076e1484342 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman@bardt.me>
Date: Fri, 15 Dec 2023 20:40:34 +0100
Subject: [PATCH 31/36] Fix compilation issues after merging main

---
 crates/bevy_render/src/camera/camera.rs | 4 ++--
 crates/bevy_ui/src/layout/mod.rs        | 2 +-
 crates/bevy_ui/src/render/mod.rs        | 3 +--
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 803cd059fbd1c..884e0d02f771f 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -223,7 +223,7 @@ impl Camera {
     }
 
     #[inline]
-    pub fn target_scaling_factor(&self) -> Option<f64> {
+    pub fn target_scaling_factor(&self) -> Option<f32> {
         self.computed.target_info.as_ref().map(|t| t.scale_factor)
     }
 
@@ -638,7 +638,7 @@ pub fn camera_system<T: CameraProjection + Component>(
                     ) {
                         let resize_factor = new_scale_factor / old_scale_factor;
                         if let Some(ref mut viewport) = camera.viewport {
-                            let resize = |vec: UVec2| (vec.as_dvec2() * resize_factor).as_uvec2();
+                            let resize = |vec: UVec2| (vec.as_vec2() * resize_factor).as_uvec2();
                             viewport.physical_position = resize(viewport.physical_position);
                             viewport.physical_size = resize(viewport.physical_size);
                             viewport_size = Some(viewport.physical_size);
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 1b2d9dda415f5..41d0210839010 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -262,7 +262,7 @@ pub fn ui_layout_system(
     struct CameraLayoutInfo {
         size: UVec2,
         resized: bool,
-        scale_factor: f64,
+        scale_factor: f32,
         root_nodes: Vec<Entity>,
     }
 
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 84ae3db9ca3ac..27a503397e529 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -413,7 +413,6 @@ pub fn extract_uinode_outlines(
             &Outline,
             &ViewVisibility,
             Option<&CalculatedClip>,
-            Option<&Parent>,
             Option<&TargetCamera>,
         )>,
     >,
@@ -421,7 +420,7 @@ pub fn extract_uinode_outlines(
     // If there is only one camera, we use it as default
     let default_single_camera = camera_query.get_single().ok();
     let image = AssetId::<Image>::default();
-    for (node, global_transform, outline, view_visibility, maybe_clip, maybe_parent, camera) in &uinode_query {
+    for (node, global_transform, outline, view_visibility, maybe_clip, camera) in &uinode_query {
         let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
             continue;
         };

From 085fce0e5e24f774d580281379a2efa0e2f4bdb3 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman.salnikov@insurello.se>
Date: Sun, 14 Jan 2024 19:46:43 +0100
Subject: [PATCH 32/36] Predefined query for default UI camera

---
 crates/bevy_ui/src/focus.rs      | 10 +++++----
 crates/bevy_ui/src/layout/mod.rs |  7 +++----
 crates/bevy_ui/src/render/mod.rs | 35 +++++++++++++++-----------------
 crates/bevy_ui/src/ui_node.rs    | 29 ++++++++++++++++++++++++--
 4 files changed, 52 insertions(+), 29 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index aff792ff0eea6..49f693e827d38 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,4 +1,7 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, TargetCamera, UiScale, UiStack};
+use crate::{
+    camera_config::UiCameraConfig, CalculatedClip, DefaultUiCamera, Node, TargetCamera, UiScale,
+    UiStack,
+};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
@@ -143,6 +146,7 @@ pub struct NodeQuery {
 pub fn ui_focus_system(
     mut state: Local<State>,
     camera_query: Query<(Entity, &Camera, Option<&UiCameraConfig>)>,
+    default_ui_camera: DefaultUiCamera,
     primary_window: Query<Entity, With<PrimaryWindow>>,
     windows: Query<&Window>,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
@@ -178,8 +182,6 @@ pub fn ui_focus_system(
     let is_ui_disabled =
         |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
 
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok().map(|(entity, _, _)| entity);
     let camera_cursor_positions: Vec<(Entity, Vec2)> = camera_query
         .iter()
         .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
@@ -235,7 +237,7 @@ pub fn ui_focus_system(
             let Some(camera_entity) = node
                 .target_camera
                 .map(TargetCamera::entity)
-                .or(default_single_camera)
+                .or(default_ui_camera.get())
             else {
                 return None;
             };
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 41d0210839010..6edae1c9c7de3 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, Outline, Style, TargetCamera, UiScale};
+use crate::{ContentSize, DefaultUiCamera, Node, Outline, Style, TargetCamera, UiScale};
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
     entity::Entity,
@@ -245,6 +245,7 @@ pub enum LayoutError {
 pub fn ui_layout_system(
     primary_window: Query<(Entity, &Window), With<PrimaryWindow>>,
     cameras: Query<(Entity, &Camera)>,
+    default_ui_camera: DefaultUiCamera,
     ui_scale: Res<UiScale>,
     mut scale_factor_events: EventReader<WindowScaleFactorChanged>,
     mut resize_events: EventReader<bevy_window::WindowResized>,
@@ -266,12 +267,10 @@ pub fn ui_layout_system(
         root_nodes: Vec<Entity>,
     }
 
-    // If there is only one camera, we use it as default
-    let default_single_camera = cameras.get_single().ok().map(|(entity, _)| entity);
     let camera_with_default = |target_camera: Option<&TargetCamera>| {
         target_camera
             .map(TargetCamera::entity)
-            .or(default_single_camera)
+            .or(default_ui_camera.get())
     };
 
     let resized_windows: HashSet<Entity> = resize_events.read().map(|event| event.window).collect();
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 8d6f742e3c540..7b3445a5b1557 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -16,7 +16,7 @@ use crate::{
     prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
     Style, UiImage, UiScale, UiTextureAtlasImage, Val,
 };
-use crate::{Outline, TargetCamera};
+use crate::{DefaultUiCamera, Outline, TargetCamera};
 
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, AssetEvent, AssetId, Assets, Handle};
@@ -179,7 +179,7 @@ pub fn extract_atlas_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
-    camera_query: Extract<Query<Entity, With<Camera>>>,
+    default_ui_camera: Extract<DefaultUiCamera>,
     uinode_query: Extract<
         Query<
             (
@@ -197,8 +197,6 @@ pub fn extract_atlas_uinodes(
         >,
     >,
 ) {
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok();
     for (
         entity,
         uinode,
@@ -211,7 +209,8 @@ pub fn extract_atlas_uinodes(
         camera,
     ) in uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
             continue;
         };
         // Skip invisible and completely transparent nodes
@@ -285,6 +284,7 @@ pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     camera_query: Extract<Query<(Entity, &Camera)>>,
+    default_ui_camera: DefaultUiCamera,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<
@@ -303,14 +303,13 @@ pub fn extract_uinode_borders(
     >,
     node_query: Extract<Query<&Node>>,
 ) {
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok().map(|(entity, _)| entity);
     let image = AssetId::<Image>::default();
 
     for (node, global_transform, style, border_color, parent, view_visibility, clip, camera) in
         &uinode_query
     {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
             continue;
         };
         // Skip invisible borders
@@ -406,7 +405,7 @@ pub fn extract_uinode_borders(
 pub fn extract_uinode_outlines(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
-    camera_query: Extract<Query<Entity, With<Camera>>>,
+    default_ui_camera: Extract<DefaultUiCamera>,
     uinode_query: Extract<
         Query<(
             &Node,
@@ -418,11 +417,10 @@ pub fn extract_uinode_outlines(
         )>,
     >,
 ) {
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok();
     let image = AssetId::<Image>::default();
     for (node, global_transform, outline, view_visibility, maybe_clip, camera) in &uinode_query {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
             continue;
         };
         // Skip invisible outlines
@@ -498,7 +496,7 @@ pub fn extract_uinode_outlines(
 pub fn extract_uinodes(
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     images: Extract<Res<Assets<Image>>>,
-    camera_query: Extract<Query<Entity, With<Camera>>>,
+    default_ui_camera: Extract<DefaultUiCamera>,
     uinode_query: Extract<
         Query<
             (
@@ -515,12 +513,11 @@ pub fn extract_uinodes(
         >,
     >,
 ) {
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok();
     for (entity, uinode, transform, color, maybe_image, view_visibility, clip, camera) in
         uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
             continue;
         };
         // Skip invisible and completely transparent nodes
@@ -643,6 +640,7 @@ pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     camera_query: Extract<Query<(Entity, &Camera)>>,
+    default_ui_camera: DefaultUiCamera,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
@@ -657,12 +655,11 @@ pub fn extract_text_uinodes(
         )>,
     >,
 ) {
-    // If there is only one camera, we use it as default
-    let default_single_camera = camera_query.get_single().ok().map(|(entity, _)| entity);
     for (uinode, global_transform, text, text_layout_info, view_visibility, clip, camera) in
         uinode_query.iter()
     {
-        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_single_camera) else {
+        let Some(camera_entity) = camera.map(TargetCamera::entity).or(default_ui_camera.get())
+        else {
             continue;
         };
         // Skip if not visible or if size is set to zero (e.g. when a parent is set to `Display::None`)
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 7fdd91022f94b..8b2f42e699997 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,11 +1,16 @@
 use crate::{UiRect, Val};
 use bevy_asset::Handle;
-use bevy_ecs::{entity::Entity, prelude::Component, reflect::ReflectComponent};
+use bevy_ecs::{prelude::*, system::SystemParam};
 use bevy_math::{Rect, Vec2};
 use bevy_reflect::prelude::*;
-use bevy_render::{color::Color, texture::Image};
+use bevy_render::{
+    camera::{Camera, RenderTarget},
+    color::Color,
+    texture::Image,
+};
 use bevy_transform::prelude::GlobalTransform;
 use bevy_utils::smallvec::SmallVec;
+use bevy_window::{PrimaryWindow, WindowRef};
 use std::num::{NonZeroI16, NonZeroU16};
 use thiserror::Error;
 
@@ -1850,3 +1855,23 @@ impl TargetCamera {
         self.0
     }
 }
+
+#[derive(SystemParam)]
+pub struct DefaultUiCamera<'w, 's> {
+    cameras: Query<'w, 's, (Entity, &'static Camera)>,
+    primary_window: Query<'w, 's, Entity, With<PrimaryWindow>>,
+}
+
+impl<'w, 's> DefaultUiCamera<'w, 's> {
+    pub fn get(&self) -> Option<Entity> {
+        self.cameras
+            .iter()
+            .filter(|(_, c)| match c.target {
+                RenderTarget::Window(WindowRef::Primary) => true,
+                RenderTarget::Window(WindowRef::Entity(w)) => self.primary_window.get(w).is_ok(),
+                _ => false,
+            })
+            .max_by_key(|(e, c)| (c.order, *e))
+            .map(|(e, _)| e)
+    }
+}

From 0502405c7f5a88d263906e066bfbc6e73bdde0da Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman.salnikov@insurello.se>
Date: Sun, 14 Jan 2024 20:23:26 +0100
Subject: [PATCH 33/36] HashMap for camera cursor positions

---
 crates/bevy_ui/src/focus.rs | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 49f693e827d38..916d4bfb80a1b 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -16,7 +16,7 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{camera::NormalizedRenderTarget, prelude::Camera, view::ViewVisibility};
 use bevy_transform::components::GlobalTransform;
 
-use bevy_utils::smallvec::SmallVec;
+use bevy_utils::{smallvec::SmallVec, HashMap};
 use bevy_window::{PrimaryWindow, Window};
 
 #[cfg(feature = "serialize")]
@@ -182,7 +182,7 @@ pub fn ui_focus_system(
     let is_ui_disabled =
         |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
 
-    let camera_cursor_positions: Vec<(Entity, Vec2)> = camera_query
+    let camera_cursor_positions: HashMap<Entity, Vec2> = camera_query
         .iter()
         .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
         .filter_map(|(entity, camera, _)| {
@@ -242,16 +242,6 @@ pub fn ui_focus_system(
                 return None;
             };
 
-            let cursor_position = camera_cursor_positions
-                .iter()
-                .find_map(|(entity, position)| {
-                    if *entity == camera_entity {
-                        Some(*position)
-                    } else {
-                        None
-                    }
-                });
-
             let node_rect = node.node.logical_rect(node.global_transform);
 
             // Intersect with the calculated clip rect to find the bounds of the visible region of the node
@@ -263,8 +253,9 @@ pub fn ui_focus_system(
             // The mouse position relative to the node
             // (0., 0.) is the top-left corner, (1., 1.) is the bottom-right corner
             // Coordinates are relative to the entire node, not just the visible region.
-            let relative_cursor_position = cursor_position
-                .map(|cursor_position| (cursor_position - node_rect.min) / node_rect.size());
+            let relative_cursor_position = camera_cursor_positions
+                .get(&camera_entity)
+                .map(|cursor_position| (*cursor_position - node_rect.min) / node_rect.size());
 
             // If the current cursor position is within the bounds of the node's visible area, consider it for
             // clicking
@@ -285,7 +276,8 @@ pub fn ui_focus_system(
                 Some(*entity)
             } else {
                 if let Some(mut interaction) = node.interaction {
-                    if *interaction == Interaction::Hovered || (cursor_position.is_none()) {
+                    if *interaction == Interaction::Hovered || (relative_cursor_position.is_none())
+                    {
                         interaction.set_if_neq(Interaction::None);
                     }
                 }

From 58566940b669d6f32391ae5d7926da976cd26d43 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman.salnikov@insurello.se>
Date: Sun, 14 Jan 2024 20:28:18 +0100
Subject: [PATCH 34/36] Fix disappeared text and borders

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

diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 4af90e871c9f3..e883e8e5e0ea1 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -283,7 +283,7 @@ pub fn extract_uinode_borders(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     camera_query: Extract<Query<(Entity, &Camera)>>,
-    default_ui_camera: DefaultUiCamera,
+    default_ui_camera: Extract<DefaultUiCamera>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<
         Query<
@@ -639,7 +639,7 @@ pub fn extract_text_uinodes(
     mut commands: Commands,
     mut extracted_uinodes: ResMut<ExtractedUiNodes>,
     camera_query: Extract<Query<(Entity, &Camera)>>,
-    default_ui_camera: DefaultUiCamera,
+    default_ui_camera: Extract<DefaultUiCamera>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
     ui_scale: Extract<Res<UiScale>>,
     uinode_query: Extract<

From 067429db0721a4fac87d2f487de4c48b70322e98 Mon Sep 17 00:00:00 2001
From: Roman Salnikov <roman.salnikov@insurello.se>
Date: Sun, 14 Jan 2024 20:36:18 +0100
Subject: [PATCH 35/36] Remove UiCameraConfig component

---
 crates/bevy_ui/src/camera_config.rs      | 30 ------------------------
 crates/bevy_ui/src/focus.rs              | 13 +++-------
 crates/bevy_ui/src/lib.rs                | 12 ++++------
 crates/bevy_ui/src/render/mod.rs         | 13 ++++------
 crates/bevy_ui/src/render/render_pass.rs |  9 ++-----
 5 files changed, 13 insertions(+), 64 deletions(-)
 delete mode 100644 crates/bevy_ui/src/camera_config.rs

diff --git a/crates/bevy_ui/src/camera_config.rs b/crates/bevy_ui/src/camera_config.rs
deleted file mode 100644
index 857bd57ebec7c..0000000000000
--- a/crates/bevy_ui/src/camera_config.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Configuration for cameras related to UI.
-
-use bevy_ecs::component::Component;
-use bevy_ecs::prelude::With;
-use bevy_ecs::reflect::ReflectComponent;
-use bevy_reflect::{std_traits::ReflectDefault, Reflect};
-use bevy_render::camera::Camera;
-use bevy_render::extract_component::ExtractComponent;
-
-/// Configuration for cameras related to UI.
-///
-/// When a [`Camera`] doesn't have the [`UiCameraConfig`] component,
-/// it will display the UI by default.
-///
-#[derive(Component, Clone, ExtractComponent, Reflect)]
-#[extract_component_filter(With<Camera>)]
-#[reflect(Component, Default)]
-pub struct UiCameraConfig {
-    /// Whether to output UI to this camera view.
-    ///
-    /// When a [`Camera`] doesn't have the [`UiCameraConfig`] component,
-    /// it will display the UI by default.
-    pub show_ui: bool,
-}
-
-impl Default for UiCameraConfig {
-    fn default() -> Self {
-        Self { show_ui: true }
-    }
-}
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 916d4bfb80a1b..c89e291292333 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,7 +1,4 @@
-use crate::{
-    camera_config::UiCameraConfig, CalculatedClip, DefaultUiCamera, Node, TargetCamera, UiScale,
-    UiStack,
-};
+use crate::{CalculatedClip, DefaultUiCamera, Node, TargetCamera, UiScale, UiStack};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
@@ -145,7 +142,7 @@ pub struct NodeQuery {
 #[allow(clippy::too_many_arguments)]
 pub fn ui_focus_system(
     mut state: Local<State>,
-    camera_query: Query<(Entity, &Camera, Option<&UiCameraConfig>)>,
+    camera_query: Query<(Entity, &Camera)>,
     default_ui_camera: DefaultUiCamera,
     primary_window: Query<Entity, With<PrimaryWindow>>,
     windows: Query<&Window>,
@@ -179,13 +176,9 @@ pub fn ui_focus_system(
     let mouse_clicked =
         mouse_button_input.just_pressed(MouseButton::Left) || touches_input.any_just_pressed();
 
-    let is_ui_disabled =
-        |camera_ui| matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. }));
-
     let camera_cursor_positions: HashMap<Entity, Vec2> = camera_query
         .iter()
-        .filter(|(_, _, camera_ui)| !is_ui_disabled(*camera_ui))
-        .filter_map(|(entity, camera, _)| {
+        .filter_map(|(entity, camera)| {
             // Interactions are only supported for cameras rendering to a window.
             let Some(NormalizedRenderTarget::Window(window_ref)) =
                 camera.target.normalize(primary_window)
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index cf468509dd287..ee4c27baa8409 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -3,7 +3,6 @@
 //! Spawn UI elements with [`node_bundles::ButtonBundle`], [`node_bundles::ImageBundle`], [`node_bundles::TextBundle`] and [`node_bundles::NodeBundle`]
 //! This UI is laid out with the Flexbox and CSS Grid layout models (see <https://cssreference.io/flexbox/>)
 
-pub mod camera_config;
 pub mod measurement;
 pub mod node_bundles;
 pub mod ui_material;
@@ -36,18 +35,17 @@ use widget::UiImageSize;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        camera_config::*, geometry::*, node_bundles::*, ui_material::*, ui_node::*, widget::Button,
-        widget::Label, Interaction, UiMaterialPlugin, UiScale,
+        geometry::*, node_bundles::*, ui_material::*, ui_node::*, widget::Button, widget::Label,
+        Interaction, UiMaterialPlugin, UiScale,
     };
 }
 
-use crate::prelude::UiCameraConfig;
 #[cfg(feature = "bevy_text")]
 use crate::widget::TextFlags;
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_input::InputSystem;
-use bevy_render::{extract_component::ExtractComponentPlugin, RenderApp};
+use bevy_render::RenderApp;
 use bevy_transform::TransformSystem;
 use stack::ui_stack_system;
 pub use stack::UiStack;
@@ -85,8 +83,7 @@ impl Default for UiScale {
 
 impl Plugin for UiPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(ExtractComponentPlugin::<UiCameraConfig>::default())
-            .init_resource::<UiSurface>()
+        app.init_resource::<UiSurface>()
             .init_resource::<UiScale>()
             .init_resource::<UiStack>()
             .register_type::<AlignContent>()
@@ -117,7 +114,6 @@ impl Plugin for UiPlugin {
             .register_type::<RepeatedGridTrack>()
             .register_type::<Style>()
             .register_type::<TargetCamera>()
-            .register_type::<UiCameraConfig>()
             .register_type::<UiImage>()
             .register_type::<UiImageSize>()
             .register_type::<UiRect>()
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index e883e8e5e0ea1..58855c2afdc28 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -13,8 +13,8 @@ pub use render_pass::*;
 pub use ui_material_pipeline::*;
 
 use crate::{
-    prelude::UiCameraConfig, BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node,
-    Style, UiImage, UiScale, UiTextureAtlasImage, Val,
+    BackgroundColor, BorderColor, CalculatedClip, ContentSize, Node, Style, UiImage, UiScale,
+    UiTextureAtlasImage, Val,
 };
 use crate::{DefaultUiCamera, Outline, TargetCamera};
 
@@ -572,15 +572,10 @@ pub struct DefaultCameraView(pub Entity);
 pub fn extract_default_ui_camera_view<T: Component>(
     mut commands: Commands,
     ui_scale: Extract<Res<UiScale>>,
-    query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
+    query: Extract<Query<(Entity, &Camera), With<T>>>,
 ) {
     let scale = ui_scale.0.recip();
-    for (entity, camera, camera_ui) in &query {
-        // ignore cameras with disabled ui
-        if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
-            continue;
-        }
-
+    for (entity, camera) in &query {
         // ignore inactive cameras
         if !camera.is_active {
             continue;
diff --git a/crates/bevy_ui/src/render/render_pass.rs b/crates/bevy_ui/src/render/render_pass.rs
index 25e615fa3e20c..0b993cd9fc79b 100644
--- a/crates/bevy_ui/src/render/render_pass.rs
+++ b/crates/bevy_ui/src/render/render_pass.rs
@@ -1,7 +1,7 @@
 use std::ops::Range;
 
 use super::{UiBatch, UiImageBindGroups, UiMeta};
-use crate::{prelude::UiCameraConfig, DefaultCameraView};
+use crate::DefaultCameraView;
 use bevy_ecs::{
     prelude::*,
     system::{lifetimeless::*, SystemParamItem},
@@ -22,7 +22,6 @@ pub struct UiPassNode {
             &'static RenderPhase<TransparentUi>,
             &'static ViewTarget,
             &'static ExtractedCamera,
-            Option<&'static UiCameraConfig>,
         ),
         With<ExtractedView>,
     >,
@@ -52,7 +51,7 @@ impl Node for UiPassNode {
     ) -> Result<(), NodeRunError> {
         let input_view_entity = graph.view_entity();
 
-        let Ok((transparent_phase, target, camera, camera_ui)) =
+        let Ok((transparent_phase, target, camera)) =
             self.ui_view_query.get_manual(world, input_view_entity)
         else {
             return Ok(());
@@ -60,10 +59,6 @@ impl Node for UiPassNode {
         if transparent_phase.items.is_empty() {
             return Ok(());
         }
-        // Don't render UI for cameras where it is explicitly disabled
-        if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false })) {
-            return Ok(());
-        }
 
         // use the "default" view entity if it is defined
         let view_entity = if let Ok(default_view) = self

From afe71dad2d5f4760e701a123afd1f5930efe846b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecil@gmail.com>
Date: Mon, 15 Jan 2024 19:22:24 -0500
Subject: [PATCH 36/36] Repair merge conflicts

---
 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 35efd915a5155..a089ec7418f4c 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -16,8 +16,8 @@ use bevy_log::warn;
 use bevy_math::{UVec2, Vec2};
 use bevy_render::camera::{Camera, NormalizedRenderTarget};
 use bevy_transform::components::Transform;
-use bevy_utils::{default, HashMap, HashSet};
-use bevy_window::{PrimaryWindow, Window, WindowResolution, WindowScaleFactorChanged};
+use bevy_utils::{default, EntityHashMap, HashMap, HashSet};
+use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use std::fmt;
 use taffy::Taffy;
 use thiserror::Error;