From e230d6ae81421d2325c4aba206b25aba0fe3b0c7 Mon Sep 17 00:00:00 2001 From: Tim Date: Wed, 1 Aug 2018 16:51:43 +0200 Subject: [PATCH] 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 7c30bbe..97565dd 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)]