Merge branch 'master' into beacon

Author: hecrj

.github/workflows/test.yml

@@ -5,6 +5,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     env:
       RUSTFLAGS: --deny warnings
+      ICED_TEST_BACKEND: tiny-skia
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]

benches/wgpu.rs

@@ -80,16 +80,15 @@ fn benchmark<'a>(
 
     let format = wgpu::TextureFormat::Bgra8UnormSrgb;
 
-    let mut engine = iced_wgpu::Engine::new(
+    let engine = iced_wgpu::Engine::new(
         adapter,
-        device,
-        queue,
+        device.clone(),
+        queue.clone(),
         format,
         Some(Antialiasing::MSAAx4),
     );
 
-    let mut renderer =
-        Renderer::new(device, &engine, Font::DEFAULT, Pixels::from(16));
+    let mut renderer = Renderer::new(engine, Font::DEFAULT, Pixels::from(16));
 
     let viewport =
         graphics::Viewport::with_physical_size(Size::new(3840, 2160), 2.0);
@@ -134,23 +133,13 @@ fn benchmark<'a>(
 
         cache = Some(user_interface.into_cache());
 
-        let mut encoder =
-            device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                label: None,
-            });
-
-        renderer.present(
-            &mut engine,
-            device,
-            queue,
-            &mut encoder,
+        let submission = renderer.present(
             Some(Color::BLACK),
             format,
             &texture_view,
             &viewport,
         );
 
-        let submission = engine.submit(queue, encoder);
         let _ = device.poll(wgpu::Maintain::WaitForSubmissionIndex(submission));
 
         i += 1;

core/src/renderer.rs

@@ -106,7 +106,19 @@ impl Default for Style {
 /// a window nor a compositor.
 pub trait Headless {
     /// Creates a new [`Headless`] renderer;
-    fn new(default_font: Font, default_text_size: Pixels) -> Self;
+    fn new(
+        default_font: Font,
+        default_text_size: Pixels,
+        backend: Option<&str>,
+    ) -> impl Future<Output = Option<Self>>
+    where
+        Self: Sized;
+
+    /// Returns the unique name of the renderer.
+    ///
+    /// This name may be used by testing libraries to uniquely identify
+    /// snapshots.
+    fn name(&self) -> String;
 
     /// Draws offscreen into a screenshot, returning a collection of
     /// bytes representing the rendered pixels in RGBA order.

examples/integration/src/main.rs

@@ -36,11 +36,9 @@ pub fn main() -> Result<(), winit::error::EventLoopError> {
         Loading,
         Ready {
             window: Arc<winit::window::Window>,
-            device: wgpu::Device,
-            queue: wgpu::Queue,
             surface: wgpu::Surface<'static>,
             format: wgpu::TextureFormat,
-            engine: Engine,
+            device: wgpu::Device,
             renderer: Renderer,
             scene: Scene,
             controls: Controls,
@@ -146,25 +144,26 @@ pub fn main() -> Result<(), winit::error::EventLoopError> {
                 let controls = Controls::new();
 
                 // Initialize iced
-                let engine =
-                    Engine::new(&adapter, &device, &queue, format, None);
-                let renderer = Renderer::new(
-                    &device,
-                    &engine,
-                    Font::default(),
-                    Pixels::from(16),
-                );
+                let renderer = {
+                    let engine = Engine::new(
+                        &adapter,
+                        device.clone(),
+                        queue,
+                        format,
+                        None,
+                    );
+
+                    Renderer::new(engine, Font::default(), Pixels::from(16))
+                };
 
                 // You should change this if you want to render continuously
                 event_loop.set_control_flow(ControlFlow::Wait);
 
                 *self = Self::Ready {
                     window,
-                    device,
-                    queue,
                     surface,
                     format,
-                    engine,
+                    device,
                     renderer,
                     scene,
                     controls,
@@ -188,10 +187,8 @@ pub fn main() -> Result<(), winit::error::EventLoopError> {
             let Self::Ready {
                 window,
                 device,
-                queue,
                 surface,
                 format,
-                engine,
                 renderer,
                 scene,
                 controls,
@@ -285,18 +282,13 @@ pub fn main() -> Result<(), winit::error::EventLoopError> {
                             *cache = interface.into_cache();
 
                             renderer.present(
-                                engine,
-                                device,
-                                queue,
-                                &mut encoder,
                                 None,
                                 frame.texture.format(),
                                 &view,
                                 viewport,
                             );
 
                             // Then we submit the work
-                            engine.submit(queue, encoder);
                             frame.present();
 
                             // Update the mouse cursor

examples/multi_window/src/main.rs

@@ -1,6 +1,6 @@
 use iced::widget::{
-    button, center, center_x, column, horizontal_space, scrollable, text,
-    text_input,
+    button, center, center_x, column, container, horizontal_space, scrollable,
+    text, text_input,
 };
 use iced::window;
 use iced::{
@@ -189,13 +189,12 @@ impl Window {
         let new_window_button =
             button(text("New Window")).on_press(Message::OpenWindow);
 
-        let content = scrollable(
-            column![scale_input, title_input, new_window_button]
-                .spacing(50)
-                .width(Fill)
-                .align_x(Center),
-        );
+        let content = column![scale_input, title_input, new_window_button]
+            .spacing(50)
+            .width(Fill)
+            .align_x(Center)
+            .width(200);
 
-        center_x(content).width(200).into()
+        container(scrollable(center_x(content))).padding(10).into()
     }
 }

…odos/snapshots/creates_a_new_task.sha256 …hots/creates_a_new_task-tiny-skia.sha256examples/todos/snapshots/creates_a_new_task.sha256 renamed to examples/todos/snapshots/creates_a_new_task-tiny-skia.sha256 examples/todos/snapshots/creates_a_new_task.sha256 renamed to examples/todos/snapshots/creates_a_new_task-tiny-skia.sha256

@@ -0,0 +1 @@
+804a1bb6d49e3b3158463202960447d9e7820b967280f41dd0c34c00d3edf2c3

examples/todos/snapshots/creates_a_new_task-wgpu.sha256

@@ -79,6 +79,7 @@ pub trait Compositor: Sized {
         surface: &mut Self::Surface,
         viewport: &Viewport,
         background_color: Color,
+        on_pre_present: impl FnOnce(),
     ) -> Result<(), SurfaceError>;
 
     /// Screenshots the current [`Renderer`] primitives to an offscreen texture, and returns the bytes of
@@ -190,6 +191,7 @@ impl Compositor for () {
         _surface: &mut Self::Surface,
         _viewport: &Viewport,
         _background_color: Color,
+        _on_pre_present: impl FnOnce(),
     ) -> Result<(), SurfaceError> {
         Ok(())
     }

graphics/src/compositor.rs

@@ -3,7 +3,8 @@ use crate::core::image;
 use crate::core::renderer;
 use crate::core::svg;
 use crate::core::{
-    self, Background, Color, Image, Point, Rectangle, Size, Svg, Transformation,
+    self, Background, Color, Font, Image, Pixels, Point, Rectangle, Size, Svg,
+    Transformation,
 };
 use crate::graphics;
 use crate::graphics::compositor;
@@ -321,6 +322,7 @@ where
         surface: &mut Self::Surface,
         viewport: &graphics::Viewport,
         background_color: Color,
+        on_pre_present: impl FnOnce(),
     ) -> Result<(), compositor::SurfaceError> {
         match (self, renderer, surface) {
             (
@@ -332,6 +334,7 @@ where
                 surface,
                 viewport,
                 background_color,
+                on_pre_present,
             ),
             (
                 Self::Secondary(compositor),
@@ -342,6 +345,7 @@ where
                 surface,
                 viewport,
                 background_color,
+                on_pre_present,
             ),
             _ => unreachable!(),
         }
@@ -600,6 +604,48 @@ mod geometry {
     }
 }
 
+impl<A, B> renderer::Headless for Renderer<A, B>
+where
+    A: renderer::Headless,
+    B: renderer::Headless,
+{
+    async fn new(
+        default_font: Font,
+        default_text_size: Pixels,
+        backend: Option<&str>,
+    ) -> Option<Self> {
+        if let Some(renderer) =
+            A::new(default_font, default_text_size, backend).await
+        {
+            return Some(Self::Primary(renderer));
+        }
+
+        B::new(default_font, default_text_size, backend)
+            .await
+            .map(Self::Secondary)
+    }
+
+    fn name(&self) -> String {
+        delegate!(self, renderer, renderer.name())
+    }
+
+    fn screenshot(
+        &mut self,
+        size: Size<u32>,
+        scale_factor: f32,
+        background_color: Color,
+    ) -> Vec<u8> {
+        match self {
+            crate::fallback::Renderer::Primary(renderer) => {
+                renderer.screenshot(size, scale_factor, background_color)
+            }
+            crate::fallback::Renderer::Secondary(renderer) => {
+                renderer.screenshot(size, scale_factor, background_color)
+            }
+        }
+    }
+}
+
 impl<A, B> compositor::Default for Renderer<A, B>
 where
     A: compositor::Default,

renderer/src/fallback.rs

@@ -23,9 +23,6 @@ pub type Compositor = renderer::Compositor;
 
 #[cfg(all(feature = "wgpu", feature = "tiny-skia"))]
 mod renderer {
-    use crate::core::renderer;
-    use crate::core::{Color, Font, Pixels, Size};
-
     pub type Renderer = crate::fallback::Renderer<
         iced_wgpu::Renderer,
         iced_tiny_skia::Renderer,
@@ -35,31 +32,6 @@ mod renderer {
         iced_wgpu::window::Compositor,
         iced_tiny_skia::window::Compositor,
     >;
-
-    impl renderer::Headless for Renderer {
-        fn new(default_font: Font, default_text_size: Pixels) -> Self {
-            Self::Secondary(iced_tiny_skia::Renderer::new(
-                default_font,
-                default_text_size,
-            ))
-        }
-
-        fn screenshot(
-            &mut self,
-            size: Size<u32>,
-            scale_factor: f32,
-            background_color: Color,
-        ) -> Vec<u8> {
-            match self {
-                crate::fallback::Renderer::Primary(_) => unreachable!(
-                    "iced_wgpu does not support headless mode yet!"
-                ),
-                crate::fallback::Renderer::Secondary(renderer) => {
-                    renderer.screenshot(size, scale_factor, background_color)
-                }
-            }
-        }
-    }
 }
 
 #[cfg(all(feature = "wgpu", not(feature = "tiny-skia")))]