Add logging for testing purposes

Author: B0ryskart0n

crates/bevy_render/src/camera.rs

@@ -363,10 +363,16 @@ pub fn camera_system(
 
     let mut changed_window_ids = EntityHashSet::default();
     changed_window_ids.extend(window_created_reader.read().map(|event| event.window));
-    changed_window_ids.extend(window_resized_reader.read().map(|event| event.window));
+    changed_window_ids.extend(window_resized_reader.read().map(|event| {
+        warn!("Camera system got Bevy's WindowResized message.");
+        event.window
+    }));
     let scale_factor_changed_window_ids: EntityHashSet = window_scale_factor_changed_reader
         .read()
-        .map(|event| event.window)
+        .map(|event| {
+            warn!("Camera system got Bevy's WindowScaleFactorChanged message.");
+            event.window
+        })
         .collect();
     changed_window_ids.extend(scale_factor_changed_window_ids.clone());
 

crates/bevy_winit/src/state.rs

@@ -245,10 +245,13 @@ impl ApplicationHandler<WinitUserEvent> for WinitAppRunnerState {
                 }
 
                 match event {
-                    WindowEvent::Resized(size) => self
-                        .bevy_window_events
-                        .send(react_to_resize(window, &mut win, size)),
+                    WindowEvent::Resized(size) => {
+                        warn!("Handling Winit's WindowEvent::Resized and sending Bevy's WindowEvent::WindowResized");
+                        self.bevy_window_events
+                            .send(react_to_resize(window, &mut win, size))
+                    }
                     WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                        warn!("Handling Winit's WindowEvent::ScaleFactorChanged. Current WindowResolution :{:?}", win.resolution);
                         let (window_backend_scale_factor_changed, window_scale_factor_changed) =
                             react_to_scale_factor_change(window, &mut win, scale_factor);
 
@@ -829,9 +832,11 @@ impl WinitAppRunnerState {
                     world.write_message(e);
                 }
                 BevyWindowEvent::WindowResized(e) => {
+                    warn!("Forwarding WindowEvent::WindowResized as WindowResized.");
                     world.write_message(e);
                 }
                 BevyWindowEvent::WindowScaleFactorChanged(e) => {
+                    warn!("Forwarding WindowEvent::WindowScaleFactorChanged as WindowScaleFactorChanged.");
                     world.write_message(e);
                 }
                 BevyWindowEvent::WindowThemeChanged(e) => {

crates/bevy_winit/src/system.rs

@@ -302,6 +302,7 @@ pub(crate) struct CachedCursorOptions(CursorOptions);
 /// - [`Window::transparent`] cannot be changed after the window is created.
 /// - [`Window::canvas`] cannot be changed after the window is created.
 /// - [`Window::focused`] cannot be manually changed to `false` after the window is created.
+#[tracing::instrument(skip_all)]
 pub(crate) fn changed_windows(
     mut commands: Commands,
     mut changed_windows: Query<
@@ -377,6 +378,7 @@ pub(crate) fn changed_windows(
                 }
 
             if window.resolution != cache.resolution {
+                warn!("WindowResolution has changed.");
 
                 let cache_physical_size = PhysicalSize::new(
                     cache.resolution.physical_width(),
@@ -390,6 +392,7 @@ pub(crate) fn changed_windows(
                 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) {
+                        warn!("Winit resize request handled instantly: changing the resolution. Sending WindowResized events.");
                         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());
@@ -402,6 +405,7 @@ pub(crate) fn changed_windows(
 
                 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.
+                    warn!("Scale factor has changed. Sending ScaleFactor Message.");
                     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());