vkobject_rs/

device.rs

use crate::prelude::*;
use std::{
	ffi::CStr,
	fmt::{self, Debug, Formatter},
	mem::MaybeUninit,
	ptr::{null, null_mut},
	sync::Arc,
};

/// The physical device info
#[derive(Debug, Clone)]
pub struct VulkanGpuInfo {
	/// The physical device
	pub(crate) gpu: VkPhysicalDevice,

	/// The properties of the physical device
	pub(crate) properties: VkPhysicalDeviceProperties,

	/// The properties of the physical device memory
	pub(crate) mem_properties: VkPhysicalDeviceMemoryProperties,

	/// The queue families
	pub(crate) queue_families: Vec<VkQueueFamilyProperties>,

	/// The extension properties
	pub(crate) extension_properties: Vec<VkExtensionProperties>,
}

impl VulkanGpuInfo {
	/// Create a list of all the GPUs info
	pub fn get_gpu_info(vkcore: &VkCore) -> Result<Vec<VulkanGpuInfo>, VulkanError> {
		let mut num_gpus = 0u32;
		vkcore.vkEnumeratePhysicalDevices(vkcore.get_instance(), &mut num_gpus, null_mut())?;
		let mut gpus = Vec::<VkPhysicalDevice>::with_capacity(num_gpus as usize);
		vkcore.vkEnumeratePhysicalDevices(vkcore.get_instance(), &mut num_gpus, gpus.as_mut_ptr())?;
		unsafe {gpus.set_len(num_gpus as usize)};
		let mut ret = Vec::<VulkanGpuInfo>::with_capacity(num_gpus as usize);
		for gpu in gpus {
			let mut properties: VkPhysicalDeviceProperties = unsafe {MaybeUninit::zeroed().assume_init()};
			vkcore.vkGetPhysicalDeviceProperties(gpu, &mut properties)?;
			let mut mem_properties: VkPhysicalDeviceMemoryProperties = unsafe {MaybeUninit::zeroed().assume_init()};
			vkcore.vkGetPhysicalDeviceMemoryProperties(gpu, &mut mem_properties)?;
			let mut num_queue_families = 0u32;
			vkcore.vkGetPhysicalDeviceQueueFamilyProperties(gpu, &mut num_queue_families, null_mut())?;
			let mut queue_families = Vec::<VkQueueFamilyProperties>::with_capacity(num_queue_families as usize);
			vkcore.vkGetPhysicalDeviceQueueFamilyProperties(gpu, &mut num_queue_families, queue_families.as_mut_ptr())?;
			unsafe {queue_families.set_len(num_queue_families as usize)};
			let mut num_extension_properties = 0u32;
			vkcore.vkEnumerateDeviceExtensionProperties(gpu, null(), &mut num_extension_properties, null_mut())?;
			let mut extension_properties = Vec::<VkExtensionProperties>::with_capacity(num_extension_properties as usize);
			vkcore.vkEnumerateDeviceExtensionProperties(gpu, null(), &mut num_extension_properties, extension_properties.as_mut_ptr())?;
			unsafe {extension_properties.set_len(num_extension_properties as usize)};
			ret.push(VulkanGpuInfo {
				gpu,
				properties,
				mem_properties,
				queue_families,
				extension_properties,
			});
		}
		Ok(ret)
	}

	/// Get the `VkPhysicalDevice`
	pub(crate) fn get_vk_physical_device(&self) -> VkPhysicalDevice {
		self.gpu
	}

	/// Get the `VkQueueFamilyProperties` list
	pub fn get_queue_families(&self) -> &[VkQueueFamilyProperties] {
		self.queue_families.as_ref()
	}

	/// Find a queue family index that matches the flags
	pub fn get_queue_family_index_by_flags(&self, queue_flag_match: u32) -> u32 {
		for i in 0..self.queue_families.len() {
			if (self.queue_families[i].queueFlags & queue_flag_match) == queue_flag_match {
				return i as u32;
			}
		}
		u32::MAX
	}

	/// Get the `VkPhysicalDeviceProperties`
	pub fn get_properties(&self) -> &VkPhysicalDeviceProperties {
		&self.properties
	}

	/// Get the list of the `VkExtensionProperties`
	pub fn get_extension_properties(&self) -> &[VkExtensionProperties] {
		self.extension_properties.as_ref()
	}

	/// Get memory type index by the memory properties flags
	pub fn get_memory_type_index(&self, mut type_bits: u32, properties: VkMemoryPropertyFlags) -> Result<u32, VulkanError> {
		for i in 0..self.mem_properties.memoryTypeCount {
			if (type_bits & 1) == 1
				&& (self.mem_properties.memoryTypes[i as usize].propertyFlags & properties) == properties {
				return Ok(i)
			}
			type_bits >>= 1;
		}
		Err(VulkanError::NoSuitableMemoryType)
	}
}

unsafe impl Send for VulkanGpuInfo {}
unsafe impl Sync for VulkanGpuInfo {}

/// The Vulkan device with its queues to submit the rendering commands
pub struct VulkanDevice {
	/// The Vulkan driver
	pub(crate) vkcore: Arc<VkCore>,

	/// The current queue family index
	queue_family_index: u32,

	/// The info of the GPU
	gpu: VulkanGpuInfo,

	/// The handle to the device
	device: VkDevice,

	/// The queues of the device. Submit commands to the queue to control GPU.
	pub(crate) queue: VkQueue,
}

impl VulkanDevice {
	/// Create the `VulkanDevice` by the given `VkPhysicalDevice` and the queue family index
	pub fn new(vkcore: Arc<VkCore>, gpu: VulkanGpuInfo, queue_family_index: u32) -> Result<Self, VulkanError> {
		fn remove_c_string_from_vec(v: &mut Vec<*const i8>, to_remove: &str) {
			let mut found_index = None;
			for (i, &ptr) in v.iter().enumerate() {
				unsafe {
					let c_str = CStr::from_ptr(ptr);
					// Compare without assuming it's UTF-8
					if c_str.to_bytes() == to_remove.as_bytes() {
						found_index = Some(i);
						break;
					}
				}
			}
			found_index.map(|i| v.swap_remove(i));
		}
		let priorities = [1.0_f32];
		let queue_ci = VkDeviceQueueCreateInfo {
			sType: VkStructureType::VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
			pNext: null(),
			flags: 0,
			queueFamilyIndex: queue_family_index,
			queueCount: 1,
			pQueuePriorities: priorities.as_ptr(),
		};
		let mut extensions: Vec<*const i8> = Vec::with_capacity(gpu.extension_properties.len());
		let mut has_vk_khr_buffer_device_address = false;
		let mut has_vk_ext_buffer_device_address = false;
		for ext in gpu.extension_properties.iter() {
			let ext_ptr = ext.extensionName.as_ptr();
			let ext_str = unsafe {CStr::from_ptr(ext_ptr)}.to_string_lossy();
			if ext_str == "VK_KHR_buffer_device_address" {
				has_vk_khr_buffer_device_address = true;
			} else if ext_str == "VK_EXT_buffer_device_address" {
				has_vk_ext_buffer_device_address = true;
			} else if ext_str == "VK_NV_disk_cache_utils" || ext_str == "VK_NV_internal_nvpresent" {
				// The validation layer doesn't know what these extensions are. It will say you are asking for some unknown extensions. Also, we are not going to use these.
				continue;
			}
			extensions.push(ext_ptr)
		}
		if has_vk_khr_buffer_device_address && has_vk_ext_buffer_device_address {
			remove_c_string_from_vec(&mut extensions, "VK_EXT_buffer_device_address");
		}

		let device_ci = VkDeviceCreateInfo {
			sType: VkStructureType::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
			pNext: null(),
			flags: 0,
			queueCreateInfoCount: 1,
			pQueueCreateInfos: &queue_ci,
			enabledLayerCount: 0,
			ppEnabledLayerNames: null(),
			enabledExtensionCount: extensions.len() as u32,
			ppEnabledExtensionNames: extensions.as_ptr(),
			pEnabledFeatures: null(),
		};

		let mut device: VkDevice = null();
		vkcore.vkCreateDevice(gpu.get_vk_physical_device(), &device_ci, null(), &mut device)?;
		let device = ResourceGuard::new(device, |&d|proceed_run(vkcore.vkDestroyDevice(d, null())));

		let mut queue: VkQueue = null();
		vkcore.vkGetDeviceQueue(*device, queue_family_index, 0, &mut queue)?;
		let device = device.release();

		Ok(Self {
			vkcore,
			queue_family_index,
			gpu,
			device,
			queue,
		})
	}

	/// Choose a GPU that matches the `VkQueueFlags`
	/// * `flags`: The flags you want to match
	pub fn choose_gpu_by_flags(vkcore: Arc<VkCore>, flags: VkQueueFlags, name_substr: &str) -> Result<Self, VulkanError> {
		for gpu in VulkanGpuInfo::get_gpu_info(&vkcore)?.iter() {
			if !unsafe{CStr::from_ptr(gpu.properties.deviceName.as_ptr())}.to_str().unwrap().contains(name_substr) {
				continue;
			}
			let index = gpu.get_queue_family_index_by_flags(flags);
			if index != u32::MAX {
				return Self::new(vkcore, gpu.clone(), index);
			}
		}
		Err(VulkanError::ChooseGpuFailed)
	}

	/// Choose a GPU that must support graphics
	/// * `queue_count`: see `VulkanDevice::new()`
	pub fn choose_gpu_with_graphics(vkcore: Arc<VkCore>, name_substr: &str) -> Result<Self, VulkanError> {
		Self::choose_gpu_by_flags(vkcore, VkQueueFlagBits::VK_QUEUE_GRAPHICS_BIT as VkQueueFlags, name_substr)
	}

	/// Choose a GPU that must support compute
	/// * `queue_count`: see `VulkanDevice::new()`
	pub fn choose_gpu_with_compute(vkcore: Arc<VkCore>, name_substr: &str) -> Result<Self, VulkanError> {
		Self::choose_gpu_by_flags(vkcore, VkQueueFlagBits::VK_QUEUE_COMPUTE_BIT as VkQueueFlags, name_substr)
	}

	/// Choose a GPU that must support both graphics and compute
	/// * `queue_count`: see `VulkanDevice::new()`
	pub fn choose_gpu_with_graphics_and_compute(vkcore: Arc<VkCore>, name_substr: &str) -> Result<Self, VulkanError> {
		Self::choose_gpu_by_flags(vkcore,
			VkQueueFlagBits::VK_QUEUE_GRAPHICS_BIT as VkQueueFlags |
			VkQueueFlagBits::VK_QUEUE_COMPUTE_BIT as VkQueueFlags, name_substr)
	}

	/// Choose a GPU that is, anyway, a GPU regardless of can do graphics/compute or not.
	/// * `queue_count`: see `VulkanDevice::new()`
	pub fn choose_gpu_anyway(vkcore: Arc<VkCore>, name_substr: &str) -> Result<Self, VulkanError> {
		Self::choose_gpu_by_flags(vkcore, 0, name_substr)
	}

	/// Get the current queue family index
	pub fn get_queue_family_index(&self) -> u32 {
		self.queue_family_index
	}

	/// Get the GPU info
	pub fn get_gpu(&self) -> &VulkanGpuInfo {
		&self.gpu
	}

	/// Check if the `queue_index` and the `VkSurfaceKHR` were supported by the `VkPhysicalDevice`
	pub fn get_supported_by_surface(&self, queue_index: usize, surface: VkSurfaceKHR) -> Result<bool, VulkanError> {
		let mut result: VkBool32 = 0;
		self.vkcore.vkGetPhysicalDeviceSurfaceSupportKHR(self.get_vk_physical_device(), queue_index as u32, surface, &mut result)?;
		Ok(result != 0)
	}

	/// A wrapper for `vkDeviceWaitIdle`
	pub fn wait_idle(&self) -> Result<(), VulkanError> {
		self.vkcore.vkDeviceWaitIdle(self.device)?;
		Ok(())
	}

	/// Get the `VkPhysicalDevice`
	pub(crate) fn get_vk_physical_device(&self) -> VkPhysicalDevice {
		self.gpu.get_vk_physical_device()
	}

	/// Get the `VkDevice`
	pub(crate) fn get_vk_device(&self) -> VkDevice {
		self.device
	}

	/// Get a queue for the current device
	pub(crate) fn get_vk_queue(&self) -> VkQueue {
		self.queue
	}
}

impl Debug for VulkanDevice {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		f.debug_struct("VulkanDevice")
		.field("queue_family_index", &self.queue_family_index)
		.field("gpu", &self.gpu)
		.field("device", &self.device)
		.field("queue", &self.queue)
		.finish()
	}
}

impl Clone for VulkanDevice {
	fn clone(&self) -> Self {
		Self::new(self.vkcore.clone(), self.gpu.clone(), self.queue_family_index).unwrap()
	}
}

impl Drop for VulkanDevice {
	fn drop(&mut self) {
		proceed_run(self.vkcore.vkDestroyDevice(self.device, null()))
	}
}

unsafe impl Send for VulkanDevice {}
unsafe impl Sync for VulkanDevice {}