Only use physical coords internally in bevy_ui

crates/bevy_ui/src/focus.rs

@@ -1,6 +1,5 @@
 use crate::{
-    CalculatedClip, ComputedNode, DefaultUiCamera, ResolvedBorderRadius, TargetCamera, UiScale,
-    UiStack,
+    CalculatedClip, ComputedNode, DefaultUiCamera, ResolvedBorderRadius, TargetCamera, UiStack,
 };
 use bevy_ecs::{
     change_detection::DetectChangesMut,
@@ -158,7 +157,6 @@ pub fn ui_focus_system(
     windows: Query<&Window>,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
     touches_input: Res<Touches>,
-    ui_scale: Res<UiScale>,
     ui_stack: Res<UiStack>,
     mut node_query: Query<NodeQuery>,
 ) {
@@ -201,19 +199,16 @@ pub fn ui_focus_system(
             };
 
             let viewport_position = camera
-                .logical_viewport_rect()
-                .map(|rect| rect.min)
+                .physical_viewport_rect()
+                .map(|rect| rect.min.as_vec2())
                 .unwrap_or_default();
             windows
                 .get(window_ref.entity())
                 .ok()
-                .and_then(Window::cursor_position)
+                .and_then(Window::physical_cursor_position)
                 .or_else(|| touches_input.first_pressed_position())
                 .map(|cursor_position| (entity, cursor_position - viewport_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(|(entity, cursor_position)| (entity, cursor_position / ui_scale.0))
         .collect();
 
     // prepare an iterator that contains all the nodes that have the cursor in their rect,

crates/bevy_ui/src/layout/mod.rs

@@ -293,8 +293,6 @@ with UI components as a child of an entity without UI components, your UI layout
     });
 
     for (camera_id, mut camera) in camera_layout_info.drain() {
-        let inverse_target_scale_factor = camera.scale_factor.recip();
-
         ui_surface.compute_camera_layout(camera_id, camera.size, text_buffers, &mut font_system);
 
         for root in &camera.root_nodes {
@@ -305,7 +303,6 @@ with UI components as a child of an entity without UI components, your UI layout
                 None,
                 &mut node_transform_query,
                 &ui_children,
-                inverse_target_scale_factor,
                 Vec2::ZERO,
                 Vec2::ZERO,
             );
@@ -330,7 +327,6 @@ with UI components as a child of an entity without UI components, your UI layout
             Option<&ScrollPosition>,
         )>,
         ui_children: &UiChildren,
-        inverse_target_scale_factor: f32,
         parent_size: Vec2,
         parent_scroll_position: Vec2,
     ) {
@@ -343,15 +339,13 @@ with UI components as a child of an entity without UI components, your UI layout
             maybe_scroll_position,
         )) = node_transform_query.get_mut(entity)
         {
-            let Ok((layout, unrounded_unscaled_size)) = ui_surface.get_layout(entity) else {
+            let Ok((layout, unrounded_size)) = ui_surface.get_layout(entity) else {
                 return;
             };
 
-            let layout_size =
-                inverse_target_scale_factor * Vec2::new(layout.size.width, layout.size.height);
-            let unrounded_size = inverse_target_scale_factor * unrounded_unscaled_size;
-            let layout_location =
-                inverse_target_scale_factor * Vec2::new(layout.location.x, layout.location.y);
+            let layout_size = Vec2::new(layout.size.width, layout.size.height);
+
+            let layout_location = Vec2::new(layout.location.x, layout.location.y);
 
             // The position of the center of the node, stored in the node's transform
             let node_center =
@@ -364,10 +358,10 @@ with UI components as a child of an entity without UI components, your UI layout
             }
 
             let taffy_rect_to_border_rect = |rect: taffy::Rect<f32>| BorderRect {
-                left: rect.left * inverse_target_scale_factor,
-                right: rect.right * inverse_target_scale_factor,
-                top: rect.top * inverse_target_scale_factor,
-                bottom: rect.bottom * inverse_target_scale_factor,
+                left: rect.left,
+                right: rect.right,
+                top: rect.top,
+                bottom: rect.bottom,
             };
 
             node.bypass_change_detection().border = taffy_rect_to_border_rect(layout.border);
@@ -422,8 +416,7 @@ with UI components as a child of an entity without UI components, your UI layout
                 })
                 .unwrap_or_default();
 
-            let content_size = Vec2::new(layout.content_size.width, layout.content_size.height)
-                * inverse_target_scale_factor;
+            let content_size = Vec2::new(layout.content_size.width, layout.content_size.height);
             let max_possible_offset = (content_size - layout_size).max(Vec2::ZERO);
             let clamped_scroll_position = scroll_position.clamp(Vec2::ZERO, max_possible_offset);
 
@@ -441,7 +434,6 @@ with UI components as a child of an entity without UI components, your UI layout
                     Some(viewport_size),
                     node_transform_query,
                     ui_children,
-                    inverse_target_scale_factor,
                     layout_size,
                     clamped_scroll_position,
                 );
@@ -1131,7 +1123,7 @@ mod tests {
                     .sum();
                 let parent_width = world.get::<ComputedNode>(parent).unwrap().size.x;
                 assert!((width_sum - parent_width).abs() < 0.001);
-                assert!((width_sum - 320.).abs() <= 1.);
+                assert!((width_sum - 320. * s).abs() <= 1.);
                 s += r;
             }
         }

crates/bevy_ui/src/picking_backend.rs

@@ -65,7 +65,6 @@ pub fn ui_picking(
     camera_query: Query<(Entity, &Camera, Has<IsDefaultUiCamera>)>,
     default_ui_camera: DefaultUiCamera,
     primary_window: Query<Entity, With<PrimaryWindow>>,
-    ui_scale: Res<UiScale>,
     ui_stack: Res<UiStack>,
     node_query: Query<NodeQuery>,
     mut output: EventWriter<PointerHits>,
@@ -95,15 +94,15 @@ pub fn ui_picking(
             let Ok((_, camera_data, _)) = camera_query.get(camera) else {
                 continue;
             };
-            let mut pointer_pos = pointer_location.position;
-            if let Some(viewport) = camera_data.logical_viewport_rect() {
-                pointer_pos -= viewport.min;
+            let mut pointer_pos =
+                pointer_location.position * camera_data.target_scaling_factor().unwrap_or(1.);
+            if let Some(viewport) = camera_data.physical_viewport_rect() {
+                pointer_pos -= viewport.min.as_vec2();
             }
-            let scaled_pointer_pos = pointer_pos / **ui_scale;
             pointer_pos_by_camera
                 .entry(camera)
                 .or_default()
-                .insert(pointer_id, scaled_pointer_pos);
+                .insert(pointer_id, pointer_pos);
         }
     }
 

crates/bevy_ui/src/render/box_shadow.rs

@@ -373,7 +373,6 @@ pub fn queue_shadows(
             ),
             batch_range: 0..0,
             extra_index: PhaseItemExtraIndex::NONE,
-            inverse_scale_factor: 1.,
         });
     }
 }