Fix handling of WindowResolution change

crates/bevy_winit/src/system.rs

@@ -13,7 +13,7 @@ use bevy_input::keyboard::{Key, KeyCode, KeyboardFocusLost, KeyboardInput};
 use bevy_window::{
     ClosingWindow, CursorOptions, Monitor, OnMonitor, PrimaryMonitor, RawHandleWrapper, VideoMode,
     Window, WindowClosed, WindowClosing, WindowCreated, WindowEvent, WindowFocused, WindowMode,
-    WindowResized, WindowWrapper,
+    WindowResized, WindowScaleFactorChanged, WindowWrapper,
 };
 use tracing::{error, info, warn};
 
@@ -311,6 +311,7 @@ pub(crate) fn changed_windows(
     monitors: Res<WinitMonitors>,
     mut window_resized: MessageWriter<WindowResized>,
     mut window_event: MessageWriter<WindowEvent>,
+    mut window_rescaled: MessageWriter<WindowScaleFactorChanged>,
     _non_send_marker: NonSendMarker,
 ) {
     WINIT_WINDOWS.with_borrow(|winit_windows| {
@@ -376,49 +377,35 @@ pub(crate) fn changed_windows(
                 }
 
             if window.resolution != cache.resolution {
-                let mut physical_size = PhysicalSize::new(
+                let cache_physical_size = PhysicalSize::new(
+                    cache.resolution.physical_width(),
+                    cache.resolution.physical_height(),
+                );
+                let requested_physical_size = PhysicalSize::new(
                     window.resolution.physical_width(),
                     window.resolution.physical_height(),
                 );
 
-                let cached_physical_size = PhysicalSize::new(
-                    cache.physical_width(),
-                    cache.physical_height(),
-                );
-
-                let base_scale_factor = window.resolution.base_scale_factor();
-
-                // Note: this may be different from `winit`'s base scale factor if
-                // `scale_factor_override` is set to Some(f32)
-                let scale_factor = window.scale_factor();
-                let cached_scale_factor = cache.scale_factor();
-
-                // Check and update `winit`'s physical size only if the window is not maximized
-                if scale_factor != cached_scale_factor && !winit_window.is_maximized() {
-                    let logical_size =
-                        if let Some(cached_factor) = cache.resolution.scale_factor_override() {
-                            physical_size.to_logical::<f32>(cached_factor as f64)
-                        } else {
-                            physical_size.to_logical::<f32>(base_scale_factor as f64)
-                        };
-
-                    // Scale factor changed, updating physical and logical size
-                    if let Some(forced_factor) = window.resolution.scale_factor_override() {
-                        // This window is overriding the OS-suggested DPI, so its physical size
-                        // should be set based on the overriding value. Its logical size already
-                        // incorporates any resize constraints.
-                        physical_size = logical_size.to_physical::<u32>(forced_factor as f64);
-                    } else {
-                        physical_size = logical_size.to_physical::<u32>(base_scale_factor as f64);
-                    }
-                }
-
-                if physical_size != cached_physical_size
-                    && let Some(new_physical_size) = winit_window.request_inner_size(physical_size) {
+                if cache_physical_size != requested_physical_size {
+                    // In `None` case, the request will be handled by winit::event::WindowEvent::Resized
+                    if let Some(new_physical_size) = winit_window.request_inner_size(requested_physical_size) {
                         let event = react_to_resize(entity, &mut window, new_physical_size);
+                        // Need to send two very similar events because different systems rely on those.
                         window_resized.write(event.clone());
-                        window_event.write(WindowEvent::WindowResized(event));
+                        window_event.write(event.into());
                     }
+                }
+
+                let cache_scale_factor = cache.scale_factor();
+                let requested_scale_factor = window.scale_factor();
+
+                if cache_scale_factor != requested_scale_factor {
+                    // If the scale factor has changed we don't query anything from winit, but send events for camera system to handle.
+                    let event = WindowScaleFactorChanged { scale_factor: requested_scale_factor as f64, window: entity};
+                    // Need to send two very similar events because different systems rely on those.
+                    window_rescaled.write(event.clone());
+                    window_event.write(event.into());
+                }
             }
 
             if window.physical_cursor_position() != cache.physical_cursor_position()