Use Ash builders for Vulkan struct construction + refactor

vulkano-taskgraph/src/graph/execute.rs

@@ -783,7 +783,7 @@ impl<'a, W: ?Sized + 'static> ExecuteState2<'a, W> {
                     .src_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
                     .dst_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
                     .image(image.handle())
-                    .subresource_range(image.subresource_range().into()),
+                    .subresource_range(image.subresource_range().to_vk()),
             );
         }
     }
@@ -902,7 +902,7 @@ impl<'a, W: ?Sized + 'static> ExecuteState2<'a, W> {
                     .src_queue_family_index(barrier.src_queue_family_index)
                     .dst_queue_family_index(barrier.dst_queue_family_index)
                     .image(image.handle())
-                    .subresource_range(image.subresource_range().into()),
+                    .subresource_range(image.subresource_range().to_vk()),
             );
         }
     }
@@ -1205,7 +1205,7 @@ impl<'a, W: ?Sized + 'static> ExecuteState<'a, W> {
                     .src_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
                     .dst_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
                     .image(image.handle())
-                    .subresource_range(image.subresource_range().into()),
+                    .subresource_range(image.subresource_range().to_vk()),
             );
 
             self.current_src_stage_mask |= convert_stage_mask(src_stage_mask);
@@ -1328,7 +1328,7 @@ impl<'a, W: ?Sized + 'static> ExecuteState<'a, W> {
                     .src_queue_family_index(barrier.src_queue_family_index)
                     .dst_queue_family_index(barrier.dst_queue_family_index)
                     .image(image.handle())
-                    .subresource_range(image.subresource_range().into()),
+                    .subresource_range(image.subresource_range().to_vk()),
             );
 
             self.current_src_stage_mask |= convert_stage_mask(barrier.src_stage_mask);

vulkano/src/buffer/mod.rs

@@ -510,10 +510,7 @@ impl Buffer {
     pub unsafe fn device_address_unchecked(&self) -> NonNullDeviceAddress {
         let device = self.device();
 
-        let info_vk = ash::vk::BufferDeviceAddressInfo {
-            buffer: self.handle(),
-            ..Default::default()
-        };
+        let info_vk = ash::vk::BufferDeviceAddressInfo::default().buffer(self.handle());
 
         let ptr = {
             let fns = device.fns();
@@ -933,6 +930,20 @@ impl ExternalBufferInfo {
 
         Ok(())
     }
+
+    pub(crate) fn to_vk(&self) -> ash::vk::PhysicalDeviceExternalBufferInfo<'static> {
+        let &Self {
+            flags,
+            usage,
+            handle_type,
+            _ne: _,
+        } = self;
+
+        ash::vk::PhysicalDeviceExternalBufferInfo::default()
+            .flags(flags.into())
+            .usage(usage.into())
+            .handle_type(handle_type.into())
+    }
 }
 
 /// The external memory properties supported for buffers with a given configuration.
@@ -943,6 +954,25 @@ pub struct ExternalBufferProperties {
     pub external_memory_properties: ExternalMemoryProperties,
 }
 
+impl ExternalBufferProperties {
+    pub(crate) fn to_mut_vk() -> ash::vk::ExternalBufferProperties<'static> {
+        ash::vk::ExternalBufferProperties::default()
+    }
+
+    pub(crate) fn from_vk(val_vk: &ash::vk::ExternalBufferProperties<'_>) -> Self {
+        let &ash::vk::ExternalBufferProperties {
+            ref external_memory_properties,
+            ..
+        } = val_vk;
+
+        Self {
+            external_memory_properties: ExternalMemoryProperties::from_vk(
+                external_memory_properties,
+            ),
+        }
+    }
+}
+
 vulkan_enum! {
     #[non_exhaustive]
 

vulkano/src/buffer/subbuffer.rs

@@ -173,6 +173,26 @@ impl<T: ?Sized> Subbuffer<T> {
         // SAFETY: All `Subbuffer`s share the same layout.
         mem::transmute::<&Subbuffer<T>, &Subbuffer<U>>(self)
     }
+
+    pub(crate) fn to_vk_device_or_host_address(&self) -> ash::vk::DeviceOrHostAddressKHR {
+        ash::vk::DeviceOrHostAddressKHR {
+            device_address: self
+                .device_address()
+                .expect("Can't get device address. Is the extension enabled?")
+                .into(),
+        }
+    }
+
+    pub(crate) fn to_vk_device_or_host_address_const(
+        &self,
+    ) -> ash::vk::DeviceOrHostAddressConstKHR {
+        ash::vk::DeviceOrHostAddressConstKHR {
+            device_address: self
+                .device_address()
+                .expect("Can't get device address. Is the extension enabled?")
+                .into(),
+        }
+    }
 }
 
 impl<T> Subbuffer<T>

vulkano/src/buffer/sys.rs

@@ -11,16 +11,15 @@ use crate::{
     instance::InstanceOwnedDebugWrapper,
     macros::impl_id_counter,
     memory::{
-        allocator::{AllocationType, DeviceLayout},
-        is_aligned, DedicatedTo, ExternalMemoryHandleTypes, MemoryAllocateFlags,
-        MemoryPropertyFlags, MemoryRequirements, ResourceMemory,
+        allocator::AllocationType, is_aligned, DedicatedTo, ExternalMemoryHandleTypes,
+        MemoryAllocateFlags, MemoryPropertyFlags, MemoryRequirements, ResourceMemory,
     },
     sync::Sharing,
     DeviceSize, Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version,
     VulkanError, VulkanObject,
 };
 use smallvec::SmallVec;
-use std::{mem::MaybeUninit, num::NonZeroU64, ptr, sync::Arc};
+use std::{marker::PhantomData, mem::MaybeUninit, num::NonZeroU64, ptr, sync::Arc};
 
 /// A raw buffer, with no memory backing it.
 ///
@@ -78,44 +77,8 @@ impl RawBuffer {
         device: Arc<Device>,
         create_info: BufferCreateInfo,
     ) -> Result<Self, VulkanError> {
-        let &BufferCreateInfo {
-            flags,
-            ref sharing,
-            size,
-            usage,
-            external_memory_handle_types,
-            _ne: _,
-        } = &create_info;
-
-        let (sharing_mode, queue_family_index_count, p_queue_family_indices) = match sharing {
-            Sharing::Exclusive => (ash::vk::SharingMode::EXCLUSIVE, 0, ptr::null()),
-            Sharing::Concurrent(queue_family_indices) => (
-                ash::vk::SharingMode::CONCURRENT,
-                queue_family_indices.len() as u32,
-                queue_family_indices.as_ptr(),
-            ),
-        };
-
-        let mut create_info_vk = ash::vk::BufferCreateInfo {
-            flags: flags.into(),
-            size,
-            usage: usage.into(),
-            sharing_mode,
-            queue_family_index_count,
-            p_queue_family_indices,
-            ..Default::default()
-        };
-        let mut external_memory_info_vk = None;
-
-        if !external_memory_handle_types.is_empty() {
-            let next = external_memory_info_vk.insert(ash::vk::ExternalMemoryBufferCreateInfo {
-                handle_types: external_memory_handle_types.into(),
-                ..Default::default()
-            });
-
-            next.p_next = create_info_vk.p_next;
-            create_info_vk.p_next = <*const _>::cast(next);
-        }
+        let mut extensions_vk = create_info.to_vk_extensions();
+        let create_info_vk = create_info.to_vk(&mut extensions_vk);
 
         let handle = {
             let fns = device.fns();
@@ -225,28 +188,12 @@ impl RawBuffer {
     }
 
     fn get_memory_requirements(device: &Device, handle: ash::vk::Buffer) -> MemoryRequirements {
-        let info_vk = ash::vk::BufferMemoryRequirementsInfo2 {
-            buffer: handle,
-            ..Default::default()
-        };
+        let info_vk = ash::vk::BufferMemoryRequirementsInfo2::default().buffer(handle);
 
-        let mut memory_requirements2_vk = ash::vk::MemoryRequirements2::default();
-        let mut memory_dedicated_requirements_vk = None;
-
-        if device.api_version() >= Version::V1_1
-            || device.enabled_extensions().khr_dedicated_allocation
-        {
-            debug_assert!(
-                device.api_version() >= Version::V1_1
-                    || device.enabled_extensions().khr_get_memory_requirements2
-            );
-
-            let next = memory_dedicated_requirements_vk
-                .insert(ash::vk::MemoryDedicatedRequirements::default());
-
-            next.p_next = memory_requirements2_vk.p_next;
-            memory_requirements2_vk.p_next = <*mut _>::cast(next);
-        }
+        let mut memory_requirements2_extensions_vk =
+            MemoryRequirements::to_mut_vk2_extensions(device);
+        let mut memory_requirements2_vk =
+            MemoryRequirements::to_mut_vk2(&mut memory_requirements2_extensions_vk);
 
         unsafe {
             let fns = device.fns();
@@ -277,18 +224,16 @@ impl RawBuffer {
             }
         }
 
-        MemoryRequirements {
-            layout: DeviceLayout::from_size_alignment(
-                memory_requirements2_vk.memory_requirements.size,
-                memory_requirements2_vk.memory_requirements.alignment,
-            )
-            .unwrap(),
-            memory_type_bits: memory_requirements2_vk.memory_requirements.memory_type_bits,
-            prefers_dedicated_allocation: memory_dedicated_requirements_vk
-                .map_or(false, |dreqs| dreqs.prefers_dedicated_allocation != 0),
-            requires_dedicated_allocation: memory_dedicated_requirements_vk
-                .map_or(false, |dreqs| dreqs.requires_dedicated_allocation != 0),
-        }
+        // Unborrow
+        let memory_requirements2_vk = ash::vk::MemoryRequirements2 {
+            _marker: PhantomData,
+            ..memory_requirements2_vk
+        };
+
+        MemoryRequirements::from_vk2(
+            &memory_requirements2_vk,
+            &memory_requirements2_extensions_vk,
+        )
     }
 
     /// Binds device memory to this buffer.
@@ -532,20 +477,14 @@ impl RawBuffer {
         self,
         allocation: ResourceMemory,
     ) -> Result<Buffer, (VulkanError, RawBuffer, ResourceMemory)> {
-        let memory = allocation.device_memory();
-        let memory_offset = allocation.offset();
+        let bind_info_vk = allocation.to_vk_bind_buffer_memory_info(self.handle());
 
         let fns = self.device.fns();
 
         let result = if self.device.api_version() >= Version::V1_1
             || self.device.enabled_extensions().khr_bind_memory2
         {
-            let bind_infos_vk = [ash::vk::BindBufferMemoryInfo {
-                buffer: self.handle,
-                memory: memory.handle(),
-                memory_offset,
-                ..Default::default()
-            }];
+            let bind_infos_vk = [bind_info_vk];
 
             if self.device.api_version() >= Version::V1_1 {
                 (fns.v1_1.bind_buffer_memory2)(
@@ -563,9 +502,9 @@ impl RawBuffer {
         } else {
             (fns.v1_0.bind_buffer_memory)(
                 self.device.handle(),
-                self.handle,
-                memory.handle(),
-                memory_offset,
+                bind_info_vk.buffer,
+                bind_info_vk.memory,
+                bind_info_vk.memory_offset,
             )
         }
         .result();
@@ -859,6 +798,55 @@ impl BufferCreateInfo {
 
         Ok(())
     }
+
+    pub(crate) fn to_vk<'a>(
+        &'a self,
+        extensions_vk: &'a mut BufferCreateInfoExtensionsVk,
+    ) -> ash::vk::BufferCreateInfo<'a> {
+        let &Self {
+            flags,
+            ref sharing,
+            size,
+            usage,
+            external_memory_handle_types: _,
+            _ne: _,
+        } = self;
+
+        let (sharing_mode_vk, queue_family_indices) = sharing.to_vk();
+
+        let mut val_vk = ash::vk::BufferCreateInfo::default()
+            .flags(flags.into())
+            .size(size)
+            .usage(usage.into())
+            .sharing_mode(sharing_mode_vk)
+            .queue_family_indices(queue_family_indices);
+
+        let BufferCreateInfoExtensionsVk { external_memory_vk } = extensions_vk;
+
+        if let Some(next) = external_memory_vk {
+            val_vk = val_vk.push_next(next);
+        }
+
+        val_vk
+    }
+
+    pub(crate) fn to_vk_extensions(&self) -> BufferCreateInfoExtensionsVk {
+        let &Self {
+            external_memory_handle_types,
+            ..
+        } = self;
+
+        let external_memory_vk = (!external_memory_handle_types.is_empty()).then(|| {
+            ash::vk::ExternalMemoryBufferCreateInfo::default()
+                .handle_types(external_memory_handle_types.into())
+        });
+
+        BufferCreateInfoExtensionsVk { external_memory_vk }
+    }
+}
+
+pub(crate) struct BufferCreateInfoExtensionsVk {
+    pub(crate) external_memory_vk: Option<ash::vk::ExternalMemoryBufferCreateInfo<'static>>,
 }
 
 #[cfg(test)]

vulkano/src/buffer/view.rs

@@ -287,18 +287,8 @@ impl BufferView {
         subbuffer: Subbuffer<impl ?Sized>,
         create_info: BufferViewCreateInfo,
     ) -> Result<Arc<BufferView>, VulkanError> {
-        let &BufferViewCreateInfo { format, _ne: _ } = &create_info;
-
         let device = subbuffer.device();
-
-        let create_info_vk = ash::vk::BufferViewCreateInfo {
-            flags: ash::vk::BufferViewCreateFlags::empty(),
-            buffer: subbuffer.buffer().handle(),
-            format: format.into(),
-            offset: subbuffer.offset(),
-            range: subbuffer.size(),
-            ..Default::default()
-        };
+        let create_info_vk = create_info.to_vk(subbuffer.as_bytes());
 
         let handle = unsafe {
             let fns = device.fns();
@@ -437,6 +427,20 @@ impl BufferViewCreateInfo {
 
         Ok(())
     }
+
+    pub(crate) fn to_vk(
+        &self,
+        subbuffer: &Subbuffer<[u8]>,
+    ) -> ash::vk::BufferViewCreateInfo<'static> {
+        let &Self { format, _ne: _ } = self;
+
+        ash::vk::BufferViewCreateInfo::default()
+            .flags(ash::vk::BufferViewCreateFlags::empty())
+            .buffer(subbuffer.buffer().handle())
+            .format(format.into())
+            .offset(subbuffer.offset())
+            .range(subbuffer.size())
+    }
 }
 
 #[cfg(test)]

vulkano/src/command_buffer/auto/builder.rs

@@ -18,10 +18,11 @@ use crate::{
     pipeline::{
         graphics::{
             color_blend::LogicOp,
-            conservative_rasterization::ConservativeRasterizationMode,
             depth_stencil::{CompareOp, StencilOps},
             input_assembly::PrimitiveTopology,
-            rasterization::{CullMode, DepthBiasState, FrontFace, LineStipple},
+            rasterization::{
+                ConservativeRasterizationMode, CullMode, DepthBiasState, FrontFace, LineStipple,
+            },
             subpass::PipelineRenderingCreateInfo,
             vertex_input::VertexInputState,
             viewport::{Scissor, Viewport},