| // Copyright (c) 2022 The vulkano developers |
| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or |
| // https://www.apache.org/licenses/LICENSE-2.0> or the MIT |
| // license <LICENSE-MIT or https://opensource.org/licenses/MIT>, |
| // at your option. All files in the project carrying such |
| // notice may not be copied, modified, or distributed except |
| // according to those terms. |
| |
| use super::{ |
| AttachmentDescription, AttachmentReference, LoadOp, RenderPass, RenderPassCreateInfo, |
| SubpassDependency, SubpassDescription, |
| }; |
| use crate::{ |
| device::Device, |
| format::FormatFeatures, |
| image::{ImageAspects, ImageLayout, SampleCount}, |
| sync::{AccessFlags, DependencyFlags, PipelineStages}, |
| OomError, RequirementNotMet, RequiresOneOf, Version, VulkanError, VulkanObject, |
| }; |
| use smallvec::SmallVec; |
| use std::{ |
| error::Error, |
| fmt::{Display, Error as FmtError, Formatter}, |
| mem::MaybeUninit, |
| ptr, |
| }; |
| |
| impl RenderPass { |
| pub(super) fn validate( |
| device: &Device, |
| create_info: &mut RenderPassCreateInfo, |
| ) -> Result<(), RenderPassCreationError> { |
| let properties = device.physical_device().properties(); |
| |
| let RenderPassCreateInfo { |
| attachments, |
| subpasses, |
| dependencies, |
| correlated_view_masks, |
| _ne: _, |
| } = create_info; |
| |
| /* |
| Attachments |
| */ |
| |
| let mut attachment_potential_format_features = Vec::with_capacity(attachments.len()); |
| |
| for (atch_num, attachment) in attachments.iter().enumerate() { |
| let &AttachmentDescription { |
| format, |
| samples, |
| load_op, |
| store_op, |
| stencil_load_op, |
| stencil_store_op, |
| initial_layout, |
| final_layout, |
| _ne: _, |
| } = attachment; |
| let atch_num = atch_num as u32; |
| |
| // VUID-VkAttachmentDescription2-finalLayout-03061 |
| if matches!( |
| final_layout, |
| ImageLayout::Undefined | ImageLayout::Preinitialized |
| ) { |
| return Err(RenderPassCreationError::AttachmentLayoutInvalid { |
| attachment: atch_num, |
| }); |
| } |
| |
| let format = format.unwrap(); |
| let aspects = format.aspects(); |
| |
| // VUID-VkAttachmentDescription2-format-parameter |
| format.validate_device(device)?; |
| |
| // VUID-VkAttachmentDescription2-samples-parameter |
| samples.validate_device(device)?; |
| |
| for load_op in [load_op, stencil_load_op] { |
| // VUID-VkAttachmentDescription2-loadOp-parameter |
| // VUID-VkAttachmentDescription2-stencilLoadOp-parameter |
| load_op.validate_device(device)?; |
| } |
| |
| for store_op in [store_op, stencil_store_op] { |
| // VUID-VkAttachmentDescription2-storeOp-parameter |
| // VUID-VkAttachmentDescription2-stencilStoreOp-parameter |
| store_op.validate_device(device)?; |
| } |
| |
| for layout in [initial_layout, final_layout] { |
| // VUID-VkAttachmentDescription2-initialLayout-parameter |
| // VUID-VkAttachmentDescription2-finalLayout-parameter |
| layout.validate_device(device)?; |
| |
| if aspects.intersects(ImageAspects::DEPTH | ImageAspects::STENCIL) { |
| // VUID-VkAttachmentDescription2-format-03281 |
| // VUID-VkAttachmentDescription2-format-03283 |
| if matches!(layout, ImageLayout::ColorAttachmentOptimal) { |
| return Err(RenderPassCreationError::AttachmentLayoutInvalid { |
| attachment: atch_num, |
| }); |
| } |
| } else { |
| // VUID-VkAttachmentDescription2-format-03280 |
| // VUID-VkAttachmentDescription2-format-03282 |
| // VUID-VkAttachmentDescription2-format-06487 |
| // VUID-VkAttachmentDescription2-format-06488 |
| if matches!( |
| layout, |
| ImageLayout::DepthStencilAttachmentOptimal |
| | ImageLayout::DepthStencilReadOnlyOptimal |
| | ImageLayout::DepthAttachmentStencilReadOnlyOptimal |
| | ImageLayout::DepthReadOnlyStencilAttachmentOptimal |
| ) { |
| return Err(RenderPassCreationError::AttachmentLayoutInvalid { |
| attachment: atch_num, |
| }); |
| } |
| } |
| } |
| |
| // Use unchecked, because all validation has been done above. |
| attachment_potential_format_features.push(unsafe { |
| device |
| .physical_device() |
| .format_properties_unchecked(format) |
| .potential_format_features() |
| }); |
| } |
| |
| /* |
| Subpasses |
| */ |
| |
| // VUID-VkRenderPassCreateInfo2-subpassCount-arraylength |
| assert!(!subpasses.is_empty()); |
| |
| let is_multiview = subpasses[0].view_mask != 0; |
| |
| // VUID-VkSubpassDescription2-multiview-06558 |
| if is_multiview && !device.enabled_features().multiview { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.subpasses[0].view_mask` is not `0`", |
| requires_one_of: RequiresOneOf { |
| features: &["multiview"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| let mut attachment_used = vec![false; attachments.len()]; |
| |
| for (subpass_num, subpass) in subpasses.iter_mut().enumerate() { |
| let &mut SubpassDescription { |
| view_mask, |
| ref mut input_attachments, |
| ref color_attachments, |
| ref resolve_attachments, |
| ref depth_stencil_attachment, |
| ref preserve_attachments, |
| _ne: _, |
| } = subpass; |
| let subpass_num = subpass_num as u32; |
| |
| // VUID-VkRenderPassCreateInfo2-viewMask-03058 |
| if (view_mask != 0) != is_multiview { |
| return Err(RenderPassCreationError::SubpassMultiviewMismatch { |
| subpass: subpass_num, |
| multiview: subpass.view_mask != 0, |
| first_subpass_multiview: is_multiview, |
| }); |
| } |
| |
| let view_count = u32::BITS - view_mask.leading_zeros(); |
| |
| // VUID-VkSubpassDescription2-viewMask-06706 |
| if view_count > properties.max_multiview_view_count.unwrap_or(0) { |
| return Err( |
| RenderPassCreationError::SubpassMaxMultiviewViewCountExceeded { |
| subpass: subpass_num, |
| view_count, |
| max: properties.max_multiview_view_count.unwrap_or(0), |
| }, |
| ); |
| } |
| |
| // VUID-VkSubpassDescription2-colorAttachmentCount-03063 |
| if color_attachments.len() as u32 > properties.max_color_attachments { |
| return Err( |
| RenderPassCreationError::SubpassMaxColorAttachmentsExceeded { |
| subpass: subpass_num, |
| color_attachment_count: color_attachments.len() as u32, |
| max: properties.max_color_attachments, |
| }, |
| ); |
| } |
| |
| // Track the layout of each attachment used in this subpass |
| let mut layouts = vec![None; attachments.len()]; |
| |
| // Common checks for all attachment types |
| let mut check_attachment = |atch_ref: &AttachmentReference| { |
| // VUID-VkAttachmentReference2-layout-parameter |
| atch_ref.layout.validate_device(device)?; |
| |
| // VUID? |
| atch_ref.aspects.validate_device(device)?; |
| |
| // VUID-VkRenderPassCreateInfo2-attachment-03051 |
| let atch = attachments.get(atch_ref.attachment as usize).ok_or( |
| RenderPassCreationError::SubpassAttachmentOutOfRange { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }, |
| )?; |
| |
| // VUID-VkSubpassDescription2-layout-02528 |
| match &mut layouts[atch_ref.attachment as usize] { |
| Some(layout) if *layout == atch_ref.layout => (), |
| Some(_) => { |
| return Err(RenderPassCreationError::SubpassAttachmentLayoutMismatch { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }) |
| } |
| layout @ None => *layout = Some(atch_ref.layout), |
| } |
| |
| let first_use = |
| !std::mem::replace(&mut attachment_used[atch_ref.attachment as usize], true); |
| |
| if first_use { |
| // VUID-VkRenderPassCreateInfo2-pAttachments-02522 |
| if atch.load_op == LoadOp::Clear |
| && matches!( |
| atch_ref.layout, |
| ImageLayout::ShaderReadOnlyOptimal |
| | ImageLayout::DepthStencilReadOnlyOptimal |
| | ImageLayout::DepthReadOnlyStencilAttachmentOptimal |
| ) |
| { |
| return Err(RenderPassCreationError::AttachmentFirstUseLoadOpInvalid { |
| attachment: atch_ref.attachment, |
| first_use_subpass: subpass_num, |
| }); |
| } |
| |
| // VUID-VkRenderPassCreateInfo2-pAttachments-02523 |
| if atch.stencil_load_op == LoadOp::Clear |
| && matches!( |
| atch_ref.layout, |
| ImageLayout::ShaderReadOnlyOptimal |
| | ImageLayout::DepthStencilReadOnlyOptimal |
| | ImageLayout::DepthAttachmentStencilReadOnlyOptimal |
| ) |
| { |
| return Err(RenderPassCreationError::AttachmentFirstUseLoadOpInvalid { |
| attachment: atch_ref.attachment, |
| first_use_subpass: subpass_num, |
| }); |
| } |
| } |
| |
| let potential_format_features = |
| &attachment_potential_format_features[atch_ref.attachment as usize]; |
| |
| Ok((atch, potential_format_features, first_use)) |
| }; |
| |
| /* |
| Check color attachments |
| */ |
| |
| let mut color_samples = None; |
| |
| for atch_ref in color_attachments.iter().flatten() { |
| let (atch, features, _first_use) = check_attachment(atch_ref)?; |
| |
| // VUID-VkSubpassDescription2-pColorAttachments-02898 |
| if !features.intersects(FormatFeatures::COLOR_ATTACHMENT) { |
| return Err( |
| RenderPassCreationError::SubpassAttachmentFormatUsageNotSupported { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "color", |
| }, |
| ); |
| } |
| |
| // VUID-VkAttachmentReference2-layout-03077 |
| // VUID-VkSubpassDescription2-attachment-06913 |
| // VUID-VkSubpassDescription2-attachment-06916 |
| if matches!( |
| atch_ref.layout, |
| ImageLayout::Undefined |
| | ImageLayout::Preinitialized |
| | ImageLayout::PresentSrc |
| | ImageLayout::DepthStencilAttachmentOptimal |
| | ImageLayout::ShaderReadOnlyOptimal |
| | ImageLayout::DepthAttachmentStencilReadOnlyOptimal |
| | ImageLayout::DepthReadOnlyStencilAttachmentOptimal |
| ) { |
| return Err(RenderPassCreationError::SubpassAttachmentLayoutInvalid { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "color", |
| }); |
| } |
| |
| // Not required by spec, but enforced by Vulkano for sanity. |
| if !atch_ref.aspects.is_empty() { |
| return Err(RenderPassCreationError::SubpassAttachmentAspectsNotEmpty { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }); |
| } |
| |
| // VUID-VkSubpassDescription2-pColorAttachments-03069 |
| match &mut color_samples { |
| Some(samples) if *samples == atch.samples => (), |
| Some(samples) => { |
| return Err( |
| RenderPassCreationError::SubpassColorDepthStencilAttachmentSamplesMismatch { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| samples: atch.samples, |
| first_samples: *samples, |
| }, |
| ) |
| } |
| samples @ None => *samples = Some(atch.samples), |
| } |
| } |
| |
| /* |
| Check depth/stencil attachment |
| */ |
| |
| if let Some(atch_ref) = depth_stencil_attachment.as_ref() { |
| let (atch, features, _first_use) = check_attachment(atch_ref)?; |
| |
| // VUID-VkSubpassDescription2-pDepthStencilAttachment-02900 |
| if !features.intersects(FormatFeatures::DEPTH_STENCIL_ATTACHMENT) { |
| return Err( |
| RenderPassCreationError::SubpassAttachmentFormatUsageNotSupported { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "depth/stencil", |
| }, |
| ); |
| } |
| |
| // VUID-VkAttachmentReference2-layout-03077 |
| // VUID-VkSubpassDescription2-attachment-06915 |
| if matches!( |
| atch_ref.layout, |
| ImageLayout::Undefined |
| | ImageLayout::Preinitialized |
| | ImageLayout::PresentSrc |
| | ImageLayout::ColorAttachmentOptimal |
| | ImageLayout::ShaderReadOnlyOptimal |
| ) { |
| return Err(RenderPassCreationError::SubpassAttachmentLayoutInvalid { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "depth/stencil", |
| }); |
| } |
| |
| // Not required by spec, but enforced by Vulkano for sanity. |
| if !atch_ref.aspects.is_empty() { |
| return Err(RenderPassCreationError::SubpassAttachmentAspectsNotEmpty { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }); |
| } |
| |
| // VUID-VkSubpassDescription2-pDepthStencilAttachment-04440 |
| if color_attachments |
| .iter() |
| .flatten() |
| .any(|color_atch_ref| color_atch_ref.attachment == atch_ref.attachment) |
| { |
| return Err( |
| RenderPassCreationError::SubpassAttachmentUsageColorDepthStencil { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }, |
| ); |
| } |
| |
| // VUID-VkSubpassDescription2-pDepthStencilAttachment-03071 |
| if let Some(samples) = color_samples.filter(|samples| *samples != atch.samples) { |
| return Err( |
| RenderPassCreationError::SubpassColorDepthStencilAttachmentSamplesMismatch { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| samples: atch.samples, |
| first_samples: samples, |
| }, |
| ); |
| } |
| } |
| |
| /* |
| Check input attachments |
| This must be placed after color and depth/stencil checks so that `first_use` |
| will be true for VUID-VkSubpassDescription2-loadOp-03064. |
| */ |
| |
| for atch_ref in input_attachments.iter_mut().flatten() { |
| let (atch, features, first_use) = check_attachment(atch_ref)?; |
| |
| // VUID-VkSubpassDescription2-pInputAttachments-02897 |
| if !features.intersects( |
| FormatFeatures::COLOR_ATTACHMENT | FormatFeatures::DEPTH_STENCIL_ATTACHMENT, |
| ) { |
| return Err( |
| RenderPassCreationError::SubpassAttachmentFormatUsageNotSupported { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "input", |
| }, |
| ); |
| } |
| |
| // VUID-VkAttachmentReference2-layout-03077 |
| // VUID-VkSubpassDescription2-attachment-06912 |
| if matches!( |
| atch_ref.layout, |
| ImageLayout::Undefined |
| | ImageLayout::Preinitialized |
| | ImageLayout::PresentSrc |
| | ImageLayout::ColorAttachmentOptimal |
| | ImageLayout::DepthStencilAttachmentOptimal |
| ) { |
| return Err(RenderPassCreationError::SubpassAttachmentLayoutInvalid { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "input", |
| }); |
| } |
| |
| let atch_aspects = atch.format.unwrap().aspects(); |
| |
| if atch_ref.aspects.is_empty() { |
| // VUID-VkSubpassDescription2-attachment-02800 |
| atch_ref.aspects = atch_aspects; |
| } else if atch_ref.aspects != atch_aspects { |
| if !(device.api_version() >= Version::V1_1 |
| || device.enabled_extensions().khr_create_renderpass2 |
| || device.enabled_extensions().khr_maintenance2) |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.subpasses` has an element, where \ |
| `input_attachments` has an element that is `Some(atch_ref)`, \ |
| where `atch_ref.aspects` does not match the aspects of the \ |
| attachment itself", |
| requires_one_of: RequiresOneOf { |
| api_version: Some(Version::V1_1), |
| device_extensions: &["khr_create_renderpass2", "khr_maintenance2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkSubpassDescription2-attachment-02801 |
| // VUID-VkSubpassDescription2-attachment-04563 |
| // VUID-VkRenderPassCreateInfo2-attachment-02525 |
| if !atch_aspects.contains(atch_ref.aspects) { |
| return Err( |
| RenderPassCreationError::SubpassInputAttachmentAspectsNotCompatible { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }, |
| ); |
| } |
| } |
| |
| // VUID-VkSubpassDescription2-loadOp-03064 |
| if first_use && atch.load_op == LoadOp::Clear { |
| return Err(RenderPassCreationError::AttachmentFirstUseLoadOpInvalid { |
| attachment: atch_ref.attachment, |
| first_use_subpass: subpass_num, |
| }); |
| } |
| } |
| |
| /* |
| Check resolve attachments |
| */ |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-parameter |
| if !(resolve_attachments.is_empty() |
| || resolve_attachments.len() == color_attachments.len()) |
| { |
| return Err( |
| RenderPassCreationError::SubpassResolveAttachmentsColorAttachmentsLenMismatch { |
| subpass: subpass_num, |
| }, |
| ); |
| } |
| |
| for (atch_ref, color_atch_ref) in resolve_attachments |
| .iter() |
| .zip(subpass.color_attachments.iter()) |
| .filter_map(|(r, c)| r.as_ref().map(|r| (r, c.as_ref()))) |
| { |
| let (atch, features, _first_use) = check_attachment(atch_ref)?; |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-02899 |
| if !features.intersects(FormatFeatures::COLOR_ATTACHMENT) { |
| return Err( |
| RenderPassCreationError::SubpassAttachmentFormatUsageNotSupported { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "resolve", |
| }, |
| ); |
| } |
| |
| // VUID-VkAttachmentReference2-layout-03077 |
| // VUID-VkSubpassDescription2-attachment-06914 |
| // VUID-VkSubpassDescription2-attachment-06917 |
| if matches!( |
| atch_ref.layout, |
| ImageLayout::Undefined |
| | ImageLayout::Preinitialized |
| | ImageLayout::PresentSrc |
| | ImageLayout::DepthStencilAttachmentOptimal |
| | ImageLayout::ShaderReadOnlyOptimal |
| | ImageLayout::DepthAttachmentStencilReadOnlyOptimal |
| | ImageLayout::DepthReadOnlyStencilAttachmentOptimal |
| ) { |
| return Err(RenderPassCreationError::SubpassAttachmentLayoutInvalid { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| usage: "resolve", |
| }); |
| } |
| |
| // Not required by spec, but enforced by Vulkano for sanity. |
| if !atch_ref.aspects.is_empty() { |
| return Err(RenderPassCreationError::SubpassAttachmentAspectsNotEmpty { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }); |
| } |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-03065 |
| let color_atch_ref = color_atch_ref.ok_or({ |
| RenderPassCreationError::SubpassResolveAttachmentWithoutColorAttachment { |
| subpass: subpass_num, |
| } |
| })?; |
| let color_atch = &attachments[color_atch_ref.attachment as usize]; |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-03067 |
| if atch.samples != SampleCount::Sample1 { |
| return Err( |
| RenderPassCreationError::SubpassResolveAttachmentMultisampled { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }, |
| ); |
| } |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-03066 |
| if color_atch.samples == SampleCount::Sample1 { |
| return Err( |
| RenderPassCreationError::SubpassColorAttachmentWithResolveNotMultisampled { |
| subpass: subpass_num, |
| attachment: atch_ref.attachment, |
| }, |
| ); |
| } |
| |
| // VUID-VkSubpassDescription2-pResolveAttachments-03068 |
| if atch.format != color_atch.format { |
| return Err( |
| RenderPassCreationError::SubpassResolveAttachmentFormatMismatch { |
| subpass: subpass_num, |
| resolve_attachment: atch_ref.attachment, |
| color_attachment: color_atch_ref.attachment, |
| }, |
| ); |
| } |
| } |
| |
| /* |
| Check preserve attachments |
| */ |
| |
| for &atch in preserve_attachments { |
| // VUID-VkRenderPassCreateInfo2-attachment-03051 |
| if atch as usize >= attachments.len() { |
| return Err(RenderPassCreationError::SubpassAttachmentOutOfRange { |
| subpass: subpass_num, |
| attachment: atch, |
| }); |
| } |
| |
| // VUID-VkSubpassDescription2-pPreserveAttachments-03074 |
| if layouts[atch as usize].is_some() { |
| return Err( |
| RenderPassCreationError::SubpassPreserveAttachmentUsedElsewhere { |
| subpass: subpass_num, |
| attachment: atch, |
| }, |
| ); |
| } |
| } |
| } |
| |
| /* |
| Dependencies |
| */ |
| |
| for (dependency_num, dependency) in dependencies.iter().enumerate() { |
| let &SubpassDependency { |
| src_subpass, |
| dst_subpass, |
| src_stages, |
| dst_stages, |
| src_access, |
| dst_access, |
| dependency_flags, |
| view_offset, |
| _ne: _, |
| } = dependency; |
| let dependency_num = dependency_num as u32; |
| |
| for (stages, access) in [(src_stages, src_access), (dst_stages, dst_access)] { |
| if !device.enabled_features().synchronization2 { |
| if stages.is_2() { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where \ |
| `src_stages` or `dst_stages` contains flags from \ |
| `VkPipelineStageFlagBits2`", |
| requires_one_of: RequiresOneOf { |
| features: &["synchronization2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| if access.is_2() { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where \ |
| `src_access` or `dst_access` contains flags from \ |
| `VkAccessFlagBits2`", |
| requires_one_of: RequiresOneOf { |
| features: &["synchronization2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| } else if !(device.api_version() >= Version::V1_2 |
| || device.enabled_extensions().khr_create_renderpass2) |
| { |
| // If synchronization2 is enabled but we don't have create_renderpass2, |
| // we are unable to use extension structs, so we can't use the |
| // extra flag bits. |
| |
| if stages.is_2() { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where \ |
| `src_stages` or `dst_stages` contains flags from \ |
| `VkPipelineStageFlagBits2`", |
| requires_one_of: RequiresOneOf { |
| api_version: Some(Version::V1_2), |
| device_extensions: &["khr_create_renderpass2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| if access.is_2() { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where \ |
| `src_access` or `dst_access` contains flags from \ |
| `VkAccessFlagBits2`", |
| requires_one_of: RequiresOneOf { |
| api_version: Some(Version::V1_2), |
| device_extensions: &["khr_create_renderpass2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-parameter |
| // VUID-VkMemoryBarrier2-dstStageMask-parameter |
| stages.validate_device(device)?; |
| |
| // VUID-VkMemoryBarrier2-srcAccessMask-parameter |
| // VUID-VkMemoryBarrier2-dstAccessMask-parameter |
| access.validate_device(device)?; |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03929 |
| // VUID-VkMemoryBarrier2-dstStageMask-03929 |
| if stages.intersects(PipelineStages::GEOMETRY_SHADER) |
| && !device.enabled_features().geometry_shader |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::GEOMETRY_SHADER`", |
| requires_one_of: RequiresOneOf { |
| features: &["geometry_shader"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03930 |
| // VUID-VkMemoryBarrier2-dstStageMask-03930 |
| if stages.intersects( |
| PipelineStages::TESSELLATION_CONTROL_SHADER |
| | PipelineStages::TESSELLATION_EVALUATION_SHADER, |
| ) && !device.enabled_features().tessellation_shader |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::TESSELLATION_CONTROL_SHADER` or \ |
| `PipelineStages::TESSELLATION_EVALUATION_SHADER`", |
| requires_one_of: RequiresOneOf { |
| features: &["tessellation_shader"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03931 |
| // VUID-VkMemoryBarrier2-dstStageMask-03931 |
| if stages.intersects(PipelineStages::CONDITIONAL_RENDERING) |
| && !device.enabled_features().conditional_rendering |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::CONDITIONAL_RENDERING`", |
| requires_one_of: RequiresOneOf { |
| features: &["conditional_rendering"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03932 |
| // VUID-VkMemoryBarrier2-dstStageMask-03932 |
| if stages.intersects(PipelineStages::FRAGMENT_DENSITY_PROCESS) |
| && !device.enabled_features().fragment_density_map |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::FRAGMENT_DENSITY_PROCESS`", |
| requires_one_of: RequiresOneOf { |
| features: &["fragment_density_map"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03933 |
| // VUID-VkMemoryBarrier2-dstStageMask-03933 |
| if stages.intersects(PipelineStages::TRANSFORM_FEEDBACK) |
| && !device.enabled_features().transform_feedback |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::TRANSFORM_FEEDBACK`", |
| requires_one_of: RequiresOneOf { |
| features: &["transform_feedback"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03934 |
| // VUID-VkMemoryBarrier2-dstStageMask-03934 |
| if stages.intersects(PipelineStages::MESH_SHADER) |
| && !device.enabled_features().mesh_shader |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::MESH_SHADER`", |
| requires_one_of: RequiresOneOf { |
| features: &["mesh_shader"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-03935 |
| // VUID-VkMemoryBarrier2-dstStageMask-03935 |
| if stages.intersects(PipelineStages::TASK_SHADER) |
| && !device.enabled_features().task_shader |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::TASK_SHADER`", |
| requires_one_of: RequiresOneOf { |
| features: &["task_shader"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-shadingRateImage-07316 |
| // VUID-VkMemoryBarrier2-shadingRateImage-07316 |
| if stages.intersects(PipelineStages::FRAGMENT_SHADING_RATE_ATTACHMENT) |
| && !(device.enabled_features().attachment_fragment_shading_rate |
| || device.enabled_features().shading_rate_image) |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::FRAGMENT_SHADING_RATE_ATTACHMENT`", |
| requires_one_of: RequiresOneOf { |
| features: &["attachment_fragment_shading_rate", "shading_rate_image"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-04957 |
| // VUID-VkMemoryBarrier2-dstStageMask-04957 |
| if stages.intersects(PipelineStages::SUBPASS_SHADING) |
| && !device.enabled_features().subpass_shading |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::SUBPASS_SHADING`", |
| requires_one_of: RequiresOneOf { |
| features: &["subpass_shading"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkMemoryBarrier2-srcStageMask-04995 |
| // VUID-VkMemoryBarrier2-dstStageMask-04995 |
| if stages.intersects(PipelineStages::INVOCATION_MASK) |
| && !device.enabled_features().invocation_mask |
| { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| contains `PipelineStages::INVOCATION_MASK`", |
| requires_one_of: RequiresOneOf { |
| features: &["invocation_mask"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkSubpassDependency2-srcStageMask-03937 |
| // VUID-VkSubpassDependency2-dstStageMask-03937 |
| if stages.is_empty() && !device.enabled_features().synchronization2 { |
| return Err(RenderPassCreationError::RequirementNotMet { |
| required_for: "`create_info.dependencies` has an element where `stages` \ |
| is empty", |
| requires_one_of: RequiresOneOf { |
| features: &["synchronization2"], |
| ..Default::default() |
| }, |
| }); |
| } |
| |
| // VUID-VkSubpassDependency2-srcAccessMask-03088 |
| // VUID-VkSubpassDependency2-dstAccessMask-03089 |
| if !AccessFlags::from(stages).contains(access) { |
| return Err( |
| RenderPassCreationError::DependencyAccessNotSupportedByStages { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| } |
| |
| if dependency_flags.intersects(DependencyFlags::VIEW_LOCAL) { |
| // VUID-VkRenderPassCreateInfo2-viewMask-03059 |
| if !is_multiview { |
| return Err( |
| RenderPassCreationError::DependencyViewLocalMultiviewNotEnabled { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| } else { |
| // VUID-VkSubpassDependency2-dependencyFlags-03092 |
| if view_offset != 0 { |
| return Err( |
| RenderPassCreationError::DependencyViewOffzetNonzeroWithoutViewLocal { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| } |
| |
| // VUID-VkSubpassDependency2-srcSubpass-03085 |
| if src_subpass.is_none() && dst_subpass.is_none() { |
| return Err(RenderPassCreationError::DependencyBothSubpassesExternal { |
| dependency: dependency_num, |
| }); |
| } |
| |
| for (subpass, stages) in [(src_subpass, src_stages), (dst_subpass, dst_stages)] { |
| if let Some(subpass) = subpass { |
| // VUID-VkRenderPassCreateInfo2-srcSubpass-02526 |
| // VUID-VkRenderPassCreateInfo2-dstSubpass-02527 |
| if subpass as usize >= subpasses.len() { |
| return Err(RenderPassCreationError::DependencySubpassOutOfRange { |
| dependency: dependency_num, |
| subpass, |
| }); |
| } |
| |
| let remaining_stages = stages |
| - (PipelineStages::DRAW_INDIRECT |
| | PipelineStages::INDEX_INPUT |
| | PipelineStages::VERTEX_ATTRIBUTE_INPUT |
| | PipelineStages::VERTEX_SHADER |
| | PipelineStages::TESSELLATION_CONTROL_SHADER |
| | PipelineStages::TESSELLATION_EVALUATION_SHADER |
| | PipelineStages::GEOMETRY_SHADER |
| | PipelineStages::TRANSFORM_FEEDBACK |
| | PipelineStages::FRAGMENT_SHADING_RATE_ATTACHMENT |
| | PipelineStages::EARLY_FRAGMENT_TESTS |
| | PipelineStages::FRAGMENT_SHADER |
| | PipelineStages::LATE_FRAGMENT_TESTS |
| | PipelineStages::COLOR_ATTACHMENT_OUTPUT |
| | PipelineStages::ALL_GRAPHICS); |
| |
| // VUID-VkRenderPassCreateInfo2-pDependencies-03054 |
| // VUID-VkRenderPassCreateInfo2-pDependencies-03055 |
| if !remaining_stages.is_empty() { |
| return Err(RenderPassCreationError::DependencyStageNotSupported { |
| dependency: dependency_num, |
| }); |
| } |
| } else { |
| // VUID-VkSubpassDependency2-dependencyFlags-03090 |
| // VUID-VkSubpassDependency2-dependencyFlags-03091 |
| if dependency_flags.intersects(DependencyFlags::VIEW_LOCAL) { |
| return Err( |
| RenderPassCreationError::DependencyViewLocalExternalDependency { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| } |
| } |
| |
| if let (Some(src_subpass), Some(dst_subpass)) = (src_subpass, dst_subpass) { |
| // VUID-VkSubpassDependency2-srcSubpass-03084 |
| if src_subpass > dst_subpass { |
| return Err( |
| RenderPassCreationError::DependencySourceSubpassAfterDestinationSubpass { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| |
| if src_subpass == dst_subpass { |
| let framebuffer_stages = PipelineStages::EARLY_FRAGMENT_TESTS |
| | PipelineStages::FRAGMENT_SHADER |
| | PipelineStages::LATE_FRAGMENT_TESTS |
| | PipelineStages::COLOR_ATTACHMENT_OUTPUT; |
| |
| // VUID-VkSubpassDependency2-srcSubpass-06810 |
| if src_stages.intersects(framebuffer_stages) |
| && !(dst_stages - framebuffer_stages).is_empty() |
| { |
| return Err( |
| RenderPassCreationError::DependencySelfDependencySourceStageAfterDestinationStage { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| |
| // VUID-VkSubpassDependency2-srcSubpass-02245 |
| if src_stages.intersects(framebuffer_stages) |
| && dst_stages.intersects(framebuffer_stages) |
| && !dependency_flags.intersects(DependencyFlags::BY_REGION) |
| { |
| return Err( |
| RenderPassCreationError::DependencySelfDependencyFramebufferStagesWithoutByRegion { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| |
| if dependency_flags.intersects(DependencyFlags::VIEW_LOCAL) { |
| // VUID-VkSubpassDependency2-viewOffset-02530 |
| if view_offset != 0 { |
| return Err( |
| RenderPassCreationError::DependencySelfDependencyViewLocalNonzeroViewOffset { |
| dependency: dependency_num, |
| }, |
| ); |
| } |
| } else { |
| // VUID-VkRenderPassCreateInfo2-pDependencies-03060 |
| if subpasses[src_subpass as usize].view_mask.count_ones() > 1 { |
| return Err( |
| RenderPassCreationError::DependencySelfDependencyViewMaskMultiple { |
| dependency: dependency_num, |
| subpass: src_subpass, |
| }, |
| ); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| Correlated view masks |
| */ |
| |
| // VUID-VkRenderPassCreateInfo2-viewMask-03057 |
| if !correlated_view_masks.is_empty() { |
| if !is_multiview { |
| return Err(RenderPassCreationError::CorrelatedViewMasksMultiviewNotEnabled); |
| } |
| |
| // VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-03056 |
| correlated_view_masks.iter().try_fold(0, |total, &mask| { |
| if total & mask != 0 { |
| Err(RenderPassCreationError::CorrelatedViewMasksOverlapping) |
| } else { |
| Ok(total | mask) |
| } |
| })?; |
| } |
| |
| Ok(()) |
| } |
| |
| pub(super) unsafe fn create_v2( |
| device: &Device, |
| create_info: &RenderPassCreateInfo, |
| ) -> Result<ash::vk::RenderPass, RenderPassCreationError> { |
| let RenderPassCreateInfo { |
| attachments, |
| subpasses, |
| dependencies, |
| correlated_view_masks, |
| _ne: _, |
| } = create_info; |
| |
| let attachments_vk = attachments |
| .iter() |
| .map(|attachment| ash::vk::AttachmentDescription2 { |
| flags: ash::vk::AttachmentDescriptionFlags::empty(), |
| format: attachment |
| .format |
| .map_or(ash::vk::Format::UNDEFINED, |f| f.into()), |
| samples: attachment.samples.into(), |
| load_op: attachment.load_op.into(), |
| store_op: attachment.store_op.into(), |
| stencil_load_op: attachment.stencil_load_op.into(), |
| stencil_store_op: attachment.stencil_store_op.into(), |
| initial_layout: attachment.initial_layout.into(), |
| final_layout: attachment.final_layout.into(), |
| ..Default::default() |
| }) |
| .collect::<SmallVec<[_; 4]>>(); |
| |
| let attachment_references_vk = subpasses |
| .iter() |
| .flat_map(|subpass| { |
| (subpass.input_attachments.iter()) |
| .chain(subpass.color_attachments.iter()) |
| .chain(subpass.resolve_attachments.iter()) |
| .map(Option::as_ref) |
| .chain(subpass.depth_stencil_attachment.iter().map(Some)) |
| .map(|atch_ref| { |
| if let Some(atch_ref) = atch_ref { |
| ash::vk::AttachmentReference2 { |
| attachment: atch_ref.attachment, |
| layout: atch_ref.layout.into(), |
| aspect_mask: atch_ref.aspects.into(), |
| ..Default::default() |
| } |
| } else { |
| ash::vk::AttachmentReference2 { |
| attachment: ash::vk::ATTACHMENT_UNUSED, |
| ..Default::default() |
| } |
| } |
| }) |
| }) |
| .collect::<SmallVec<[_; 8]>>(); |
| |
| let subpasses_vk = { |
| // `ref_index` is increased during the loop and points to the next element to use |
| // in `attachment_references_vk`. |
| let mut ref_index = 0usize; |
| let out: SmallVec<[_; 4]> = subpasses |
| .iter() |
| .map(|subpass| { |
| let input_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.input_attachments.len(); |
| let color_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.color_attachments.len(); |
| let resolve_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.resolve_attachments.len(); |
| let depth_stencil = if subpass.depth_stencil_attachment.is_some() { |
| let a = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += 1; |
| a |
| } else { |
| ptr::null() |
| }; |
| |
| ash::vk::SubpassDescription2 { |
| flags: ash::vk::SubpassDescriptionFlags::empty(), |
| pipeline_bind_point: ash::vk::PipelineBindPoint::GRAPHICS, // TODO: any need to make this user-specifiable? |
| view_mask: subpass.view_mask, |
| input_attachment_count: subpass.input_attachments.len() as u32, |
| p_input_attachments: if subpass.input_attachments.is_empty() { |
| ptr::null() |
| } else { |
| input_attachments |
| }, |
| color_attachment_count: subpass.color_attachments.len() as u32, |
| p_color_attachments: if subpass.color_attachments.is_empty() { |
| ptr::null() |
| } else { |
| color_attachments |
| }, |
| p_resolve_attachments: if subpass.resolve_attachments.is_empty() { |
| ptr::null() |
| } else { |
| resolve_attachments |
| }, |
| p_depth_stencil_attachment: depth_stencil, |
| preserve_attachment_count: subpass.preserve_attachments.len() as u32, |
| p_preserve_attachments: if subpass.preserve_attachments.is_empty() { |
| ptr::null() |
| } else { |
| subpass.preserve_attachments.as_ptr() |
| }, |
| ..Default::default() |
| } |
| }) |
| .collect(); |
| |
| // If this assertion fails, there's a serious bug in the code above ^. |
| debug_assert!(ref_index == attachment_references_vk.len()); |
| |
| out |
| }; |
| |
| let memory_barriers_vk: SmallVec<[_; 4]> = if device.enabled_features().synchronization2 { |
| debug_assert!( |
| device.api_version() >= Version::V1_3 |
| || device.enabled_extensions().khr_synchronization2 |
| ); |
| dependencies |
| .iter() |
| .map(|dependency| ash::vk::MemoryBarrier2 { |
| src_stage_mask: dependency.src_stages.into(), |
| src_access_mask: dependency.src_access.into(), |
| dst_stage_mask: dependency.dst_stages.into(), |
| dst_access_mask: dependency.dst_access.into(), |
| ..Default::default() |
| }) |
| .collect() |
| } else { |
| SmallVec::new() |
| }; |
| |
| let dependencies_vk = dependencies |
| .iter() |
| .enumerate() |
| .map(|(index, dependency)| { |
| ash::vk::SubpassDependency2 { |
| p_next: memory_barriers_vk |
| .get(index) |
| .map_or(ptr::null(), |mb| mb as *const _ as *const _), |
| src_subpass: dependency.src_subpass.unwrap_or(ash::vk::SUBPASS_EXTERNAL), |
| dst_subpass: dependency.dst_subpass.unwrap_or(ash::vk::SUBPASS_EXTERNAL), |
| src_stage_mask: dependency.src_stages.into(), |
| dst_stage_mask: dependency.dst_stages.into(), |
| src_access_mask: dependency.src_access.into(), |
| dst_access_mask: dependency.dst_access.into(), |
| dependency_flags: dependency.dependency_flags.into(), |
| // VUID-VkSubpassDependency2-dependencyFlags-03092 |
| view_offset: dependency.view_offset, |
| ..Default::default() |
| } |
| }) |
| .collect::<SmallVec<[_; 4]>>(); |
| |
| let create_info = ash::vk::RenderPassCreateInfo2 { |
| flags: ash::vk::RenderPassCreateFlags::empty(), |
| attachment_count: attachments_vk.len() as u32, |
| p_attachments: if attachments_vk.is_empty() { |
| ptr::null() |
| } else { |
| attachments_vk.as_ptr() |
| }, |
| subpass_count: subpasses_vk.len() as u32, |
| p_subpasses: if subpasses_vk.is_empty() { |
| ptr::null() |
| } else { |
| subpasses_vk.as_ptr() |
| }, |
| dependency_count: dependencies_vk.len() as u32, |
| p_dependencies: if dependencies_vk.is_empty() { |
| ptr::null() |
| } else { |
| dependencies_vk.as_ptr() |
| }, |
| correlated_view_mask_count: correlated_view_masks.len() as u32, |
| p_correlated_view_masks: correlated_view_masks.as_ptr(), |
| ..Default::default() |
| }; |
| |
| Ok({ |
| let fns = device.fns(); |
| let mut output = MaybeUninit::uninit(); |
| |
| if device.api_version() >= Version::V1_2 { |
| (fns.v1_2.create_render_pass2)( |
| device.handle(), |
| &create_info, |
| ptr::null(), |
| output.as_mut_ptr(), |
| ) |
| } else { |
| (fns.khr_create_renderpass2.create_render_pass2_khr)( |
| device.handle(), |
| &create_info, |
| ptr::null(), |
| output.as_mut_ptr(), |
| ) |
| } |
| .result() |
| .map_err(VulkanError::from)?; |
| |
| output.assume_init() |
| }) |
| } |
| |
| pub(super) unsafe fn create_v1( |
| device: &Device, |
| create_info: &RenderPassCreateInfo, |
| ) -> Result<ash::vk::RenderPass, RenderPassCreationError> { |
| let RenderPassCreateInfo { |
| attachments, |
| subpasses, |
| dependencies, |
| correlated_view_masks, |
| _ne: _, |
| } = create_info; |
| |
| let attachments_vk = attachments |
| .iter() |
| .map(|attachment| ash::vk::AttachmentDescription { |
| flags: ash::vk::AttachmentDescriptionFlags::empty(), |
| format: attachment |
| .format |
| .map_or(ash::vk::Format::UNDEFINED, |f| f.into()), |
| samples: attachment.samples.into(), |
| load_op: attachment.load_op.into(), |
| store_op: attachment.store_op.into(), |
| stencil_load_op: attachment.stencil_load_op.into(), |
| stencil_store_op: attachment.stencil_store_op.into(), |
| initial_layout: attachment.initial_layout.into(), |
| final_layout: attachment.final_layout.into(), |
| }) |
| .collect::<SmallVec<[_; 4]>>(); |
| |
| let attachment_references_vk = subpasses |
| .iter() |
| .flat_map(|subpass| { |
| (subpass.input_attachments.iter()) |
| .chain(subpass.color_attachments.iter()) |
| .chain(subpass.resolve_attachments.iter()) |
| .map(Option::as_ref) |
| .chain(subpass.depth_stencil_attachment.iter().map(Some)) |
| .map(|atch_ref| { |
| if let Some(atch_ref) = atch_ref { |
| ash::vk::AttachmentReference { |
| attachment: atch_ref.attachment, |
| layout: atch_ref.layout.into(), |
| } |
| } else { |
| ash::vk::AttachmentReference { |
| attachment: ash::vk::ATTACHMENT_UNUSED, |
| layout: Default::default(), |
| } |
| } |
| }) |
| }) |
| .collect::<SmallVec<[_; 8]>>(); |
| |
| let subpasses_vk = { |
| // `ref_index` is increased during the loop and points to the next element to use |
| // in `attachment_references_vk`. |
| let mut ref_index = 0usize; |
| let out: SmallVec<[_; 4]> = subpasses |
| .iter() |
| .map(|subpass| { |
| let input_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.input_attachments.len(); |
| let color_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.color_attachments.len(); |
| let resolve_attachments = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += subpass.resolve_attachments.len(); |
| let depth_stencil = if subpass.depth_stencil_attachment.is_some() { |
| let a = attachment_references_vk.as_ptr().add(ref_index); |
| ref_index += 1; |
| a |
| } else { |
| ptr::null() |
| }; |
| |
| ash::vk::SubpassDescription { |
| flags: ash::vk::SubpassDescriptionFlags::empty(), |
| pipeline_bind_point: ash::vk::PipelineBindPoint::GRAPHICS, |
| input_attachment_count: subpass.input_attachments.len() as u32, |
| p_input_attachments: if subpass.input_attachments.is_empty() { |
| ptr::null() |
| } else { |
| input_attachments |
| }, |
| color_attachment_count: subpass.color_attachments.len() as u32, |
| p_color_attachments: if subpass.color_attachments.is_empty() { |
| ptr::null() |
| } else { |
| color_attachments |
| }, |
| p_resolve_attachments: if subpass.resolve_attachments.is_empty() { |
| ptr::null() |
| } else { |
| resolve_attachments |
| }, |
| p_depth_stencil_attachment: depth_stencil, |
| preserve_attachment_count: subpass.preserve_attachments.len() as u32, |
| p_preserve_attachments: if subpass.preserve_attachments.is_empty() { |
| ptr::null() |
| } else { |
| subpass.preserve_attachments.as_ptr() |
| }, |
| } |
| }) |
| .collect(); |
| |
| // If this assertion fails, there's a serious bug in the code above ^. |
| debug_assert!(ref_index == attachment_references_vk.len()); |
| |
| out |
| }; |
| |
| let dependencies_vk = dependencies |
| .iter() |
| .map(|dependency| ash::vk::SubpassDependency { |
| src_subpass: dependency.src_subpass.unwrap_or(ash::vk::SUBPASS_EXTERNAL), |
| dst_subpass: dependency.dst_subpass.unwrap_or(ash::vk::SUBPASS_EXTERNAL), |
| src_stage_mask: dependency.src_stages.into(), |
| dst_stage_mask: dependency.dst_stages.into(), |
| src_access_mask: dependency.src_access.into(), |
| dst_access_mask: dependency.dst_access.into(), |
| dependency_flags: dependency.dependency_flags.into(), |
| }) |
| .collect::<SmallVec<[_; 4]>>(); |
| |
| /* Input attachment aspect */ |
| |
| let input_attachment_aspect_references: SmallVec<[_; 8]> = if device.api_version() |
| >= Version::V1_1 |
| || device.enabled_extensions().khr_maintenance2 |
| { |
| subpasses |
| .iter() |
| .enumerate() |
| .flat_map(|(subpass_num, subpass)| { |
| subpass.input_attachments.iter().enumerate().flat_map( |
| move |(atch_num, atch_ref)| { |
| atch_ref.as_ref().map(|atch_ref| { |
| ash::vk::InputAttachmentAspectReference { |
| subpass: subpass_num as u32, |
| input_attachment_index: atch_num as u32, |
| aspect_mask: atch_ref.aspects.into(), |
| } |
| }) |
| }, |
| ) |
| }) |
| .collect() |
| } else { |
| SmallVec::new() |
| }; |
| |
| let mut input_attachment_aspect_create_info = |
| if !input_attachment_aspect_references.is_empty() { |
| Some(ash::vk::RenderPassInputAttachmentAspectCreateInfo { |
| aspect_reference_count: input_attachment_aspect_references.len() as u32, |
| p_aspect_references: input_attachment_aspect_references.as_ptr(), |
| ..Default::default() |
| }) |
| } else { |
| None |
| }; |
| |
| /* Multiview */ |
| |
| let is_multiview = subpasses[0].view_mask != 0; |
| |
| let (multiview_view_masks, multiview_view_offsets): (SmallVec<[_; 4]>, SmallVec<[_; 4]>) = |
| if is_multiview { |
| ( |
| subpasses.iter().map(|subpass| subpass.view_mask).collect(), |
| dependencies |
| .iter() |
| .map(|dependency| dependency.view_offset) |
| .collect(), |
| ) |
| } else { |
| (SmallVec::new(), SmallVec::new()) |
| }; |
| |
| let mut multiview_create_info = if is_multiview { |
| debug_assert!(multiview_view_masks.len() == subpasses.len()); |
| debug_assert!(multiview_view_offsets.len() == dependencies.len()); |
| |
| Some(ash::vk::RenderPassMultiviewCreateInfo { |
| subpass_count: multiview_view_masks.len() as u32, |
| p_view_masks: multiview_view_masks.as_ptr(), |
| dependency_count: multiview_view_offsets.len() as u32, |
| p_view_offsets: multiview_view_offsets.as_ptr(), |
| correlation_mask_count: correlated_view_masks.len() as u32, |
| p_correlation_masks: correlated_view_masks.as_ptr(), |
| ..Default::default() |
| }) |
| } else { |
| None |
| }; |
| |
| /* Create */ |
| |
| let mut create_info = ash::vk::RenderPassCreateInfo { |
| flags: ash::vk::RenderPassCreateFlags::empty(), |
| attachment_count: attachments_vk.len() as u32, |
| p_attachments: if attachments_vk.is_empty() { |
| ptr::null() |
| } else { |
| attachments_vk.as_ptr() |
| }, |
| subpass_count: subpasses_vk.len() as u32, |
| p_subpasses: if subpasses_vk.is_empty() { |
| ptr::null() |
| } else { |
| subpasses_vk.as_ptr() |
| }, |
| dependency_count: dependencies_vk.len() as u32, |
| p_dependencies: if dependencies_vk.is_empty() { |
| ptr::null() |
| } else { |
| dependencies_vk.as_ptr() |
| }, |
| ..Default::default() |
| }; |
| |
| if let Some(input_attachment_aspect_create_info) = |
| input_attachment_aspect_create_info.as_mut() |
| { |
| input_attachment_aspect_create_info.p_next = create_info.p_next; |
| create_info.p_next = input_attachment_aspect_create_info as *const _ as *const _; |
| } |
| |
| if let Some(multiview_create_info) = multiview_create_info.as_mut() { |
| multiview_create_info.p_next = create_info.p_next; |
| create_info.p_next = multiview_create_info as *const _ as *const _; |
| } |
| |
| Ok({ |
| let fns = device.fns(); |
| let mut output = MaybeUninit::uninit(); |
| (fns.v1_0.create_render_pass)( |
| device.handle(), |
| &create_info, |
| ptr::null(), |
| output.as_mut_ptr(), |
| ) |
| .result() |
| .map_err(VulkanError::from)?; |
| output.assume_init() |
| }) |
| } |
| } |
| |
| /// Error that can happen when creating a `RenderPass`. |
| #[derive(Clone, Debug, PartialEq, Eq)] |
| pub enum RenderPassCreationError { |
| /// Not enough memory. |
| OomError(OomError), |
| |
| RequirementNotMet { |
| required_for: &'static str, |
| requires_one_of: RequiresOneOf, |
| }, |
| |
| /// An attachment is first used in the render pass with a read-only layout or as an input |
| /// attachment, but its `load_op` or `stencil_load_op` is [`LoadOp::Clear`]. |
| AttachmentFirstUseLoadOpInvalid { |
| attachment: u32, |
| first_use_subpass: u32, |
| }, |
| |
| /// An attachment has an `initial_layout` or `final_layout` value that is invalid for the |
| /// provided `format`. |
| AttachmentLayoutInvalid { attachment: u32 }, |
| |
| /// Correlated view masks were included, but multiview is not enabled on the render pass. |
| CorrelatedViewMasksMultiviewNotEnabled, |
| |
| /// The provided correlated view masks contain a bit that is set in more than one element. |
| CorrelatedViewMasksOverlapping, |
| |
| /// A subpass dependency specified an access type that was not supported by the given stages. |
| DependencyAccessNotSupportedByStages { dependency: u32 }, |
| |
| /// A subpass dependency has both `src_subpass` and `dst_subpass` set to `None`. |
| DependencyBothSubpassesExternal { dependency: u32 }, |
| |
| /// A subpass dependency specifies a subpass self-dependency and includes framebuffer stages in |
| /// both `src_stages` and `dst_stages`, but the `by_region` dependency was not enabled. |
| DependencySelfDependencyFramebufferStagesWithoutByRegion { dependency: u32 }, |
| |
| /// A subpass dependency specifies a subpass self-dependency and includes |
| /// non-framebuffer stages, but the latest stage in `src_stages` is after the earliest stage |
| /// in `dst_stages`. |
| DependencySelfDependencySourceStageAfterDestinationStage { dependency: u32 }, |
| |
| /// A subpass dependency specifies a subpass self-dependency and has the `view_local` dependency |
| /// enabled, but the inner offset value was not 0. |
| DependencySelfDependencyViewLocalNonzeroViewOffset { dependency: u32 }, |
| |
| /// A subpass dependency specifies a subpass self-dependency without the `view_local` |
| /// dependency, but the referenced subpass has more than one bit set in its `view_mask`. |
| DependencySelfDependencyViewMaskMultiple { dependency: u32, subpass: u32 }, |
| |
| /// A subpass dependency has a `src_subpass` that is later than the `dst_subpass`. |
| DependencySourceSubpassAfterDestinationSubpass { dependency: u32 }, |
| |
| /// A subpass dependency has a bit set in the `src_stages` or `dst_stages` that is |
| /// not supported for graphics pipelines. |
| DependencyStageNotSupported { dependency: u32 }, |
| |
| /// A subpass index in a subpass dependency is not less than the number of subpasses in the |
| /// render pass. |
| DependencySubpassOutOfRange { dependency: u32, subpass: u32 }, |
| |
| /// In a subpass dependency, `dependency_flags` contains [`VIEW_LOCAL`], but `src_subpass` or |
| /// `dst_subpass` were set to `None`. |
| /// |
| /// [`VIEW_LOCAL`]: crate::sync::DependencyFlags::VIEW_LOCAL |
| DependencyViewLocalExternalDependency { dependency: u32 }, |
| |
| /// In a subpass dependency, `dependency_flags` contains [`VIEW_LOCAL`], but multiview is not |
| /// enabled on the render pass. |
| /// |
| /// [`VIEW_LOCAL`]: crate::sync::DependencyFlags::VIEW_LOCAL |
| DependencyViewLocalMultiviewNotEnabled { dependency: u32 }, |
| |
| /// In a subpass dependency, `view_offset` is not zero, but `dependency_flags` does not contain |
| /// [`VIEW_LOCAL`]. |
| /// |
| /// [`VIEW_LOCAL`]: crate::sync::DependencyFlags::VIEW_LOCAL |
| DependencyViewOffzetNonzeroWithoutViewLocal { dependency: u32 }, |
| |
| /// A reference to an attachment used other than as an input attachment in a subpass has |
| /// one or more aspects selected. |
| SubpassAttachmentAspectsNotEmpty { subpass: u32, attachment: u32 }, |
| |
| /// An attachment used as an attachment in a subpass has a layout that is not supported for |
| /// that usage. |
| SubpassAttachmentLayoutInvalid { |
| subpass: u32, |
| attachment: u32, |
| usage: &'static str, |
| }, |
| |
| /// The layouts of all uses of an attachment in a subpass do not match. |
| SubpassAttachmentLayoutMismatch { subpass: u32, attachment: u32 }, |
| |
| /// An attachment index in a subpass is not less than the number of attachments in the render |
| /// pass. |
| SubpassAttachmentOutOfRange { subpass: u32, attachment: u32 }, |
| |
| /// An attachment is used as both a color attachment and a depth/stencil attachment in a |
| /// subpass. |
| SubpassAttachmentUsageColorDepthStencil { subpass: u32, attachment: u32 }, |
| |
| /// An attachment used as an attachment in a subpass has a format that does not support that |
| /// usage. |
| SubpassAttachmentFormatUsageNotSupported { |
| subpass: u32, |
| attachment: u32, |
| usage: &'static str, |
| }, |
| |
| /// An attachment used as a color attachment in a subpass with resolve attachments has a |
| /// `samples` value of [`SampleCount::Sample1`]. |
| SubpassColorAttachmentWithResolveNotMultisampled { subpass: u32, attachment: u32 }, |
| |
| /// An attachment used as a color or depth/stencil attachment in a subpass has a `samples` value |
| /// that is different from the first color attachment. |
| SubpassColorDepthStencilAttachmentSamplesMismatch { |
| subpass: u32, |
| attachment: u32, |
| samples: SampleCount, |
| first_samples: SampleCount, |
| }, |
| |
| /// A reference to an attachment used as an input attachment in a subpass selects aspects that |
| /// are not present in the format of the attachment. |
| SubpassInputAttachmentAspectsNotCompatible { subpass: u32, attachment: u32 }, |
| |
| /// The `max_color_attachments` limit has been exceeded for a subpass. |
| SubpassMaxColorAttachmentsExceeded { |
| subpass: u32, |
| color_attachment_count: u32, |
| max: u32, |
| }, |
| |
| /// The `max_multiview_view_count` limit has been exceeded for a subpass. |
| SubpassMaxMultiviewViewCountExceeded { |
| subpass: u32, |
| view_count: u32, |
| max: u32, |
| }, |
| |
| /// The multiview state (whether `view_mask` is nonzero) of a subpass is different from the |
| /// first subpass. |
| SubpassMultiviewMismatch { |
| subpass: u32, |
| multiview: bool, |
| first_subpass_multiview: bool, |
| }, |
| |
| /// An attachment marked as a preserve attachment in a subpass is also used as an attachment |
| /// in that subpass. |
| SubpassPreserveAttachmentUsedElsewhere { subpass: u32, attachment: u32 }, |
| |
| /// The `resolve_attachments` field of a subpass was not empty, but its length did not match |
| /// the length of `color_attachments`. |
| SubpassResolveAttachmentsColorAttachmentsLenMismatch { subpass: u32 }, |
| |
| /// An attachment used as a resolve attachment in a subpass has a `format` value different from |
| /// the corresponding color attachment. |
| SubpassResolveAttachmentFormatMismatch { |
| subpass: u32, |
| resolve_attachment: u32, |
| color_attachment: u32, |
| }, |
| |
| /// An attachment used as a resolve attachment in a subpass has a `samples` value other than |
| /// [`SampleCount::Sample1`]. |
| SubpassResolveAttachmentMultisampled { subpass: u32, attachment: u32 }, |
| |
| /// A resolve attachment in a subpass is `Some`, but the corresponding color attachment is |
| /// `None`. |
| SubpassResolveAttachmentWithoutColorAttachment { subpass: u32 }, |
| } |
| |
| impl Error for RenderPassCreationError { |
| fn source(&self) -> Option<&(dyn Error + 'static)> { |
| match self { |
| RenderPassCreationError::OomError(err) => Some(err), |
| _ => None, |
| } |
| } |
| } |
| |
| impl Display for RenderPassCreationError { |
| fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> { |
| match self { |
| Self::OomError(_) => write!(f, "not enough memory available"), |
| Self::RequirementNotMet { |
| required_for, |
| requires_one_of, |
| } => write!( |
| f, |
| "a requirement was not met for: {}; requires one of: {}", |
| required_for, requires_one_of, |
| ), |
| Self::AttachmentFirstUseLoadOpInvalid { |
| attachment, |
| first_use_subpass, |
| } => write!( |
| f, |
| "attachment {} is first used in the render pass in subpass {} with a read-only \ |
| layout or as an input attachment, but its `load_op` or `stencil_load_op` is \ |
| `LoadOp::Clear`", |
| attachment, first_use_subpass, |
| ), |
| Self::AttachmentLayoutInvalid { attachment } => write!( |
| f, |
| "attachment {} has an `initial_layout` or `final_layout` value that is invalid for \ |
| the provided `format`", |
| attachment, |
| ), |
| Self::CorrelatedViewMasksMultiviewNotEnabled => write!( |
| f, |
| "correlated view masks were included, but multiview is not enabled on the render \ |
| pass", |
| ), |
| Self::CorrelatedViewMasksOverlapping => write!( |
| f, |
| "the provided correlated view masks contain a bit that is set in more than one \ |
| element", |
| ), |
| Self::DependencyAccessNotSupportedByStages { dependency } => write!( |
| f, |
| "subpass dependency {} specified an access type that was not supported by the \ |
| given stages", |
| dependency, |
| ), |
| Self::DependencySelfDependencyFramebufferStagesWithoutByRegion { dependency } => { |
| write!( |
| f, |
| "subpass dependency {} specifies a subpass self-dependency and includes \ |
| framebuffer stages in both `src_stages` and `dst_stages`, but the \ |
| `by_region` dependency was not enabled", |
| dependency, |
| ) |
| } |
| Self::DependencySelfDependencySourceStageAfterDestinationStage { dependency } => { |
| write!( |
| f, |
| "subpass dependency {} specifies a subpass self-dependency and includes \ |
| non-framebuffer stages, but the latest stage in `src_stages` is after the \ |
| earliest stage in `dst_stages`", |
| dependency, |
| ) |
| } |
| Self::DependencySelfDependencyViewLocalNonzeroViewOffset { dependency } => write!( |
| f, |
| "subpass dependency {} specifies a subpass self-dependency and has the \ |
| `view_local` dependency enabled, but the inner offset value was not 0", |
| dependency, |
| ), |
| Self::DependencySelfDependencyViewMaskMultiple { |
| dependency, |
| subpass, |
| } => write!( |
| f, |
| "subpass dependency {} specifies a subpass self-dependency without the \ |
| `view_local` dependency, but the referenced subpass {} has more than one bit set \ |
| in its `view_mask`", |
| dependency, subpass, |
| ), |
| Self::DependencySourceSubpassAfterDestinationSubpass { dependency } => write!( |
| f, |
| "subpass dependency {} has a `src_subpass` that is later than the \ |
| `dst_subpass`", |
| dependency, |
| ), |
| Self::DependencyStageNotSupported { dependency } => write!( |
| f, |
| "subpass dependency {} has a bit set in the `src_stages` or \ |
| `dst_stages` that is not supported for graphics pipelines", |
| dependency, |
| ), |
| Self::DependencyBothSubpassesExternal { dependency } => write!( |
| f, |
| "subpass dependency {} has both `src_subpass` and `dst_subpass` set to \ |
| `None`", |
| dependency, |
| ), |
| Self::DependencySubpassOutOfRange { |
| dependency, |
| subpass, |
| } => write!( |
| f, |
| "the subpass index {} in subpass dependency {} is not less than the number of \ |
| subpasses in the render pass", |
| subpass, dependency, |
| ), |
| Self::DependencyViewLocalExternalDependency { dependency } => write!( |
| f, |
| "in subpass dependency {}, `dependency_flags` contains `VIEW_LOCAL`, but \ |
| `src_subpass` or `dst_subpass` were set to `None`", |
| dependency, |
| ), |
| Self::DependencyViewLocalMultiviewNotEnabled { dependency } => write!( |
| f, |
| "in subpass dependency {}, `dependency_flags` contains `VIEW_LOCAL`, but \ |
| multiview is not enabled on the render pass", |
| dependency, |
| ), |
| Self::DependencyViewOffzetNonzeroWithoutViewLocal { dependency } => write!( |
| f, |
| "in subpass dependency {}, `view_offset` is not zero, but `dependency_flags` does \ |
| not contain `VIEW_LOCAL`", |
| dependency, |
| ), |
| Self::SubpassAttachmentAspectsNotEmpty { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "a reference to attachment {} used other than as an input attachment in subpass {} \ |
| has one or more aspects selected", |
| attachment, subpass, |
| ), |
| Self::SubpassAttachmentLayoutMismatch { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "the layouts of all uses of attachment {} in subpass {} do not match.", |
| attachment, subpass, |
| ), |
| Self::SubpassAttachmentLayoutInvalid { |
| subpass, |
| attachment, |
| usage, |
| } => write!( |
| f, |
| "attachment {} used as {} attachment in subpass {} has a layout that is not \ |
| supported for that usage", |
| attachment, usage, subpass, |
| ), |
| Self::SubpassAttachmentOutOfRange { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "the attachment index {} in subpass {} is not less than the number of attachments \ |
| in the render pass", |
| attachment, subpass, |
| ), |
| Self::SubpassAttachmentUsageColorDepthStencil { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "attachment {} is used as both a color attachment and a depth/stencil attachment \ |
| in subpass {}", |
| attachment, subpass, |
| ), |
| Self::SubpassAttachmentFormatUsageNotSupported { |
| subpass, |
| attachment, |
| usage, |
| } => write!( |
| f, |
| "attachment {} used as {} attachment in subpass {} has a format that does not \ |
| support that usage", |
| attachment, usage, subpass, |
| ), |
| Self::SubpassColorAttachmentWithResolveNotMultisampled { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "attachment {} used as a color attachment in subpass {} with resolve attachments \ |
| has a `samples` value of `SampleCount::Sample1`", |
| attachment, subpass, |
| ), |
| Self::SubpassColorDepthStencilAttachmentSamplesMismatch { |
| subpass, |
| attachment, |
| samples, |
| first_samples, |
| } => write!( |
| f, |
| "attachment {} used as a color or depth/stencil attachment in subpass {} has a \ |
| `samples` value {:?} that is different from the first color attachment ({:?})", |
| attachment, subpass, samples, first_samples, |
| ), |
| Self::SubpassInputAttachmentAspectsNotCompatible { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "a reference to attachment {} used as an input attachment in subpass {} selects \ |
| aspects that are not present in the format of the attachment", |
| attachment, subpass, |
| ), |
| Self::SubpassMaxColorAttachmentsExceeded { .. } => { |
| write!(f, "the `max_color_attachments` limit has been exceeded") |
| } |
| Self::SubpassMaxMultiviewViewCountExceeded { .. } => write!( |
| f, |
| "the `max_multiview_view_count` limit has been exceeded for a subpass", |
| ), |
| Self::SubpassMultiviewMismatch { |
| subpass, |
| multiview, |
| first_subpass_multiview, |
| } => write!( |
| f, |
| "the multiview state (whether `view_mask` is nonzero) of subpass {} is {}, which \ |
| is different from the first subpass ({})", |
| subpass, multiview, first_subpass_multiview, |
| ), |
| Self::SubpassPreserveAttachmentUsedElsewhere { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "attachment {} marked as a preserve attachment in subpass {} is also used as an \ |
| attachment in that subpass", |
| attachment, subpass, |
| ), |
| Self::SubpassResolveAttachmentsColorAttachmentsLenMismatch { subpass } => write!( |
| f, |
| "the `resolve_attachments` field of subpass {} was not empty, but its length did \ |
| not match the length of `color_attachments`", |
| subpass, |
| ), |
| Self::SubpassResolveAttachmentFormatMismatch { |
| subpass, |
| resolve_attachment, |
| color_attachment, |
| } => write!( |
| f, |
| "attachment {} used as a resolve attachment in subpass {} has a `format` value \ |
| different from the corresponding color attachment {}", |
| subpass, resolve_attachment, color_attachment, |
| ), |
| Self::SubpassResolveAttachmentMultisampled { |
| subpass, |
| attachment, |
| } => write!( |
| f, |
| "attachment {} used as a resolve attachment in subpass {} has a `samples` value \ |
| other than `SampleCount::Sample1`", |
| attachment, subpass, |
| ), |
| Self::SubpassResolveAttachmentWithoutColorAttachment { subpass } => write!( |
| f, |
| "a resolve attachment in subpass {} is `Some`, but the corresponding color \ |
| attachment is `None`", |
| subpass, |
| ), |
| } |
| } |
| } |
| |
| impl From<OomError> for RenderPassCreationError { |
| fn from(err: OomError) -> RenderPassCreationError { |
| RenderPassCreationError::OomError(err) |
| } |
| } |
| |
| impl From<VulkanError> for RenderPassCreationError { |
| fn from(err: VulkanError) -> RenderPassCreationError { |
| match err { |
| err @ VulkanError::OutOfHostMemory => { |
| RenderPassCreationError::OomError(OomError::from(err)) |
| } |
| err @ VulkanError::OutOfDeviceMemory => { |
| RenderPassCreationError::OomError(OomError::from(err)) |
| } |
| _ => panic!("unexpected error: {:?}", err), |
| } |
| } |
| } |
| |
| impl From<RequirementNotMet> for RenderPassCreationError { |
| fn from(err: RequirementNotMet) -> Self { |
| Self::RequirementNotMet { |
| required_for: err.required_for, |
| requires_one_of: err.requires_one_of, |
| } |
| } |
| } |
