Make raw_window_handle optional for unit testing purposes.

Author: Wcubed

crates/bevy_render/src/lib.rs

@@ -45,6 +45,7 @@ use bevy_app::{App, AppLabel, Plugin};
 use bevy_asset::{AddAsset, AssetServer};
 use bevy_ecs::prelude::*;
 use std::ops::{Deref, DerefMut};
+use wgpu::Surface;
 
 /// Contains the default Bevy rendering backend based on wgpu.
 #[derive(Default)]
@@ -120,15 +121,7 @@ impl Plugin for RenderPlugin {
 
         if let Some(backends) = options.backends {
             let instance = wgpu::Instance::new(backends);
-            let surface = {
-                let world = app.world.cell();
-                let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
-                let raw_handle = windows.get_primary().map(|window| unsafe {
-                    let handle = window.raw_window_handle().get_handle();
-                    instance.create_surface(&handle)
-                });
-                raw_handle
-            };
+            let surface = try_create_surface(app, &instance);
             let request_adapter_options = wgpu::RequestAdapterOptions {
                 power_preference: options.power_preference,
                 compatible_surface: surface.as_ref(),
@@ -294,6 +287,17 @@ impl Plugin for RenderPlugin {
     }
 }
 
+fn try_create_surface(app: &mut App, wgpu_instance: &wgpu::Instance) -> Option<Surface> {
+    let world = app.world.cell();
+    let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
+    windows.get_primary().and_then(|window| unsafe {
+        window.raw_window_handle().map(|handle_wrapper| {
+            let window_handle = handle_wrapper.get_handle();
+            wgpu_instance.create_surface(&window_handle)
+        })
+    })
+}
+
 /// Executes the [`Extract`](RenderStage::Extract) stage of the renderer.
 /// This updates the render world with the extracted ECS data of the current frame.
 fn extract(app_world: &mut World, render_app: &mut App) {

crates/bevy_render/src/view/window.rs

@@ -40,7 +40,7 @@ impl Plugin for WindowRenderPlugin {
 
 pub struct ExtractedWindow {
     pub id: WindowId,
-    pub handle: RawWindowHandleWrapper,
+    pub handle: Option<RawWindowHandleWrapper>,
     pub physical_width: u32,
     pub physical_height: u32,
     pub vsync: bool,
@@ -125,42 +125,44 @@ pub fn prepare_windows(
 ) {
     let window_surfaces = window_surfaces.deref_mut();
     for window in windows.windows.values_mut() {
-        let surface = window_surfaces
-            .surfaces
-            .entry(window.id)
-            .or_insert_with(|| unsafe {
-                // NOTE: On some OSes this MUST be called from the main thread.
-                render_instance.create_surface(&window.handle.get_handle())
-            });
-
-        let swap_chain_descriptor = wgpu::SurfaceConfiguration {
-            format: TextureFormat::bevy_default(),
-            width: window.physical_width,
-            height: window.physical_height,
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            present_mode: if window.vsync {
-                wgpu::PresentMode::Fifo
-            } else {
-                wgpu::PresentMode::Immediate
-            },
-        };
-
-        // Do the initial surface configuration if it hasn't been configured yet
-        if window_surfaces.configured_windows.insert(window.id) || window.size_changed {
-            render_device.configure_surface(surface, &swap_chain_descriptor);
-        }
+        if let Some(window_handle_wrapper) = &window.handle {
+            let surface = window_surfaces
+                .surfaces
+                .entry(window.id)
+                .or_insert_with(|| unsafe {
+                    // NOTE: On some OSes this MUST be called from the main thread.
+                    render_instance.create_surface(&window_handle_wrapper.get_handle())
+                });
 
-        let frame = match surface.get_current_texture() {
-            Ok(swap_chain_frame) => swap_chain_frame,
-            Err(wgpu::SurfaceError::Outdated) => {
+            let swap_chain_descriptor = wgpu::SurfaceConfiguration {
+                format: TextureFormat::bevy_default(),
+                width: window.physical_width,
+                height: window.physical_height,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                present_mode: if window.vsync {
+                    wgpu::PresentMode::Fifo
+                } else {
+                    wgpu::PresentMode::Immediate
+                },
+            };
+
+            // Do the initial surface configuration if it hasn't been configured yet
+            if window_surfaces.configured_windows.insert(window.id) || window.size_changed {
                 render_device.configure_surface(surface, &swap_chain_descriptor);
-                surface
-                    .get_current_texture()
-                    .expect("Error reconfiguring surface")
             }
-            err => err.expect("Failed to acquire next swap chain texture!"),
-        };
 
-        window.swap_chain_texture = Some(TextureView::from(frame));
+            let frame = match surface.get_current_texture() {
+                Ok(swap_chain_frame) => swap_chain_frame,
+                Err(wgpu::SurfaceError::Outdated) => {
+                    render_device.configure_surface(surface, &swap_chain_descriptor);
+                    surface
+                        .get_current_texture()
+                        .expect("Error reconfiguring surface")
+                }
+                err => err.expect("Failed to acquire next swap chain texture!"),
+            };
+
+            window.swap_chain_texture = Some(TextureView::from(frame));
+        }
     }
 }

crates/bevy_window/src/window.rs

@@ -109,6 +109,9 @@ impl WindowResizeConstraints {
 /// requested size due to operating system limits on the window size, or the
 /// quantization of the logical size when converting the physical size to the
 /// logical size through the scaling factor.
+///
+/// ## Headless Testing
+/// To run tests without needing to create an actual window, set `raw_window_handle` to `None`.
 #[derive(Debug)]
 pub struct Window {
     id: WindowId,
@@ -128,7 +131,7 @@ pub struct Window {
     cursor_visible: bool,
     cursor_locked: bool,
     physical_cursor_position: Option<DVec2>,
-    raw_window_handle: RawWindowHandleWrapper,
+    raw_window_handle: Option<RawWindowHandleWrapper>,
     focused: bool,
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
@@ -209,7 +212,7 @@ impl Window {
         physical_height: u32,
         scale_factor: f64,
         position: Option<IVec2>,
-        raw_window_handle: RawWindowHandle,
+        raw_window_handle: Option<RawWindowHandle>,
     ) -> Self {
         Window {
             id,
@@ -229,7 +232,7 @@ impl Window {
             cursor_locked: window_descriptor.cursor_locked,
             cursor_icon: CursorIcon::Default,
             physical_cursor_position: None,
-            raw_window_handle: RawWindowHandleWrapper::new(raw_window_handle),
+            raw_window_handle: raw_window_handle.map(|handle| RawWindowHandleWrapper::new(handle)),
             focused: true,
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
@@ -544,7 +547,7 @@ impl Window {
         self.focused
     }
 
-    pub fn raw_window_handle(&self) -> RawWindowHandleWrapper {
+    pub fn raw_window_handle(&self) -> Option<RawWindowHandleWrapper> {
         self.raw_window_handle.clone()
     }
 }

crates/bevy_winit/src/winit_windows.rs

@@ -171,7 +171,7 @@ impl WinitWindows {
             inner_size.height,
             scale_factor,
             position,
-            raw_window_handle,
+            Some(raw_window_handle),
         )
     }