From e230d6ae81421d2325c4aba206b25aba0fe3b0c7 Mon Sep 17 00:00:00 2001 From: Tim Date: Wed, 1 Aug 2018 16:51:43 +0200 Subject: [PATCH 1/4] Add functions for Instance --- ash/src/instance.rs | 178 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 176 insertions(+), 2 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 7c30bbee4..97565dd0c 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -87,14 +87,188 @@ pub trait InstanceV1_1: InstanceV1_0 { fn fp_v1_1(&self) -> &vk::InstanceFnV1_1; unsafe fn enumerate_instance_version(&self) -> VkResult { - let mut api_version = 0; + let mut api_version = mem::uninitialized(); let err_code = self.fp_v1_1() - .enumerate_instance_version(&mut api_version as *mut _); + .enumerate_instance_version(&mut api_version); match err_code { vk::Result::SUCCESS => Ok(api_version), _ => Err(err_code) } } + + fn enumerate_physical_device_groups(&self) -> VkResult> { + unsafe { + let mut group_count = mem::uninitialized(); + self.fp_v1_1() + .enumerate_physical_device_groups(self.handle(), &mut group_count, ptr::null_mut()); + let mut physical_device_groups = Vec::with_capacity(group_count as usize); + let err_code = self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + physical_device_groups.as_mut_ptr(), + ); + physical_device_groups.set_len(group_count as usize); + match err_code { + vk::Result::SUCCESS => Ok(physical_device_groups), + _ => Err(err_code), + } + } + } + + fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceProperties2 { + unsafe { + let mut prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_properties2(physical_device, &mut prop); + prop + } + } + + fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + ) -> vk::FormatProperties2 { + unsafe { + let mut format_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_format_properties2( + physical_device, + format, + &mut format_prop, + ); + format_prop + } + } + + fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceImageFormatInfo2, + ) -> VkResult { + unsafe { + let mut image_format_prop = mem::uninitialized(); + let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( + physical_device, + format_info, + &mut image_format_prop, + ); + if err_code == vk::Result::SUCCESS { + Ok(image_format_prop) + } else { + Err(err_code) + } + } + } + + fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> Vec { + unsafe { + let mut queue_count = 0; + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + let mut queue_families_vec = Vec::with_capacity(queue_count as usize); + self.fp_v1_1().get_physical_device_queue_family_properties2( + physical_device, + &mut queue_count, + queue_families_vec.as_mut_ptr(), + ); + queue_families_vec.set_len(queue_count as usize); + queue_families_vec + } + } + + fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceMemoryProperties2 { + unsafe { + let mut memory_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_memory_properties2(physical_device, &mut memory_prop); + memory_prop + } + } + + fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + ) -> Vec { + unsafe { + let mut format_count = 0; + self.fp_v1_1().get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + let mut format_prop = Vec::with_capacity(format_count as usize); + self.fp_v1_1().get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); + format_prop.set_len(format_count as usize); + format_prop + } + } + + fn get_physical_device_external_buffer_properties( + &self, + physical_device: vk::PhysicalDevice, + external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, + ) -> vk::ExternalBufferProperties { + unsafe { + let mut image_format_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); + image_format_prop + } + } + + fn get_physical_device_external_fence_properties( + &self, + physical_device: vk::PhysicalDevice, + external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, + ) -> vk::ExternalFenceProperties { + unsafe { + let mut fence_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); + fence_prop + } + } + + fn get_physical_device_external_semaphore_properties( + &self, + physical_device: vk::PhysicalDevice, + external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, + ) -> vk::ExternalSemaphoreProperties { + unsafe { + let mut semaphore_prop = mem::uninitialized(); + self.fp_v1_1().get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); + semaphore_prop + } + } } #[allow(non_camel_case_types)] From 623c26c9bcf0ac3b00d32857b82e2ed18d531f70 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:22:51 +0200 Subject: [PATCH 2/4] Add functions for DeviceV1_1 --- ash/src/device.rs | 165 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 162 insertions(+), 3 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 7b5498ecf..03d441135 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] use prelude::*; use std::mem; +use std::ptr; use version::{FunctionPointers, V1_0, V1_1}; use vk; use RawPtr; @@ -8,12 +9,170 @@ use RawPtr; #[allow(non_camel_case_types)] pub trait DeviceV1_1: DeviceV1_0 { fn fp_v1_1(&self) -> &vk::DeviceFnV1_1; - unsafe fn bind_buffer_memory2(&self, bind_infos: &[vk::BindBufferMemoryInfo]) -> vk::Result { - self.fp_v1_1().bind_buffer_memory2( + + unsafe fn bind_buffer_memory2(&self, bind_infos: &[vk::BindBufferMemoryInfo]) -> VkResult<()> { + let err_code = self.fp_v1_1().bind_buffer_memory2( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code) + } + } + + unsafe fn bind_image_memory2(&self, bind_infos: &[vk::BindImageMemoryInfo]) -> VkResult<()> { + let err_code = self.fp_v1_1().bind_image_memory2( self.handle(), bind_infos.len() as _, bind_infos.as_ptr(), - ) + ); + match err_code { + vk::Result::SUCCESS => Ok(()), + _ => Err(err_code) + } + } + + fn get_device_group_peer_memory_features(&self, heap_index: vk::uint32_t, + local_device_index: vk::uint32_t, + remote_device_index: vk::uint32_t) -> vk::PeerMemoryFeatureFlags { + unsafe { + let mut peer_memory_features = mem::uninitialized(); + self.fp_v1_1().get_device_group_peer_memory_features( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + } + + unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: vk::uint32_t) { + self.fp_v1_1().cmd_set_device_mask( + command_buffer, + device_mask + ); + } + + unsafe fn cmd_dispatch_base(&self, command_buffer: vk::CommandBuffer, + base_group_x: vk::uint32_t, + base_group_y: vk::uint32_t, + base_group_z: vk::uint32_t, + group_count_x: vk::uint32_t, + group_count_y: vk::uint32_t, + group_count_z: vk::uint32_t,) { + self.fp_v1_1().cmd_dispatch_base( + command_buffer, + base_group_x, + base_group_y, + base_group_z, + group_count_x, + group_count_y, + group_count_z, + ); + } + + unsafe fn get_image_memory_requirements2(&self, info: &vk::ImageMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + let mut image_memory_requirements = mem::uninitialized(); + self.fp_v1_1().get_image_memory_requirements2( + self.handle(), + info, + &mut image_memory_requirements, + ); + image_memory_requirements + } + + unsafe fn get_buffer_memory_requirements2(&self, info: &vk::BufferMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + let mut image_memory_requirements = mem::uninitialized(); + self.fp_v1_1().get_buffer_memory_requirements2( + self.handle(), + info, + &mut image_memory_requirements, + ); + image_memory_requirements + } + + unsafe fn get_image_sparse_memory_requirements2(&self, info: &vk::ImageSparseMemoryRequirementsInfo2) -> Vec { + let mut count = mem::uninitialized(); + self.fp_v1_1() + .get_image_sparse_memory_requirements2(self.handle(), info, &mut count, ptr::null_mut()); + let mut requirements = Vec::with_capacity(count as usize); + self.fp_v1_1().get_image_sparse_memory_requirements2( + self.handle(), + info, + &mut count, + requirements.as_mut_ptr(), + ); + requirements.set_len(count as usize); + requirements + } + + unsafe fn trim_command_pool(&self, command_pool: vk::CommandPool, flags: vk::CommandPoolTrimFlags) { + self.fp_v1_1().trim_command_pool( + self.handle(), + command_pool, + flags + ); + } + + unsafe fn create_sampler_ycbcr_conversion(&self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + let mut ycbcr_conversion = mem::uninitialized(); + let err_code = self.fp_v1_1().create_sampler_ycbcr_conversion( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut ycbcr_conversion + ); + match err_code { + vk::Result::SUCCESS => Ok(ycbcr_conversion), + _ => Err(err_code) + } + } + + unsafe fn destroy_sampler_ycbcr_conversion(&self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>) { + self.fp_v1_1().destroy_sampler_ycbcr_conversion(self.handle(), ycbcr_conversion, allocation_callbacks.as_raw_ptr()); + } + + unsafe fn create_descriptor_update_template(&self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + let mut descriptor_update_template = mem::uninitialized(); + let err_code = self.fp_v1_1().create_descriptor_update_template( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut descriptor_update_template + ); + match err_code { + vk::Result::SUCCESS => Ok(descriptor_update_template), + _ => Err(err_code) + } + } + + unsafe fn destroy_descriptor_update_template(&self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>) { + self.fp_v1_1().destroy_descriptor_update_template(self.handle(), descriptor_update_template, allocation_callbacks.as_raw_ptr()); + } + + unsafe fn update_descriptor_set_with_template(&self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const vk::c_void) { + self.fp_v1_1().update_descriptor_set_with_template(self.handle(), descriptor_set, descriptor_update_template, data); + } + + unsafe fn get_descriptor_set_layout_support(&self, create_info: &vk::DescriptorSetLayoutCreateInfo) -> vk::DescriptorSetLayoutSupport { + let mut descriptor_set_layout_support = mem::uninitialized(); + self.fp_v1_1().get_descriptor_set_layout_support(self.handle(), create_info, &mut descriptor_set_layout_support); + descriptor_set_layout_support } } From 59d49b2159ea14e1e5e8b10a2c0729d8261c8ab0 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:37:28 +0200 Subject: [PATCH 3/4] Apply rustfmt --- ash/src/device.rs | 158 +++++++++++++++++++++++++++++--------------- ash/src/instance.rs | 71 +++++++++++--------- 2 files changed, 144 insertions(+), 85 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index 03d441135..cd2b69b8f 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -18,7 +18,7 @@ pub trait DeviceV1_1: DeviceV1_0 { ); match err_code { vk::Result::SUCCESS => Ok(()), - _ => Err(err_code) + _ => Err(err_code), } } @@ -30,13 +30,16 @@ pub trait DeviceV1_1: DeviceV1_0 { ); match err_code { vk::Result::SUCCESS => Ok(()), - _ => Err(err_code) + _ => Err(err_code), } } - fn get_device_group_peer_memory_features(&self, heap_index: vk::uint32_t, - local_device_index: vk::uint32_t, - remote_device_index: vk::uint32_t) -> vk::PeerMemoryFeatureFlags { + fn get_device_group_peer_memory_features( + &self, + heap_index: vk::uint32_t, + local_device_index: vk::uint32_t, + remote_device_index: vk::uint32_t, + ) -> vk::PeerMemoryFeatureFlags { unsafe { let mut peer_memory_features = mem::uninitialized(); self.fp_v1_1().get_device_group_peer_memory_features( @@ -50,20 +53,25 @@ pub trait DeviceV1_1: DeviceV1_0 { } } - unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: vk::uint32_t) { - self.fp_v1_1().cmd_set_device_mask( - command_buffer, - device_mask - ); + unsafe fn cmd_set_device_mask( + &self, + command_buffer: vk::CommandBuffer, + device_mask: vk::uint32_t, + ) { + self.fp_v1_1() + .cmd_set_device_mask(command_buffer, device_mask); } - unsafe fn cmd_dispatch_base(&self, command_buffer: vk::CommandBuffer, - base_group_x: vk::uint32_t, - base_group_y: vk::uint32_t, - base_group_z: vk::uint32_t, - group_count_x: vk::uint32_t, - group_count_y: vk::uint32_t, - group_count_z: vk::uint32_t,) { + unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group_x: vk::uint32_t, + base_group_y: vk::uint32_t, + base_group_z: vk::uint32_t, + group_count_x: vk::uint32_t, + group_count_y: vk::uint32_t, + group_count_z: vk::uint32_t, + ) { self.fp_v1_1().cmd_dispatch_base( command_buffer, base_group_x, @@ -75,7 +83,10 @@ pub trait DeviceV1_1: DeviceV1_0 { ); } - unsafe fn get_image_memory_requirements2(&self, info: &vk::ImageMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2, + ) -> vk::MemoryRequirements2 { let mut image_memory_requirements = mem::uninitialized(); self.fp_v1_1().get_image_memory_requirements2( self.handle(), @@ -85,7 +96,10 @@ pub trait DeviceV1_1: DeviceV1_0 { image_memory_requirements } - unsafe fn get_buffer_memory_requirements2(&self, info: &vk::BufferMemoryRequirementsInfo2) -> vk::MemoryRequirements2 { + unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2, + ) -> vk::MemoryRequirements2 { let mut image_memory_requirements = mem::uninitialized(); self.fp_v1_1().get_buffer_memory_requirements2( self.handle(), @@ -95,10 +109,17 @@ pub trait DeviceV1_1: DeviceV1_0 { image_memory_requirements } - unsafe fn get_image_sparse_memory_requirements2(&self, info: &vk::ImageSparseMemoryRequirementsInfo2) -> Vec { + unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + ) -> Vec { let mut count = mem::uninitialized(); - self.fp_v1_1() - .get_image_sparse_memory_requirements2(self.handle(), info, &mut count, ptr::null_mut()); + self.fp_v1_1().get_image_sparse_memory_requirements2( + self.handle(), + info, + &mut count, + ptr::null_mut(), + ); let mut requirements = Vec::with_capacity(count as usize); self.fp_v1_1().get_image_sparse_memory_requirements2( self.handle(), @@ -110,68 +131,99 @@ pub trait DeviceV1_1: DeviceV1_0 { requirements } - unsafe fn trim_command_pool(&self, command_pool: vk::CommandPool, flags: vk::CommandPoolTrimFlags) { - self.fp_v1_1().trim_command_pool( - self.handle(), - command_pool, - flags - ); + unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlags, + ) { + self.fp_v1_1() + .trim_command_pool(self.handle(), command_pool, flags); } - unsafe fn create_sampler_ycbcr_conversion(&self, - create_info: &vk::SamplerYcbcrConversionCreateInfo, - allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + unsafe fn create_sampler_ycbcr_conversion( + &self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { let mut ycbcr_conversion = mem::uninitialized(); let err_code = self.fp_v1_1().create_sampler_ycbcr_conversion( self.handle(), create_info, allocation_callbacks.as_raw_ptr(), - &mut ycbcr_conversion + &mut ycbcr_conversion, ); match err_code { vk::Result::SUCCESS => Ok(ycbcr_conversion), - _ => Err(err_code) + _ => Err(err_code), } } - unsafe fn destroy_sampler_ycbcr_conversion(&self, - ycbcr_conversion: vk::SamplerYcbcrConversion, - allocation_callbacks: Option<&vk::AllocationCallbacks>) { - self.fp_v1_1().destroy_sampler_ycbcr_conversion(self.handle(), ycbcr_conversion, allocation_callbacks.as_raw_ptr()); + unsafe fn destroy_sampler_ycbcr_conversion( + &self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + self.fp_v1_1().destroy_sampler_ycbcr_conversion( + self.handle(), + ycbcr_conversion, + allocation_callbacks.as_raw_ptr(), + ); } - unsafe fn create_descriptor_update_template(&self, - create_info: &vk::DescriptorUpdateTemplateCreateInfo, - allocation_callbacks: Option<&vk::AllocationCallbacks>) -> VkResult { + unsafe fn create_descriptor_update_template( + &self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { let mut descriptor_update_template = mem::uninitialized(); let err_code = self.fp_v1_1().create_descriptor_update_template( self.handle(), create_info, allocation_callbacks.as_raw_ptr(), - &mut descriptor_update_template + &mut descriptor_update_template, ); match err_code { vk::Result::SUCCESS => Ok(descriptor_update_template), - _ => Err(err_code) + _ => Err(err_code), } } - unsafe fn destroy_descriptor_update_template(&self, - descriptor_update_template: vk::DescriptorUpdateTemplate, - allocation_callbacks: Option<&vk::AllocationCallbacks>) { - self.fp_v1_1().destroy_descriptor_update_template(self.handle(), descriptor_update_template, allocation_callbacks.as_raw_ptr()); + unsafe fn destroy_descriptor_update_template( + &self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + self.fp_v1_1().destroy_descriptor_update_template( + self.handle(), + descriptor_update_template, + allocation_callbacks.as_raw_ptr(), + ); } - unsafe fn update_descriptor_set_with_template(&self, - descriptor_set: vk::DescriptorSet, - descriptor_update_template: vk::DescriptorUpdateTemplate, - data: *const vk::c_void) { - self.fp_v1_1().update_descriptor_set_with_template(self.handle(), descriptor_set, descriptor_update_template, data); + unsafe fn update_descriptor_set_with_template( + &self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const vk::c_void, + ) { + self.fp_v1_1().update_descriptor_set_with_template( + self.handle(), + descriptor_set, + descriptor_update_template, + data, + ); } - unsafe fn get_descriptor_set_layout_support(&self, create_info: &vk::DescriptorSetLayoutCreateInfo) -> vk::DescriptorSetLayoutSupport { + unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + ) -> vk::DescriptorSetLayoutSupport { let mut descriptor_set_layout_support = mem::uninitialized(); - self.fp_v1_1().get_descriptor_set_layout_support(self.handle(), create_info, &mut descriptor_set_layout_support); + self.fp_v1_1().get_descriptor_set_layout_support( + self.handle(), + create_info, + &mut descriptor_set_layout_support, + ); descriptor_set_layout_support } } diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 97565dd0c..5d1c81157 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -88,19 +88,21 @@ pub trait InstanceV1_1: InstanceV1_0 { unsafe fn enumerate_instance_version(&self) -> VkResult { let mut api_version = mem::uninitialized(); - let err_code = self.fp_v1_1() - .enumerate_instance_version(&mut api_version); + let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version); match err_code { vk::Result::SUCCESS => Ok(api_version), - _ => Err(err_code) + _ => Err(err_code), } } fn enumerate_physical_device_groups(&self) -> VkResult> { unsafe { let mut group_count = mem::uninitialized(); - self.fp_v1_1() - .enumerate_physical_device_groups(self.handle(), &mut group_count, ptr::null_mut()); + self.fp_v1_1().enumerate_physical_device_groups( + self.handle(), + &mut group_count, + ptr::null_mut(), + ); let mut physical_device_groups = Vec::with_capacity(group_count as usize); let err_code = self.fp_v1_1().enumerate_physical_device_groups( self.handle(), @@ -204,19 +206,21 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> Vec { unsafe { let mut format_count = 0; - self.fp_v1_1().get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - ptr::null_mut(), - ); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); let mut format_prop = Vec::with_capacity(format_count as usize); - self.fp_v1_1().get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - format_prop.as_mut_ptr(), - ); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); format_prop.set_len(format_count as usize); format_prop } @@ -229,11 +233,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalBufferProperties { unsafe { let mut image_format_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_buffer_properties( - physical_device, - external_buffer_info, - &mut image_format_prop, - ); + self.fp_v1_1() + .get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); image_format_prop } } @@ -245,11 +250,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalFenceProperties { unsafe { let mut fence_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_fence_properties( - physical_device, - external_fence_info, - &mut fence_prop, - ); + self.fp_v1_1() + .get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); fence_prop } } @@ -261,11 +267,12 @@ pub trait InstanceV1_1: InstanceV1_0 { ) -> vk::ExternalSemaphoreProperties { unsafe { let mut semaphore_prop = mem::uninitialized(); - self.fp_v1_1().get_physical_device_external_semaphore_properties( - physical_device, - external_semaphore_info, - &mut semaphore_prop, - ); + self.fp_v1_1() + .get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); semaphore_prop } } From cda39148e98a14c369130f99e4e5dc022a072af1 Mon Sep 17 00:00:00 2001 From: Tim Date: Fri, 3 Aug 2018 12:51:03 +0200 Subject: [PATCH 4/4] Mark some more functions as unsafe --- ash/src/device.rs | 22 ++++---- ash/src/instance.rs | 124 ++++++++++++++++++++------------------------ 2 files changed, 67 insertions(+), 79 deletions(-) diff --git a/ash/src/device.rs b/ash/src/device.rs index cd2b69b8f..960fe202b 100644 --- a/ash/src/device.rs +++ b/ash/src/device.rs @@ -34,23 +34,21 @@ pub trait DeviceV1_1: DeviceV1_0 { } } - fn get_device_group_peer_memory_features( + unsafe fn get_device_group_peer_memory_features( &self, heap_index: vk::uint32_t, local_device_index: vk::uint32_t, remote_device_index: vk::uint32_t, ) -> vk::PeerMemoryFeatureFlags { - unsafe { - let mut peer_memory_features = mem::uninitialized(); - self.fp_v1_1().get_device_group_peer_memory_features( - self.handle(), - heap_index, - local_device_index, - remote_device_index, - &mut peer_memory_features, - ); - peer_memory_features - } + let mut peer_memory_features = mem::uninitialized(); + self.fp_v1_1().get_device_group_peer_memory_features( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features } unsafe fn cmd_set_device_mask( diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 5d1c81157..151b6c544 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -145,23 +145,21 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_image_format_properties2( + unsafe fn get_physical_device_image_format_properties2( &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceImageFormatInfo2, ) -> VkResult { - unsafe { - let mut image_format_prop = mem::uninitialized(); - let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( - physical_device, - format_info, - &mut image_format_prop, - ); - if err_code == vk::Result::SUCCESS { - Ok(image_format_prop) - } else { - Err(err_code) - } + let mut image_format_prop = mem::uninitialized(); + let err_code = self.fp_v1_1().get_physical_device_image_format_properties2( + physical_device, + format_info, + &mut image_format_prop, + ); + if err_code == vk::Result::SUCCESS { + Ok(image_format_prop) + } else { + Err(err_code) } } @@ -199,82 +197,74 @@ pub trait InstanceV1_1: InstanceV1_0 { } } - fn get_physical_device_sparse_image_format_properties2( + unsafe fn get_physical_device_sparse_image_format_properties2( &self, physical_device: vk::PhysicalDevice, format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, ) -> Vec { - unsafe { - let mut format_count = 0; - self.fp_v1_1() - .get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - ptr::null_mut(), - ); - let mut format_prop = Vec::with_capacity(format_count as usize); - self.fp_v1_1() - .get_physical_device_sparse_image_format_properties2( - physical_device, - format_info, - &mut format_count, - format_prop.as_mut_ptr(), - ); - format_prop.set_len(format_count as usize); - format_prop - } + let mut format_count = 0; + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + let mut format_prop = Vec::with_capacity(format_count as usize); + self.fp_v1_1() + .get_physical_device_sparse_image_format_properties2( + physical_device, + format_info, + &mut format_count, + format_prop.as_mut_ptr(), + ); + format_prop.set_len(format_count as usize); + format_prop } - fn get_physical_device_external_buffer_properties( + unsafe fn get_physical_device_external_buffer_properties( &self, physical_device: vk::PhysicalDevice, external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, ) -> vk::ExternalBufferProperties { - unsafe { - let mut image_format_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_buffer_properties( - physical_device, - external_buffer_info, - &mut image_format_prop, - ); - image_format_prop - } + let mut image_format_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_buffer_properties( + physical_device, + external_buffer_info, + &mut image_format_prop, + ); + image_format_prop } - fn get_physical_device_external_fence_properties( + unsafe fn get_physical_device_external_fence_properties( &self, physical_device: vk::PhysicalDevice, external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, ) -> vk::ExternalFenceProperties { - unsafe { - let mut fence_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_fence_properties( - physical_device, - external_fence_info, - &mut fence_prop, - ); - fence_prop - } + let mut fence_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_fence_properties( + physical_device, + external_fence_info, + &mut fence_prop, + ); + fence_prop } - fn get_physical_device_external_semaphore_properties( + unsafe fn get_physical_device_external_semaphore_properties( &self, physical_device: vk::PhysicalDevice, external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, ) -> vk::ExternalSemaphoreProperties { - unsafe { - let mut semaphore_prop = mem::uninitialized(); - self.fp_v1_1() - .get_physical_device_external_semaphore_properties( - physical_device, - external_semaphore_info, - &mut semaphore_prop, - ); - semaphore_prop - } + let mut semaphore_prop = mem::uninitialized(); + self.fp_v1_1() + .get_physical_device_external_semaphore_properties( + physical_device, + external_semaphore_info, + &mut semaphore_prop, + ); + semaphore_prop } }