Vendor dependencies for 0.3.0 release

vendor/bevy/tests/window/change_window_mode.rs

@@ -0,0 +1,62 @@
+//! a test that confirms that 'bevy' does not panic while changing from Windowed to Fullscreen when viewport is set
+
+use bevy::{prelude::*, render::camera::Viewport, window::WindowMode};
+
+//Having a viewport set to the same size as a window used to cause panic on some occasions when switching to Fullscreen
+const WINDOW_WIDTH: f32 = 1366.0;
+const WINDOW_HEIGHT: f32 = 768.0;
+
+fn main() {
+    //Specify Window Size.
+    let window = Window {
+        resolution: (WINDOW_WIDTH, WINDOW_HEIGHT).into(),
+        ..default()
+    };
+    let primary_window = Some(window);
+
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window,
+            ..default()
+        }))
+        .add_systems(Startup, startup)
+        .add_systems(Update, toggle_window_mode)
+        .run();
+}
+
+fn startup(mut cmds: Commands) {
+    //Match viewport to Window size.
+    let physical_position = UVec2::new(0, 0);
+    let physical_size = Vec2::new(WINDOW_WIDTH, WINDOW_HEIGHT).as_uvec2();
+    let viewport = Some(Viewport {
+        physical_position,
+        physical_size,
+        ..default()
+    });
+
+    cmds.spawn(Camera2d).insert(Camera {
+        viewport,
+        ..default()
+    });
+}
+
+fn toggle_window_mode(mut qry_window: Query<&mut Window>) {
+    let Ok(mut window) = qry_window.single_mut() else {
+        return;
+    };
+
+    window.mode = match window.mode {
+        WindowMode::Windowed => {
+            // it takes a while for the window to change from `Windowed` to `Fullscreen` and back
+            std::thread::sleep(std::time::Duration::from_secs(4));
+            WindowMode::Fullscreen(
+                MonitorSelection::Entity(entity),
+                VideoModeSelection::Current,
+            )
+        }
+        _ => {
+            std::thread::sleep(std::time::Duration::from_secs(4));
+            WindowMode::Windowed
+        }
+    };
+}

vendor/bevy/tests/window/minimizing.rs

@@ -0,0 +1,77 @@
+//! A test to confirm that `bevy` allows minimizing the window
+//! This is run in CI to ensure that this doesn't regress again.
+use bevy::{diagnostic::FrameCount, prelude::*};
+
+fn main() {
+    // TODO: Combine this with `resizing` once multiple_windows is simpler than
+    // it is currently.
+    App::new()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Minimizing".into(),
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Startup, (setup_3d, setup_2d))
+        .add_systems(Update, minimize_automatically)
+        .run();
+}
+
+fn minimize_automatically(mut window: Single<&mut Window>, frames: Res<FrameCount>) {
+    if frames.0 != 60 {
+        return;
+    }
+
+    window.set_minimized(true);
+}
+
+/// A simple 3d scene, taken from the `3d_scene` example
+fn setup_3d(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // plane
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+    ));
+    // cube
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+    // light
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 8.0, 4.0),
+    ));
+    // camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A simple 2d scene, taken from the `rect` example
+fn setup_2d(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Camera {
+            // render the 2d camera after the 3d camera
+            order: 1,
+            // do not use a clear color
+            clear_color: ClearColorConfig::None,
+            ..default()
+        },
+    ));
+    commands.spawn(Sprite::from_color(
+        Color::srgb(0.25, 0.25, 0.75),
+        Vec2::new(50.0, 50.0),
+    ));
+}

vendor/bevy/tests/window/resizing.rs

@@ -0,0 +1,153 @@
+//! A test to confirm that `bevy` allows setting the window to arbitrary small sizes
+//! This is run in CI to ensure that this doesn't regress again.
+
+use bevy::{prelude::*, window::WindowResolution};
+
+// The smallest size reached is 1x1, as X11 doesn't support windows with a 0 dimension
+// TODO: Add a check for platforms other than X11 for 0xk and kx0, despite those currently unsupported on CI.
+const MAX_WIDTH: u16 = 401;
+const MAX_HEIGHT: u16 = 401;
+const MIN_WIDTH: u16 = 1;
+const MIN_HEIGHT: u16 = 1;
+const RESIZE_STEP: u16 = 4;
+
+#[derive(Resource)]
+struct Dimensions {
+    width: u16,
+    height: u16,
+}
+
+fn main() {
+    App::new()
+        .add_plugins(
+            DefaultPlugins.set(WindowPlugin {
+                primary_window: Some(Window {
+                    resolution: WindowResolution::new(MAX_WIDTH as f32, MAX_HEIGHT as f32)
+                        .with_scale_factor_override(1.0),
+                    title: "Resizing".into(),
+                    ..default()
+                }),
+                ..default()
+            }),
+        )
+        .insert_resource(Dimensions {
+            width: MAX_WIDTH,
+            height: MAX_HEIGHT,
+        })
+        .insert_resource(ContractingY)
+        .add_systems(Startup, (setup_3d, setup_2d))
+        .add_systems(Update, (change_window_size, sync_dimensions))
+        .run();
+}
+
+#[derive(Resource)]
+enum Phase {
+    ContractingY,
+    ContractingX,
+    ExpandingY,
+    ExpandingX,
+}
+
+use Phase::*;
+
+fn change_window_size(
+    mut windows: ResMut<Dimensions>,
+    mut phase: ResMut<Phase>,
+    mut first_complete: Local<bool>,
+) {
+    // Put off rendering for one frame, as currently for a frame where
+    // resizing happens, nothing is presented.
+    // TODO: Debug and fix this if feasible
+    if !*first_complete {
+        *first_complete = true;
+        return;
+    }
+    let height = windows.height;
+    let width = windows.width;
+    match *phase {
+        ContractingY => {
+            if height <= MIN_HEIGHT {
+                *phase = ContractingX;
+            } else {
+                windows.height -= RESIZE_STEP;
+            }
+        }
+        ContractingX => {
+            if width <= MIN_WIDTH {
+                *phase = ExpandingY;
+            } else {
+                windows.width -= RESIZE_STEP;
+            }
+        }
+        ExpandingY => {
+            if height >= MAX_HEIGHT {
+                *phase = ExpandingX;
+            } else {
+                windows.height += RESIZE_STEP;
+            }
+        }
+        ExpandingX => {
+            if width >= MAX_WIDTH {
+                *phase = ContractingY;
+            } else {
+                windows.width += RESIZE_STEP;
+            }
+        }
+    }
+}
+
+fn sync_dimensions(dim: Res<Dimensions>, mut window: Single<&mut Window>) {
+    if dim.is_changed() {
+        window.resolution.set(dim.width as f32, dim.height as f32);
+    }
+}
+
+/// A simple 3d scene, taken from the `3d_scene` example
+fn setup_3d(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // plane
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+    ));
+    // cube
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+    // light
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 8.0, 4.0),
+    ));
+    // camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A simple 2d scene, taken from the `rect` example
+fn setup_2d(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Camera {
+            // render the 2d camera after the 3d camera
+            order: 1,
+            // do not use a clear color
+            clear_color: ClearColorConfig::None,
+            ..default()
+        },
+    ));
+    commands.spawn(Sprite::from_color(
+        Color::srgb(0.25, 0.25, 0.75),
+        Vec2::new(50.0, 50.0),
+    ));
+}