From 6ebdf3d9d7e098c4784de9e585553327142ca0b4 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sat, 4 Jun 2022 12:22:36 +0200 Subject: [PATCH] extensions/khr: Add VK_KHR_device_group --- Changelog.md | 1 + ash/src/extensions/khr/device_group.rs | 138 +++++++++++++++++++++++++ ash/src/extensions/khr/mod.rs | 2 + ash/src/extensions/khr/swapchain.rs | 14 +++ 4 files changed, 155 insertions(+) create mode 100644 ash/src/extensions/khr/device_group.rs diff --git a/Changelog.md b/Changelog.md index e208af985..30b655e90 100644 --- a/Changelog.md +++ b/Changelog.md @@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `VK_EXT_image_drm_format_modifier` device extension (#603) - Added new functions to `VK_KHR_swapchain`, available since Vulkan 1.1 (#629) - Added `VK_KHR_device_group_creation` instance extension (#630) +- Added `VK_KHR_device_group` device extension (#631) ### Removed diff --git a/ash/src/extensions/khr/device_group.rs b/ash/src/extensions/khr/device_group.rs new file mode 100644 index 000000000..f168d3fee --- /dev/null +++ b/ash/src/extensions/khr/device_group.rs @@ -0,0 +1,138 @@ +#[cfg(doc)] +use super::Swapchain; +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DeviceGroup { + handle: vk::Device, + fp: vk::KhrDeviceGroupFn, +} + +impl DeviceGroup { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDeviceGroupFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + pub unsafe fn get_device_group_peer_memory_features( + &self, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + ) -> vk::PeerMemoryFeatureFlags { + let mut peer_memory_features = mem::zeroed(); + (self.fp.get_device_group_peer_memory_features_khr)( + self.handle, + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + + /// + pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) { + (self.fp.cmd_set_device_mask_khr)(command_buffer, device_mask) + } + + /// + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group: (u32, u32, u32), + group_count: (u32, u32, u32), + ) { + (self.fp.cmd_dispatch_base_khr)( + command_buffer, + base_group.0, + base_group.1, + base_group.2, + group_count.0, + group_count.1, + group_count.2, + ) + } + + /// Also available as [`Swapchain::get_device_group_present_capabilities()`] since Vulkan 1.1. + /// + /// + pub unsafe fn get_device_group_present_capabilities( + &self, + device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR, + ) -> VkResult<()> { + (self.fp.get_device_group_present_capabilities_khr)( + self.handle, + device_group_present_capabilities, + ) + .result() + } + + /// Also available as [`Swapchain::get_device_group_surface_present_modes()`] since Vulkan 1.1. + /// + /// + pub unsafe fn get_device_group_surface_present_modes( + &self, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes) + .result_with_success(modes) + } + + /// Also available as [`Swapchain::get_physical_device_present_rectangles()`] since Vulkan 1.1. + /// + /// + pub unsafe fn get_physical_device_present_rectangles( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// Also available as [`Swapchain::acquire_next_image2()`] since Vulkan 1.1. + /// + /// + pub unsafe fn acquire_next_image2( + &self, + acquire_info: &vk::AcquireNextImageInfoKHR, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + pub const fn name() -> &'static CStr { + vk::KhrDeviceGroupFn::name() + } + + pub fn fp(&self) -> &vk::KhrDeviceGroupFn { + &self.fp + } + + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/ash/src/extensions/khr/mod.rs b/ash/src/extensions/khr/mod.rs index fe1c5cf92..babb0626f 100644 --- a/ash/src/extensions/khr/mod.rs +++ b/ash/src/extensions/khr/mod.rs @@ -4,6 +4,7 @@ pub use self::buffer_device_address::BufferDeviceAddress; pub use self::copy_commands2::CopyCommands2; pub use self::create_render_pass2::CreateRenderPass2; pub use self::deferred_host_operations::DeferredHostOperations; +pub use self::device_group::DeviceGroup; pub use self::device_group_creation::DeviceGroupCreation; pub use self::display::Display; pub use self::display_swapchain::DisplaySwapchain; @@ -40,6 +41,7 @@ mod buffer_device_address; mod copy_commands2; mod create_render_pass2; mod deferred_host_operations; +mod device_group; mod device_group_creation; mod display; mod display_swapchain; diff --git a/ash/src/extensions/khr/swapchain.rs b/ash/src/extensions/khr/swapchain.rs index d37553889..522612430 100755 --- a/ash/src/extensions/khr/swapchain.rs +++ b/ash/src/extensions/khr/swapchain.rs @@ -1,3 +1,5 @@ +#[cfg(doc)] +use super::DeviceGroup; use crate::prelude::*; use crate::vk; use crate::RawPtr; @@ -99,6 +101,9 @@ impl Swapchain { /// Only available since Vulkan 1.1. /// + /// Also available as [`DeviceGroup::get_device_group_present_capabilities()`] + /// when `VK_KHR_surface` is enabled. + /// /// pub unsafe fn get_device_group_present_capabilities( &self, @@ -113,6 +118,9 @@ impl Swapchain { /// Only available since Vulkan 1.1. /// + /// Also available as [`DeviceGroup::get_device_group_surface_present_modes()`] + /// when `VK_KHR_surface` is enabled. + /// /// pub unsafe fn get_device_group_surface_present_modes( &self, @@ -125,6 +133,9 @@ impl Swapchain { /// Only available since Vulkan 1.1. /// + /// Also available as [`DeviceGroup::get_physical_device_present_rectangles()`] + /// when `VK_KHR_surface` is enabled. + /// /// pub unsafe fn get_physical_device_present_rectangles( &self, @@ -145,6 +156,9 @@ impl Swapchain { /// /// Only available since Vulkan 1.1. /// + /// Also available as [`DeviceGroup::acquire_next_image2()`] + /// when `VK_KHR_swapchain` is enabled. + /// /// pub unsafe fn acquire_next_image2( &self,