Merge branch 'master' into remove-vertex-indexing

1 files changed, 35 insertions, 35 deletions

diff --git a/wgpu/src/window/compositor.rs b/wgpu/src/window/compositor.rs
index 1ddbe5fe..31cf3819 100644
--- a/wgpu/src/window/compositor.rs
+++ b/wgpu/src/window/compositor.rs
@@ -6,8 +6,6 @@ use crate::graphics::compositor;
 use crate::graphics::{Error, Viewport};
 use crate::{Backend, Primitive, Renderer, Settings};
 
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
-
 use std::marker::PhantomData;
 
 /// A window graphics backend for iced powered by `wgpu`.
@@ -26,9 +24,9 @@ impl<Theme> Compositor<Theme> {
     /// Requests a new [`Compositor`] with the given [`Settings`].
     ///
     /// Returns `None` if no compatible graphics adapter could be found.
-    pub async fn request<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    pub async fn request<W: compositor::Window>(
         settings: Settings,
-        compatible_window: Option<&W>,
+        compatible_window: Option<W>,
     ) -> Option<Self> {
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
             backends: settings.internal_backend,
@@ -41,14 +39,15 @@ impl<Theme> Compositor<Theme> {
         if log::max_level() >= log::LevelFilter::Info {
             let available_adapters: Vec<_> = instance
                 .enumerate_adapters(settings.internal_backend)
-                .map(|adapter| adapter.get_info())
+                .iter()
+                .map(wgpu::Adapter::get_info)
                 .collect();
             log::info!("Available adapters: {available_adapters:#?}");
         }
 
         #[allow(unsafe_code)]
         let compatible_surface = compatible_window
-            .and_then(|window| unsafe { instance.create_surface(window).ok() });
+            .and_then(|window| instance.create_surface(window).ok());
 
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
@@ -100,14 +99,14 @@ impl<Theme> Compositor<Theme> {
 
         let (device, queue) =
             loop {
-                let limits = limits.next()?;
+                let required_limits = limits.next()?;
                 let device = adapter.request_device(
                     &wgpu::DeviceDescriptor {
                         label: Some(
                             "iced_wgpu::window::compositor device descriptor",
                         ),
-                        features: wgpu::Features::empty(),
-                        limits,
+                        required_features: wgpu::Features::empty(),
+                        required_limits,
                     },
                     None,
                 ).await.ok();
@@ -136,26 +135,24 @@ impl<Theme> Compositor<Theme> {
 
 /// Creates a [`Compositor`] and its [`Backend`] for the given [`Settings`] and
 /// window.
-pub fn new<Theme, W: HasRawWindowHandle + HasRawDisplayHandle>(
+pub fn new<W: compositor::Window, Theme>(
     settings: Settings,
-    compatible_window: Option<&W>,
-) -> Result<(Compositor<Theme>, Backend), Error> {
+    compatible_window: W,
+) -> Result<Compositor<Theme>, Error> {
     let compositor = futures::executor::block_on(Compositor::request(
         settings,
-        compatible_window,
+        Some(compatible_window),
     ))
     .ok_or(Error::GraphicsAdapterNotFound)?;
 
-    let backend = compositor.create_backend();
-
-    Ok((compositor, backend))
+    Ok(compositor)
 }
 
 /// Presents the given primitives with the given [`Compositor`] and [`Backend`].
 pub fn present<Theme, T: AsRef<str>>(
     compositor: &mut Compositor<Theme>,
     backend: &mut Backend,
-    surface: &mut wgpu::Surface,
+    surface: &mut wgpu::Surface<'static>,
     primitives: &[Primitive],
     viewport: &Viewport,
     background_color: Color,
@@ -178,6 +175,7 @@ pub fn present<Theme, T: AsRef<str>>(
                 &compositor.queue,
                 &mut encoder,
                 Some(background_color),
+                frame.texture.format(),
                 view,
                 primitives,
                 viewport,
@@ -208,32 +206,32 @@ pub fn present<Theme, T: AsRef<str>>(
 impl<Theme> graphics::Compositor for Compositor<Theme> {
     type Settings = Settings;
     type Renderer = Renderer<Theme>;
-    type Surface = wgpu::Surface;
+    type Surface = wgpu::Surface<'static>;
 
-    fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn new<W: compositor::Window>(
         settings: Self::Settings,
-        compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error> {
-        let (compositor, backend) = new(settings, compatible_window)?;
+        compatible_window: W,
+    ) -> Result<Self, Error> {
+        new(settings, compatible_window)
+    }
 
-        Ok((
-            compositor,
-            Renderer::new(
-                backend,
-                settings.default_font,
-                settings.default_text_size,
-            ),
-        ))
+    fn create_renderer(&self) -> Self::Renderer {
+        Renderer::new(
+            self.create_backend(),
+            self.settings.default_font,
+            self.settings.default_text_size,
+        )
     }
 
-    fn create_surface<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn create_surface<W: compositor::Window>(
         &mut self,
-        window: &W,
+        window: W,
         width: u32,
         height: u32,
-    ) -> wgpu::Surface {
-        #[allow(unsafe_code)]
-        let mut surface = unsafe { self.instance.create_surface(window) }
+    ) -> Self::Surface {
+        let mut surface = self
+            .instance
+            .create_surface(window)
             .expect("Create surface");
 
         self.configure_surface(&mut surface, width, height);
@@ -257,6 +255,7 @@ impl<Theme> graphics::Compositor for Compositor<Theme> {
                 height,
                 alpha_mode: wgpu::CompositeAlphaMode::Auto,
                 view_formats: vec![],
+                desired_maximum_frame_latency: 2,
             },
         );
     }
@@ -357,6 +356,7 @@ pub fn screenshot<Theme, T: AsRef<str>>(
         &compositor.queue,
         &mut encoder,
         Some(background_color),
+        texture.format(),
         &view,
         primitives,
         viewport,