entailz/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

Merge pull request #221 from mahkoh/jorth/ash38

Browse source 
vulkan: upgrade to ash 0.38
This commit is contained in:
mahkoh 2024-07-09 09:57:54 +02:00 • committed by GitHub
commit 1a0181f2ac
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 236 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Cargo.lock generated
View file

@ -116,11 +116,11 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
[[package]] [[package]]
name = "ash" name = "ash"
version = "0.37.3+1.3.251" version = "0.38.0+1.3.281"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39e9c3835d686b0a6084ab4234fcd1b07dbf6e4767dce60874b12356a25ecd4a" checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
dependencies = [ dependencies = [
"libloading 0.7.4", "libloading",
] ]
[[package]] [[package]]
@ -458,9 +458,9 @@ dependencies = [
[[package]] [[package]]
name = "gpu-alloc-ash" name = "gpu-alloc-ash"
version = "0.6.0" version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2424bc9be88170e1a56e57c25d3d0e2dfdd22e8f328e892786aeb4da1415732" checksum = "cbda7a18a29bc98c2e0de0435c347df935bf59489935d0cbd0b73f1679b6f79a"
dependencies = [ dependencies = [
"ash", "ash",
"gpu-alloc-types", "gpu-alloc-types",
@ -574,7 +574,7 @@ dependencies = [
"jay-algorithms", "jay-algorithms",
"jay-config", "jay-config",
"jay-toml-config", "jay-toml-config",
"libloading 0.8.1", "libloading",
"log", "log",
"num-derive", "num-derive",
"num-traits", "num-traits",
@ -645,16 +645,6 @@ version = "0.2.153"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
[[package]]
name = "libloading"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
dependencies = [
"cfg-if",
"winapi",
]
[[package]] [[package]]
name = "libloading" name = "libloading"
version = "0.8.1" version = "0.8.1"

4
Cargo.toml
View file

@ -51,9 +51,9 @@ chrono = "0.4.33"
parking_lot = "0.12.1" parking_lot = "0.12.1"
arrayvec = "0.7.4" arrayvec = "0.7.4"
indexmap = "2.2.0" indexmap = "2.2.0"
ash = "0.37.3" ash = "0.38.0"
gpu-alloc = "0.6.0" gpu-alloc = "0.6.0"
gpu-alloc-ash = "0.6.0" gpu-alloc-ash = "0.7.0"
serde = { version = "1.0.196", features = ["derive"] } serde = { version = "1.0.196", features = ["derive"] }
enum-map = "2.7.3" enum-map = "2.7.3"
png = "0.17.13" png = "0.17.13"

2
deploy-notes.md
View file

@ -1,5 +1,7 @@
# Unreleased # Unreleased
- Needs jay-compositor release.
# 1.4.0 # 1.4.0
- Needs jay-config release. - Needs jay-config release.

4
src/gfx_apis/vulkan/command.rs
View file

@ -38,7 +38,7 @@ impl Drop for VulkanCommandBuffer {
impl VulkanCommandPool { impl VulkanCommandPool {
pub fn allocate_buffer(self: &Rc<Self>) -> Result<Rc<VulkanCommandBuffer>, VulkanError> { pub fn allocate_buffer(self: &Rc<Self>) -> Result<Rc<VulkanCommandBuffer>, VulkanError> {
let create_info = CommandBufferAllocateInfo::builder() let create_info = CommandBufferAllocateInfo::default()
.command_pool(self.pool) .command_pool(self.pool)
.command_buffer_count(1) .command_buffer_count(1)
.level(CommandBufferLevel::PRIMARY); .level(CommandBufferLevel::PRIMARY);
@ -54,7 +54,7 @@ impl VulkanCommandPool {
impl VulkanDevice { impl VulkanDevice {
pub fn create_command_pool(self: &Rc<Self>) -> Result<Rc<VulkanCommandPool>, VulkanError> { pub fn create_command_pool(self: &Rc<Self>) -> Result<Rc<VulkanCommandPool>, VulkanError> {
let info = CommandPoolCreateInfo::builder() let info = CommandPoolCreateInfo::default()
.queue_family_index(self.graphics_queue_idx) .queue_family_index(self.graphics_queue_idx)
.flags( .flags(
CommandPoolCreateFlags::TRANSIENT | CommandPoolCreateFlags::RESET_COMMAND_BUFFER, CommandPoolCreateFlags::TRANSIENT | CommandPoolCreateFlags::RESET_COMMAND_BUFFER,

7
src/gfx_apis/vulkan/descriptor.rs
View file

@ -29,13 +29,12 @@ impl VulkanDevice {
sampler: &Rc<VulkanSampler>, sampler: &Rc<VulkanSampler>,
) -> Result<Rc<VulkanDescriptorSetLayout>, VulkanError> { ) -> Result<Rc<VulkanDescriptorSetLayout>, VulkanError> {
let immutable_sampler = [sampler.sampler]; let immutable_sampler = [sampler.sampler];
let binding = DescriptorSetLayoutBinding::builder() let binding = DescriptorSetLayoutBinding::default()
.stage_flags(ShaderStageFlags::FRAGMENT) .stage_flags(ShaderStageFlags::FRAGMENT)
.immutable_samplers(&immutable_sampler) .immutable_samplers(&immutable_sampler)
.descriptor_count(1) .descriptor_count(1)
.descriptor_type(DescriptorType::COMBINED_IMAGE_SAMPLER) .descriptor_type(DescriptorType::COMBINED_IMAGE_SAMPLER);
.build(); let create_info = DescriptorSetLayoutCreateInfo::default()
let create_info = DescriptorSetLayoutCreateInfo::builder()
.bindings(slice::from_ref(&binding)) .bindings(slice::from_ref(&binding))
.flags(DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR); .flags(DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR);
let layout = unsafe { self.device.create_descriptor_set_layout(&create_info, None) }; let layout = unsafe { self.device.create_descriptor_set_layout(&create_info, None) };

80
src/gfx_apis/vulkan/device.rs
View file

@ -18,14 +18,18 @@ use {
ahash::AHashMap, ahash::AHashMap,
arrayvec::ArrayVec, arrayvec::ArrayVec,
ash::{ ash::{
extensions::khr::{ExternalFenceFd, ExternalMemoryFd, ExternalSemaphoreFd, PushDescriptor}, ext::{
external_memory_dma_buf, image_drm_format_modifier, physical_device_drm,
queue_family_foreign,
},
khr::{
driver_properties, external_fence_fd, external_memory_fd, external_semaphore_fd,
push_descriptor,
},
vk::{ vk::{
DeviceCreateInfo, DeviceQueueCreateInfo, ExtExternalMemoryDmaBufFn, DeviceCreateInfo, DeviceQueueCreateInfo, ExternalSemaphoreFeatureFlags,
ExtImageDrmFormatModifierFn, ExtPhysicalDeviceDrmFn, ExtQueueFamilyForeignFn, ExternalSemaphoreHandleTypeFlags, ExternalSemaphoreProperties, MemoryPropertyFlags,
ExternalSemaphoreFeatureFlags, ExternalSemaphoreHandleTypeFlags, MemoryType, PhysicalDevice, PhysicalDeviceDriverProperties,
ExternalSemaphoreProperties, KhrDriverPropertiesFn, KhrExternalFenceFdFn,
KhrExternalMemoryFdFn, KhrExternalSemaphoreFdFn, KhrPushDescriptorFn,
MemoryPropertyFlags, MemoryType, PhysicalDevice, PhysicalDeviceDriverProperties,
PhysicalDeviceDriverPropertiesKHR, PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceDriverPropertiesKHR, PhysicalDeviceDrmPropertiesEXT,
PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceExternalSemaphoreInfo, PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceExternalSemaphoreInfo,
PhysicalDeviceProperties, PhysicalDeviceProperties2, PhysicalDeviceProperties, PhysicalDeviceProperties2,
@ -49,10 +53,10 @@ pub struct VulkanDevice {
pub(super) sync_ctx: Rc<SyncObjCtx>, pub(super) sync_ctx: Rc<SyncObjCtx>,
pub(super) instance: Rc<VulkanInstance>, pub(super) instance: Rc<VulkanInstance>,
pub(super) device: Device, pub(super) device: Device,
pub(super) external_memory_fd: ExternalMemoryFd, pub(super) external_memory_fd: external_memory_fd::Device,
pub(super) external_semaphore_fd: ExternalSemaphoreFd, pub(super) external_semaphore_fd: external_semaphore_fd::Device,
pub(super) external_fence_fd: ExternalFenceFd, pub(super) external_fence_fd: external_fence_fd::Device,
pub(super) push_descriptor: PushDescriptor, pub(super) push_descriptor: push_descriptor::Device,
pub(super) formats: AHashMap<u32, VulkanFormat>, pub(super) formats: AHashMap<u32, VulkanFormat>,
pub(super) memory_types: ArrayVec<MemoryType, MAX_MEMORY_TYPES>, pub(super) memory_types: ArrayVec<MemoryType, MAX_MEMORY_TYPES>,
pub(super) graphics_queue: Queue, pub(super) graphics_queue: Queue,
@ -129,14 +133,14 @@ impl VulkanInstance {
continue; continue;
} }
}; };
if !extensions.contains_key(ExtPhysicalDeviceDrmFn::name()) { if !extensions.contains_key(physical_device_drm::NAME) {
devices.push((props, Some(extensions), None)); devices.push((props, Some(extensions), None));
continue; continue;
} }
let has_driver_props = extensions.contains_key(KhrDriverPropertiesFn::name()); let has_driver_props = extensions.contains_key(driver_properties::NAME);
let mut drm_props = PhysicalDeviceDrmPropertiesEXT::builder().build(); let mut drm_props = PhysicalDeviceDrmPropertiesEXT::default();
let mut driver_props = PhysicalDeviceDriverPropertiesKHR::builder().build(); let mut driver_props = PhysicalDeviceDriverPropertiesKHR::default();
let mut props2 = PhysicalDeviceProperties2::builder().push_next(&mut drm_props); let mut props2 = PhysicalDeviceProperties2::default().push_next(&mut drm_props);
if has_driver_props { if has_driver_props {
props2 = props2.push_next(&mut driver_props); props2 = props2.push_next(&mut driver_props);
} }
@ -181,10 +185,9 @@ impl VulkanInstance {
} }
fn supports_semaphore_import(&self, phy_dev: PhysicalDevice) -> bool { fn supports_semaphore_import(&self, phy_dev: PhysicalDevice) -> bool {
let mut props = ExternalSemaphoreProperties::builder().build(); let mut props = ExternalSemaphoreProperties::default();
let info = PhysicalDeviceExternalSemaphoreInfo::builder() let info = PhysicalDeviceExternalSemaphoreInfo::default()
.handle_type(ExternalSemaphoreHandleTypeFlags::OPAQUE_FD) .handle_type(ExternalSemaphoreHandleTypeFlags::OPAQUE_FD);
.build();
unsafe { unsafe {
self.instance self.instance
.get_physical_device_external_semaphore_properties(phy_dev, &info, &mut props); .get_physical_device_external_semaphore_properties(phy_dev, &info, &mut props);
@ -217,16 +220,15 @@ impl VulkanInstance {
.map(|n| n.as_ptr()) .map(|n| n.as_ptr())
.collect(); .collect();
let mut semaphore_features = let mut semaphore_features =
PhysicalDeviceTimelineSemaphoreFeatures::builder().timeline_semaphore(true); PhysicalDeviceTimelineSemaphoreFeatures::default().timeline_semaphore(true);
let mut synchronization2_features = let mut synchronization2_features =
PhysicalDeviceSynchronization2Features::builder().synchronization2(true); PhysicalDeviceSynchronization2Features::default().synchronization2(true);
let mut dynamic_rendering_features = let mut dynamic_rendering_features =
PhysicalDeviceDynamicRenderingFeatures::builder().dynamic_rendering(true); PhysicalDeviceDynamicRenderingFeatures::default().dynamic_rendering(true);
let queue_create_info = DeviceQueueCreateInfo::builder() let queue_create_info = DeviceQueueCreateInfo::default()
.queue_family_index(graphics_queue_idx) .queue_family_index(graphics_queue_idx)
.queue_priorities(&[1.0]) .queue_priorities(&[1.0]);
.build(); let device_create_info = DeviceCreateInfo::default()
let device_create_info = DeviceCreateInfo::builder()
.push_next(&mut semaphore_features) .push_next(&mut semaphore_features)
.push_next(&mut synchronization2_features) .push_next(&mut synchronization2_features)
.push_next(&mut dynamic_rendering_features) .push_next(&mut dynamic_rendering_features)
@ -258,10 +260,10 @@ impl VulkanInstance {
return Err(VulkanError::XRGB8888); return Err(VulkanError::XRGB8888);
} }
destroy_device.forget(); destroy_device.forget();
let external_memory_fd = ExternalMemoryFd::new(&self.instance, &device); let external_memory_fd = external_memory_fd::Device::new(&self.instance, &device);
let external_semaphore_fd = ExternalSemaphoreFd::new(&self.instance, &device); let external_semaphore_fd = external_semaphore_fd::Device::new(&self.instance, &device);
let external_fence_fd = ExternalFenceFd::new(&self.instance, &device); let external_fence_fd = external_fence_fd::Device::new(&self.instance, &device);
let push_descriptor = PushDescriptor::new(&self.instance, &device); let push_descriptor = push_descriptor::Device::new(&self.instance, &device);
let memory_properties = let memory_properties =
unsafe { self.instance.get_physical_device_memory_properties(phy_dev) }; unsafe { self.instance.get_physical_device_memory_properties(phy_dev) };
let memory_types = memory_properties.memory_types let memory_types = memory_properties.memory_types
@ -290,13 +292,13 @@ impl VulkanInstance {
} }
const REQUIRED_DEVICE_EXTENSIONS: &[&CStr] = &[ const REQUIRED_DEVICE_EXTENSIONS: &[&CStr] = &[
KhrExternalMemoryFdFn::name(), external_memory_fd::NAME,
KhrExternalSemaphoreFdFn::name(), external_semaphore_fd::NAME,
KhrExternalFenceFdFn::name(), external_fence_fd::NAME,
ExtExternalMemoryDmaBufFn::name(), external_memory_dma_buf::NAME,
ExtQueueFamilyForeignFn::name(), queue_family_foreign::NAME,
ExtImageDrmFormatModifierFn::name(), image_drm_format_modifier::NAME,
KhrPushDescriptorFn::name(), push_descriptor::NAME,
]; ];
fn log_device( fn log_device(
@ -322,7 +324,7 @@ fn log_device(
log::warn!(" device does not support vulkan 1.3"); log::warn!(" device does not support vulkan 1.3");
} }
if let Some(extensions) = extensions { if let Some(extensions) = extensions {
if !extensions.contains_key(ExtPhysicalDeviceDrmFn::name()) { if !extensions.contains_key(physical_device_drm::NAME) {
log::warn!(" device does support not the VK_EXT_physical_device_drm extension"); log::warn!(" device does support not the VK_EXT_physical_device_drm extension");
} }
} }

6
src/gfx_apis/vulkan/fence.rs
View file

@ -27,9 +27,9 @@ impl Drop for VulkanFence {
impl VulkanDevice { impl VulkanDevice {
pub fn create_fence(self: &Rc<Self>) -> Result<Rc<VulkanFence>, VulkanError> { pub fn create_fence(self: &Rc<Self>) -> Result<Rc<VulkanFence>, VulkanError> {
let fence = { let fence = {
let mut export_info = ExportFenceCreateInfo::builder() let mut export_info = ExportFenceCreateInfo::default()
.handle_types(ExternalFenceHandleTypeFlags::SYNC_FD); .handle_types(ExternalFenceHandleTypeFlags::SYNC_FD);
let create_info = FenceCreateInfo::builder().push_next(&mut export_info); let create_info = FenceCreateInfo::default().push_next(&mut export_info);
let fence = unsafe { self.device.create_fence(&create_info, None) }; let fence = unsafe { self.device.create_fence(&create_info, None) };
fence.map_err(VulkanError::CreateFence)? fence.map_err(VulkanError::CreateFence)?
}; };
@ -42,7 +42,7 @@ impl VulkanDevice {
impl VulkanFence { impl VulkanFence {
pub fn export_sync_file(&self) -> Result<SyncFile, VulkanError> { pub fn export_sync_file(&self) -> Result<SyncFile, VulkanError> {
let info = FenceGetFdInfoKHR::builder() let info = FenceGetFdInfoKHR::default()
.fence(self.fence) .fence(self.fence)
.handle_type(ExternalFenceHandleTypeFlags::SYNC_FD); .handle_type(ExternalFenceHandleTypeFlags::SYNC_FD);
let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) }; let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) };

72
src/gfx_apis/vulkan/format.rs
View file

@ -10,7 +10,7 @@ use {
vk::{ vk::{
DrmFormatModifierPropertiesEXT, DrmFormatModifierPropertiesListEXT, DrmFormatModifierPropertiesEXT, DrmFormatModifierPropertiesListEXT,
ExternalImageFormatProperties, ExternalMemoryFeatureFlags, ExternalImageFormatProperties, ExternalMemoryFeatureFlags,
ExternalMemoryHandleTypeFlags, FormatFeatureFlags, FormatProperties2, ExternalMemoryHandleTypeFlags, FormatFeatureFlags, FormatProperties, FormatProperties2,
ImageFormatProperties2, ImageTiling, ImageType, ImageUsageFlags, PhysicalDevice, ImageFormatProperties2, ImageTiling, ImageType, ImageUsageFlags, PhysicalDevice,
PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageDrmFormatModifierInfoEXT,
PhysicalDeviceImageFormatInfo2, SharingMode, PhysicalDeviceImageFormatInfo2, SharingMode,
@ -95,10 +95,8 @@ impl VulkanInstance {
format: &'static Format, format: &'static Format,
dst: &mut AHashMap<u32, VulkanFormat>, dst: &mut AHashMap<u32, VulkanFormat>,
) -> Result<(), VulkanError> { ) -> Result<(), VulkanError> {
let mut modifier_props = DrmFormatModifierPropertiesListEXT::builder().build(); let mut modifier_props = DrmFormatModifierPropertiesListEXT::default();
let mut format_properties = FormatProperties2::builder() let mut format_properties = FormatProperties2::default().push_next(&mut modifier_props);
.push_next(&mut modifier_props)
.build();
unsafe { unsafe {
self.instance.get_physical_device_format_properties2( self.instance.get_physical_device_format_properties2(
phy_dev, phy_dev,
@ -106,9 +104,13 @@ impl VulkanInstance {
&mut format_properties, &mut format_properties,
); );
} }
let shm = self.load_shm_format(phy_dev, format, &format_properties)?; let shm = self.load_shm_format(phy_dev, format, &format_properties.format_properties)?;
let modifiers = let modifiers = self.load_drm_format(
self.load_drm_format(phy_dev, format, &format_properties, &modifier_props)?; phy_dev,
format,
&format_properties.format_properties,
&modifier_props,
)?;
if shm.is_some() || modifiers.is_not_empty() { if shm.is_some() || modifiers.is_not_empty() {
dst.insert( dst.insert(
format.drm, format.drm,
@ -126,7 +128,7 @@ impl VulkanInstance {
&self, &self,
phy_dev: PhysicalDevice, phy_dev: PhysicalDevice,
format: &Format, format: &Format,
props: &FormatProperties2, props: &FormatProperties,
) -> Result<Option<VulkanInternalFormat>, VulkanError> { ) -> Result<Option<VulkanInternalFormat>, VulkanError> {
if format.shm_info.is_none() { if format.shm_info.is_none() {
return Ok(None); return Ok(None);
@ -138,23 +140,19 @@ impl VulkanInstance {
&self, &self,
phy_dev: PhysicalDevice, phy_dev: PhysicalDevice,
format: &Format, format: &Format,
props: &FormatProperties2, props: &FormatProperties,
features: FormatFeatureFlags, features: FormatFeatureFlags,
usage: ImageUsageFlags, usage: ImageUsageFlags,
) -> Result<Option<VulkanInternalFormat>, VulkanError> { ) -> Result<Option<VulkanInternalFormat>, VulkanError> {
if !props if !props.optimal_tiling_features.contains(features) {
.format_properties
.optimal_tiling_features
.contains(features)
{
return Ok(None); return Ok(None);
} }
let format_info = PhysicalDeviceImageFormatInfo2::builder() let format_info = PhysicalDeviceImageFormatInfo2::default()
.ty(ImageType::TYPE_2D) .ty(ImageType::TYPE_2D)
.format(format.vk_format) .format(format.vk_format)
.tiling(ImageTiling::OPTIMAL) .tiling(ImageTiling::OPTIMAL)
.usage(usage); .usage(usage);
let mut format_properties = ImageFormatProperties2::builder(); let mut format_properties = ImageFormatProperties2::default();
let res = unsafe { let res = unsafe {
self.instance.get_physical_device_image_format_properties2( self.instance.get_physical_device_image_format_properties2(
phy_dev, phy_dev,
@ -180,7 +178,7 @@ impl VulkanInstance {
&self, &self,
phy_dev: PhysicalDevice, phy_dev: PhysicalDevice,
format: &Format, format: &Format,
internal_format_properties: &FormatProperties2, internal_format_properties: &FormatProperties,
props: &DrmFormatModifierPropertiesListEXT, props: &DrmFormatModifierPropertiesListEXT,
) -> Result<AHashMap<Modifier, VulkanModifier>, VulkanError> { ) -> Result<AHashMap<Modifier, VulkanModifier>, VulkanError> {
if props.drm_format_modifier_count == 0 { if props.drm_format_modifier_count == 0 {
@ -190,12 +188,9 @@ impl VulkanInstance {
DrmFormatModifierPropertiesEXT::default(); DrmFormatModifierPropertiesEXT::default();
props.drm_format_modifier_count as usize props.drm_format_modifier_count as usize
]; ];
let mut modifier_props = DrmFormatModifierPropertiesListEXT::builder() let mut modifier_props = DrmFormatModifierPropertiesListEXT::default()
.drm_format_modifier_properties(&mut drm_mods) .drm_format_modifier_properties(&mut drm_mods);
.build(); let mut format_properties = FormatProperties2::default().push_next(&mut modifier_props);
let mut format_properties = FormatProperties2::builder()
.push_next(&mut modifier_props)
.build();
unsafe { unsafe {
self.instance.get_physical_device_format_properties2( self.instance.get_physical_device_format_properties2(
phy_dev, phy_dev,
@ -245,7 +240,7 @@ impl VulkanInstance {
&self, &self,
phy_dev: PhysicalDevice, phy_dev: PhysicalDevice,
format: &Format, format: &Format,
internal_format_properties: &FormatProperties2, internal_format_properties: &FormatProperties,
modifier: &DrmFormatModifierPropertiesEXT, modifier: &DrmFormatModifierPropertiesEXT,
) -> Result<Option<VulkanMaxExtents>, VulkanError> { ) -> Result<Option<VulkanMaxExtents>, VulkanError> {
let transfer_dst_max_extents = self.get_max_extents( let transfer_dst_max_extents = self.get_max_extents(
@ -291,26 +286,22 @@ impl VulkanInstance {
if !props.drm_format_modifier_tiling_features.contains(features) { if !props.drm_format_modifier_tiling_features.contains(features) {
return Ok(None); return Ok(None);
} }
let mut modifier_info = PhysicalDeviceImageDrmFormatModifierInfoEXT::builder() let mut modifier_info = PhysicalDeviceImageDrmFormatModifierInfoEXT::default()
.drm_format_modifier(props.drm_format_modifier) .drm_format_modifier(props.drm_format_modifier)
.sharing_mode(SharingMode::EXCLUSIVE) .sharing_mode(SharingMode::EXCLUSIVE);
.build(); let mut external_image_format_info = PhysicalDeviceExternalImageFormatInfo::default()
let mut external_image_format_info = PhysicalDeviceExternalImageFormatInfo::builder() .handle_type(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
.handle_type(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT) let image_format_info = PhysicalDeviceImageFormatInfo2::default()
.build();
let image_format_info = PhysicalDeviceImageFormatInfo2::builder()
.ty(ImageType::TYPE_2D) .ty(ImageType::TYPE_2D)
.format(format.vk_format) .format(format.vk_format)
.usage(usage) .usage(usage)
.tiling(ImageTiling::DRM_FORMAT_MODIFIER_EXT) .tiling(ImageTiling::DRM_FORMAT_MODIFIER_EXT)
.push_next(&mut external_image_format_info) .push_next(&mut external_image_format_info)
.push_next(&mut modifier_info) .push_next(&mut modifier_info);
.build();
let mut external_image_format_props = ExternalImageFormatProperties::builder().build(); let mut external_image_format_props = ExternalImageFormatProperties::default();
let mut image_format_props = ImageFormatProperties2::builder() let mut image_format_props =
.push_next(&mut external_image_format_props) ImageFormatProperties2::default().push_next(&mut external_image_format_props);
.build();
let res = unsafe { let res = unsafe {
self.instance.get_physical_device_image_format_properties2( self.instance.get_physical_device_image_format_properties2(
@ -326,6 +317,7 @@ impl VulkanInstance {
_ => Err(VulkanError::LoadImageProperties(e)), _ => Err(VulkanError::LoadImageProperties(e)),
}; };
} }
let image_format_props = &image_format_props.image_format_properties;
let importable = external_image_format_props let importable = external_image_format_props
.external_memory_properties .external_memory_properties
.external_memory_features .external_memory_features
@ -335,8 +327,8 @@ impl VulkanInstance {
} }
Ok(Some(VulkanMaxExtents { Ok(Some(VulkanMaxExtents {
width: image_format_props.image_format_properties.max_extent.width, width: image_format_props.max_extent.width,
height: image_format_props.image_format_properties.max_extent.height, height: image_format_props.max_extent.height,
})) }))
} }
} }

77
src/gfx_apis/vulkan/image.rs
View file

@ -17,8 +17,8 @@ use {
ImageDrmFormatModifierExplicitCreateInfoEXT, ImageLayout, ImageMemoryRequirementsInfo2, ImageDrmFormatModifierExplicitCreateInfoEXT, ImageLayout, ImageMemoryRequirementsInfo2,
ImagePlaneMemoryRequirementsInfo, ImageSubresourceRange, ImageTiling, ImageType, ImagePlaneMemoryRequirementsInfo, ImageSubresourceRange, ImageTiling, ImageType,
ImageUsageFlags, ImageView, ImageViewCreateInfo, ImageViewType, ImportMemoryFdInfoKHR, ImageUsageFlags, ImageView, ImageViewCreateInfo, ImageViewType, ImportMemoryFdInfoKHR,
MemoryAllocateInfo, MemoryDedicatedAllocateInfo, MemoryPropertyFlags, MemoryRequirements2, MemoryAllocateInfo, MemoryDedicatedAllocateInfo, MemoryFdPropertiesKHR,
SampleCountFlags, SharingMode, SubresourceLayout, MemoryPropertyFlags, MemoryRequirements2, SampleCountFlags, SharingMode, SubresourceLayout,
}, },
gpu_alloc::UsageFlags, gpu_alloc::UsageFlags,
std::{ std::{
@ -165,7 +165,7 @@ impl VulkanDevice {
format: &'static Format, format: &'static Format,
for_rendering: bool, for_rendering: bool,
) -> Result<ImageView, VulkanError> { ) -> Result<ImageView, VulkanError> {
let create_info = ImageViewCreateInfo::builder() let create_info = ImageViewCreateInfo::default()
.image(image) .image(image)
.view_type(ImageViewType::TYPE_2D) .view_type(ImageViewType::TYPE_2D)
.format(format.vk_format) .format(format.vk_format)
@ -222,13 +222,11 @@ impl VulkanDmaBufImageTemplate {
depth_pitch: 0, depth_pitch: 0,
}) })
.collect(); .collect();
let mut mod_info = ImageDrmFormatModifierExplicitCreateInfoEXT::builder() let mut mod_info = ImageDrmFormatModifierExplicitCreateInfoEXT::default()
.drm_format_modifier(self.dmabuf.modifier) .drm_format_modifier(self.dmabuf.modifier)
.plane_layouts(&plane_layouts) .plane_layouts(&plane_layouts);
.build(); let mut memory_image_create_info = ExternalMemoryImageCreateInfo::default()
let mut memory_image_create_info = ExternalMemoryImageCreateInfo::builder() .handle_types(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
.handle_types(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT)
.build();
let flags = match self.disjoint { let flags = match self.disjoint {
true => ImageCreateFlags::DISJOINT, true => ImageCreateFlags::DISJOINT,
false => ImageCreateFlags::empty(), false => ImageCreateFlags::empty(),
@ -240,7 +238,7 @@ impl VulkanDmaBufImageTemplate {
}, },
false => ImageUsageFlags::TRANSFER_SRC | ImageUsageFlags::SAMPLED, false => ImageUsageFlags::TRANSFER_SRC | ImageUsageFlags::SAMPLED,
}; };
let create_info = ImageCreateInfo::builder() let create_info = ImageCreateInfo::default()
.image_type(ImageType::TYPE_2D) .image_type(ImageType::TYPE_2D)
.format(self.dmabuf.format.vk_format) .format(self.dmabuf.format.vk_format)
.mip_levels(1) .mip_levels(1)
@ -257,8 +255,7 @@ impl VulkanDmaBufImageTemplate {
.usage(usage) .usage(usage)
.flags(flags) .flags(flags)
.push_next(&mut memory_image_create_info) .push_next(&mut memory_image_create_info)
.push_next(&mut mod_info) .push_next(&mut mod_info);
.build();
let image = unsafe { device.device.create_image(&create_info, None) }; let image = unsafe { device.device.create_image(&create_info, None) };
image.map_err(VulkanError::CreateImage)? image.map_err(VulkanError::CreateImage)?
}; };
@ -272,16 +269,19 @@ impl VulkanDmaBufImageTemplate {
let mut bind_image_plane_memory_infos = PlaneVec::new(); let mut bind_image_plane_memory_infos = PlaneVec::new();
for plane_idx in 0..num_device_memories { for plane_idx in 0..num_device_memories {
let dma_buf_plane = &self.dmabuf.planes[plane_idx]; let dma_buf_plane = &self.dmabuf.planes[plane_idx];
let memory_fd_properties = unsafe { let mut memory_fd_properties = MemoryFdPropertiesKHR::default();
device.external_memory_fd.get_memory_fd_properties( unsafe {
ExternalMemoryHandleTypeFlags::DMA_BUF_EXT, device
dma_buf_plane.fd.raw(), .external_memory_fd
) .get_memory_fd_properties(
}; ExternalMemoryHandleTypeFlags::DMA_BUF_EXT,
let memory_fd_properties = dma_buf_plane.fd.raw(),
memory_fd_properties.map_err(VulkanError::MemoryFdProperties)?; &mut memory_fd_properties,
)
.map_err(VulkanError::MemoryFdProperties)?;
}
let mut image_memory_requirements_info = let mut image_memory_requirements_info =
ImageMemoryRequirementsInfo2::builder().image(image); ImageMemoryRequirementsInfo2::default().image(image);
let mut image_plane_memory_requirements_info; let mut image_plane_memory_requirements_info;
if self.disjoint { if self.disjoint {
let plane_aspect = match plane_idx { let plane_aspect = match plane_idx {
@ -292,14 +292,11 @@ impl VulkanDmaBufImageTemplate {
_ => unreachable!(), _ => unreachable!(),
}; };
image_plane_memory_requirements_info = image_plane_memory_requirements_info =
ImagePlaneMemoryRequirementsInfo::builder().plane_aspect(plane_aspect); ImagePlaneMemoryRequirementsInfo::default().plane_aspect(plane_aspect);
image_memory_requirements_info = image_memory_requirements_info image_memory_requirements_info = image_memory_requirements_info
.push_next(&mut image_plane_memory_requirements_info); .push_next(&mut image_plane_memory_requirements_info);
bind_image_plane_memory_infos.push( bind_image_plane_memory_infos
BindImagePlaneMemoryInfo::builder() .push(BindImagePlaneMemoryInfo::default().plane_aspect(plane_aspect));
.plane_aspect(plane_aspect)
.build(),
);
} }
let mut memory_requirements = MemoryRequirements2::default(); let mut memory_requirements = MemoryRequirements2::default();
unsafe { unsafe {
@ -318,17 +315,15 @@ impl VulkanDmaBufImageTemplate {
let fd = uapi::fcntl_dupfd_cloexec(dma_buf_plane.fd.raw(), 0) let fd = uapi::fcntl_dupfd_cloexec(dma_buf_plane.fd.raw(), 0)
.map_err(|e| VulkanError::Dupfd(e.into()))?; .map_err(|e| VulkanError::Dupfd(e.into()))?;
let mut memory_dedicated_allocate_info = let mut memory_dedicated_allocate_info =
MemoryDedicatedAllocateInfo::builder().image(image).build(); MemoryDedicatedAllocateInfo::default().image(image);
let mut import_memory_fd_info = ImportMemoryFdInfoKHR::builder() let mut import_memory_fd_info = ImportMemoryFdInfoKHR::default()
.fd(fd.raw()) .fd(fd.raw())
.handle_type(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT) .handle_type(ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
.build(); let memory_allocate_info = MemoryAllocateInfo::default()
let memory_allocate_info = MemoryAllocateInfo::builder()
.allocation_size(memory_requirements.memory_requirements.size) .allocation_size(memory_requirements.memory_requirements.size)
.memory_type_index(memory_type_index) .memory_type_index(memory_type_index)
.push_next(&mut import_memory_fd_info) .push_next(&mut import_memory_fd_info)
.push_next(&mut memory_dedicated_allocate_info) .push_next(&mut memory_dedicated_allocate_info);
.build();
let device_memory = let device_memory =
unsafe { device.device.allocate_memory(&memory_allocate_info, None) }; unsafe { device.device.allocate_memory(&memory_allocate_info, None) };
let device_memory = device_memory.map_err(VulkanError::AllocateMemory)?; let device_memory = device_memory.map_err(VulkanError::AllocateMemory)?;
@ -339,12 +334,13 @@ impl VulkanDmaBufImageTemplate {
})); }));
} }
let mut bind_image_memory_infos = Vec::with_capacity(num_device_memories); let mut bind_image_memory_infos = Vec::with_capacity(num_device_memories);
for (i, mem) in device_memories.iter().copied().enumerate() { let mut bind_image_plane_memory_infos = bind_image_plane_memory_infos.iter_mut();
let mut info = BindImageMemoryInfo::builder().image(image).memory(mem); for mem in device_memories.iter().copied() {
let mut info = BindImageMemoryInfo::default().image(image).memory(mem);
if self.disjoint { if self.disjoint {
info = info.push_next(&mut bind_image_plane_memory_infos[i]); info = info.push_next(bind_image_plane_memory_infos.next().unwrap());
} }
bind_image_memory_infos.push(info.build()); bind_image_memory_infos.push(info);
} }
let res = unsafe { device.device.bind_image_memory2(&bind_image_memory_infos) }; let res = unsafe { device.device.bind_image_memory2(&bind_image_memory_infos) };
res.map_err(VulkanError::BindImageMemory)?; res.map_err(VulkanError::BindImageMemory)?;
@ -387,7 +383,7 @@ impl VulkanDmaBufImageTemplate {
} }
fn create_bridge(&self) -> Result<(Image, VulkanAllocation), VulkanError> { fn create_bridge(&self) -> Result<(Image, VulkanAllocation), VulkanError> {
let create_info = ImageCreateInfo::builder() let create_info = ImageCreateInfo::default()
.image_type(ImageType::TYPE_2D) .image_type(ImageType::TYPE_2D)
.format(self.dmabuf.format.vk_format) .format(self.dmabuf.format.vk_format)
.mip_levels(1) .mip_levels(1)
@ -401,8 +397,7 @@ impl VulkanDmaBufImageTemplate {
height: self.height, height: self.height,
depth: 1, depth: 1,
}) })
.usage(ImageUsageFlags::COLOR_ATTACHMENT | ImageUsageFlags::TRANSFER_SRC) .usage(ImageUsageFlags::COLOR_ATTACHMENT | ImageUsageFlags::TRANSFER_SRC);
.build();
let image = unsafe { self.renderer.device.device.create_image(&create_info, None) }; let image = unsafe { self.renderer.device.device.create_image(&create_info, None) };
let image = image.map_err(VulkanError::CreateImage)?; let image = image.map_err(VulkanError::CreateImage)?;
let destroy_image = let destroy_image =

47
src/gfx_apis/vulkan/instance.rs
View file

@ -6,14 +6,13 @@ use {
}, },
ahash::{AHashMap, AHashSet}, ahash::{AHashMap, AHashSet},
ash::{ ash::{
extensions::ext::DebugUtils, ext::{debug_utils, validation_features},
vk::{ vk::{
api_version_major, api_version_minor, api_version_patch, api_version_variant, api_version_major, api_version_minor, api_version_patch, api_version_variant,
ApplicationInfo, Bool32, DebugUtilsMessageSeverityFlagsEXT, ApplicationInfo, Bool32, DebugUtilsMessageSeverityFlagsEXT,
DebugUtilsMessageTypeFlagsEXT, DebugUtilsMessengerCallbackDataEXT, DebugUtilsMessageTypeFlagsEXT, DebugUtilsMessengerCallbackDataEXT,
DebugUtilsMessengerCreateInfoEXT, DebugUtilsMessengerEXT, ExtDebugUtilsFn, DebugUtilsMessengerCreateInfoEXT, DebugUtilsMessengerEXT, ExtensionProperties,
ExtValidationFeaturesFn, ExtensionProperties, InstanceCreateInfo, LayerProperties, InstanceCreateInfo, LayerProperties, ValidationFeaturesEXT, API_VERSION_1_3, FALSE,
ValidationFeaturesEXT, API_VERSION_1_3, FALSE,
}, },
Entry, Instance, LoadingError, Entry, Instance, LoadingError,
}, },
@ -34,7 +33,7 @@ use {
pub struct VulkanInstance { pub struct VulkanInstance {
pub(super) _entry: &'static Entry, pub(super) _entry: &'static Entry,
pub(super) instance: Instance, pub(super) instance: Instance,
pub(super) debug_utils: DebugUtils, pub(super) debug_utils: debug_utils::Instance,
pub(super) messenger: DebugUtilsMessengerEXT, pub(super) messenger: DebugUtilsMessengerEXT,
pub(super) eng: Rc<AsyncEngine>, pub(super) eng: Rc<AsyncEngine>,
pub(super) ring: Rc<IoUring>, pub(super) ring: Rc<IoUring>,
@ -62,7 +61,7 @@ impl VulkanInstance {
.iter() .iter()
.map(|c| c.as_ptr()) .map(|c| c.as_ptr())
.collect(); .collect();
let app_info = ApplicationInfo::builder() let app_info = ApplicationInfo::default()
.api_version(API_VERSION) .api_version(API_VERSION)
.application_name(ustr!("jay").as_c_str().unwrap()) .application_name(ustr!("jay").as_c_str().unwrap())
.application_version(1); .application_version(1);
@ -77,7 +76,7 @@ impl VulkanInstance {
| DebugUtilsMessageTypeFlagsEXT::VALIDATION | DebugUtilsMessageTypeFlagsEXT::VALIDATION
| DebugUtilsMessageTypeFlagsEXT::PERFORMANCE | DebugUtilsMessageTypeFlagsEXT::PERFORMANCE
| DebugUtilsMessageTypeFlagsEXT::GENERAL; | DebugUtilsMessageTypeFlagsEXT::GENERAL;
let mut debug_info = DebugUtilsMessengerCreateInfoEXT::builder() let mut debug_info = DebugUtilsMessengerCreateInfoEXT::default()
.message_severity(severity) .message_severity(severity)
.message_type(types) .message_type(types)
.pfn_user_callback(Some(debug_callback)); .pfn_user_callback(Some(debug_callback));
@ -88,8 +87,8 @@ impl VulkanInstance {
// ash::vk::ValidationFeatureEnableEXT::GPU_ASSISTED, // ash::vk::ValidationFeatureEnableEXT::GPU_ASSISTED,
]; ];
let mut validation_info = let mut validation_info =
ValidationFeaturesEXT::builder().enabled_validation_features(&validation_features); ValidationFeaturesEXT::default().enabled_validation_features(&validation_features);
let mut create_info = InstanceCreateInfo::builder() let mut create_info = InstanceCreateInfo::default()
.application_info(&app_info) .application_info(&app_info)
.push_next(&mut debug_info); .push_next(&mut debug_info);
let validation_layer_name = VALIDATION_LAYER.as_ptr(); let validation_layer_name = VALIDATION_LAYER.as_ptr();
@ -98,11 +97,11 @@ impl VulkanInstance {
create_info = create_info =
create_info.enabled_layer_names(slice::from_ref(&validation_layer_name)); create_info.enabled_layer_names(slice::from_ref(&validation_layer_name));
let extensions = get_instance_extensions(entry, Some(VALIDATION_LAYER))?; let extensions = get_instance_extensions(entry, Some(VALIDATION_LAYER))?;
if extensions.contains_key(ExtValidationFeaturesFn::name()) { if extensions.contains_key(validation_features::NAME) {
enabled_extensions.push(ExtValidationFeaturesFn::name().as_ptr()); enabled_extensions.push(validation_features::NAME.as_ptr());
create_info = create_info.push_next(&mut validation_info); create_info = create_info.push_next(&mut validation_info);
} else { } else {
log::warn!("{:?} is not available", ExtValidationFeaturesFn::name(),); log::warn!("{:?} is not available", validation_features::NAME);
} }
} else { } else {
log::warn!( log::warn!(
@ -116,7 +115,7 @@ impl VulkanInstance {
Err(e) => return Err(VulkanError::CreateInstance(e)), Err(e) => return Err(VulkanError::CreateInstance(e)),
}; };
let destroy_instance = OnDrop(|| unsafe { instance.destroy_instance(None) }); let destroy_instance = OnDrop(|| unsafe { instance.destroy_instance(None) });
let debug_utils = DebugUtils::new(entry, &instance); let debug_utils = debug_utils::Instance::new(entry, &instance);
let messenger = unsafe { debug_utils.create_debug_utils_messenger(&debug_info, None) }; let messenger = unsafe { debug_utils.create_debug_utils_messenger(&debug_info, None) };
let messenger = match messenger { let messenger = match messenger {
Ok(m) => m, Ok(m) => m,
@ -144,24 +143,28 @@ impl Drop for VulkanInstance {
} }
} }
const REQUIRED_INSTANCE_EXTENSIONS: &[&CStr] = &[ExtDebugUtilsFn::name()]; const REQUIRED_INSTANCE_EXTENSIONS: &[&CStr] = &[debug_utils::NAME];
const VALIDATION_LAYER: &CStr = c"VK_LAYER_KHRONOS_validation"; const VALIDATION_LAYER: &CStr = c"VK_LAYER_KHRONOS_validation";
pub type Extensions = AHashMap<CString, u32>; pub type Extensions = AHashMap<CString, u32>;
fn get_instance_extensions(entry: &Entry, layer: Option<&CStr>) -> Result<Extensions, VulkanError> { fn get_instance_extensions(entry: &Entry, layer: Option<&CStr>) -> Result<Extensions, VulkanError> {
entry unsafe {
.enumerate_instance_extension_properties(layer) entry
.map_err(VulkanError::InstanceExtensions) .enumerate_instance_extension_properties(layer)
.map(map_extension_properties) .map_err(VulkanError::InstanceExtensions)
.map(map_extension_properties)
}
} }
fn get_available_layers(entry: &Entry) -> Result<AHashSet<CString>, VulkanError> { fn get_available_layers(entry: &Entry) -> Result<AHashSet<CString>, VulkanError> {
entry unsafe {
.enumerate_instance_layer_properties() entry
.map_err(VulkanError::InstanceLayers) .enumerate_instance_layer_properties()
.map(map_layer_properties) .map_err(VulkanError::InstanceLayers)
.map(map_layer_properties)
}
} }
fn map_layer_properties(props: Vec<LayerProperties>) -> AHashSet<CString> { fn map_layer_properties(props: Vec<LayerProperties>) -> AHashSet<CString> {

42
src/gfx_apis/vulkan/pipeline.rs
View file

@ -56,21 +56,19 @@ impl VulkanDevice {
let mut push_constant_offset = 0; let mut push_constant_offset = 0;
if vert_push_size > 0 { if vert_push_size > 0 {
push_constant_ranges.push( push_constant_ranges.push(
PushConstantRange::builder() PushConstantRange::default()
.stage_flags(ShaderStageFlags::VERTEX) .stage_flags(ShaderStageFlags::VERTEX)
.offset(0) .offset(0)
.size(vert_push_size) .size(vert_push_size),
.build(),
); );
push_constant_offset += vert_push_size; push_constant_offset += vert_push_size;
} }
if frag_push_size > 0 { if frag_push_size > 0 {
push_constant_ranges.push( push_constant_ranges.push(
PushConstantRange::builder() PushConstantRange::default()
.stage_flags(ShaderStageFlags::FRAGMENT) .stage_flags(ShaderStageFlags::FRAGMENT)
.offset(push_constant_offset) .offset(push_constant_offset)
.size(frag_push_size) .size(frag_push_size),
.build(),
); );
#[allow(unused_assignments)] #[allow(unused_assignments)]
{ {
@ -80,7 +78,7 @@ impl VulkanDevice {
let mut descriptor_set_layouts = ArrayVec::<_, 1>::new(); let mut descriptor_set_layouts = ArrayVec::<_, 1>::new();
descriptor_set_layouts descriptor_set_layouts
.extend(info.frag_descriptor_set_layout.as_ref().map(|l| l.layout)); .extend(info.frag_descriptor_set_layout.as_ref().map(|l| l.layout));
let create_info = PipelineLayoutCreateInfo::builder() let create_info = PipelineLayoutCreateInfo::default()
.push_constant_ranges(&push_constant_ranges) .push_constant_ranges(&push_constant_ranges)
.set_layouts(&descriptor_set_layouts); .set_layouts(&descriptor_set_layouts);
let layout = unsafe { self.device.create_pipeline_layout(&create_info, None) }; let layout = unsafe { self.device.create_pipeline_layout(&create_info, None) };
@ -91,29 +89,27 @@ impl VulkanDevice {
let pipeline = { let pipeline = {
let main = ustr!("main").as_c_str().unwrap(); let main = ustr!("main").as_c_str().unwrap();
let stages = [ let stages = [
PipelineShaderStageCreateInfo::builder() PipelineShaderStageCreateInfo::default()
.stage(ShaderStageFlags::VERTEX) .stage(ShaderStageFlags::VERTEX)
.module(info.vert.module) .module(info.vert.module)
.name(main) .name(main),
.build(), PipelineShaderStageCreateInfo::default()
PipelineShaderStageCreateInfo::builder()
.stage(ShaderStageFlags::FRAGMENT) .stage(ShaderStageFlags::FRAGMENT)
.module(info.frag.module) .module(info.frag.module)
.name(main) .name(main),
.build(),
]; ];
let input_assembly_state = PipelineInputAssemblyStateCreateInfo::builder() let input_assembly_state = PipelineInputAssemblyStateCreateInfo::default()
.topology(PrimitiveTopology::TRIANGLE_STRIP); .topology(PrimitiveTopology::TRIANGLE_STRIP);
let vertex_input_state = PipelineVertexInputStateCreateInfo::builder(); let vertex_input_state = PipelineVertexInputStateCreateInfo::default();
let rasterization_state = PipelineRasterizationStateCreateInfo::builder() let rasterization_state = PipelineRasterizationStateCreateInfo::default()
.polygon_mode(PolygonMode::FILL) .polygon_mode(PolygonMode::FILL)
.cull_mode(CullModeFlags::NONE) .cull_mode(CullModeFlags::NONE)
.line_width(1.0) .line_width(1.0)
.front_face(FrontFace::COUNTER_CLOCKWISE); .front_face(FrontFace::COUNTER_CLOCKWISE);
let multisampling_state = PipelineMultisampleStateCreateInfo::builder() let multisampling_state = PipelineMultisampleStateCreateInfo::default()
.sample_shading_enable(false) .sample_shading_enable(false)
.rasterization_samples(SampleCountFlags::TYPE_1); .rasterization_samples(SampleCountFlags::TYPE_1);
let mut blending = PipelineColorBlendAttachmentState::builder() let mut blending = PipelineColorBlendAttachmentState::default()
.color_write_mask(ColorComponentFlags::RGBA); .color_write_mask(ColorComponentFlags::RGBA);
if info.alpha { if info.alpha {
blending = blending blending = blending
@ -125,17 +121,17 @@ impl VulkanDevice {
.dst_alpha_blend_factor(BlendFactor::ONE_MINUS_SRC_ALPHA) .dst_alpha_blend_factor(BlendFactor::ONE_MINUS_SRC_ALPHA)
.alpha_blend_op(BlendOp::ADD); .alpha_blend_op(BlendOp::ADD);
} }
let color_blend_state = PipelineColorBlendStateCreateInfo::builder() let color_blend_state = PipelineColorBlendStateCreateInfo::default()
.attachments(slice::from_ref(&blending)); .attachments(slice::from_ref(&blending));
let dynamic_states = [DynamicState::VIEWPORT, DynamicState::SCISSOR]; let dynamic_states = [DynamicState::VIEWPORT, DynamicState::SCISSOR];
let dynamic_state = let dynamic_state =
PipelineDynamicStateCreateInfo::builder().dynamic_states(&dynamic_states); PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_states);
let viewport_state = PipelineViewportStateCreateInfo::builder() let viewport_state = PipelineViewportStateCreateInfo::default()
.viewport_count(1) .viewport_count(1)
.scissor_count(1); .scissor_count(1);
let mut pipeline_rendering_create_info = PipelineRenderingCreateInfo::builder() let mut pipeline_rendering_create_info = PipelineRenderingCreateInfo::default()
.color_attachment_formats(slice::from_ref(&ARGB8888.vk_format)); .color_attachment_formats(slice::from_ref(&ARGB8888.vk_format));
let create_info = GraphicsPipelineCreateInfo::builder() let create_info = GraphicsPipelineCreateInfo::default()
.push_next(&mut pipeline_rendering_create_info) .push_next(&mut pipeline_rendering_create_info)
.stages(&stages) .stages(&stages)
.input_assembly_state(&input_assembly_state) .input_assembly_state(&input_assembly_state)

107
src/gfx_apis/vulkan/renderer.rs
View file

@ -34,10 +34,10 @@ use {
CommandBufferBeginInfo, CommandBufferSubmitInfo, CommandBufferUsageFlags, CommandBufferBeginInfo, CommandBufferSubmitInfo, CommandBufferUsageFlags,
CopyImageInfo2, DependencyInfo, DependencyInfoKHR, DescriptorImageInfo, DescriptorType, CopyImageInfo2, DependencyInfo, DependencyInfoKHR, DescriptorImageInfo, DescriptorType,
Extent2D, Extent3D, Fence, ImageAspectFlags, ImageCopy2, ImageLayout, Extent2D, Extent3D, Fence, ImageAspectFlags, ImageCopy2, ImageLayout,
ImageMemoryBarrier2, ImageMemoryBarrier2Builder, ImageSubresourceLayers, ImageMemoryBarrier2, ImageSubresourceLayers, ImageSubresourceRange, PipelineBindPoint,
ImageSubresourceRange, PipelineBindPoint, PipelineStageFlags2, Rect2D, PipelineStageFlags2, Rect2D, RenderingAttachmentInfo, RenderingInfo,
RenderingAttachmentInfo, RenderingInfo, SemaphoreSubmitInfo, SemaphoreSubmitInfoKHR, SemaphoreSubmitInfo, SemaphoreSubmitInfoKHR, ShaderStageFlags, SubmitInfo2, Viewport,
ShaderStageFlags, SubmitInfo2, Viewport, WriteDescriptorSet, QUEUE_FAMILY_FOREIGN_EXT, WriteDescriptorSet, QUEUE_FAMILY_FOREIGN_EXT,
}, },
Device, Device,
}, },
@ -93,9 +93,9 @@ pub(super) enum TexSourceType {
pub(super) struct Memory { pub(super) struct Memory {
sample: Vec<Rc<VulkanImage>>, sample: Vec<Rc<VulkanImage>>,
textures: Vec<UsedTexture>, textures: Vec<UsedTexture>,
image_barriers: Vec<ImageMemoryBarrier2>, image_barriers: Vec<ImageMemoryBarrier2<'static>>,
wait_semaphores: Vec<Rc<VulkanSemaphore>>, wait_semaphores: Vec<Rc<VulkanSemaphore>>,
wait_semaphore_infos: Vec<SemaphoreSubmitInfo>, wait_semaphore_infos: Vec<SemaphoreSubmitInfo<'static>>,
release_fence: Option<Rc<VulkanFence>>, release_fence: Option<Rc<VulkanFence>>,
release_sync_file: Option<SyncFile>, release_sync_file: Option<SyncFile>,
} }
@ -226,7 +226,7 @@ impl VulkanRenderer {
fn begin_command_buffer(&self, buf: CommandBuffer) -> Result<(), VulkanError> { fn begin_command_buffer(&self, buf: CommandBuffer) -> Result<(), VulkanError> {
let begin_info = let begin_info =
CommandBufferBeginInfo::builder().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT); CommandBufferBeginInfo::default().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT);
unsafe { unsafe {
self.device self.device
.device .device
@ -265,7 +265,6 @@ impl VulkanRenderer {
ImageLayout::GENERAL ImageLayout::GENERAL
}); });
} }
let fb_image_memory_barrier = fb_image_memory_barrier.build();
memory.image_barriers.push(fb_image_memory_barrier); memory.image_barriers.push(fb_image_memory_barrier);
for img in &memory.sample { for img in &memory.sample {
let image_memory_barrier = image_barrier() let image_memory_barrier = image_barrier()
@ -275,11 +274,10 @@ impl VulkanRenderer {
.old_layout(ImageLayout::GENERAL) .old_layout(ImageLayout::GENERAL)
.new_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL) .new_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL)
.dst_access_mask(AccessFlags2::SHADER_SAMPLED_READ) .dst_access_mask(AccessFlags2::SHADER_SAMPLED_READ)
.dst_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER) .dst_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER);
.build();
memory.image_barriers.push(image_memory_barrier); memory.image_barriers.push(image_memory_barrier);
} }
let dep_info = DependencyInfoKHR::builder().image_memory_barriers(&memory.image_barriers); let dep_info = DependencyInfoKHR::default().image_memory_barriers(&memory.image_barriers);
unsafe { unsafe {
self.device.device.cmd_pipeline_barrier2(buf, &dep_info); self.device.device.cmd_pipeline_barrier2(buf, &dep_info);
} }
@ -287,7 +285,7 @@ impl VulkanRenderer {
fn begin_rendering(&self, buf: CommandBuffer, fb: &VulkanImage, clear: Option<&Color>) { fn begin_rendering(&self, buf: CommandBuffer, fb: &VulkanImage, clear: Option<&Color>) {
let rendering_attachment_info = { let rendering_attachment_info = {
let mut rai = RenderingAttachmentInfo::builder() let mut rai = RenderingAttachmentInfo::default()
.image_view(fb.render_view.unwrap_or(fb.texture_view)) .image_view(fb.render_view.unwrap_or(fb.texture_view))
.image_layout(ImageLayout::GENERAL) .image_layout(ImageLayout::GENERAL)
.load_op(AttachmentLoadOp::LOAD) .load_op(AttachmentLoadOp::LOAD)
@ -303,7 +301,7 @@ impl VulkanRenderer {
} }
rai rai
}; };
let rendering_info = RenderingInfo::builder() let rendering_info = RenderingInfo::default()
.render_area(Rect2D { .render_area(Rect2D {
offset: Default::default(), offset: Default::default(),
extent: Extent2D { extent: Extent2D {
@ -400,13 +398,12 @@ impl VulkanRenderer {
pos: c.target.to_points(), pos: c.target.to_points(),
tex_pos: c.source.to_points(), tex_pos: c.source.to_points(),
}; };
let image_info = DescriptorImageInfo::builder() let image_info = DescriptorImageInfo::default()
.image_view(tex.texture_view) .image_view(tex.texture_view)
.image_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL); .image_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL);
let write_descriptor_set = WriteDescriptorSet::builder() let write_descriptor_set = WriteDescriptorSet::default()
.descriptor_type(DescriptorType::COMBINED_IMAGE_SAMPLER) .descriptor_type(DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(slice::from_ref(&image_info)) .image_info(slice::from_ref(&image_info));
.build();
unsafe { unsafe {
self.device.push_descriptor.cmd_push_descriptor_set( self.device.push_descriptor.cmd_push_descriptor_set(
buf, buf,
@ -462,8 +459,7 @@ impl VulkanRenderer {
) )
.src_stage_mask(PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT) .src_stage_mask(PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT)
.dst_access_mask(AccessFlags2::TRANSFER_READ) .dst_access_mask(AccessFlags2::TRANSFER_READ)
.dst_stage_mask(PipelineStageFlags2::TRANSFER) .dst_stage_mask(PipelineStageFlags2::TRANSFER);
.build();
memory.image_barriers.push(bridge_image_memory_barrier); memory.image_barriers.push(bridge_image_memory_barrier);
let dmabuf_image_memory_barrier = image_barrier() let dmabuf_image_memory_barrier = image_barrier()
.src_queue_family_index(QUEUE_FAMILY_FOREIGN_EXT) .src_queue_family_index(QUEUE_FAMILY_FOREIGN_EXT)
@ -476,35 +472,31 @@ impl VulkanRenderer {
}) })
.new_layout(ImageLayout::TRANSFER_DST_OPTIMAL) .new_layout(ImageLayout::TRANSFER_DST_OPTIMAL)
.dst_access_mask(AccessFlags2::TRANSFER_WRITE) .dst_access_mask(AccessFlags2::TRANSFER_WRITE)
.dst_stage_mask(PipelineStageFlags2::TRANSFER) .dst_stage_mask(PipelineStageFlags2::TRANSFER);
.build();
memory.image_barriers.push(dmabuf_image_memory_barrier); memory.image_barriers.push(dmabuf_image_memory_barrier);
let dep_info = DependencyInfoKHR::builder().image_memory_barriers(&memory.image_barriers); let dep_info = DependencyInfoKHR::default().image_memory_barriers(&memory.image_barriers);
unsafe { unsafe {
self.device.device.cmd_pipeline_barrier2(buf, &dep_info); self.device.device.cmd_pipeline_barrier2(buf, &dep_info);
} }
let image_subresource_layers = ImageSubresourceLayers::builder() let image_subresource_layers = ImageSubresourceLayers::default()
.aspect_mask(ImageAspectFlags::COLOR) .aspect_mask(ImageAspectFlags::COLOR)
.layer_count(1) .layer_count(1)
.base_array_layer(0) .base_array_layer(0)
.mip_level(0) .mip_level(0);
.build(); let image_copy = ImageCopy2::default()
let image_copy = ImageCopy2::builder()
.src_subresource(image_subresource_layers) .src_subresource(image_subresource_layers)
.dst_subresource(image_subresource_layers) .dst_subresource(image_subresource_layers)
.extent(Extent3D { .extent(Extent3D {
width: fb.width, width: fb.width,
height: fb.height, height: fb.height,
depth: 1, depth: 1,
}) });
.build(); let copy_image_info = CopyImageInfo2::default()
let copy_image_info = CopyImageInfo2::builder()
.src_image(fb.image) .src_image(fb.image)
.src_image_layout(ImageLayout::TRANSFER_SRC_OPTIMAL) .src_image_layout(ImageLayout::TRANSFER_SRC_OPTIMAL)
.dst_image(bridge.dmabuf_image) .dst_image(bridge.dmabuf_image)
.dst_image_layout(ImageLayout::TRANSFER_DST_OPTIMAL) .dst_image_layout(ImageLayout::TRANSFER_DST_OPTIMAL)
.regions(slice::from_ref(&image_copy)) .regions(slice::from_ref(&image_copy));
.build();
unsafe { unsafe {
self.device.device.cmd_copy_image2(buf, &copy_image_info); self.device.device.cmd_copy_image2(buf, &copy_image_info);
} }
@ -533,7 +525,6 @@ impl VulkanRenderer {
) )
.src_stage_mask(PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT); .src_stage_mask(PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT);
} }
let fb_image_memory_barrier = fb_image_memory_barrier.build();
memory.image_barriers.push(fb_image_memory_barrier); memory.image_barriers.push(fb_image_memory_barrier);
for img in &memory.sample { for img in &memory.sample {
let image_memory_barrier = image_barrier() let image_memory_barrier = image_barrier()
@ -543,11 +534,10 @@ impl VulkanRenderer {
.new_layout(ImageLayout::GENERAL) .new_layout(ImageLayout::GENERAL)
.image(img.image) .image(img.image)
.src_access_mask(AccessFlags2::SHADER_SAMPLED_READ) .src_access_mask(AccessFlags2::SHADER_SAMPLED_READ)
.src_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER) .src_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER);
.build();
memory.image_barriers.push(image_memory_barrier); memory.image_barriers.push(image_memory_barrier);
} }
let dep_info = DependencyInfoKHR::builder().image_memory_barriers(&memory.image_barriers); let dep_info = DependencyInfoKHR::default().image_memory_barriers(&memory.image_barriers);
unsafe { unsafe {
self.device.device.cmd_pipeline_barrier2(buf, &dep_info); self.device.device.cmd_pipeline_barrier2(buf, &dep_info);
} }
@ -577,10 +567,9 @@ impl VulkanRenderer {
let semaphore = self.allocate_semaphore()?; let semaphore = self.allocate_semaphore()?;
semaphore.import_sync_file(fd)?; semaphore.import_sync_file(fd)?;
infos.push( infos.push(
SemaphoreSubmitInfo::builder() SemaphoreSubmitInfo::default()
.semaphore(semaphore.semaphore) .semaphore(semaphore.semaphore)
.stage_mask(PipelineStageFlags2::TOP_OF_PIPE) .stage_mask(PipelineStageFlags2::TOP_OF_PIPE),
.build(),
); );
semaphores.push(semaphore); semaphores.push(semaphore);
Ok(()) Ok(())
@ -659,13 +648,10 @@ impl VulkanRenderer {
fn submit(&self, buf: CommandBuffer) -> Result<(), VulkanError> { fn submit(&self, buf: CommandBuffer) -> Result<(), VulkanError> {
let mut memory = self.memory.borrow_mut(); let mut memory = self.memory.borrow_mut();
let release_fence = self.device.create_fence()?; let release_fence = self.device.create_fence()?;
let command_buffer_info = CommandBufferSubmitInfo::builder() let command_buffer_info = CommandBufferSubmitInfo::default().command_buffer(buf);
.command_buffer(buf) let submit_info = SubmitInfo2::default()
.build();
let submit_info = SubmitInfo2::builder()
.wait_semaphore_infos(&memory.wait_semaphore_infos) .wait_semaphore_infos(&memory.wait_semaphore_infos)
.command_buffer_infos(slice::from_ref(&command_buffer_info)) .command_buffer_infos(slice::from_ref(&command_buffer_info));
.build();
unsafe { unsafe {
self.device self.device
.device .device
@ -776,7 +762,7 @@ impl VulkanRenderer {
if size != dst.len() as u64 { if size != dst.len() as u64 {
return Err(VulkanError::InvalidBufferSize); return Err(VulkanError::InvalidBufferSize);
} }
let region = BufferImageCopy::builder() let region = BufferImageCopy::default()
.buffer_row_length(stride / shm_info.bpp) .buffer_row_length(stride / shm_info.bpp)
.buffer_image_height(tex.height) .buffer_image_height(tex.height)
.image_subresource(ImageSubresourceLayers { .image_subresource(ImageSubresourceLayers {
@ -789,17 +775,16 @@ impl VulkanRenderer {
width: tex.width, width: tex.width,
height: tex.height, height: tex.height,
depth: 1, depth: 1,
}) });
.build();
let staging = self.create_staging_buffer(size, false, true, true)?; let staging = self.create_staging_buffer(size, false, true, true)?;
let initial_tex_barrier; let initial_tex_barrier;
let initial_buffer_barrier = BufferMemoryBarrier2::builder() let initial_buffer_barrier = BufferMemoryBarrier2::default()
.buffer(staging.buffer) .buffer(staging.buffer)
.offset(0) .offset(0)
.size(staging.size) .size(staging.size)
.dst_access_mask(AccessFlags2::TRANSFER_WRITE) .dst_access_mask(AccessFlags2::TRANSFER_WRITE)
.dst_stage_mask(PipelineStageFlags2::TRANSFER); .dst_stage_mask(PipelineStageFlags2::TRANSFER);
let mut initial_barriers = DependencyInfo::builder() let mut initial_barriers = DependencyInfo::default()
.buffer_memory_barriers(slice::from_ref(&initial_buffer_barrier)); .buffer_memory_barriers(slice::from_ref(&initial_buffer_barrier));
if tex.bridge.is_none() { if tex.bridge.is_none() {
initial_tex_barrier = image_barrier() initial_tex_barrier = image_barrier()
@ -814,7 +799,7 @@ impl VulkanRenderer {
initial_barriers.image_memory_barriers(slice::from_ref(&initial_tex_barrier)); initial_barriers.image_memory_barriers(slice::from_ref(&initial_tex_barrier));
} }
let final_tex_barrier; let final_tex_barrier;
let final_buffer_barrier = BufferMemoryBarrier2::builder() let final_buffer_barrier = BufferMemoryBarrier2::default()
.buffer(staging.buffer) .buffer(staging.buffer)
.offset(0) .offset(0)
.size(staging.size) .size(staging.size)
@ -822,7 +807,7 @@ impl VulkanRenderer {
.src_stage_mask(PipelineStageFlags2::TRANSFER) .src_stage_mask(PipelineStageFlags2::TRANSFER)
.dst_access_mask(AccessFlags2::HOST_READ) .dst_access_mask(AccessFlags2::HOST_READ)
.dst_stage_mask(PipelineStageFlags2::HOST); .dst_stage_mask(PipelineStageFlags2::HOST);
let mut final_barriers = DependencyInfo::builder() let mut final_barriers = DependencyInfo::default()
.buffer_memory_barriers(slice::from_ref(&final_buffer_barrier)); .buffer_memory_barriers(slice::from_ref(&final_buffer_barrier));
if tex.bridge.is_none() { if tex.bridge.is_none() {
final_tex_barrier = image_barrier() final_tex_barrier = image_barrier()
@ -845,20 +830,19 @@ impl VulkanRenderer {
.map_err(VulkanError::IoctlExportSyncFile)?; .map_err(VulkanError::IoctlExportSyncFile)?;
let semaphore = self.allocate_semaphore()?; let semaphore = self.allocate_semaphore()?;
semaphore.import_sync_file(fd)?; semaphore.import_sync_file(fd)?;
let semaphore_info = SemaphoreSubmitInfo::builder() let semaphore_info = SemaphoreSubmitInfo::default()
.semaphore(semaphore.semaphore) .semaphore(semaphore.semaphore)
.stage_mask(PipelineStageFlags2::TOP_OF_PIPE) .stage_mask(PipelineStageFlags2::TOP_OF_PIPE);
.build();
semaphores.push(semaphore); semaphores.push(semaphore);
semaphore_infos.push(semaphore_info); semaphore_infos.push(semaphore_info);
} }
} }
let command_buffer_info = CommandBufferSubmitInfo::builder().command_buffer(buf.buffer); let command_buffer_info = CommandBufferSubmitInfo::default().command_buffer(buf.buffer);
let submit_info = SubmitInfo2::builder() let submit_info = SubmitInfo2::default()
.wait_semaphore_infos(&semaphore_infos) .wait_semaphore_infos(&semaphore_infos)
.command_buffer_infos(slice::from_ref(&command_buffer_info)); .command_buffer_infos(slice::from_ref(&command_buffer_info));
let begin_info = let begin_info =
CommandBufferBeginInfo::builder().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT); CommandBufferBeginInfo::default().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT);
unsafe { unsafe {
self.device self.device
.device .device
@ -1023,13 +1007,12 @@ impl dyn GfxTexture {
} }
} }
pub(super) fn image_barrier() -> ImageMemoryBarrier2Builder<'static> { pub(super) fn image_barrier() -> ImageMemoryBarrier2<'static> {
ImageMemoryBarrier2::builder().subresource_range( ImageMemoryBarrier2::default().subresource_range(
ImageSubresourceRange::builder() ImageSubresourceRange::default()
.aspect_mask(ImageAspectFlags::COLOR) .aspect_mask(ImageAspectFlags::COLOR)
.layer_count(1) .layer_count(1)
.level_count(1) .level_count(1),
.build(),
) )
} }

2
src/gfx_apis/vulkan/sampler.rs
View file

@ -13,7 +13,7 @@ pub struct VulkanSampler {
impl VulkanDevice { impl VulkanDevice {
pub(super) fn create_sampler(self: &Rc<Self>) -> Result<Rc<VulkanSampler>, VulkanError> { pub(super) fn create_sampler(self: &Rc<Self>) -> Result<Rc<VulkanSampler>, VulkanError> {
let create_info = SamplerCreateInfo::builder() let create_info = SamplerCreateInfo::default()
.mag_filter(Filter::LINEAR) .mag_filter(Filter::LINEAR)
.min_filter(Filter::LINEAR) .min_filter(Filter::LINEAR)
.mipmap_mode(SamplerMipmapMode::NEAREST) .mipmap_mode(SamplerMipmapMode::NEAREST)

4
src/gfx_apis/vulkan/semaphore.rs
View file

@ -24,7 +24,7 @@ impl Drop for VulkanSemaphore {
impl VulkanDevice { impl VulkanDevice {
pub fn create_semaphore(self: &Rc<Self>) -> Result<Rc<VulkanSemaphore>, VulkanError> { pub fn create_semaphore(self: &Rc<Self>) -> Result<Rc<VulkanSemaphore>, VulkanError> {
let sem = { let sem = {
let create_info = SemaphoreCreateInfo::builder(); let create_info = SemaphoreCreateInfo::default();
let sem = unsafe { self.device.create_semaphore(&create_info, None) }; let sem = unsafe { self.device.create_semaphore(&create_info, None) };
sem.map_err(VulkanError::CreateSemaphore)? sem.map_err(VulkanError::CreateSemaphore)?
}; };
@ -37,7 +37,7 @@ impl VulkanDevice {
impl VulkanSemaphore { impl VulkanSemaphore {
pub fn import_sync_file(&self, sync_file: OwnedFd) -> Result<(), VulkanError> { pub fn import_sync_file(&self, sync_file: OwnedFd) -> Result<(), VulkanError> {
let fd_info = ImportSemaphoreFdInfoKHR::builder() let fd_info = ImportSemaphoreFdInfoKHR::default()
.fd(sync_file.raw()) .fd(sync_file.raw())
.flags(SemaphoreImportFlags::TEMPORARY) .flags(SemaphoreImportFlags::TEMPORARY)
.handle_type(ExternalSemaphoreHandleTypeFlags::SYNC_FD) .handle_type(ExternalSemaphoreHandleTypeFlags::SYNC_FD)

2
src/gfx_apis/vulkan/shaders.rs
View file

@ -57,7 +57,7 @@ impl VulkanDevice {
src: &[u8], src: &[u8],
) -> Result<Rc<VulkanShader>, VulkanError> { ) -> Result<Rc<VulkanShader>, VulkanError> {
let src: Vec<u32> = uapi::pod_iter(src).unwrap().collect(); let src: Vec<u32> = uapi::pod_iter(src).unwrap().collect();
let create_info = ShaderModuleCreateInfo::builder().code(&src); let create_info = ShaderModuleCreateInfo::default().code(&src);
let module = unsafe { self.device.create_shader_module(&create_info, None) }; let module = unsafe { self.device.create_shader_module(&create_info, None) };
module module
.map_err(VulkanError::CreateShaderModule) .map_err(VulkanError::CreateShaderModule)

32
src/gfx_apis/vulkan/shm_image.rs
View file

@ -48,7 +48,7 @@ impl VulkanShmImage {
} }
} }
let copy = |full: bool, off, x, y, width, height| { let copy = |full: bool, off, x, y, width, height| {
let mut builder = BufferImageCopy2::builder() let mut builder = BufferImageCopy2::default()
.buffer_offset(off) .buffer_offset(off)
.image_offset(Offset3D { x, y, z: 0 }) .image_offset(Offset3D { x, y, z: 0 })
.image_extent(Extent3D { .image_extent(Extent3D {
@ -67,7 +67,7 @@ impl VulkanShmImage {
.buffer_image_height(img.height) .buffer_image_height(img.height)
.buffer_row_length(img.stride / self.shm_info.bpp); .buffer_row_length(img.stride / self.shm_info.bpp);
} }
builder.build() builder
}; };
let mut total_size; let mut total_size;
let cpy_one; let cpy_one;
@ -130,7 +130,7 @@ impl VulkanShmImage {
} }
})?; })?;
let memory_barrier = |sam, ssm, dam, dsm| { let memory_barrier = |sam, ssm, dam, dsm| {
BufferMemoryBarrier2::builder() BufferMemoryBarrier2::default()
.buffer(staging.buffer) .buffer(staging.buffer)
.offset(0) .offset(0)
.size(staging.size) .size(staging.size)
@ -138,7 +138,6 @@ impl VulkanShmImage {
.src_stage_mask(ssm) .src_stage_mask(ssm)
.dst_access_mask(dam) .dst_access_mask(dam)
.dst_stage_mask(dsm) .dst_stage_mask(dsm)
.build()
}; };
let initial_image_barrier = image_barrier() let initial_image_barrier = image_barrier()
.image(img.image) .image(img.image)
@ -151,15 +150,14 @@ impl VulkanShmImage {
}) })
.new_layout(ImageLayout::TRANSFER_DST_OPTIMAL) .new_layout(ImageLayout::TRANSFER_DST_OPTIMAL)
.dst_access_mask(AccessFlags2::TRANSFER_WRITE) .dst_access_mask(AccessFlags2::TRANSFER_WRITE)
.dst_stage_mask(PipelineStageFlags2::TRANSFER) .dst_stage_mask(PipelineStageFlags2::TRANSFER);
.build();
let initial_buffer_barrier = memory_barrier( let initial_buffer_barrier = memory_barrier(
AccessFlags2::HOST_WRITE, AccessFlags2::HOST_WRITE,
PipelineStageFlags2::HOST, PipelineStageFlags2::HOST,
AccessFlags2::TRANSFER_READ, AccessFlags2::TRANSFER_READ,
PipelineStageFlags2::TRANSFER, PipelineStageFlags2::TRANSFER,
); );
let initial_dep_info = DependencyInfoKHR::builder() let initial_dep_info = DependencyInfoKHR::default()
.buffer_memory_barriers(slice::from_ref(&initial_buffer_barrier)) .buffer_memory_barriers(slice::from_ref(&initial_buffer_barrier))
.image_memory_barriers(slice::from_ref(&initial_image_barrier)); .image_memory_barriers(slice::from_ref(&initial_image_barrier));
let final_image_barrier = image_barrier() let final_image_barrier = image_barrier()
@ -169,29 +167,28 @@ impl VulkanShmImage {
.old_layout(ImageLayout::TRANSFER_DST_OPTIMAL) .old_layout(ImageLayout::TRANSFER_DST_OPTIMAL)
.new_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL) .new_layout(ImageLayout::SHADER_READ_ONLY_OPTIMAL)
.dst_access_mask(AccessFlags2::SHADER_SAMPLED_READ) .dst_access_mask(AccessFlags2::SHADER_SAMPLED_READ)
.dst_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER) .dst_stage_mask(PipelineStageFlags2::FRAGMENT_SHADER);
.build();
let final_buffer_barrier = memory_barrier( let final_buffer_barrier = memory_barrier(
AccessFlags2::TRANSFER_READ, AccessFlags2::TRANSFER_READ,
PipelineStageFlags2::TRANSFER, PipelineStageFlags2::TRANSFER,
AccessFlags2::HOST_WRITE, AccessFlags2::HOST_WRITE,
PipelineStageFlags2::HOST, PipelineStageFlags2::HOST,
); );
let final_dep_info = DependencyInfoKHR::builder() let final_dep_info = DependencyInfoKHR::default()
.buffer_memory_barriers(slice::from_ref(&final_buffer_barrier)) .buffer_memory_barriers(slice::from_ref(&final_buffer_barrier))
.image_memory_barriers(slice::from_ref(&final_image_barrier)); .image_memory_barriers(slice::from_ref(&final_image_barrier));
let cpy_info = CopyBufferToImageInfo2::builder() let cpy_info = CopyBufferToImageInfo2::default()
.src_buffer(staging.buffer) .src_buffer(staging.buffer)
.dst_image(img.image) .dst_image(img.image)
.dst_image_layout(ImageLayout::TRANSFER_DST_OPTIMAL) .dst_image_layout(ImageLayout::TRANSFER_DST_OPTIMAL)
.regions(cpy); .regions(cpy);
let cmd = img.renderer.allocate_command_buffer()?; let cmd = img.renderer.allocate_command_buffer()?;
let dev = &img.renderer.device.device; let dev = &img.renderer.device.device;
let command_buffer_info = CommandBufferSubmitInfo::builder().command_buffer(cmd.buffer); let command_buffer_info = CommandBufferSubmitInfo::default().command_buffer(cmd.buffer);
let submit_info = let submit_info =
SubmitInfo2::builder().command_buffer_infos(slice::from_ref(&command_buffer_info)); SubmitInfo2::default().command_buffer_infos(slice::from_ref(&command_buffer_info));
let begin_info = let begin_info =
CommandBufferBeginInfo::builder().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT); CommandBufferBeginInfo::default().flags(CommandBufferUsageFlags::ONE_TIME_SUBMIT);
let release_fence = img.renderer.device.create_fence()?; let release_fence = img.renderer.device.create_fence()?;
unsafe { unsafe {
dev.begin_command_buffer(cmd.buffer, &begin_info) dev.begin_command_buffer(cmd.buffer, &begin_info)
@ -294,7 +291,7 @@ impl VulkanRenderer {
true => ImageUsageFlags::COLOR_ATTACHMENT, true => ImageUsageFlags::COLOR_ATTACHMENT,
false => ImageUsageFlags::SAMPLED | ImageUsageFlags::TRANSFER_DST, false => ImageUsageFlags::SAMPLED | ImageUsageFlags::TRANSFER_DST,
}; };
let create_info = ImageCreateInfo::builder() let create_info = ImageCreateInfo::default()
.image_type(ImageType::TYPE_2D) .image_type(ImageType::TYPE_2D)
.format(format.vk_format) .format(format.vk_format)
.mip_levels(1) .mip_levels(1)
@ -308,8 +305,7 @@ impl VulkanRenderer {
height, height,
depth: 1, depth: 1,
}) })
.usage(usage) .usage(usage);
.build();
let image = unsafe { self.device.device.create_image(&create_info, None) }; let image = unsafe { self.device.device.create_image(&create_info, None) };
let image = image.map_err(VulkanError::CreateImage)?; let image = image.map_err(VulkanError::CreateImage)?;
let destroy_image = OnDrop(|| unsafe { self.device.device.destroy_image(image, None) }); let destroy_image = OnDrop(|| unsafe { self.device.device.destroy_image(image, None) });
@ -324,7 +320,7 @@ impl VulkanRenderer {
.bind_image_memory(image, allocation.memory, allocation.offset) .bind_image_memory(image, allocation.memory, allocation.offset)
}; };
res.map_err(VulkanError::BindImageMemory)?; res.map_err(VulkanError::BindImageMemory)?;
let image_view_create_info = ImageViewCreateInfo::builder() let image_view_create_info = ImageViewCreateInfo::default()
.image(image) .image(image)
.format(format.vk_format) .format(format.vk_format)
.view_type(ImageViewType::TYPE_2D) .view_type(ImageViewType::TYPE_2D)

5
src/gfx_apis/vulkan/staging.rs
View file

@ -37,7 +37,7 @@ impl VulkanRenderer {
usage |= UsageFlags::TRANSIENT; usage |= UsageFlags::TRANSIENT;
} }
let buffer = { let buffer = {
let create_info = BufferCreateInfo::builder().size(size).usage(vk_usage); let create_info = BufferCreateInfo::default().size(size).usage(vk_usage);
let buffer = unsafe { self.device.device.create_buffer(&create_info, None) }; let buffer = unsafe { self.device.device.create_buffer(&create_info, None) };
buffer.map_err(VulkanError::CreateBuffer)? buffer.map_err(VulkanError::CreateBuffer)?
}; };
@ -86,11 +86,10 @@ impl VulkanStagingBuffer {
fn range(&self) -> MappedMemoryRange { fn range(&self) -> MappedMemoryRange {
let atom_mask = self.allocation.allocator.non_coherent_atom_mask; let atom_mask = self.allocation.allocator.non_coherent_atom_mask;
MappedMemoryRange::builder() MappedMemoryRange::default()
.memory(self.allocation.memory) .memory(self.allocation.memory)
.offset(self.allocation.offset & !atom_mask) .offset(self.allocation.offset & !atom_mask)
.size((self.allocation.size + atom_mask) & !atom_mask) .size((self.allocation.size + atom_mask) & !atom_mask)
.build()
} }
} }