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

---
 crates/bevy_ui/src/focus.rs             |  9 +++---
 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(+), 77 deletions(-)

diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index b0096dcbd500e..e2abb8d6889d5 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,5 +1,4 @@
-use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, UiCamera, UiScale, UiStack};
-use bevy_derive::{Deref, DerefMut};
+use crate::{camera_config::UiCameraConfig, CalculatedClip, Node, TargetCamera, UiScale, UiStack};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
@@ -126,7 +125,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
@@ -226,8 +225,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 bd12af0869a15..a194348ba595e 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, update_ui_camera_system};
+use update::{update_clipping_system, update_target_camera_system};
 
 /// The basic plugin for Bevy UI
 #[derive(Default)]
@@ -119,7 +119,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>()
@@ -182,11 +182,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 a95032c0e5d97..4f26030eb5771 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};
@@ -190,7 +190,7 @@ pub fn extract_atlas_uinodes(
                 Option<&CalculatedClip>,
                 &Handle<TextureAtlas>,
                 &UiTextureAtlasImage,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<UiImage>,
         >,
@@ -210,7 +210,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
@@ -295,7 +295,7 @@ pub fn extract_uinode_borders(
                 Option<&Parent>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<ContentSize>,
         >,
@@ -309,7 +309,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
@@ -413,7 +413,7 @@ pub fn extract_uinode_outlines(
             &Outline,
             &ViewVisibility,
             Option<&Parent>,
-            Option<&UiCamera>,
+            Option<&TargetCamera>,
         )>,
     >,
     clip_query: Query<&CalculatedClip>,
@@ -422,7 +422,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
@@ -513,7 +513,7 @@ pub fn extract_uinodes(
                 Option<&UiImage>,
                 &ViewVisibility,
                 Option<&CalculatedClip>,
-                Option<&UiCamera>,
+                Option<&TargetCamera>,
             ),
             Without<UiTextureAtlasImage>,
         >,
@@ -524,7 +524,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
@@ -657,7 +657,7 @@ pub fn extract_text_uinodes(
             &TextLayoutInfo,
             &ViewVisibility,
             Option<&CalculatedClip>,
-            Option<&UiCamera>,
+            Option<&TargetCamera>,
         )>,
     >,
 ) {
@@ -666,7 +666,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 1c4ed2380ef0c..c2f02475767e9 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1714,10 +1714,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",