Improve Presentation Api

cts_runner/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = [
 	"Luca Casonato <hello@lcas.dev>",
 ]
-edition = "2018"
+edition = "2021"
 description = "CTS runner for wgpu"
 license = "MIT OR Apache-2.0"
 publish = false

deno_webgpu/Cargo.toml

@@ -4,7 +4,7 @@
 name = "deno_webgpu"
 version = "0.54.0"
 authors = ["the Deno authors"]
-edition = "2018"
+edition = "2021"
 license = "MIT"
 readme = "README.md"
 repository = "https://github.com/gfx-rs/wgpu"

dummy/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = [
     "Dzmitry Malyshau <kvark@mozilla.com>",
 ]
-edition = "2018"
+edition = "2021"
 license = "MIT OR Apache-2.0"
 publish = false
 

player/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = [
 	"Dzmitry Malyshau <kvark@mozilla.com>",
 ]
-edition = "2018"
+edition = "2021"
 description = "WebGPU trace player"
 homepage = "https://github.com/gfx-rs/wgpu"
 repository = "https://github.com/gfx-rs/wgpu"

run-wasm/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "run-wasm"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

wgpu-core/Cargo.toml

@@ -2,7 +2,7 @@
 name = "wgpu-core"
 version = "0.12.0"
 authors = ["wgpu developers"]
-edition = "2018"
+edition = "2021"
 description = "WebGPU core logic on wgpu-hal"
 homepage = "https://github.com/gfx-rs/wgpu"
 repository = "https://github.com/gfx-rs/wgpu"

wgpu-core/src/device/mod.rs

@@ -3117,7 +3117,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         &self,
         surface_id: id::SurfaceId,
         adapter_id: id::AdapterId,
-    ) -> Result<Vec<TextureFormat>, instance::GetSurfacePreferredFormatError> {
+    ) -> Result<Vec<TextureFormat>, instance::GetSurfaceSupportError> {
         profiling::scope!("Surface::get_supported_formats");
         let hub = A::hub(self);
         let mut token = Token::root();
@@ -3126,13 +3126,33 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (adapter_guard, mut _token) = hub.adapters.read(&mut token);
         let adapter = adapter_guard
             .get(adapter_id)
-            .map_err(|_| instance::GetSurfacePreferredFormatError::InvalidAdapter)?;
+            .map_err(|_| instance::GetSurfaceSupportError::InvalidAdapter)?;
         let surface = surface_guard
             .get(surface_id)
-            .map_err(|_| instance::GetSurfacePreferredFormatError::InvalidSurface)?;
+            .map_err(|_| instance::GetSurfaceSupportError::InvalidSurface)?;
 
         surface.get_supported_formats(adapter)
     }
+    pub fn surface_get_supported_modes<A: HalApi>(
+        &self,
+        surface_id: id::SurfaceId,
+        adapter_id: id::AdapterId,
+    ) -> Result<Vec<wgt::PresentMode>, instance::GetSurfaceSupportError> {
+        profiling::scope!("Surface::get_supported_modes");
+        let hub = A::hub(self);
+        let mut token = Token::root();
+
+        let (surface_guard, mut token) = self.surfaces.read(&mut token);
+        let (adapter_guard, mut _token) = hub.adapters.read(&mut token);
+        let adapter = adapter_guard
+            .get(adapter_id)
+            .map_err(|_| instance::GetSurfaceSupportError::InvalidAdapter)?;
+        let surface = surface_guard
+            .get(surface_id)
+            .map_err(|_| instance::GetSurfaceSupportError::InvalidSurface)?;
+
+        surface.get_supported_modes(adapter)
+    }
 
     pub fn device_features<A: HalApi>(
         &self,
@@ -4938,11 +4958,40 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 );
             }
             if !caps.present_modes.contains(&config.present_mode) {
-                log::warn!(
-                    "Surface does not support present mode: {:?}, falling back to FIFO",
-                    config.present_mode,
+                let new_mode = loop {
+                    // Automatic present mode checks.
+                    //
+                    // The "Automatic" modes are never supported by the backends.
+                    match config.present_mode {
+                        wgt::PresentMode::AutoVsync => {
+                            if caps.present_modes.contains(&wgt::PresentMode::FifoRelaxed) {
+                                break wgt::PresentMode::FifoRelaxed;
+                            }
+                            if caps.present_modes.contains(&wgt::PresentMode::Fifo) {
+                                break wgt::PresentMode::Fifo;
+                            }
+                        }
+                        wgt::PresentMode::AutoNoVsync => {
+                            if caps.present_modes.contains(&wgt::PresentMode::Immediate) {
+                                break wgt::PresentMode::Immediate;
+                            }
+                            if caps.present_modes.contains(&wgt::PresentMode::Mailbox) {
+                                break wgt::PresentMode::Mailbox;
+                            }
+                        }
+                        _ => {}
+                    }
+                    return Err(E::UnsupportedPresentMode {
+                        requested: config.present_mode,
+                        available: caps.present_modes.clone(),
+                    });
+                };
+
+                log::info!(
+                    "Automatically choosing presentation mode by rule {:?}. Chose {new_mode:?}",
+                    config.present_mode
                 );
-                config.present_mode = wgt::PresentMode::Fifo;
+                config.present_mode = new_mode;
             }
             if !caps.formats.contains(&config.format) {
                 return Err(E::UnsupportedFormat {

wgpu-core/src/instance.rs

@@ -155,22 +155,39 @@ impl Surface {
     pub fn get_supported_formats<A: HalApi>(
         &self,
         adapter: &Adapter<A>,
-    ) -> Result<Vec<wgt::TextureFormat>, GetSurfacePreferredFormatError> {
+    ) -> Result<Vec<wgt::TextureFormat>, GetSurfaceSupportError> {
         let suf = A::get_surface(self);
         let mut caps = unsafe {
             profiling::scope!("surface_capabilities");
             adapter
                 .raw
                 .adapter
                 .surface_capabilities(&suf.raw)
-                .ok_or(GetSurfacePreferredFormatError::UnsupportedQueueFamily)?
+                .ok_or(GetSurfaceSupportError::UnsupportedQueueFamily)?
         };
 
         // TODO: maybe remove once we support texture view changing srgb-ness
         caps.formats.sort_by_key(|f| !f.describe().srgb);
 
         Ok(caps.formats)
     }
+
+    pub fn get_supported_modes<A: HalApi>(
+        &self,
+        adapter: &Adapter<A>,
+    ) -> Result<Vec<wgt::PresentMode>, GetSurfaceSupportError> {
+        let suf = A::get_surface(self);
+        let caps = unsafe {
+            profiling::scope!("surface_capabilities");
+            adapter
+                .raw
+                .adapter
+                .surface_capabilities(&suf.raw)
+                .ok_or(GetSurfaceSupportError::UnsupportedQueueFamily)?
+        };
+
+        Ok(caps.present_modes)
+    }
 }
 
 pub struct Adapter<A: hal::Api> {
@@ -341,7 +358,7 @@ pub enum IsSurfaceSupportedError {
 }
 
 #[derive(Clone, Debug, Error)]
-pub enum GetSurfacePreferredFormatError {
+pub enum GetSurfaceSupportError {
     #[error("invalid adapter")]
     InvalidAdapter,
     #[error("invalid surface")]

wgpu-core/src/present.rs

@@ -75,6 +75,11 @@ pub enum ConfigureSurfaceError {
         requested: wgt::TextureFormat,
         available: Vec<wgt::TextureFormat>,
     },
+    #[error("requested present mode {requested:?} is not in the list of supported present modes: {available:?}")]
+    UnsupportedPresentMode {
+        requested: wgt::PresentMode,
+        available: Vec<wgt::PresentMode>,
+    },
     #[error("requested usage is not supported")]
     UnsupportedUsage,
 }

wgpu-hal/Cargo.toml

@@ -2,7 +2,7 @@
 name = "wgpu-hal"
 version = "0.12.0"
 authors = ["wgpu developers"]
-edition = "2018"
+edition = "2021"
 description = "WebGPU hardware abstraction layer"
 homepage = "https://github.com/gfx-rs/wgpu"
 repository = "https://github.com/gfx-rs/wgpu"

wgpu-hal/src/dx12/adapter.rs

@@ -425,7 +425,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
             }
         };
 
-        let mut present_modes = vec![wgt::PresentMode::Fifo];
+        let mut present_modes = vec![wgt::PresentMode::Mailbox, wgt::PresentMode::Fifo];
         #[allow(trivial_casts)]
         if let Some(factory5) = surface.factory.as_factory5() {
             let mut allow_tearing: minwindef::BOOL = minwindef::FALSE;

wgpu-hal/src/dx12/mod.rs

@@ -770,8 +770,8 @@ impl crate::Queue<Api> for Queue {
 
         let (interval, flags) = match sc.present_mode {
             wgt::PresentMode::Immediate => (0, dxgi::DXGI_PRESENT_ALLOW_TEARING),
+            wgt::PresentMode::Mailbox => (0, 0),
             wgt::PresentMode::Fifo => (1, 0),
-            wgt::PresentMode::Mailbox => (1, 0),
         };
 
         profiling::scope!("IDXGISwapchain3::Present");

wgpu-hal/src/metal/adapter.rs

@@ -281,13 +281,18 @@ impl crate::Adapter<super::Api> for super::Adapter {
             None
         };
 
+        let mut formats = vec![
+            wgt::TextureFormat::Bgra8Unorm,
+            wgt::TextureFormat::Bgra8UnormSrgb,
+            wgt::TextureFormat::Rgba16Float,
+        ];
+        if self.shared.private_caps.format_rgb10a2_unorm_surface {
+            formats.push(wgt::TextureFormat::Rgb10a2Unorm);
+        }
+
         let pc = &self.shared.private_caps;
         Some(crate::SurfaceCapabilities {
-            formats: vec![
-                wgt::TextureFormat::Bgra8Unorm,
-                wgt::TextureFormat::Bgra8UnormSrgb,
-                wgt::TextureFormat::Rgba16Float,
-            ],
+            formats,
             //Note: this is hardcoded in `CAMetalLayer` documentation
             swap_chain_sizes: if pc.can_set_maximum_drawables_count {
                 2..=3
@@ -575,6 +580,7 @@ impl super::PrivateCapabilities {
             format_rgba8_srgb_no_write: !Self::supports_any(device, RGBA8_SRGB),
             format_rgb10a2_unorm_all: Self::supports_any(device, RGB10A2UNORM_ALL),
             format_rgb10a2_unorm_no_write: !Self::supports_any(device, RGB10A2UNORM_ALL),
+            format_rgb10a2_unorm_surface: os_is_mac,
             format_rgb10a2_uint_color: !Self::supports_any(device, RGB10A2UINT_COLOR_WRITE),
             format_rgb10a2_uint_color_write: Self::supports_any(device, RGB10A2UINT_COLOR_WRITE),
             format_rg11b10_all: Self::supports_any(device, RG11B10FLOAT_ALL),

wgpu-hal/src/metal/mod.rs

@@ -180,6 +180,7 @@ struct PrivateCapabilities {
     format_rgba8_srgb_no_write: bool,
     format_rgb10a2_unorm_all: bool,
     format_rgb10a2_unorm_no_write: bool,
+    format_rgb10a2_unorm_surface: bool,
     format_rgb10a2_uint_color: bool,
     format_rgb10a2_uint_color_write: bool,
     format_rg11b10_all: bool,

wgpu-hal/src/metal/surface.rs

@@ -170,7 +170,11 @@ impl crate::Surface<super::Api> for super::Surface {
 
         let render_layer = self.render_layer.lock();
         let framebuffer_only = config.usage == crate::TextureUses::COLOR_TARGET;
-        let display_sync = config.present_mode != wgt::PresentMode::Immediate;
+        let display_sync = match config.present_mode {
+            wgt::PresentMode::Fifo => true,
+            wgt::PresentMode::Immediate => false,
+            m => unreachable!("Unsupported present mode: {m:?}"),
+        };
         let drawable_size = CGSize::new(config.extent.width as f64, config.extent.height as f64);
 
         match config.composite_alpha_mode {

wgpu-hal/src/vulkan/adapter.rs

@@ -1616,22 +1616,9 @@ impl crate::Adapter<super::Api> for super::Adapter {
             }
         };
 
-        let supported_formats = [
-            wgt::TextureFormat::Rgba8Unorm,
-            wgt::TextureFormat::Rgba8UnormSrgb,
-            wgt::TextureFormat::Bgra8Unorm,
-            wgt::TextureFormat::Bgra8UnormSrgb,
-            wgt::TextureFormat::Rgba16Float,
-        ];
-        let formats = supported_formats
-            .iter()
-            .cloned()
-            .filter(|&format| {
-                let vk_format = self.private_caps.map_texture_format(format);
-                raw_surface_formats
-                    .iter()
-                    .any(|sf| sf.format == vk_format || sf.format == vk::Format::UNDEFINED)
-            })
+        let formats = raw_surface_formats
+            .into_iter()
+            .map(|sf| self.private_caps.map_texture_format(sf.format))
             .collect();
         Some(crate::SurfaceCapabilities {
             formats,

wgpu-hal/src/vulkan/conv.rs

@@ -405,7 +405,10 @@ pub fn map_present_mode(mode: wgt::PresentMode) -> vk::PresentModeKHR {
         wgt::PresentMode::Immediate => vk::PresentModeKHR::IMMEDIATE,
         wgt::PresentMode::Mailbox => vk::PresentModeKHR::MAILBOX,
         wgt::PresentMode::Fifo => vk::PresentModeKHR::FIFO,
-        //wgt::PresentMode::Relaxed => vk::PresentModeKHR::FIFO_RELAXED,
+        wgt::PresentMode::FifoRelaxed => vk::PresentModeKHR::FIFO_RELAXED,
+        wgt::PresentMode::AutoNoVsync | wgt::PresentMode::AutoVsync => {
+            unreachable!("Cannot create swapchain with Auto PresentationMode")
+        }
     }
 }
 

wgpu-info/Cargo.toml

@@ -2,7 +2,7 @@
 name = "wgpu-info"
 version = "0.12.0"
 authors = ["wgpu developers"]
-edition = "2018"
+edition = "2021"
 description = "Adapter information and per-adapter test program"
 homepage = "https://github.com/gfx-rs/wgpu"
 repository = "https://github.com/gfx-rs/wgpu"

wgpu-types/Cargo.toml

@@ -2,7 +2,7 @@
 name = "wgpu-types"
 version = "0.12.0"
 authors = ["wgpu developers"]
-edition = "2018"
+edition = "2021"
 description = "WebGPU types"
 homepage = "https://github.com/gfx-rs/wgpu"
 repository = "https://github.com/gfx-rs/wgpu"