Merge branch 'master' into workspace-dependencies

CHANGELOG.md

@@ -14,9 +14,17 @@
 ### Additions
 
 - Partially validated versions of `submit` and `present` commands (called via `QueueGuard`).
+- Support for the `khr_timeline_semaphore` extension.
 
 ### Bugs fixed
 
+# Version 0.34.1 (2023-10-29)
+
+### Bugs fixed
+
+- `StandardDescriptorSetAllocator` panicking due to an arithmetic overflow when arithmetic overflow checks are enabled.
+- Vulkano-util still depending on the now-deprecated vulkano-win.
+
 # Version 0.34.0 (2023-10-25)
 
 ### Public dependency updates

vulkano-util/Cargo.toml

@@ -15,6 +15,4 @@ readme = "../README.md"
 [dependencies]
 ahash = { workspace = true }
 vulkano = { workspace = true }
-# FIXME: These need to be removed.
-vulkano-win = { version = "0.34.0", path = "../vulkano-win" }
 winit = { version = "0.28" }

vulkano-util/src/context.rs

@@ -125,8 +125,6 @@ impl VulkanoContext {
     /// # Panics
     ///
     /// - Panics where the underlying Vulkano struct creations fail
-    // FIXME:
-    #[allow(deprecated)]
     pub fn new(mut config: VulkanoConfig) -> Self {
         let library = match VulkanLibrary::new() {
             Ok(x) => x,
@@ -139,7 +137,21 @@ impl VulkanoContext {
         };
 
         // Append required extensions
-        config.instance_create_info.enabled_extensions = vulkano_win::required_extensions(&library)
+        // HACK: This should be replaced with `Surface::required_extensions`, but will need to
+        // happen in the next minor version bump. It should have been done before releasing 0.34.
+        config.instance_create_info.enabled_extensions = library
+            .supported_extensions()
+            .intersection(&InstanceExtensions {
+                khr_surface: true,
+                khr_xlib_surface: true,
+                khr_xcb_surface: true,
+                khr_wayland_surface: true,
+                khr_android_surface: true,
+                khr_win32_surface: true,
+                mvk_ios_surface: true,
+                mvk_macos_surface: true,
+                ..InstanceExtensions::empty()
+            })
             .union(&config.instance_create_info.enabled_extensions);
 
         // Create instance

vulkano/src/command_buffer/mod.rs

@@ -128,7 +128,10 @@ use crate::{
     query::{QueryControlFlags, QueryPipelineStatisticFlags},
     range_map::RangeMap,
     render_pass::{Framebuffer, Subpass},
-    sync::{semaphore::Semaphore, PipelineStageAccessFlags, PipelineStages},
+    sync::{
+        semaphore::{Semaphore, SemaphoreType},
+        PipelineStageAccessFlags, PipelineStages,
+    },
     DeviceSize, Requires, RequiresAllOf, RequiresOneOf, ValidationError,
 };
 use ahash::HashMap;
@@ -774,6 +777,7 @@ impl SubmitInfo {
 
             let &SemaphoreSubmitInfo {
                 semaphore: _,
+                value: _,
                 stages,
                 _ne: _,
             } = semaphore_submit_info;
@@ -791,6 +795,11 @@ impl SubmitInfo {
             }
         }
 
+        // unsafe
+        // VUID-VkSubmitInfo2-semaphore-03882
+        // VUID-VkSubmitInfo2-semaphore-03883
+        // VUID-VkSubmitInfo2-semaphore-03884
+
         Ok(())
     }
 }
@@ -837,6 +846,18 @@ pub struct SemaphoreSubmitInfo {
     /// There is no default value.
     pub semaphore: Arc<Semaphore>,
 
+    /// If `semaphore.semaphore_type()` is [`SemaphoreType::Timeline`], specifies the value that
+    /// will be used for the semaphore operation:
+    /// - If it's a signal operation, then the semaphore's value will be set to this value
+    ///   when it is signaled.
+    /// - If it's a wait operation, then the semaphore will wait until its value is greater than
+    ///   or equal to this value.
+    ///
+    /// If `semaphore.semaphore_type()` is [`SemaphoreType::Binary`], then this must be `0`.
+    ///
+    /// The default value is `0`.
+    pub value: u64,
+
     /// For a semaphore wait operation, specifies the pipeline stages in the second synchronization
     /// scope: stages of queue operations following the wait operation that can start executing
     /// after the semaphore is signalled.
@@ -862,6 +883,7 @@ impl SemaphoreSubmitInfo {
     pub fn new(semaphore: Arc<Semaphore>) -> Self {
         Self {
             semaphore,
+            value: 0,
             stages: PipelineStages::ALL_COMMANDS,
             _ne: crate::NonExhaustive(()),
         }
@@ -870,13 +892,28 @@ impl SemaphoreSubmitInfo {
     pub(crate) fn validate(&self, device: &Device) -> Result<(), Box<ValidationError>> {
         let &Self {
             ref semaphore,
+            value,
             stages,
             _ne: _,
         } = self;
 
         // VUID?
         assert_eq!(device, semaphore.device().as_ref());
 
+        match semaphore.semaphore_type() {
+            SemaphoreType::Binary => {
+                if value != 0 {
+                    return Err(Box::new(ValidationError {
+                        problem: "`semaphore.semaphore_type()` is `SemaphoreType::Binary`, but \
+                            `value` is not `0`"
+                            .into(),
+                        ..Default::default()
+                    }));
+                }
+            }
+            SemaphoreType::Timeline => {}
+        }
+
         stages.validate_device(device).map_err(|err| {
             err.add_context("stages")
                 .set_vuids(&["VUID-VkSemaphoreSubmitInfo-stageMask-parameter"])

vulkano/src/device/physical.rs

@@ -27,7 +27,7 @@ use crate::{
     },
     sync::{
         fence::{ExternalFenceInfo, ExternalFenceProperties},
-        semaphore::{ExternalSemaphoreInfo, ExternalSemaphoreProperties},
+        semaphore::{ExternalSemaphoreInfo, ExternalSemaphoreProperties, SemaphoreType},
         Sharing,
     },
     DebugWrapper, ExtensionProperties, Requires, RequiresAllOf, RequiresOneOf, Validated,
@@ -1191,13 +1191,28 @@ impl PhysicalDevice {
 
                 let &ExternalSemaphoreInfo {
                     handle_type,
+                    semaphore_type,
+                    initial_value,
                     _ne: _,
                 } = info;
 
-                let external_semaphore_info = ash::vk::PhysicalDeviceExternalSemaphoreInfo {
+                let mut external_semaphore_info_vk = ash::vk::PhysicalDeviceExternalSemaphoreInfo {
                     handle_type: handle_type.into(),
                     ..Default::default()
                 };
+                let mut semaphore_type_create_info_vk = None;
+
+                if semaphore_type != SemaphoreType::Binary {
+                    let next =
+                        semaphore_type_create_info_vk.insert(ash::vk::SemaphoreTypeCreateInfo {
+                            semaphore_type: semaphore_type.into(),
+                            initial_value,
+                            ..Default::default()
+                        });
+
+                    next.p_next = external_semaphore_info_vk.p_next;
+                    external_semaphore_info_vk.p_next = next as *const _ as *const _;
+                }
 
                 /* Output */
 
@@ -1211,14 +1226,14 @@ impl PhysicalDevice {
                 if self.instance.api_version() >= Version::V1_1 {
                     (fns.v1_1.get_physical_device_external_semaphore_properties)(
                         self.handle,
-                        &external_semaphore_info,
+                        &external_semaphore_info_vk,
                         &mut external_semaphore_properties,
                     )
                 } else {
                     (fns.khr_external_semaphore_capabilities
                         .get_physical_device_external_semaphore_properties_khr)(
                         self.handle,
-                        &external_semaphore_info,
+                        &external_semaphore_info_vk,
                         &mut external_semaphore_properties,
                     );
                 }