From c0379fce9674c6cfcb90a28d49eaba074743fa65 Mon Sep 17 00:00:00 2001 From: Rua Date: Wed, 9 Aug 2023 21:19:38 +0200 Subject: [PATCH] Remove remaining old error types, other cleanup (#2281) * Remove remaining old error types, other cleanup * Fix * Add and fix or_fun_call lints * Update vulkano/src/query.rs Co-authored-by: marc0246 <40955683+marc0246@users.noreply.github.com> * Fix slightly borked context messages --------- Co-authored-by: marc0246 <40955683+marc0246@users.noreply.github.com> --- vulkano-shaders/src/structs.rs | 5 +- vulkano/autogen/formats.rs | 15 +- vulkano/src/acceleration_structure.rs | 106 +++---- vulkano/src/buffer/mod.rs | 21 +- vulkano/src/buffer/subbuffer.rs | 24 +- vulkano/src/buffer/sys.rs | 29 +- vulkano/src/buffer/view.rs | 11 +- .../src/command_buffer/commands/bind_push.rs | 14 +- vulkano/src/command_buffer/commands/clear.rs | 22 +- vulkano/src/command_buffer/commands/copy.rs | 99 +++---- .../command_buffer/commands/dynamic_state.rs | 138 ++++----- .../src/command_buffer/commands/pipeline.rs | 216 +++++++------- vulkano/src/command_buffer/commands/query.rs | 22 +- .../command_buffer/commands/render_pass.rs | 164 +++++------ .../src/command_buffer/commands/secondary.rs | 43 +-- vulkano/src/command_buffer/commands/sync.rs | 11 +- vulkano/src/command_buffer/mod.rs | 48 ++- vulkano/src/command_buffer/pool.rs | 22 +- vulkano/src/descriptor_set/layout.rs | 47 ++- vulkano/src/descriptor_set/pool.rs | 22 +- vulkano/src/device/mod.rs | 75 +++-- vulkano/src/device/physical.rs | 33 ++- vulkano/src/device/queue.rs | 8 +- vulkano/src/image/mod.rs | 115 +++----- vulkano/src/image/sampler/mod.rs | 106 +++---- vulkano/src/image/sampler/ycbcr.rs | 57 ++-- vulkano/src/image/sys.rs | 124 ++++---- vulkano/src/image/view.rs | 33 +-- vulkano/src/instance/debug.rs | 15 +- vulkano/src/instance/mod.rs | 37 ++- vulkano/src/lib.rs | 52 +--- vulkano/src/library.rs | 6 +- vulkano/src/macros.rs | 48 +-- vulkano/src/memory/allocator/mod.rs | 5 +- vulkano/src/memory/device_memory.rs | 57 ++-- vulkano/src/pipeline/cache.rs | 11 +- vulkano/src/pipeline/compute.rs | 33 +-- vulkano/src/pipeline/graphics/color_blend.rs | 81 +++--- .../src/pipeline/graphics/depth_stencil.rs | 69 ++--- .../pipeline/graphics/discard_rectangle.rs | 8 +- .../src/pipeline/graphics/input_assembly.rs | 20 +- vulkano/src/pipeline/graphics/mod.rs | 21 +- vulkano/src/pipeline/graphics/multisample.rs | 8 +- .../src/pipeline/graphics/rasterization.rs | 41 +-- vulkano/src/pipeline/graphics/subpass.rs | 33 +-- vulkano/src/pipeline/graphics/tessellation.rs | 14 +- .../src/pipeline/graphics/vertex_input/mod.rs | 29 +- vulkano/src/pipeline/layout.rs | 22 +- vulkano/src/pipeline/mod.rs | 22 +- vulkano/src/query.rs | 70 +++-- vulkano/src/render_pass/framebuffer.rs | 11 +- vulkano/src/render_pass/mod.rs | 274 +++++++----------- vulkano/src/swapchain/acquire_present.rs | 13 +- vulkano/src/swapchain/display.rs | 17 +- vulkano/src/swapchain/mod.rs | 180 ++++++------ vulkano/src/swapchain/surface.rs | 7 +- vulkano/src/sync/event.rs | 11 +- vulkano/src/sync/fence.rs | 95 +++--- vulkano/src/sync/future/fence_signal.rs | 15 +- vulkano/src/sync/future/semaphore_signal.rs | 15 +- vulkano/src/sync/mod.rs | 2 +- vulkano/src/sync/pipeline.rs | 143 ++++----- vulkano/src/sync/semaphore.rs | 117 +++----- 63 files changed, 1323 insertions(+), 1909 deletions(-) diff --git a/vulkano-shaders/src/structs.rs b/vulkano-shaders/src/structs.rs index e6f7b6a5..4251c530 100644 --- a/vulkano-shaders/src/structs.rs +++ b/vulkano-shaders/src/structs.rs @@ -817,10 +817,7 @@ impl TypeStruct { members.push(Member { ident, ty, offset }); } - Ok(TypeStruct { - ident, - members, - }) + Ok(TypeStruct { ident, members }) } fn size(&self) -> Option { diff --git a/vulkano/autogen/formats.rs b/vulkano/autogen/formats.rs index b4e17049..a0dad3a6 100644 --- a/vulkano/autogen/formats.rs +++ b/vulkano/autogen/formats.rs @@ -291,7 +291,7 @@ fn formats_output(members: &[FormatMember]) -> TokenStream { let ident = format_ident!("{}", ext_name); quote! { instance_extensions.#ident } })); - let required_for = format!("`Format::{}`", name); + let required_for = format!("is `Format::{}`", name); let requires_one_of_items = (api_version.iter().map(|(major, minor)| { let version = format_ident!("V{}_{}", major, minor); quote! { @@ -317,12 +317,13 @@ fn formats_output(members: &[FormatMember]) -> TokenStream { quote! { if !(#(#condition_items)||*) { - return Err(crate::RequirementNotMet { - required_for: #required_for, + return Err(Box::new(crate::ValidationError { + problem: #required_for.into(), requires_one_of: crate::RequiresOneOf(&[ #(#requires_one_of_items)* ]), - }); + ..Default::default() + })); } } }, @@ -482,7 +483,7 @@ fn formats_output(members: &[FormatMember]) -> TokenStream { pub(crate) fn validate_device( self, #[allow(unused_variables)] device: &crate::device::Device, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( device.api_version(), device.enabled_features(), @@ -495,7 +496,7 @@ fn formats_output(members: &[FormatMember]) -> TokenStream { pub(crate) fn validate_physical_device( self, #[allow(unused_variables)] physical_device: &crate::device::physical::PhysicalDevice, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( physical_device.api_version(), physical_device.supported_features(), @@ -511,7 +512,7 @@ fn formats_output(members: &[FormatMember]) -> TokenStream { #[allow(unused_variables)] device_features: &crate::device::Features, #[allow(unused_variables)] device_extensions: &crate::device::DeviceExtensions, #[allow(unused_variables)] instance_extensions: &crate::instance::InstanceExtensions, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { match self { #(#validate_device_items)* } diff --git a/vulkano/src/acceleration_structure.rs b/vulkano/src/acceleration_structure.rs index bc60d9ae..8bb91b29 100644 --- a/vulkano/src/acceleration_structure.rs +++ b/vulkano/src/acceleration_structure.rs @@ -378,18 +378,14 @@ impl AccelerationStructureCreateInfo { _ne: _, } = self; - create_flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "create_flags".into(), - vuids: &["VUID-VkAccelerationStructureCreateInfoKHR-createFlags-parameter"], - ..ValidationError::from_requirement(err) - })?; + create_flags.validate_device(device).map_err(|err| { + err.add_context("create_flags") + .set_vuids(&["VUID-VkAccelerationStructureCreateInfoKHR-createFlags-parameter"]) + })?; - ty.validate_device(device).map_err(|err| ValidationError { - context: "ty".into(), - vuids: &["VUID-VkAccelerationStructureCreateInfoKHR-type-parameter"], - ..ValidationError::from_requirement(err) + ty.validate_device(device).map_err(|err| { + err.add_context("ty") + .set_vuids(&["VUID-VkAccelerationStructureCreateInfoKHR-type-parameter"]) })?; if !buffer @@ -513,13 +509,10 @@ impl AccelerationStructureBuildGeometryInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkAccelerationStructureBuildGeometryInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkAccelerationStructureBuildGeometryInfoKHR-flags-parameter"]) + })?; let max_geometry_count = device .physical_device() @@ -1009,23 +1002,16 @@ impl AccelerationStructureGeometryTrianglesData { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"]) + })?; - vertex_format - .validate_device(device) - .map_err(|err| ValidationError { - context: "vertex_format".into(), - vuids: &[ - "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-vertexFormat-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + vertex_format.validate_device(device).map_err(|err| { + err.add_context("vertex_format").set_vuids(&[ + "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-vertexFormat-parameter", + ]) + })?; if unsafe { !device @@ -1127,13 +1113,10 @@ impl AccelerationStructureGeometryAabbsData { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"]) + })?; if stride % 8 != 0 { return Err(Box::new(ValidationError { @@ -1199,13 +1182,10 @@ impl AccelerationStructureGeometryInstancesData { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkAccelerationStructureGeometryKHR-flags-parameter"]) + })?; Ok(()) } @@ -1402,12 +1382,10 @@ impl CopyAccelerationStructureInfo { assert_eq!(device, src.device().as_ref()); assert_eq!(device, dst.device().as_ref()); - mode.validate_device(device) - .map_err(|err| ValidationError { - context: "mode".into(), - vuids: &["VUID-VkCopyAccelerationStructureInfoKHR-mode-parameter"], - ..ValidationError::from_requirement(err) - })?; + mode.validate_device(device).map_err(|err| { + err.add_context("mode") + .set_vuids(&["VUID-VkCopyAccelerationStructureInfoKHR-mode-parameter"]) + })?; if !matches!( mode, @@ -1485,12 +1463,10 @@ impl CopyAccelerationStructureToMemoryInfo { assert_eq!(device, src.device().as_ref()); assert_eq!(device, dst.device().as_ref()); - mode.validate_device(device) - .map_err(|err| ValidationError { - context: "mode".into(), - vuids: &["VUID-VkCopyAccelerationStructureToMemoryInfoKHR-mode-parameter"], - ..ValidationError::from_requirement(err) - })?; + mode.validate_device(device).map_err(|err| { + err.add_context("mode") + .set_vuids(&["VUID-VkCopyAccelerationStructureToMemoryInfoKHR-mode-parameter"]) + })?; if !matches!(mode, CopyAccelerationStructureMode::Serialize) { return Err(Box::new(ValidationError { @@ -1555,12 +1531,10 @@ impl CopyMemoryToAccelerationStructureInfo { assert_eq!(device, src.device().as_ref()); assert_eq!(device, dst.device().as_ref()); - mode.validate_device(device) - .map_err(|err| ValidationError { - context: "mode".into(), - vuids: &["VUID-VkCopyMemoryToAccelerationStructureInfoKHR-mode-parameter"], - ..ValidationError::from_requirement(err) - })?; + mode.validate_device(device).map_err(|err| { + err.add_context("mode") + .set_vuids(&["VUID-VkCopyMemoryToAccelerationStructureInfoKHR-mode-parameter"]) + })?; if !matches!(mode, CopyAccelerationStructureMode::Deserialize) { return Err(Box::new(ValidationError { diff --git a/vulkano/src/buffer/mod.rs b/vulkano/src/buffer/mod.rs index 4d9552bd..a35912f5 100644 --- a/vulkano/src/buffer/mod.rs +++ b/vulkano/src/buffer/mod.rs @@ -912,18 +912,16 @@ impl ExternalBufferInfo { flags .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter"]) })?; usage .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter"]) })?; if usage.is_empty() { @@ -937,10 +935,9 @@ impl ExternalBufferInfo { handle_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter"]) })?; Ok(()) diff --git a/vulkano/src/buffer/subbuffer.rs b/vulkano/src/buffer/subbuffer.rs index 7f556622..06c0bc88 100644 --- a/vulkano/src/buffer/subbuffer.rs +++ b/vulkano/src/buffer/subbuffer.rs @@ -340,12 +340,12 @@ where }; } - let mapped_ptr = - self.mapped_ptr() - .ok_or(HostAccessError::ValidationError(ValidationError { - problem: "the memory of this subbuffer is not host-visible".into(), - ..Default::default() - }))?; + let mapped_ptr = self.mapped_ptr().ok_or_else(|| { + HostAccessError::ValidationError(Box::new(ValidationError { + problem: "the memory of this subbuffer is not host-visible".into(), + ..Default::default() + })) + })?; // SAFETY: `Subbuffer` guarantees that its contents are laid out correctly for `T`. let data = unsafe { &*T::from_ffi(mapped_ptr.as_ptr(), self.size as usize) }; @@ -415,12 +415,12 @@ where }; } - let mapped_ptr = - self.mapped_ptr() - .ok_or(HostAccessError::ValidationError(ValidationError { - problem: "the memory of this subbuffer is not host-visible".into(), - ..Default::default() - }))?; + let mapped_ptr = self.mapped_ptr().ok_or_else(|| { + HostAccessError::ValidationError(Box::new(ValidationError { + problem: "the memory of this subbuffer is not host-visible".into(), + ..Default::default() + })) + })?; // SAFETY: `Subbuffer` guarantees that its contents are laid out correctly for `T`. let data = unsafe { &mut *T::from_ffi(mapped_ptr.as_ptr(), self.size as usize) }; diff --git a/vulkano/src/buffer/sys.rs b/vulkano/src/buffer/sys.rs index cf457042..4e8001b1 100644 --- a/vulkano/src/buffer/sys.rs +++ b/vulkano/src/buffer/sys.rs @@ -674,21 +674,15 @@ impl BufferCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkBufferCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkBufferCreateInfo-flags-parameter"]) + })?; - usage - .validate_device(device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkBufferCreateInfo-usage-parameter"], - ..ValidationError::from_requirement(err) - })?; + usage.validate_device(device).map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkBufferCreateInfo-usage-parameter"]) + })?; if usage.is_empty() { return Err(Box::new(ValidationError { @@ -819,10 +813,9 @@ impl BufferCreateInfo { external_memory_handle_types .validate_device(device) - .map_err(|err| ValidationError { - context: "external_memory_handle_types".into(), - vuids: &["VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("external_memory_handle_types") + .set_vuids(&["VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter"]) })?; // TODO: diff --git a/vulkano/src/buffer/view.rs b/vulkano/src/buffer/view.rs index 1c6fd599..aed2fd35 100644 --- a/vulkano/src/buffer/view.rs +++ b/vulkano/src/buffer/view.rs @@ -439,13 +439,10 @@ impl BufferViewCreateInfo { pub(crate) fn validate(&self, device: &Device) -> Result<(), Box> { let Self { format, _ne: _ } = self; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkBufferViewCreateInfo-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkBufferViewCreateInfo-format-parameter"]) + })?; Ok(()) } diff --git a/vulkano/src/command_buffer/commands/bind_push.rs b/vulkano/src/command_buffer/commands/bind_push.rs index 93e9ee60..8e6a9e3b 100644 --- a/vulkano/src/command_buffer/commands/bind_push.rs +++ b/vulkano/src/command_buffer/commands/bind_push.rs @@ -482,10 +482,9 @@ where ) -> Result<(), Box> { pipeline_bind_point .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "pipeline_bind_point".into(), - vuids: &["VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("pipeline_bind_point") + .set_vuids(&["VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter"]) })?; let queue_family_properties = self.queue_family_properties(); @@ -1185,10 +1184,9 @@ where pipeline_bind_point .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "pipeline_bind_point".into(), - vuids: &["VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("pipeline_bind_point") + .set_vuids(&["VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter"]) })?; let queue_family_properties = self.queue_family_properties(); diff --git a/vulkano/src/command_buffer/commands/clear.rs b/vulkano/src/command_buffer/commands/clear.rs index 9d497cbd..a9443e31 100644 --- a/vulkano/src/command_buffer/commands/clear.rs +++ b/vulkano/src/command_buffer/commands/clear.rs @@ -703,13 +703,10 @@ impl ClearColorImageInfo { _ne: _, } = self; - image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_layout".into(), - vuids: &["VUID-vkCmdClearColorImage-imageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_layout.validate_device(device).map_err(|err| { + err.add_context("image_layout") + .set_vuids(&["VUID-vkCmdClearColorImage-imageLayout-parameter"]) + })?; // VUID-vkCmdClearColorImage-commonparent assert_eq!(device, image.device().as_ref()); @@ -885,13 +882,10 @@ impl ClearDepthStencilImageInfo { _ne: _, } = self; - image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_layout".into(), - vuids: &["VUID-vkCmdClearDepthStencilImage-imageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_layout.validate_device(device).map_err(|err| { + err.add_context("image_layout") + .set_vuids(&["VUID-vkCmdClearDepthStencilImage-imageLayout-parameter"]) + })?; // VUID-vkCmdClearDepthStencilImage-commonparent assert_eq!(device, image.device().as_ref()); diff --git a/vulkano/src/command_buffer/commands/copy.rs b/vulkano/src/command_buffer/commands/copy.rs index d7459672..ca41e377 100644 --- a/vulkano/src/command_buffer/commands/copy.rs +++ b/vulkano/src/command_buffer/commands/copy.rs @@ -2514,21 +2514,15 @@ impl CopyImageInfo { _ne: _, } = self; - src_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_image_layout".into(), - vuids: &["VUID-VkCopyImageInfo2-srcImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_image_layout.validate_device(device).map_err(|err| { + err.add_context("src_image_layout") + .set_vuids(&["VUID-VkCopyImageInfo2-srcImageLayout-parameter"]) + })?; - dst_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_image_layout".into(), - vuids: &["VUID-VkCopyImageInfo2-dstImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_image_layout.validate_device(device).map_err(|err| { + err.add_context("dst_image_layout") + .set_vuids(&["VUID-VkCopyImageInfo2-dstImageLayout-parameter"]) + })?; // VUID-VkCopyImageInfo2-commonparent assert_eq!(device, src_image.device().as_ref()); @@ -3878,13 +3872,10 @@ impl CopyBufferToImageInfo { _ne: _, } = self; - dst_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_image_layout".into(), - vuids: &["VUID-VkCopyBufferToImageInfo2-dstImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_image_layout.validate_device(device).map_err(|err| { + err.add_context("dst_image_layout") + .set_vuids(&["VUID-VkCopyBufferToImageInfo2-dstImageLayout-parameter"]) + })?; // VUID-VkCopyBufferToImageInfo2-commonparent assert_eq!(device, src_buffer.device().as_ref()); @@ -4490,13 +4481,10 @@ impl CopyImageToBufferInfo { _ne: _, } = self; - src_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_image_layout".into(), - vuids: &["VUID-VkCopyImageToBufferInfo2-srcImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_image_layout.validate_device(device).map_err(|err| { + err.add_context("src_image_layout") + .set_vuids(&["VUID-VkCopyImageToBufferInfo2-srcImageLayout-parameter"]) + })?; // VUID-VkCopyImageToBufferInfo2-commonparent assert_eq!(device, src_image.device().as_ref()); @@ -5308,29 +5296,20 @@ impl BlitImageInfo { _ne: _, } = self; - src_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_image_layout".into(), - vuids: &["VUID-VkBlitImageInfo2-srcImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_image_layout.validate_device(device).map_err(|err| { + err.add_context("src_image_layout") + .set_vuids(&["VUID-VkBlitImageInfo2-srcImageLayout-parameter"]) + })?; - dst_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_image_layout".into(), - vuids: &["VUID-VkBlitImageInfo2-dstImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_image_layout.validate_device(device).map_err(|err| { + err.add_context("dst_image_layout") + .set_vuids(&["VUID-VkBlitImageInfo2-dstImageLayout-parameter"]) + })?; - filter - .validate_device(device) - .map_err(|err| ValidationError { - context: "filter".into(), - vuids: &["VUID-VkBlitImageInfo2-filter-parameter"], - ..ValidationError::from_requirement(err) - })?; + filter.validate_device(device).map_err(|err| { + err.add_context("filter") + .set_vuids(&["VUID-VkBlitImageInfo2-filter-parameter"]) + })?; // VUID-VkBlitImageInfo2-commonparent assert_eq!(device, src_image.device().as_ref()); @@ -6221,21 +6200,15 @@ impl ResolveImageInfo { _ne: _, } = self; - src_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_image_layout".into(), - vuids: &["VUID-VkResolveImageInfo2-srcImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_image_layout.validate_device(device).map_err(|err| { + err.add_context("src_image_layout") + .set_vuids(&["VUID-VkResolveImageInfo2-srcImageLayout-parameter"]) + })?; - dst_image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_image_layout".into(), - vuids: &["VUID-VkResolveImageInfo2-dstImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_image_layout.validate_device(device).map_err(|err| { + err.add_context("dst_image_layout") + .set_vuids(&["VUID-VkResolveImageInfo2-dstImageLayout-parameter"]) + })?; // VUID-VkResolveImageInfo2-commonparent assert_eq!(device, src_image.device().as_ref()); diff --git a/vulkano/src/command_buffer/commands/dynamic_state.rs b/vulkano/src/command_buffer/commands/dynamic_state.rs index a6eb7678..6b267a92 100644 --- a/vulkano/src/command_buffer/commands/dynamic_state.rs +++ b/vulkano/src/command_buffer/commands/dynamic_state.rs @@ -1312,13 +1312,10 @@ where })); } - cull_mode - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "cull_mode".into(), - vuids: &["VUID-vkCmdSetCullMode-cullMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + cull_mode.validate_device(self.device()).map_err(|err| { + err.add_context("cull_mode") + .set_vuids(&["VUID-vkCmdSetCullMode-cullMode-parameter"]) + })?; Ok(()) } @@ -1611,13 +1608,10 @@ where })); } - compare_op - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "compare_op".into(), - vuids: &["VUID-vkCmdSetDepthCompareOp-depthCompareOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + compare_op.validate_device(self.device()).map_err(|err| { + err.add_context("compare_op") + .set_vuids(&["VUID-vkCmdSetDepthCompareOp-depthCompareOp-parameter"]) + })?; Ok(()) } @@ -1863,12 +1857,10 @@ where })); } - face.validate_device(self.device()) - .map_err(|err| ValidationError { - context: "face".into(), - vuids: &["VUID-vkCmdSetFrontFace-frontFace-parameter"], - ..ValidationError::from_requirement(err) - })?; + face.validate_device(self.device()).map_err(|err| { + err.add_context("face") + .set_vuids(&["VUID-vkCmdSetFrontFace-frontFace-parameter"]) + })?; Ok(()) } @@ -2028,13 +2020,10 @@ where })); } - logic_op - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "logic_op".into(), - vuids: &["VUID-vkCmdSetLogicOpEXT-logicOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + logic_op.validate_device(self.device()).map_err(|err| { + err.add_context("logic_op") + .set_vuids(&["VUID-vkCmdSetLogicOpEXT-logicOp-parameter"]) + })?; Ok(()) } @@ -2214,13 +2203,10 @@ where })); } - topology - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "topology".into(), - vuids: &["VUID-vkCmdSetPrimitiveTopology-primitiveTopology-parameter"], - ..ValidationError::from_requirement(err) - })?; + topology.validate_device(self.device()).map_err(|err| { + err.add_context("topology") + .set_vuids(&["VUID-vkCmdSetPrimitiveTopology-primitiveTopology-parameter"]) + })?; // VUID? // Since these requirements exist for fixed state when creating the pipeline, @@ -2561,13 +2547,10 @@ where })); } - faces - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "faces".into(), - vuids: &["VUID-vkCmdSetStencilCompareMask-faceMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + faces.validate_device(self.device()).map_err(|err| { + err.add_context("faces") + .set_vuids(&["VUID-vkCmdSetStencilCompareMask-faceMask-parameter"]) + })?; Ok(()) } @@ -2632,45 +2615,32 @@ where })); } - faces - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "faces".into(), - vuids: &["VUID-vkCmdSetStencilOp-faceMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + faces.validate_device(self.device()).map_err(|err| { + err.add_context("faces") + .set_vuids(&["VUID-vkCmdSetStencilOp-faceMask-parameter"]) + })?; - fail_op - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "fail_op".into(), - vuids: &["VUID-vkCmdSetStencilOp-failOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + fail_op.validate_device(self.device()).map_err(|err| { + err.add_context("fail_op") + .set_vuids(&["VUID-vkCmdSetStencilOp-failOp-parameter"]) + })?; - pass_op - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "pass_op".into(), - vuids: &["VUID-vkCmdSetStencilOp-passOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + pass_op.validate_device(self.device()).map_err(|err| { + err.add_context("pass_op") + .set_vuids(&["VUID-vkCmdSetStencilOp-passOp-parameter"]) + })?; depth_fail_op .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "depth_fail_op".into(), - vuids: &["VUID-vkCmdSetStencilOp-depthFailOp-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("depth_fail_op") + .set_vuids(&["VUID-vkCmdSetStencilOp-depthFailOp-parameter"]) })?; - compare_op - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "compare_op".into(), - vuids: &["VUID-vkCmdSetStencilOp-compareOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + compare_op.validate_device(self.device()).map_err(|err| { + err.add_context("compare_op") + .set_vuids(&["VUID-vkCmdSetStencilOp-compareOp-parameter"]) + })?; Ok(()) } @@ -2738,13 +2708,10 @@ where })); } - faces - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "faces".into(), - vuids: &["VUID-vkCmdSetStencilReference-faceMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + faces.validate_device(self.device()).map_err(|err| { + err.add_context("faces") + .set_vuids(&["VUID-vkCmdSetStencilReference-faceMask-parameter"]) + })?; Ok(()) } @@ -2844,13 +2811,10 @@ where })); } - faces - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "faces".into(), - vuids: &["VUID-vkCmdSetStencilWriteMask-faceMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + faces.validate_device(self.device()).map_err(|err| { + err.add_context("faces") + .set_vuids(&["VUID-vkCmdSetStencilWriteMask-faceMask-parameter"]) + })?; Ok(()) } diff --git a/vulkano/src/command_buffer/commands/pipeline.rs b/vulkano/src/command_buffer/commands/pipeline.rs index 22363be0..721c1eba 100644 --- a/vulkano/src/command_buffer/commands/pipeline.rs +++ b/vulkano/src/command_buffer/commands/pipeline.rs @@ -83,11 +83,13 @@ where .builder_state .pipeline_compute .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no compute pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDispatch-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no compute pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDispatch-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::Dispatch; @@ -153,11 +155,13 @@ where .builder_state .pipeline_compute .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no compute pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDispatchIndirect-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no compute pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDispatchIndirect-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::DispatchIndirect; @@ -229,25 +233,25 @@ where self.inner .validate_draw(vertex_count, instance_count, first_vertex, first_instance)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdDraw-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdDraw-renderpass"], + ..Default::default() + }) + })?; let pipeline = self .builder_state .pipeline_graphics .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no graphics pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDraw-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no graphics pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDraw-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::Draw; @@ -406,25 +410,25 @@ where self.inner .validate_draw_indirect(indirect_buffer, draw_count, stride)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdDrawIndirect-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdDrawIndirect-renderpass"], + ..Default::default() + }) + })?; let pipeline = self .builder_state .pipeline_graphics .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no graphics pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDrawIndirect-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no graphics pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDrawIndirect-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::DrawIndirect; @@ -534,25 +538,25 @@ where first_instance, )?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdDrawIndexed-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdDrawIndexed-renderpass"], + ..Default::default() + }) + })?; let pipeline = self .builder_state .pipeline_graphics .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no graphics pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDrawIndexed-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no graphics pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDrawIndexed-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::DrawIndexed; @@ -562,15 +566,13 @@ where self.validate_pipeline_graphics_render_pass(VUID_TYPE, pipeline, render_pass_state)?; self.validate_pipeline_graphics_vertex_buffers(VUID_TYPE, pipeline)?; - let index_buffer = - self.builder_state - .index_buffer - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no index buffer is currently bound".into(), - vuids: &["VUID-vkCmdDrawIndexed-None-07312"], - ..Default::default() - }))?; + let index_buffer = self.builder_state.index_buffer.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "no index buffer is currently bound".into(), + vuids: &["VUID-vkCmdDrawIndexed-None-07312"], + ..Default::default() + }) + })?; let index_buffer_bytes = index_buffer.as_bytes(); @@ -736,25 +738,25 @@ where self.inner .validate_draw_indexed_indirect(indirect_buffer, draw_count, stride)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdDrawIndexedIndirect-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdDrawIndexedIndirect-renderpass"], + ..Default::default() + }) + })?; let pipeline = self .builder_state .pipeline_graphics .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no graphics pipeline is currently bound".into(), - vuids: &["VUID-vkCmdDrawIndexedIndirect-None-08606"], - ..Default::default() - }))? + .ok_or_else(|| { + Box::new(ValidationError { + problem: "no graphics pipeline is currently bound".into(), + vuids: &["VUID-vkCmdDrawIndexedIndirect-None-08606"], + ..Default::default() + }) + })? .as_ref(); const VUID_TYPE: VUIDType = VUIDType::DrawIndexedIndirect; @@ -764,15 +766,13 @@ where self.validate_pipeline_graphics_render_pass(VUID_TYPE, pipeline, render_pass_state)?; self.validate_pipeline_graphics_vertex_buffers(VUID_TYPE, pipeline)?; - let _index_buffer = - self.builder_state - .index_buffer - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "no index buffer is currently bound".into(), - vuids: &["VUID-vkCmdDrawIndexedIndirect-None-07312"], - ..Default::default() - }))?; + let _index_buffer = self.builder_state.index_buffer.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "no index buffer is currently bound".into(), + vuids: &["VUID-vkCmdDrawIndexedIndirect-None-07312"], + ..Default::default() + }) + })?; Ok(()) } @@ -830,7 +830,7 @@ where let elements_to_check = if let Some(descriptor_count) = binding_reqs.descriptor_count { // The shader has a fixed-sized array, so it will never access more than // the first `descriptor_count` elements. - elements.get(..descriptor_count as usize).ok_or({ + elements.get(..descriptor_count as usize).ok_or_else(|| { // There are less than `descriptor_count` elements in `elements` Box::new(ValidationError { problem: format!( @@ -885,13 +885,15 @@ where .builder_state .descriptor_sets .get(&pipeline.bind_point()) - .ok_or(Box::new(ValidationError { - problem: "the currently bound pipeline accesses descriptor sets, but no \ + .ok_or_else(|| { + Box::new(ValidationError { + problem: "the currently bound pipeline accesses descriptor sets, but no \ descriptor sets were previously bound" - .into(), - vuids: vuids!(vuid_type, "None-02697"), - ..Default::default() - }))?; + .into(), + vuids: vuids!(vuid_type, "None-02697"), + ..Default::default() + }) + })?; if !pipeline.layout().is_compatible_with( &descriptor_set_state.pipeline_layout, @@ -1352,15 +1354,17 @@ where let set_resources = descriptor_set_state .descriptor_sets .get(&set_num) - .ok_or(Box::new(ValidationError { - problem: format!( - "the currently bound pipeline accesses descriptor set {set_num}, but \ + .ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "the currently bound pipeline accesses descriptor set {set_num}, but \ no descriptor set was previously bound" - ) - .into(), - // vuids? - ..Default::default() - }))? + ) + .into(), + // vuids? + ..Default::default() + }) + })? .resources(); let binding_resources = set_resources.binding(binding_num).unwrap(); @@ -1464,13 +1468,15 @@ where .builder_state .push_constants_pipeline_layout .as_ref() - .ok_or(Box::new(ValidationError { - problem: "the currently bound pipeline accesses push constants, but no \ + .ok_or_else(|| { + Box::new(ValidationError { + problem: "the currently bound pipeline accesses push constants, but no \ push constants were previously set" - .into(), - vuids: vuids!(vuid_type, "maintenance4-06425"), - ..Default::default() - }))?; + .into(), + vuids: vuids!(vuid_type, "maintenance4-06425"), + ..Default::default() + }) + })?; if pipeline_layout.handle() != constants_pipeline_layout.handle() && pipeline_layout.push_constant_ranges() diff --git a/vulkano/src/command_buffer/commands/query.rs b/vulkano/src/command_buffer/commands/query.rs index e9960f94..556480a8 100644 --- a/vulkano/src/command_buffer/commands/query.rs +++ b/vulkano/src/command_buffer/commands/query.rs @@ -453,13 +453,10 @@ where let device = self.device(); - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-vkCmdBeginQuery-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-vkCmdBeginQuery-flags-parameter"]) + })?; // VUID-vkCmdBeginQuery-commonparent assert_eq!(device, query_pool.device()); @@ -673,13 +670,10 @@ where let device = self.device(); - stage - .validate_device(device) - .map_err(|err| ValidationError { - context: "stage".into(), - vuids: &["VUID-vkCmdWriteTimestamp2-stage-parameter"], - ..ValidationError::from_requirement(err) - })?; + stage.validate_device(device).map_err(|err| { + err.add_context("stage") + .set_vuids(&["VUID-vkCmdWriteTimestamp2-stage-parameter"]) + })?; if !device.enabled_features().synchronization2 && PipelineStages::from(stage).contains_flags2() diff --git a/vulkano/src/command_buffer/commands/render_pass.rs b/vulkano/src/command_buffer/commands/render_pass.rs index ce1278f6..e7ed8dbf 100644 --- a/vulkano/src/command_buffer/commands/render_pass.rs +++ b/vulkano/src/command_buffer/commands/render_pass.rs @@ -176,15 +176,13 @@ where self.inner .validate_next_subpass(subpass_end_info, subpass_begin_info)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdNextSubpass2-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdNextSubpass2-renderpass"], + ..Default::default() + }) + })?; let begin_render_pass_state = match &render_pass_state.render_pass { RenderPassStateType::BeginRenderPass(state) => state, @@ -279,15 +277,13 @@ where ) -> Result<(), Box> { self.inner.validate_end_render_pass(subpass_end_info)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdEndRenderPass2-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdEndRenderPass2-renderpass"], + ..Default::default() + }) + })?; let begin_render_pass_state = match &render_pass_state.render_pass { RenderPassStateType::BeginRenderPass(state) => state, @@ -595,18 +591,16 @@ where fn validate_end_rendering(&self) -> Result<(), Box> { self.inner.validate_end_rendering()?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &[ - "VUID-vkCmdEndRendering-renderpass", - "VUID-vkCmdEndRendering-commandBuffer-06162", - ], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &[ + "VUID-vkCmdEndRendering-renderpass", + "VUID-vkCmdEndRendering-commandBuffer-06162", + ], + ..Default::default() + }) + })?; match &render_pass_state.render_pass { RenderPassStateType::BeginRenderPass(_) => { @@ -683,15 +677,13 @@ where ) -> Result<(), Box> { self.inner.validate_clear_attachments(attachments, rects)?; - let render_pass_state = - self.builder_state - .render_pass - .as_ref() - .ok_or(Box::new(ValidationError { - problem: "a render pass instance is not active".into(), - vuids: &["VUID-vkCmdClearAttachments-renderpass"], - ..Default::default() - }))?; + let render_pass_state = self.builder_state.render_pass.as_ref().ok_or_else(|| { + Box::new(ValidationError { + problem: "a render pass instance is not active".into(), + vuids: &["VUID-vkCmdClearAttachments-renderpass"], + ..Default::default() + }) + })?; if render_pass_state.contents != SubpassContents::Inline { return Err(Box::new(ValidationError { @@ -715,15 +707,17 @@ where .rendering_info .color_attachment_formats .get(color_attachment as usize) - .ok_or(Box::new(ValidationError { - context: format!("attachments[{}].color_attachment", clear_index) - .into(), - problem: "is not less than the number of color attachments in the \ + .ok_or_else(|| { + Box::new(ValidationError { + context: format!("attachments[{}].color_attachment", clear_index) + .into(), + problem: "is not less than the number of color attachments in the \ current subpass instance" - .into(), - vuids: &["VUID-vkCmdClearAttachments-aspectMask-07271"], - ..Default::default() - }))?; + .into(), + vuids: &["VUID-vkCmdClearAttachments-aspectMask-07271"], + ..Default::default() + }) + })?; if let Some(attachment_format) = attachment_format { let required_numeric_type = attachment_format @@ -2030,13 +2024,10 @@ impl SubpassBeginInfo { pub(crate) fn validate(&self, device: &Device) -> Result<(), Box> { let &Self { contents, _ne: _ } = self; - contents - .validate_device(device) - .map_err(|err| ValidationError { - context: "contents".into(), - vuids: &["VUID-VkSubpassBeginInfo-contents-parameter"], - ..ValidationError::from_requirement(err) - })?; + contents.validate_device(device).map_err(|err| { + err.add_context("contents") + .set_vuids(&["VUID-VkSubpassBeginInfo-contents-parameter"]) + })?; Ok(()) } @@ -2251,13 +2242,10 @@ impl RenderingInfo { let properties = device.physical_device().properties(); - contents - .validate_device(device) - .map_err(|err| ValidationError { - context: "contents".into(), - vuids: &["VUID-VkRenderingInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + contents.validate_device(device).map_err(|err| { + err.add_context("contents") + .set_vuids(&["VUID-VkRenderingInfo-flags-parameter"]) + })?; if render_area_extent[0] == 0 { return Err(Box::new(ValidationError { @@ -2916,29 +2904,20 @@ impl RenderingAttachmentInfo { _ne, } = self; - image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_layout".into(), - vuids: &["VUID-VkRenderingAttachmentInfo-imageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_layout.validate_device(device).map_err(|err| { + err.add_context("image_layout") + .set_vuids(&["VUID-VkRenderingAttachmentInfo-imageLayout-parameter"]) + })?; - load_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "load_op".into(), - vuids: &["VUID-VkRenderingAttachmentInfo-loadOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + load_op.validate_device(device).map_err(|err| { + err.add_context("load_op") + .set_vuids(&["VUID-VkRenderingAttachmentInfo-loadOp-parameter"]) + })?; - store_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "store_op".into(), - vuids: &["VUID-VkRenderingAttachmentInfo-storeOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + store_op.validate_device(device).map_err(|err| { + err.add_context("store_op") + .set_vuids(&["VUID-VkRenderingAttachmentInfo-storeOp-parameter"]) + })?; if matches!( image_layout, @@ -3073,20 +3052,15 @@ impl RenderingAttachmentResolveInfo { image_layout, } = self; - mode.validate_device(device) - .map_err(|err| ValidationError { - context: "mode".into(), - vuids: &["VUID-VkRenderingAttachmentInfo-resolveMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + mode.validate_device(device).map_err(|err| { + err.add_context("mode") + .set_vuids(&["VUID-VkRenderingAttachmentInfo-resolveMode-parameter"]) + })?; - image_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_layout".into(), - vuids: &["VUID-VkRenderingAttachmentInfo-resolveImageLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_layout.validate_device(device).map_err(|err| { + err.add_context("image_layout") + .set_vuids(&["VUID-VkRenderingAttachmentInfo-resolveImageLayout-parameter"]) + })?; if let Some(numeric_format) = image_view.format().numeric_format_color() { match numeric_format.numeric_type() { diff --git a/vulkano/src/command_buffer/commands/secondary.rs b/vulkano/src/command_buffer/commands/secondary.rs index 3c41ab65..b4a5e21f 100644 --- a/vulkano/src/command_buffer/commands/secondary.rs +++ b/vulkano/src/command_buffer/commands/secondary.rs @@ -107,16 +107,18 @@ where .inheritance_info() .render_pass .as_ref() - .ok_or(Box::new(ValidationError { - problem: format!( - "a render pass instance is active, but \ + .ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "a render pass instance is active, but \ `command_buffers[{}].inheritance_info().render_pass` is `None`", - command_buffer_index - ) - .into(), - vuids: &["VUID-vkCmdExecuteCommands-pCommandBuffers-00096"], - ..Default::default() - }))?; + command_buffer_index + ) + .into(), + vuids: &["VUID-vkCmdExecuteCommands-pCommandBuffers-00096"], + ..Default::default() + }) + })?; match (&render_pass_state.render_pass, inheritance_render_pass) { ( @@ -406,17 +408,20 @@ where let inherited_flags = command_buffer .inheritance_info() .occlusion_query - .ok_or(Box::new(ValidationError { - context: format!( - "command_buffers[{}].inheritance_info().occlusion_query", - command_buffer_index - ) - .into(), - problem: "is `None`, but an occlusion query is currently active" + .ok_or_else(|| { + Box::new(ValidationError { + context: format!( + "command_buffers[{}].inheritance_info().occlusion_query", + command_buffer_index + ) .into(), - vuids: &["VUID-vkCmdExecuteCommands-commandBuffer-00102"], - ..Default::default() - }))?; + problem: + "is `None`, but an occlusion query is currently active" + .into(), + vuids: &["VUID-vkCmdExecuteCommands-commandBuffer-00102"], + ..Default::default() + }) + })?; if !inherited_flags.contains(state.flags) { return Err(Box::new(ValidationError { diff --git a/vulkano/src/command_buffer/commands/sync.rs b/vulkano/src/command_buffer/commands/sync.rs index 3657c892..3293c761 100644 --- a/vulkano/src/command_buffer/commands/sync.rs +++ b/vulkano/src/command_buffer/commands/sync.rs @@ -1359,13 +1359,10 @@ where // VUID-vkCmdResetEvent2-commonparent assert_eq!(device, event.device()); - stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "stages".into(), - vuids: &["VUID-vkCmdResetEvent2-stageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + stages.validate_device(device).map_err(|err| { + err.add_context("stages") + .set_vuids(&["VUID-vkCmdResetEvent2-stageMask-parameter"]) + })?; if !device.enabled_features().synchronization2 { if stages.contains_flags2() { diff --git a/vulkano/src/command_buffer/mod.rs b/vulkano/src/command_buffer/mod.rs index add6357c..15208744 100644 --- a/vulkano/src/command_buffer/mod.rs +++ b/vulkano/src/command_buffer/mod.rs @@ -283,13 +283,10 @@ impl CommandBufferInheritanceInfo { } if let Some(control_flags) = occlusion_query { - control_flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "occlusion_query".into(), - vuids: &["VUID-VkCommandBufferInheritanceInfo-queryFlags-00057"], - ..ValidationError::from_requirement(err) - })?; + control_flags.validate_device(device).map_err(|err| { + err.add_context("occlusion_query") + .set_vuids(&["VUID-VkCommandBufferInheritanceInfo-queryFlags-00057"]) + })?; if !device.enabled_features().inherited_queries { return Err(Box::new(ValidationError { @@ -318,10 +315,9 @@ impl CommandBufferInheritanceInfo { query_statistics_flags .validate_device(device) - .map_err(|err| ValidationError { - context: "query_statistics_flags".into(), - vuids: &["VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("query_statistics_flags") + .set_vuids(&["VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789"]) })?; if query_statistics_flags.count() > 0 @@ -534,10 +530,10 @@ impl CommandBufferInheritanceRenderingInfo { .enumerate() .flat_map(|(i, f)| f.map(|f| (i, f))) { - format.validate_device(device).map_err(|err| ValidationError { - context: format!("color_attachment_formats[{}]", index).into(), - vuids: &["VUID-VkCommandBufferInheritanceRenderingInfo-pColorAttachmentFormats-parameter"], - ..ValidationError::from_requirement(err) + format.validate_device(device).map_err(|err| { + err.add_context(format!("color_attachment_formats[{}]", index)).set_vuids( + &["VUID-VkCommandBufferInheritanceRenderingInfo-pColorAttachmentFormats-parameter"], + ) })?; if format == Format::UNDEFINED { @@ -567,10 +563,10 @@ impl CommandBufferInheritanceRenderingInfo { } if let Some(format) = depth_attachment_format { - format.validate_device(device).map_err(|err| ValidationError { - context: "depth_attachment_format".into(), - vuids: &["VUID-VkCommandBufferInheritanceRenderingInfo-depthAttachmentFormat-parameter"], - ..ValidationError::from_requirement(err) + format.validate_device(device).map_err(|err| { + err.add_context("depth_attachment_format").set_vuids(&[ + "VUID-VkCommandBufferInheritanceRenderingInfo-depthAttachmentFormat-parameter", + ]) })?; if format == Format::UNDEFINED { @@ -614,10 +610,8 @@ impl CommandBufferInheritanceRenderingInfo { } if let Some(format) = stencil_attachment_format { - format.validate_device(device).map_err(|err| ValidationError { - context: "stencil_attachment_format".into(), - vuids: &["VUID-VkCommandBufferInheritanceRenderingInfo-stencilAttachmentFormat-parameter"], - ..ValidationError::from_requirement(err) + format.validate_device(device).map_err(|err| { + err.add_context("stencil_attachment_format").set_vuids(&["VUID-VkCommandBufferInheritanceRenderingInfo-stencilAttachmentFormat-parameter"]) })?; if format == Format::UNDEFINED { @@ -678,12 +672,10 @@ impl CommandBufferInheritanceRenderingInfo { rasterization_samples .validate_device(device) - .map_err(|err| ValidationError { - context: "rasterization_samples".into(), - vuids: &[ + .map_err(|err| { + err.add_context("rasterization_samples").set_vuids(&[ "VUID-VkCommandBufferInheritanceRenderingInfo-rasterizationSamples-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; Ok(()) diff --git a/vulkano/src/command_buffer/pool.rs b/vulkano/src/command_buffer/pool.rs index 27e32b1c..233df066 100644 --- a/vulkano/src/command_buffer/pool.rs +++ b/vulkano/src/command_buffer/pool.rs @@ -157,13 +157,10 @@ impl CommandPool { } fn validate_reset(&self, flags: CommandPoolResetFlags) -> Result<(), Box> { - flags - .validate_device(self.device()) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-vkResetCommandPool-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(self.device()).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-vkResetCommandPool-flags-parameter"]) + })?; Ok(()) } @@ -389,13 +386,10 @@ impl CommandPoolCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkCommandPoolCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkCommandPoolCreateInfo-flags-parameter"]) + })?; if queue_family_index >= device.physical_device().queue_family_properties().len() as u32 { return Err(Box::new(ValidationError { diff --git a/vulkano/src/descriptor_set/layout.rs b/vulkano/src/descriptor_set/layout.rs index 87968e73..41c4e438 100644 --- a/vulkano/src/descriptor_set/layout.rs +++ b/vulkano/src/descriptor_set/layout.rs @@ -329,13 +329,10 @@ impl DescriptorSetLayoutCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter"]) + })?; // VUID-VkDescriptorSetLayoutCreateInfo-binding-00279 // Ensured because it is a map @@ -620,23 +617,16 @@ impl DescriptorSetLayoutBinding { _ne: _, } = self; - binding_flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "binding_flags".into(), - vuids: &[ - "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + binding_flags.validate_device(device).map_err(|err| { + err.add_context("binding_flags").set_vuids(&[ + "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-parameter", + ]) + })?; - descriptor_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "descriptor_type".into(), - vuids: &["VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter"], - ..ValidationError::from_requirement(err) - })?; + descriptor_type.validate_device(device).map_err(|err| { + err.add_context("descriptor_type") + .set_vuids(&["VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter"]) + })?; if descriptor_type == DescriptorType::InlineUniformBlock { if !device.enabled_features().inline_uniform_block { @@ -679,13 +669,10 @@ impl DescriptorSetLayoutBinding { } if descriptor_count != 0 { - stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "stages".into(), - vuids: &["VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283"], - ..ValidationError::from_requirement(err) - })?; + stages.validate_device(device).map_err(|err| { + err.add_context("stages") + .set_vuids(&["VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283"]) + })?; if descriptor_type == DescriptorType::InputAttachment && !(stages.is_empty() || stages == ShaderStages::FRAGMENT) diff --git a/vulkano/src/descriptor_set/pool.rs b/vulkano/src/descriptor_set/pool.rs index b1e13c45..eef07530 100644 --- a/vulkano/src/descriptor_set/pool.rs +++ b/vulkano/src/descriptor_set/pool.rs @@ -408,13 +408,10 @@ impl DescriptorPoolCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkDescriptorPoolCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkDescriptorPoolCreateInfo-flags-parameter"]) + })?; if max_sets == 0 { return Err(Box::new(ValidationError { @@ -436,13 +433,10 @@ impl DescriptorPoolCreateInfo { // VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter for (&descriptor_type, &pool_size) in pool_sizes.iter() { - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "pool_sizes".into(), - vuids: &["VUID-VkDescriptorPoolSize-type-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("pool_sizes") + .set_vuids(&["VUID-VkDescriptorPoolSize-type-parameter"]) + })?; if pool_size == 0 { return Err(Box::new(ValidationError { diff --git a/vulkano/src/device/mod.rs b/vulkano/src/device/mod.rs index c32d15e3..5bc22505 100644 --- a/vulkano/src/device/mod.rs +++ b/vulkano/src/device/mod.rs @@ -119,8 +119,8 @@ use crate::{ instance::{Instance, InstanceOwned, InstanceOwnedDebugWrapper}, macros::{impl_id_counter, vulkan_bitflags}, memory::ExternalMemoryHandleType, - OomError, Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, - VulkanError, VulkanObject, + Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, VulkanError, + VulkanObject, }; use ash::vk::Handle; use parking_lot::Mutex; @@ -618,13 +618,10 @@ impl Device { })); } - build_type - .validate_device(self) - .map_err(|err| ValidationError { - context: "build_type".into(), - vuids: &["VUID-vkGetAccelerationStructureBuildSizesKHR-buildType-parameter"], - ..ValidationError::from_requirement(err) - })?; + build_type.validate_device(self).map_err(|err| { + err.add_context("build_type") + .set_vuids(&["VUID-vkGetAccelerationStructureBuildSizesKHR-buildType-parameter"]) + })?; // VUID-vkGetAccelerationStructureBuildSizesKHR-pBuildInfo-parameter build_info @@ -978,13 +975,10 @@ impl Device { })); } - handle_type - .validate_device(self) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(self).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter"]) + })?; if handle_type == ExternalMemoryHandleType::OpaqueFd { return Err(Box::new(ValidationError { @@ -1040,7 +1034,7 @@ impl Device { &self, object: &T, object_name: Option<&str>, - ) -> Result<(), OomError> { + ) -> Result<(), VulkanError> { assert!(object.device().handle() == self.handle()); let object_name_vk = object_name.map(|object_name| CString::new(object_name).unwrap()); @@ -1074,7 +1068,7 @@ impl Device { /// of the device (either explicitly or implicitly, for example with a future's destructor) /// while this function is waiting. #[inline] - pub unsafe fn wait_idle(&self) -> Result<(), OomError> { + pub unsafe fn wait_idle(&self) -> Result<(), VulkanError> { let fns = self.fns(); (fns.v1_0.device_wait_idle)(self.handle) .result() @@ -1289,19 +1283,21 @@ impl DeviceCreateInfo { physical_device.api_version(), physical_device.instance().enabled_extensions(), ) - .map_err(|err| ValidationError { - context: "enabled_extensions".into(), - problem: err.to_string().into(), - vuids: &["VUID-vkCreateDevice-ppEnabledExtensionNames-01387"], - ..Default::default() + .map_err(|err| { + Box::new(ValidationError { + context: "enabled_extensions".into(), + vuids: &["VUID-vkCreateDevice-ppEnabledExtensionNames-01387"], + ..ValidationError::from_error(err) + }) })?; enabled_features .check_requirements(physical_device.supported_features()) - .map_err(|err| ValidationError { - context: "enabled_features".into(), - problem: err.to_string().into(), - ..Default::default() + .map_err(|err| { + Box::new(ValidationError { + context: "enabled_features".into(), + ..ValidationError::from_error(err) + }) })?; let mut dependency_extensions = *enabled_extensions; @@ -1592,21 +1588,22 @@ impl QueueCreateInfo { device_extensions, physical_device.instance().enabled_extensions(), ) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkDeviceQueueCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkDeviceQueueCreateInfo-flags-parameter"]) })?; let queue_family_properties = physical_device .queue_family_properties() .get(queue_family_index as usize) - .ok_or(ValidationError { - context: "queue_family_index".into(), - problem: "is not less than the number of queue families in the physical device" - .into(), - vuids: &["VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381"], - ..Default::default() + .ok_or_else(|| { + Box::new(ValidationError { + context: "queue_family_index".into(), + problem: "is not less than the number of queue families in the physical device" + .into(), + vuids: &["VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381"], + ..Default::default() + }) })?; if queues.is_empty() { @@ -1680,14 +1677,14 @@ pub unsafe trait DeviceOwnedVulkanObject { /// Assigns a human-readable name to the object for debugging purposes. /// /// If `object_name` is `None`, a previously set object name is removed. - fn set_debug_utils_object_name(&self, object_name: Option<&str>) -> Result<(), OomError>; + fn set_debug_utils_object_name(&self, object_name: Option<&str>) -> Result<(), VulkanError>; } unsafe impl DeviceOwnedVulkanObject for T where T: DeviceOwned + VulkanObject, { - fn set_debug_utils_object_name(&self, object_name: Option<&str>) -> Result<(), OomError> { + fn set_debug_utils_object_name(&self, object_name: Option<&str>) -> Result<(), VulkanError> { self.device().set_debug_utils_object_name(self, object_name) } } diff --git a/vulkano/src/device/physical.rs b/vulkano/src/device/physical.rs index 6e7bd29f..f62c75df 100644 --- a/vulkano/src/device/physical.rs +++ b/vulkano/src/device/physical.rs @@ -807,13 +807,10 @@ impl PhysicalDevice { } fn validate_format_properties(&self, format: Format) -> Result<(), Box> { - format - .validate_physical_device(self) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_physical_device(self).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter"]) + })?; Ok(()) } @@ -1509,10 +1506,13 @@ impl PhysicalDevice { if let Some(present_mode) = present_mode { let mut present_modes = unsafe { self.surface_present_modes_unchecked(surface) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_present_modes".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_present_modes` \ + returned an error" + .into(), + ..Default::default() + }) })? }; @@ -1874,10 +1874,13 @@ impl PhysicalDevice { if let Some(present_mode) = present_mode { let mut present_modes = unsafe { self.surface_present_modes_unchecked(surface) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_present_modes".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_present_modes` \ + returned an error" + .into(), + ..Default::default() + }) })? }; diff --git a/vulkano/src/device/queue.rs b/vulkano/src/device/queue.rs index 26965c23..ddb6f7a5 100644 --- a/vulkano/src/device/queue.rs +++ b/vulkano/src/device/queue.rs @@ -26,8 +26,8 @@ use crate::{ future::{AccessCheckError, GpuFuture}, semaphore::SemaphoreState, }, - OomError, Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, - VulkanError, VulkanObject, + Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, VulkanError, + VulkanObject, }; use ahash::HashMap; use parking_lot::{Mutex, MutexGuard}; @@ -193,7 +193,7 @@ impl<'a> QueueGuard<'a> { /// Just like [`Device::wait_idle`], you shouldn't have to call this function in a typical /// program. #[inline] - pub fn wait_idle(&mut self) -> Result<(), OomError> { + pub fn wait_idle(&mut self) -> Result<(), VulkanError> { self.state.wait_idle(&self.queue.device, self.queue.handle) } @@ -1358,7 +1358,7 @@ struct QueueState { } impl QueueState { - fn wait_idle(&mut self, device: &Device, handle: ash::vk::Queue) -> Result<(), OomError> { + fn wait_idle(&mut self, device: &Device, handle: ash::vk::Queue) -> Result<(), VulkanError> { unsafe { let fns = device.fns(); (fns.v1_0.queue_wait_idle)(handle) diff --git a/vulkano/src/image/mod.rs b/vulkano/src/image/mod.rs index 91b449ce..297dcc80 100644 --- a/vulkano/src/image/mod.rs +++ b/vulkano/src/image/mod.rs @@ -1386,13 +1386,10 @@ impl ImageSubresourceLayers { ref array_layers, } = self; - aspects - .validate_device(device) - .map_err(|err| ValidationError { - context: "aspects".into(), - vuids: &["VUID-VkImageSubresourceLayers-aspectMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + aspects.validate_device(device).map_err(|err| { + err.add_context("aspects") + .set_vuids(&["VUID-VkImageSubresourceLayers-aspectMask-parameter"]) + })?; if aspects.is_empty() { return Err(Box::new(ValidationError { @@ -1519,13 +1516,10 @@ impl ImageSubresourceRange { ref array_layers, } = self; - aspects - .validate_device(device) - .map_err(|err| ValidationError { - context: "aspects".into(), - vuids: &["VUID-VkImageSubresourceRange-aspectMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + aspects.validate_device(device).map_err(|err| { + err.add_context("aspects") + .set_vuids(&["VUID-VkImageSubresourceRange-aspectMask-parameter"]) + })?; if aspects.is_empty() { return Err(Box::new(ValidationError { @@ -1749,42 +1743,37 @@ impl ImageFormatInfo { flags .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter"]) })?; format .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter"]) })?; image_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "image_type".into(), - vuids: &["VUID-VkPhysicalDeviceImageFormatInfo2-imageType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("image_type") + .set_vuids(&["VUID-VkPhysicalDeviceImageFormatInfo2-imageType-parameter"]) })?; tiling .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "tiling".into(), - vuids: &["VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("tiling") + .set_vuids(&["VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter"]) })?; usage .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter"]) })?; if usage.is_empty() { @@ -1815,10 +1804,9 @@ impl ImageFormatInfo { stencil_usage .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "stencil_usage".into(), - vuids: &["VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("stencil_usage") + .set_vuids(&["VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter"]) })?; if stencil_usage.is_empty() { @@ -1870,10 +1858,10 @@ impl ImageFormatInfo { handle_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("handle_type").set_vuids(&[ + "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter", + ]) })?; } @@ -1890,12 +1878,10 @@ impl ImageFormatInfo { image_view_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "image_view_type".into(), - vuids: &[ + .map_err(|err| { + err.add_context("image_view_type").set_vuids(&[ "VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-imageViewType-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; } @@ -2156,34 +2142,30 @@ impl SparseImageFormatInfo { format .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkPhysicalDeviceSparseImageFormatInfo2-format-parameter"]) })?; image_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "image_type".into(), - vuids: &["VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("image_type") + .set_vuids(&["VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter"]) })?; samples .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "samples".into(), - vuids: &["VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("samples") + .set_vuids(&["VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter"]) })?; usage .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter"]) })?; if usage.is_empty() { @@ -2197,10 +2179,9 @@ impl SparseImageFormatInfo { tiling .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "tiling".into(), - vuids: &["VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("tiling") + .set_vuids(&["VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter"]) })?; // VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095 diff --git a/vulkano/src/image/sampler/mod.rs b/vulkano/src/image/sampler/mod.rs index c6d72cb3..55a74280 100644 --- a/vulkano/src/image/sampler/mod.rs +++ b/vulkano/src/image/sampler/mod.rs @@ -814,60 +814,43 @@ impl SamplerCreateInfo { let properties = device.physical_device().properties(); - mag_filter - .validate_device(device) - .map_err(|err| ValidationError { - context: "mag_filter".into(), - vuids: &["VUID-VkSamplerCreateInfo-magFilter-parameter"], - ..ValidationError::from_requirement(err) - })?; + mag_filter.validate_device(device).map_err(|err| { + err.add_context("mag_filter") + .set_vuids(&["VUID-VkSamplerCreateInfo-magFilter-parameter"]) + })?; - min_filter - .validate_device(device) - .map_err(|err| ValidationError { - context: "min_filter".into(), - vuids: &["VUID-VkSamplerCreateInfo-minFilter-parameter"], - ..ValidationError::from_requirement(err) - })?; + min_filter.validate_device(device).map_err(|err| { + err.add_context("min_filter") + .set_vuids(&["VUID-VkSamplerCreateInfo-minFilter-parameter"]) + })?; - mipmap_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: "mipmap_mode".into(), - vuids: &["VUID-VkSamplerCreateInfo-mipmapMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + mipmap_mode.validate_device(device).map_err(|err| { + err.add_context("mipmap_mode") + .set_vuids(&["VUID-VkSamplerCreateInfo-mipmapMode-parameter"]) + })?; for (index, mode) in address_mode.into_iter().enumerate() { - mode.validate_device(device) - .map_err(|err| ValidationError { - context: format!("address_mode[{}]", index).into(), - vuids: &[ + mode.validate_device(device).map_err(|err| { + err.add_context(format!("address_mode[{}]", index)) + .set_vuids(&[ "VUID-VkSamplerCreateInfo-addressModeU-parameter", "VUID-VkSamplerCreateInfo-addressModeV-parameter", "VUID-VkSamplerCreateInfo-addressModeW-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + ]) + })?; } if address_mode.contains(&SamplerAddressMode::ClampToBorder) { - border_color - .validate_device(device) - .map_err(|err| ValidationError { - context: "border_color".into(), - vuids: &["VUID-VkSamplerCreateInfo-addressModeU-01078"], - ..ValidationError::from_requirement(err) - })?; + border_color.validate_device(device).map_err(|err| { + err.add_context("border_color") + .set_vuids(&["VUID-VkSamplerCreateInfo-addressModeU-01078"]) + })?; } - reduction_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: "reduction_mode".into(), - vuids: &["VUID-VkSamplerReductionModeCreateInfo-reductionMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + reduction_mode.validate_device(device).map_err(|err| { + err.add_context("reduction_mode") + .set_vuids(&["VUID-VkSamplerReductionModeCreateInfo-reductionMode-parameter"]) + })?; if address_mode.contains(&SamplerAddressMode::MirrorClampToEdge) { if !(device.enabled_features().sampler_mirror_clamp_to_edge @@ -964,13 +947,10 @@ impl SamplerCreateInfo { } if let Some(compare_op) = compare { - compare_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "compare".into(), - vuids: &["VUID-VkSamplerCreateInfo-compareEnable-01080"], - ..ValidationError::from_requirement(err) - })?; + compare_op.validate_device(device).map_err(|err| { + err.add_context("compare") + .set_vuids(&["VUID-VkSamplerCreateInfo-compareEnable-01080"]) + })?; if reduction_mode != SamplerReductionMode::WeightedAverage { return Err(Box::new(ValidationError { @@ -1249,28 +1229,24 @@ impl ComponentMapping { pub(crate) fn validate(&self, device: &Device) -> Result<(), Box> { let &Self { r, g, b, a } = self; - r.validate_device(device).map_err(|err| ValidationError { - context: "r".into(), - vuids: &["VUID-VkComponentMapping-r-parameter"], - ..ValidationError::from_requirement(err) + r.validate_device(device).map_err(|err| { + err.add_context("r") + .set_vuids(&["VUID-VkComponentMapping-r-parameter"]) })?; - g.validate_device(device).map_err(|err| ValidationError { - context: "g".into(), - vuids: &["VUID-VkComponentMapping-g-parameter"], - ..ValidationError::from_requirement(err) + g.validate_device(device).map_err(|err| { + err.add_context("g") + .set_vuids(&["VUID-VkComponentMapping-g-parameter"]) })?; - b.validate_device(device).map_err(|err| ValidationError { - context: "b".into(), - vuids: &["VUID-VkComponentMapping-b-parameter"], - ..ValidationError::from_requirement(err) + b.validate_device(device).map_err(|err| { + err.add_context("b") + .set_vuids(&["VUID-VkComponentMapping-b-parameter"]) })?; - a.validate_device(device).map_err(|err| ValidationError { - context: "a".into(), - vuids: &["VUID-VkComponentMapping-a-parameter"], - ..ValidationError::from_requirement(err) + a.validate_device(device).map_err(|err| { + err.add_context("a") + .set_vuids(&["VUID-VkComponentMapping-a-parameter"]) })?; Ok(()) diff --git a/vulkano/src/image/sampler/ycbcr.rs b/vulkano/src/image/sampler/ycbcr.rs index 6a83ff30..55c926b1 100644 --- a/vulkano/src/image/sampler/ycbcr.rs +++ b/vulkano/src/image/sampler/ycbcr.rs @@ -468,54 +468,39 @@ impl SamplerYcbcrConversionCreateInfo { _ne: _, } = self; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"]) + })?; - ycbcr_model - .validate_device(device) - .map_err(|err| ValidationError { - context: "ycbcr_model".into(), - vuids: &["VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter"], - ..ValidationError::from_requirement(err) - })?; + ycbcr_model.validate_device(device).map_err(|err| { + err.add_context("ycbcr_model") + .set_vuids(&["VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter"]) + })?; - ycbcr_range - .validate_device(device) - .map_err(|err| ValidationError { - context: "ycbcr_range".into(), - vuids: &["VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter"], - ..ValidationError::from_requirement(err) - })?; + ycbcr_range.validate_device(device).map_err(|err| { + err.add_context("ycbcr_range") + .set_vuids(&["VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter"]) + })?; component_mapping .validate(device) .map_err(|err| err.add_context("component_mapping"))?; for (index, offset) in chroma_offset.into_iter().enumerate() { - offset - .validate_device(device) - .map_err(|err| ValidationError { - context: format!("chroma_offset[{}]", index).into(), - vuids: &[ + offset.validate_device(device).map_err(|err| { + err.add_context(format!("chroma_offset[{}]", index)) + .set_vuids(&[ "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + ]) + })?; } - chroma_filter - .validate_device(device) - .map_err(|err| ValidationError { - context: "chroma_filter".into(), - vuids: &["VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter"], - ..ValidationError::from_requirement(err) - })?; + chroma_filter.validate_device(device).map_err(|err| { + err.add_context("chroma_filter") + .set_vuids(&["VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter"]) + })?; if !format .numeric_format_color() diff --git a/vulkano/src/image/sys.rs b/vulkano/src/image/sys.rs index d06fe3af..ef8dd035 100644 --- a/vulkano/src/image/sys.rs +++ b/vulkano/src/image/sys.rs @@ -943,10 +943,12 @@ impl RawImage { _ne: crate::NonExhaustive(()), }) } - .map_err(|_| ValidationError { - problem: "`PhysicalDevice::image_format_properties` returned an error" - .into(), - ..Default::default() + .map_err(|_| { + Box::new(ValidationError { + problem: "`PhysicalDevice::image_format_properties` returned an error" + .into(), + ..Default::default() + }) })? .unwrap(); @@ -1323,13 +1325,10 @@ impl RawImage { mip_level: u32, array_layer: u32, ) -> Result<(), Box> { - aspect - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "aspect".into(), - vuids: &["VUID-VkImageSubresource-aspectMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + aspect.validate_device(&self.device).map_err(|err| { + err.add_context("aspect") + .set_vuids(&["VUID-VkImageSubresource-aspectMask-parameter"]) + })?; // VUID-VkImageSubresource-aspectMask-requiredbitmask // VUID-vkGetImageSubresourceLayout-aspectMask-00997 @@ -1766,45 +1765,30 @@ impl ImageCreateInfo { let physical_device = device.physical_device(); let device_properties = physical_device.properties(); - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImageCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImageCreateInfo-flags-parameter"]) + })?; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkImageCreateInfo-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkImageCreateInfo-format-parameter"]) + })?; - samples - .validate_device(device) - .map_err(|err| ValidationError { - context: "samples".into(), - vuids: &["VUID-VkImageCreateInfo-samples-parameter"], - ..ValidationError::from_requirement(err) - })?; + samples.validate_device(device).map_err(|err| { + err.add_context("samples") + .set_vuids(&["VUID-VkImageCreateInfo-samples-parameter"]) + })?; - tiling - .validate_device(device) - .map_err(|err| ValidationError { - context: "tiling".into(), - vuids: &["VUID-VkImageCreateInfo-tiling-parameter"], - ..ValidationError::from_requirement(err) - })?; + tiling.validate_device(device).map_err(|err| { + err.add_context("tiling") + .set_vuids(&["VUID-VkImageCreateInfo-tiling-parameter"]) + })?; - usage - .validate_device(device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkImageCreateInfo-usage-parameter"], - ..ValidationError::from_requirement(err) - })?; + usage.validate_device(device).map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkImageCreateInfo-usage-parameter"]) + })?; if usage.is_empty() { return Err(Box::new(ValidationError { @@ -1837,13 +1821,10 @@ impl ImageCreateInfo { let image_create_format_features = format_properties.format_features(tiling, drm_format_modifiers); - initial_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "initial_layout".into(), - vuids: &["VUID-VkImageCreateInfo-initialLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + initial_layout.validate_device(device).map_err(|err| { + err.add_context("initial_layout") + .set_vuids(&["VUID-VkImageCreateInfo-initialLayout-parameter"]) + })?; if !matches!( initial_layout, @@ -2215,13 +2196,10 @@ impl ImageCreateInfo { })); } - stencil_usage - .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_usage".into(), - vuids: &["VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter"], - ..ValidationError::from_requirement(err) - })?; + stencil_usage.validate_device(device).map_err(|err| { + err.add_context("stencil_usage") + .set_vuids(&["VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter"]) + })?; if stencil_usage.is_empty() { return Err(Box::new(ValidationError { @@ -2523,10 +2501,9 @@ impl ImageCreateInfo { external_memory_handle_types .validate_device(device) - .map_err(|err| ValidationError { - context: "external_memory_handle_types".into(), - vuids: &["VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("external_memory_handle_types") + .set_vuids(&["VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter"]) })?; if initial_layout != ImageLayout::Undefined { @@ -2569,14 +2546,14 @@ impl ImageCreateInfo { .drm_format_modifier_properties .iter() .find(|properties| properties.drm_format_modifier == drm_format_modifier) - .ok_or(ValidationError { + .ok_or_else(|| Box::new(ValidationError { problem: "`drm_format_modifiers` has a length of 1, but \ `drm_format_modifiers[0]` is not one of the modifiers in \ `FormatProperties::drm_format_properties`, as returned by \ `PhysicalDevice::format_properties` for `format`".into(), vuids: &["VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265"], ..Default::default() - })?; + }))?; if drm_format_modifier_plane_layouts.len() != drm_format_modifier_properties.drm_format_modifier_plane_count as usize @@ -2705,14 +2682,17 @@ impl ImageCreateInfo { ), ..Default::default() }) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::image_format_properties".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::image_format_properties` \ + returned an error" + .into(), + ..Default::default() + }) })? }; - let image_format_properties = image_format_properties.ok_or(ValidationError { + let image_format_properties = image_format_properties.ok_or_else(|| Box::new(ValidationError { problem: "the combination of parameters of this image is not \ supported by the physical device, as returned by \ `PhysicalDevice::image_format_properties`" @@ -2722,7 +2702,7 @@ impl ImageCreateInfo { "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263", ], ..Default::default() - })?; + }))?; let ImageFormatProperties { max_extent, diff --git a/vulkano/src/image/view.rs b/vulkano/src/image/view.rs index 77569667..c527b097 100644 --- a/vulkano/src/image/view.rs +++ b/vulkano/src/image/view.rs @@ -931,21 +931,15 @@ impl ImageViewCreateInfo { _ne: _, } = self; - view_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "view_type".into(), - vuids: &["VUID-VkImageViewCreateInfo-viewType-parameter"], - ..ValidationError::from_requirement(err) - })?; + view_type.validate_device(device).map_err(|err| { + err.add_context("view_type") + .set_vuids(&["VUID-VkImageViewCreateInfo-viewType-parameter"]) + })?; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkImageViewCreateInfo-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkImageViewCreateInfo-format-parameter"]) + })?; component_mapping .validate(device) @@ -955,13 +949,10 @@ impl ImageViewCreateInfo { .validate(device) .map_err(|err| err.add_context("subresource_range"))?; - usage - .validate_device(device) - .map_err(|err| ValidationError { - context: "usage".into(), - vuids: &["VUID-VkImageViewUsageCreateInfo-usage-parameter"], - ..ValidationError::from_requirement(err) - })?; + usage.validate_device(device).map_err(|err| { + err.add_context("usage") + .set_vuids(&["VUID-VkImageViewUsageCreateInfo-usage-parameter"]) + })?; match view_type { ImageViewType::Dim1d | ImageViewType::Dim2d | ImageViewType::Dim3d => { diff --git a/vulkano/src/instance/debug.rs b/vulkano/src/instance/debug.rs index d5bfc502..97867b7f 100644 --- a/vulkano/src/instance/debug.rs +++ b/vulkano/src/instance/debug.rs @@ -229,10 +229,10 @@ impl DebugUtilsMessengerCreateInfo { message_severity .validate_instance_raw(instance_api_version, instance_extensions) - .map_err(|err| ValidationError { - context: "message_severity".into(), - vuids: &["VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("message_severity").set_vuids(&[ + "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", + ]) })?; if message_severity.is_empty() { @@ -246,10 +246,9 @@ impl DebugUtilsMessengerCreateInfo { message_type .validate_instance_raw(instance_api_version, instance_extensions) - .map_err(|err| ValidationError { - context: "message_type".into(), - vuids: &["VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("message_type") + .set_vuids(&["VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter"]) })?; if message_type.is_empty() { diff --git a/vulkano/src/instance/mod.rs b/vulkano/src/instance/mod.rs index 72a07d4e..692f5215 100644 --- a/vulkano/src/instance/mod.rs +++ b/vulkano/src/instance/mod.rs @@ -338,11 +338,12 @@ impl Instance { enabled_extensions .check_requirements(&supported_extensions, api_version) - .map_err(|err| ValidationError { - context: "create_info.enabled_extensions".into(), - problem: err.to_string().into(), - vuids: &["VUID-vkCreateInstance-ppEnabledExtensionNames-01388"], - ..Default::default() + .map_err(|err| { + Box::new(ValidationError { + context: "create_info.enabled_extensions".into(), + vuids: &["VUID-vkCreateInstance-ppEnabledExtensionNames-01388"], + ..ValidationError::from_error(err) + }) })?; Ok(()) @@ -1051,10 +1052,9 @@ impl InstanceCreateInfo { flags .validate_instance_raw(api_version, enabled_extensions) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkInstanceCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkInstanceCreateInfo-flags-parameter"]) })?; if !debug_utils_messengers.is_empty() { @@ -1091,12 +1091,11 @@ impl InstanceCreateInfo { for (index, enabled) in enabled_validation_features.iter().enumerate() { enabled .validate_instance_raw(api_version, enabled_extensions) - .map_err(|err| ValidationError { - context: format!("enabled_validation_features[{}]", index).into(), - vuids: &[ - "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-parameter", - ], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context(format!("enabled_validation_features[{}]", index)) + .set_vuids(&[ + "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-parameter", + ]) })?; } @@ -1144,12 +1143,12 @@ impl InstanceCreateInfo { for (index, disabled) in disabled_validation_features.iter().enumerate() { disabled .validate_instance_raw(api_version, enabled_extensions) - .map_err(|err| ValidationError { - context: format!("disabled_validation_features[{}]", index).into(), - vuids: &[ + .map_err(|err| { + err.add_context(format!("disabled_validation_features[{}]", index)).set_vuids( + &[ "VUID-VkValidationFeaturesEXT-pDisabledValidationFeatures-parameter", ], - ..ValidationError::from_requirement(err) + ) })?; } } diff --git a/vulkano/src/lib.rs b/vulkano/src/lib.rs index 97754dbd..145af3aa 100644 --- a/vulkano/src/lib.rs +++ b/vulkano/src/lib.rs @@ -501,15 +501,6 @@ pub struct ValidationError { } impl ValidationError { - fn from_requirement(err: RequirementNotMet) -> Self { - Self { - context: "".into(), - problem: err.required_for.into(), - vuids: &[], - requires_one_of: err.requires_one_of, - } - } - fn from_error(err: E) -> Self { Self { context: "".into(), @@ -528,6 +519,11 @@ impl ValidationError { self } + + fn set_vuids(mut self: Box, vuids: &'static [&'static str]) -> Box { + self.vuids = vuids; + self + } } impl Debug for ValidationError { @@ -688,44 +684,6 @@ impl Display for Requires { } } -#[derive(Clone, Copy, Debug)] -pub(crate) struct RequirementNotMet { - pub(crate) required_for: &'static str, - pub(crate) requires_one_of: RequiresOneOf, -} - -/// Error type returned by most Vulkan functions. -#[derive(Copy, Clone, Debug, PartialEq, Eq)] -pub enum OomError { - /// There is no memory available on the host (ie. the CPU, RAM, etc.). - OutOfHostMemory, - /// There is no memory available on the device (ie. video memory). - OutOfDeviceMemory, -} - -impl Error for OomError {} - -impl Display for OomError { - fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> { - let msg = match self { - OomError::OutOfHostMemory => "no memory available on the host", - OomError::OutOfDeviceMemory => "no memory available on the graphical device", - }; - - write!(f, "{msg}") - } -} - -impl From for OomError { - fn from(err: VulkanError) -> OomError { - match err { - VulkanError::OutOfHostMemory => OomError::OutOfHostMemory, - VulkanError::OutOfDeviceMemory => OomError::OutOfDeviceMemory, - _ => panic!("unexpected error: {:?}", err), - } - } -} - /// A helper type for non-exhaustive structs. /// /// This type cannot be constructed outside Vulkano. Structures with a field of this type can only diff --git a/vulkano/src/library.rs b/vulkano/src/library.rs index 528473ce..bbb3f38e 100644 --- a/vulkano/src/library.rs +++ b/vulkano/src/library.rs @@ -21,7 +21,7 @@ pub use crate::fns::EntryFunctions; use crate::{ instance::{InstanceExtensions, LayerProperties}, - ExtensionProperties, OomError, SafeDeref, Version, VulkanError, + ExtensionProperties, SafeDeref, Version, VulkanError, }; use libloading::{Error as LibloadingError, Library}; use std::{ @@ -233,7 +233,7 @@ impl VulkanLibrary { /// ``` pub fn layer_properties( &self, - ) -> Result, OomError> { + ) -> Result, VulkanError> { let fns = self.fns(); let layer_properties = unsafe { @@ -255,7 +255,7 @@ impl VulkanLibrary { break properties; } ash::vk::Result::INCOMPLETE => (), - err => return Err(VulkanError::from(err).into()), + err => return Err(VulkanError::from(err)), } } }; diff --git a/vulkano/src/macros.rs b/vulkano/src/macros.rs index ef2cbe78..4b6dacdc 100644 --- a/vulkano/src/macros.rs +++ b/vulkano/src/macros.rs @@ -330,7 +330,7 @@ macro_rules! vulkan_bitflags { pub(crate) fn validate_device( self, device: &crate::device::Device, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( device.api_version(), device.enabled_features(), @@ -344,7 +344,7 @@ macro_rules! vulkan_bitflags { pub(crate) fn validate_physical_device( self, physical_device: &crate::device::physical::PhysicalDevice, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( physical_device.api_version(), physical_device.supported_features(), @@ -360,7 +360,7 @@ macro_rules! vulkan_bitflags { #[allow(unused_variables)] device_features: &crate::device::Features, #[allow(unused_variables)] device_extensions: &crate::device::DeviceExtensions, #[allow(unused_variables)] instance_extensions: &crate::instance::InstanceExtensions, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { $( $( if self.intersects(Self::$flag_name) && ![ @@ -379,8 +379,8 @@ macro_rules! vulkan_bitflags { )+)? ].into_iter().all(|x| x)),* ].into_iter().any(|x| x) { - return Err(crate::RequirementNotMet { - required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), + return Err(Box::new(crate::ValidationError { + problem: concat!("is `", stringify!($ty), "::", stringify!($flag_name), "`").into(), requires_one_of: crate::RequiresOneOf(&[ $(crate::RequiresAllOf(&[ $( @@ -397,7 +397,8 @@ macro_rules! vulkan_bitflags { )+)? ])),* ]), - }); + ..Default::default() + })); } )? )* @@ -410,7 +411,7 @@ macro_rules! vulkan_bitflags { pub(crate) fn validate_instance( self, instance: &crate::instance::Instance, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_instance_raw( instance.api_version(), instance.enabled_extensions(), @@ -422,7 +423,7 @@ macro_rules! vulkan_bitflags { self, #[allow(unused_variables)] instance_api_version: crate::Version, #[allow(unused_variables)] instance_extensions: &crate::instance::InstanceExtensions, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { $( $( if self.intersects(Self::$flag_name) && ![ @@ -435,8 +436,8 @@ macro_rules! vulkan_bitflags { )+)? ].into_iter().all(|x| x)),* ].into_iter().any(|x| x) { - return Err(crate::RequirementNotMet { - required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), + return Err(Box::new(crate::ValidationError { + problem: concat!("is `", stringify!($ty), "::", stringify!($flag_name), "`").into(), requires_one_of: crate::RequiresOneOf(&[ $(crate::RequiresAllOf(&[ $( @@ -447,7 +448,8 @@ macro_rules! vulkan_bitflags { )+)? ])),* ]), - }); + ..Default::default() + })); } )? )* @@ -668,7 +670,7 @@ macro_rules! vulkan_enum { pub(crate) fn validate_device( self, device: &crate::device::Device, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( device.api_version(), device.enabled_features(), @@ -682,7 +684,7 @@ macro_rules! vulkan_enum { pub(crate) fn validate_physical_device( self, physical_device: &crate::device::physical::PhysicalDevice, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_device_raw( physical_device.api_version(), physical_device.supported_features(), @@ -698,7 +700,7 @@ macro_rules! vulkan_enum { #[allow(unused_variables)] device_features: &crate::device::Features, #[allow(unused_variables)] device_extensions: &crate::device::DeviceExtensions, #[allow(unused_variables)] instance_extensions: &crate::instance::InstanceExtensions, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { match self { $( $( @@ -719,8 +721,8 @@ macro_rules! vulkan_enum { )+)? ].into_iter().all(|x| x)),* ].into_iter().any(|x| x) { - return Err(crate::RequirementNotMet { - required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), + return Err(Box::new(crate::ValidationError { + problem: concat!("is `", stringify!($ty), "::", stringify!($flag_name), "`").into(), requires_one_of: crate::RequiresOneOf(&[ $(crate::RequiresAllOf(&[ $( @@ -737,7 +739,8 @@ macro_rules! vulkan_enum { )+)? ])),* ]), - }); + ..Default::default() + })); } }, )? @@ -753,7 +756,7 @@ macro_rules! vulkan_enum { pub(crate) fn validate_instance( self, instance: &crate::instance::Instance, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { self.validate_instance_raw( instance.api_version(), instance.enabled_extensions(), @@ -765,7 +768,7 @@ macro_rules! vulkan_enum { self, #[allow(unused_variables)] instance_api_version: crate::Version, #[allow(unused_variables)] instance_extensions: &crate::instance::InstanceExtensions, - ) -> Result<(), crate::RequirementNotMet> { + ) -> Result<(), Box> { match self { $( $( @@ -780,8 +783,8 @@ macro_rules! vulkan_enum { )+)? ].into_iter().all(|x| x)),* ].into_iter().any(|x| x) { - return Err(crate::RequirementNotMet { - required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), + return Err(Box::new(crate::ValidationError { + problem: concat!("is `", stringify!($ty), "::", stringify!($flag_name), "`").into(), requires_one_of: crate::RequiresOneOf(&[ $(crate::RequiresAllOf(&[ $( @@ -792,7 +795,8 @@ macro_rules! vulkan_enum { )+)? ])),* ]), - }); + ..Default::default() + })); } }, )? diff --git a/vulkano/src/memory/allocator/mod.rs b/vulkano/src/memory/allocator/mod.rs index 66c5cba5..d28792b1 100644 --- a/vulkano/src/memory/allocator/mod.rs +++ b/vulkano/src/memory/allocator/mod.rs @@ -939,10 +939,7 @@ impl GenericMemoryAllocator { for (index, export_handle_types) in export_handle_types.iter().enumerate() { export_handle_types .validate_device(device) - .map_err(|err| ValidationError { - context: format!("export_handle_types[{}]", index).into(), - ..ValidationError::from_requirement(err) - })?; + .map_err(|err| err.add_context(format!("export_handle_types[{}]", index)))?; } } diff --git a/vulkano/src/memory/device_memory.rs b/vulkano/src/memory/device_memory.rs index 1fad016d..70e27850 100644 --- a/vulkano/src/memory/device_memory.rs +++ b/vulkano/src/memory/device_memory.rs @@ -440,13 +440,10 @@ impl DeviceMemory { &self, handle_type: ExternalMemoryHandleType, ) -> Result<(), Box> { - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkMemoryGetFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkMemoryGetFdInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -621,11 +618,13 @@ impl<'d> MemoryAllocateInfo<'d> { let memory_type = memory_properties .memory_types .get(memory_type_index as usize) - .ok_or(ValidationError { - context: "memory_type_index".into(), - problem: "is not less than the number of memory types in the device".into(), - vuids: &["VUID-vkAllocateMemory-pAllocateInfo-01714"], - ..Default::default() + .ok_or_else(|| { + Box::new(ValidationError { + context: "memory_type_index".into(), + problem: "is not less than the number of memory types in the device".into(), + vuids: &["VUID-vkAllocateMemory-pAllocateInfo-01714"], + ..Default::default() + }) })?; let memory_heap = &memory_properties.memory_heaps[memory_type.heap_index as usize]; @@ -733,13 +732,10 @@ impl<'d> MemoryAllocateInfo<'d> { })); } - export_handle_types - .validate_device(device) - .map_err(|err| ValidationError { - context: "export_handle_types".into(), - vuids: &["VUID-VkExportMemoryAllocateInfo-handleTypes-parameter"], - ..ValidationError::from_requirement(err) - })?; + export_handle_types.validate_device(device).map_err(|err| { + err.add_context("export_handle_types") + .set_vuids(&["VUID-VkExportMemoryAllocateInfo-handleTypes-parameter"]) + })?; // VUID-VkMemoryAllocateInfo-pNext-00639 // VUID-VkExportMemoryAllocateInfo-handleTypes-00656 @@ -869,13 +865,10 @@ impl MemoryImportInfo { #[cfg(unix)] { - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportMemoryFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportMemoryFdInfoKHR-handleType-parameter"]) + })?; match handle_type { ExternalMemoryHandleType::OpaqueFd => { @@ -929,13 +922,11 @@ impl MemoryImportInfo { #[cfg(windows)] { - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type").set_vuids(&[ + "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter", + ]) + })?; match handle_type { ExternalMemoryHandleType::OpaqueWin32 diff --git a/vulkano/src/pipeline/cache.rs b/vulkano/src/pipeline/cache.rs index c3b78335..33c9d1ba 100644 --- a/vulkano/src/pipeline/cache.rs +++ b/vulkano/src/pipeline/cache.rs @@ -365,13 +365,10 @@ impl PipelineCacheCreateInfo { _ne, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPipelineCacheCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPipelineCacheCreateInfo-flags-parameter"]) + })?; Ok(()) } diff --git a/vulkano/src/pipeline/compute.rs b/vulkano/src/pipeline/compute.rs index d58155b3..dfb4c78c 100644 --- a/vulkano/src/pipeline/compute.rs +++ b/vulkano/src/pipeline/compute.rs @@ -163,7 +163,7 @@ impl ComputePipeline { let mut output = MaybeUninit::uninit(); (fns.v1_0.create_compute_pipelines)( device.handle(), - cache.as_ref().map_or(Default::default(), |c| c.handle()), + cache.as_ref().map_or_else(Default::default, |c| c.handle()), 1, &create_infos_vk, ptr::null(), @@ -320,13 +320,10 @@ impl ComputePipelineCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkComputePipelineCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkComputePipelineCreateInfo-flags-parameter"]) + })?; stage .validate(device) @@ -359,15 +356,17 @@ impl ComputePipelineCreateInfo { .map(|(k, v)| (*k, v)), entry_point_info.push_constant_requirements.as_ref(), ) - .map_err(|err| ValidationError { - context: "stage.entry_point".into(), - vuids: &[ - "VUID-VkComputePipelineCreateInfo-layout-07987", - "VUID-VkComputePipelineCreateInfo-layout-07988", - "VUID-VkComputePipelineCreateInfo-layout-07990", - "VUID-VkComputePipelineCreateInfo-layout-07991", - ], - ..ValidationError::from_error(err) + .map_err(|err| { + Box::new(ValidationError { + context: "stage.entry_point".into(), + vuids: &[ + "VUID-VkComputePipelineCreateInfo-layout-07987", + "VUID-VkComputePipelineCreateInfo-layout-07988", + "VUID-VkComputePipelineCreateInfo-layout-07990", + "VUID-VkComputePipelineCreateInfo-layout-07991", + ], + ..ValidationError::from_error(err) + }) })?; // TODO: diff --git a/vulkano/src/pipeline/graphics/color_blend.rs b/vulkano/src/pipeline/graphics/color_blend.rs index 61acc037..73579326 100644 --- a/vulkano/src/pipeline/graphics/color_blend.rs +++ b/vulkano/src/pipeline/graphics/color_blend.rs @@ -154,13 +154,10 @@ impl ColorBlendState { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPipelineColorBlendStateCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPipelineColorBlendStateCreateInfo-flags-parameter"]) + })?; if let Some(logic_op) = logic_op { if !device.enabled_features().logic_op { @@ -175,17 +172,11 @@ impl ColorBlendState { } match logic_op { - StateMode::Fixed(logic_op) => { - logic_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "logic_op".into(), - vuids: &[ - "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", - ], - ..ValidationError::from_requirement(err) - })? - } + StateMode::Fixed(logic_op) => logic_op.validate_device(device).map_err(|err| { + err.add_context("logic_op").set_vuids(&[ + "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", + ]) + })?, StateMode::Dynamic => { if !device.enabled_features().extended_dynamic_state2_logic_op { return Err(Box::new(ValidationError { @@ -471,51 +462,45 @@ impl AttachmentBlend { src_color_blend_factor .validate_device(device) - .map_err(|err| ValidationError { - context: "src_color_blend_factor".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("src_color_blend_factor").set_vuids(&[ + "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter", + ]) })?; dst_color_blend_factor .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_color_blend_factor".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("dst_color_blend_factor").set_vuids(&[ + "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter", + ]) })?; - color_blend_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "color_blend_op".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + color_blend_op.validate_device(device).map_err(|err| { + err.add_context("color_blend_op") + .set_vuids(&["VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter"]) + })?; src_alpha_blend_factor .validate_device(device) - .map_err(|err| ValidationError { - context: "src_alpha_blend_factor".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("src_alpha_blend_factor").set_vuids(&[ + "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter", + ]) })?; dst_alpha_blend_factor .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_alpha_blend_factor".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("dst_alpha_blend_factor").set_vuids(&[ + "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter", + ]) })?; - alpha_blend_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "alpha_blend_op".into(), - vuids: &["VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + alpha_blend_op.validate_device(device).map_err(|err| { + err.add_context("alpha_blend_op") + .set_vuids(&["VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter"]) + })?; if !device.enabled_features().dual_src_blend { if matches!( diff --git a/vulkano/src/pipeline/graphics/depth_stencil.rs b/vulkano/src/pipeline/graphics/depth_stencil.rs index f60d92b2..8cba6d95 100644 --- a/vulkano/src/pipeline/graphics/depth_stencil.rs +++ b/vulkano/src/pipeline/graphics/depth_stencil.rs @@ -96,13 +96,10 @@ impl DepthStencilState { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPipelineDepthStencilStateCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPipelineDepthStencilStateCreateInfo-flags-parameter"]) + })?; if let Some(depth_state) = depth { depth_state @@ -243,15 +240,11 @@ impl DepthState { match compare_op { StateMode::Fixed(compare_op) => { - compare_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "compare_op".into(), - vuids: &[ - "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + compare_op.validate_device(device).map_err(|err| { + err.add_context("compare_op").set_vuids(&[ + "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", + ]) + })?; } StateMode::Dynamic => { if !(device.api_version() >= Version::V1_3 @@ -568,37 +561,25 @@ impl StencilOps { compare_op, } = self; - fail_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "fail_op".into(), - vuids: &["VUID-VkStencilOpState-failOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + fail_op.validate_device(device).map_err(|err| { + err.add_context("fail_op") + .set_vuids(&["VUID-VkStencilOpState-failOp-parameter"]) + })?; - pass_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "pass_op".into(), - vuids: &["VUID-VkStencilOpState-passOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + pass_op.validate_device(device).map_err(|err| { + err.add_context("pass_op") + .set_vuids(&["VUID-VkStencilOpState-passOp-parameter"]) + })?; - depth_fail_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "depth_fail_op".into(), - vuids: &["VUID-VkStencilOpState-depthFailOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + depth_fail_op.validate_device(device).map_err(|err| { + err.add_context("depth_fail_op") + .set_vuids(&["VUID-VkStencilOpState-depthFailOp-parameter"]) + })?; - compare_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "compare_op".into(), - vuids: &["VUID-VkStencilOpState-compareOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + compare_op.validate_device(device).map_err(|err| { + err.add_context("compare_op") + .set_vuids(&["VUID-VkStencilOpState-compareOp-parameter"]) + })?; Ok(()) } diff --git a/vulkano/src/pipeline/graphics/discard_rectangle.rs b/vulkano/src/pipeline/graphics/discard_rectangle.rs index 3e9d2db7..99fb4b3a 100644 --- a/vulkano/src/pipeline/graphics/discard_rectangle.rs +++ b/vulkano/src/pipeline/graphics/discard_rectangle.rs @@ -55,10 +55,10 @@ impl DiscardRectangleState { let properties = device.physical_device().properties(); - mode.validate_device(device).map_err(|err| ValidationError { - context: "mode".into(), - vuids: &["VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter"], - ..ValidationError::from_requirement(err) + mode.validate_device(device).map_err(|err| { + err.add_context("mode").set_vuids(&[ + "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter", + ]) })?; let discard_rectangle_count = match rectangles { diff --git a/vulkano/src/pipeline/graphics/input_assembly.rs b/vulkano/src/pipeline/graphics/input_assembly.rs index f2e3caef..c82b4c92 100644 --- a/vulkano/src/pipeline/graphics/input_assembly.rs +++ b/vulkano/src/pipeline/graphics/input_assembly.rs @@ -93,13 +93,11 @@ impl InputAssemblyState { match topology { PartialStateMode::Fixed(topology) => { - topology - .validate_device(device) - .map_err(|err| ValidationError { - context: "topology".into(), - vuids: &["VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter"], - ..ValidationError::from_requirement(err) - })?; + topology.validate_device(device).map_err(|err| { + err.add_context("topology").set_vuids(&[ + "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", + ]) + })?; match topology { PrimitiveTopology::TriangleFan => { @@ -156,10 +154,10 @@ impl InputAssemblyState { topology_class .example() .validate_device(device) - .map_err(|err| ValidationError { - context: "topology".into(), - vuids: &["VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("topology").set_vuids(&[ + "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", + ]) })?; if !(device.api_version() >= Version::V1_3 diff --git a/vulkano/src/pipeline/graphics/mod.rs b/vulkano/src/pipeline/graphics/mod.rs index 82e09ec4..28d14bc1 100644 --- a/vulkano/src/pipeline/graphics/mod.rs +++ b/vulkano/src/pipeline/graphics/mod.rs @@ -1900,13 +1900,10 @@ impl GraphicsPipelineCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkGraphicsPipelineCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkGraphicsPipelineCreateInfo-flags-parameter"]) + })?; /* Gather shader stages @@ -2436,10 +2433,12 @@ impl GraphicsPipelineCreateInfo { .map(|(k, v)| (*k, v)), entry_point_info.push_constant_requirements.as_ref(), ) - .map_err(|err| ValidationError { - context: format!("stages[{}].entry_point", stage_index).into(), - vuids: &["VUID-VkGraphicsPipelineCreateInfo-layout-00756"], - ..ValidationError::from_error(err) + .map_err(|err| { + Box::new(ValidationError { + context: format!("stages[{}].entry_point", stage_index).into(), + vuids: &["VUID-VkGraphicsPipelineCreateInfo-layout-00756"], + ..ValidationError::from_error(err) + }) })?; } diff --git a/vulkano/src/pipeline/graphics/multisample.rs b/vulkano/src/pipeline/graphics/multisample.rs index e58b0d8b..6fb1a651 100644 --- a/vulkano/src/pipeline/graphics/multisample.rs +++ b/vulkano/src/pipeline/graphics/multisample.rs @@ -87,12 +87,10 @@ impl MultisampleState { rasterization_samples .validate_device(device) - .map_err(|err| ValidationError { - context: "rasterization_samples".into(), - vuids: &[ + .map_err(|err| { + err.add_context("rasterization_samples").set_vuids(&[ "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; if let Some(min_sample_shading) = sample_shading { diff --git a/vulkano/src/pipeline/graphics/rasterization.rs b/vulkano/src/pipeline/graphics/rasterization.rs index d5b459bb..a3a6a8ee 100644 --- a/vulkano/src/pipeline/graphics/rasterization.rs +++ b/vulkano/src/pipeline/graphics/rasterization.rs @@ -156,21 +156,14 @@ impl RasterizationState { let properties = device.physical_device().properties(); - polygon_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: "polygon_mode".into(), - vuids: &["VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + polygon_mode.validate_device(device).map_err(|err| { + err.add_context("polygon_mode") + .set_vuids(&["VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter"]) + })?; line_rasterization_mode .validate_device(device) - .map_err(|err| ValidationError { - context: "line_rasterization_mode".into(), - vuids: &["VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + .map_err(|err| err.add_context("line_rasterization_mode").set_vuids(&["VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter"]))?; if depth_clamp_enable && !device.enabled_features().depth_clamp { return Err(Box::new(ValidationError { @@ -234,13 +227,11 @@ impl RasterizationState { match cull_mode { StateMode::Fixed(cull_mode) => { - cull_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: "cull_mode".into(), - vuids: &["VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + cull_mode.validate_device(device).map_err(|err| { + err.add_context("cull_mode").set_vuids(&[ + "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", + ]) + })?; } StateMode::Dynamic => { if !(device.api_version() >= Version::V1_3 @@ -262,13 +253,11 @@ impl RasterizationState { match front_face { StateMode::Fixed(front_face) => { - front_face - .validate_device(device) - .map_err(|err| ValidationError { - context: "front_face".into(), - vuids: &["VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter"], - ..ValidationError::from_requirement(err) - })?; + front_face.validate_device(device).map_err(|err| { + err.add_context("front_face").set_vuids(&[ + "VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", + ]) + })?; } StateMode::Dynamic => { if !(device.api_version() >= Version::V1_3 diff --git a/vulkano/src/pipeline/graphics/subpass.rs b/vulkano/src/pipeline/graphics/subpass.rs index 58f94096..eb9f6f9f 100644 --- a/vulkano/src/pipeline/graphics/subpass.rs +++ b/vulkano/src/pipeline/graphics/subpass.rs @@ -185,13 +185,10 @@ impl PipelineRenderingCreateInfo { { let attachment_index = attachment_index as u32; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: format!("color_attachment_formats[{}]", attachment_index).into(), - vuids: &["VUID-VkGraphicsPipelineCreateInfo-renderPass-06580"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context(format!("color_attachment_formats[{}]", attachment_index)) + .set_vuids(&["VUID-VkGraphicsPipelineCreateInfo-renderPass-06580"]) + })?; if format == Format::UNDEFINED { return Err(Box::new(ValidationError { @@ -217,13 +214,10 @@ impl PipelineRenderingCreateInfo { } if let Some(format) = depth_attachment_format { - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "depth_attachment_format".into(), - vuids: &["VUID-VkGraphicsPipelineCreateInfo-renderPass-06583"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("depth_attachment_format") + .set_vuids(&["VUID-VkGraphicsPipelineCreateInfo-renderPass-06583"]) + })?; if format == Format::UNDEFINED { return Err(Box::new(ValidationError { @@ -258,13 +252,10 @@ impl PipelineRenderingCreateInfo { } if let Some(format) = stencil_attachment_format { - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_attachment_format".into(), - vuids: &["VUID-VkGraphicsPipelineCreateInfo-renderPass-06584"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("stencil_attachment_format") + .set_vuids(&["VUID-VkGraphicsPipelineCreateInfo-renderPass-06584"]) + })?; if format == Format::UNDEFINED { return Err(Box::new(ValidationError { diff --git a/vulkano/src/pipeline/graphics/tessellation.rs b/vulkano/src/pipeline/graphics/tessellation.rs index e39e42a6..ac2363ac 100644 --- a/vulkano/src/pipeline/graphics/tessellation.rs +++ b/vulkano/src/pipeline/graphics/tessellation.rs @@ -112,15 +112,11 @@ impl TessellationState { } }; - domain_origin - .validate_device(device) - .map_err(|err| ValidationError { - context: "domain_origin".into(), - vuids: &[ - "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + domain_origin.validate_device(device).map_err(|err| { + err.add_context("domain_origin").set_vuids(&[ + "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", + ]) + })?; if domain_origin != TessellationDomainOrigin::UpperLeft && !(device.api_version() >= Version::V1_1 diff --git a/vulkano/src/pipeline/graphics/vertex_input/mod.rs b/vulkano/src/pipeline/graphics/vertex_input/mod.rs index 7fa07901..3331b520 100644 --- a/vulkano/src/pipeline/graphics/vertex_input/mod.rs +++ b/vulkano/src/pipeline/graphics/vertex_input/mod.rs @@ -243,14 +243,16 @@ impl VertexInputState { })); } - let binding_desc = bindings.get(&binding).ok_or(ValidationError { - problem: format!( - "`attributes[{}].binding` is not present in `bindings`", - binding - ) - .into(), - vuids: &["VUID-VkPipelineVertexInputStateCreateInfo-binding-00615"], - ..Default::default() + let binding_desc = bindings.get(&binding).ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "`attributes[{}].binding` is not present in `bindings`", + binding + ) + .into(), + vuids: &["VUID-VkPipelineVertexInputStateCreateInfo-binding-00615"], + ..Default::default() + }) })?; if device.enabled_extensions().khr_portability_subset @@ -438,13 +440,10 @@ impl VertexInputAttributeDescription { let properties = device.physical_device().properties(); - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkVertexInputAttributeDescription-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkVertexInputAttributeDescription-format-parameter"]) + })?; if binding > properties.max_vertex_input_bindings { return Err(Box::new(ValidationError { diff --git a/vulkano/src/pipeline/layout.rs b/vulkano/src/pipeline/layout.rs index 39d7f32f..e7808e17 100644 --- a/vulkano/src/pipeline/layout.rs +++ b/vulkano/src/pipeline/layout.rs @@ -457,13 +457,10 @@ impl PipelineLayoutCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPipelineLayoutCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPipelineLayoutCreateInfo-flags-parameter"]) + })?; if set_layouts.len() > properties.max_bound_descriptor_sets as usize { return Err(Box::new(ValidationError { @@ -819,13 +816,10 @@ impl PushConstantRange { size, } = self; - stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "stages".into(), - vuids: &["VUID-VkPushConstantRange-stageFlags-parameter"], - ..ValidationError::from_requirement(err) - })?; + stages.validate_device(device).map_err(|err| { + err.add_context("stages") + .set_vuids(&["VUID-VkPushConstantRange-stageFlags-parameter"]) + })?; if stages.is_empty() { return Err(Box::new(ValidationError { diff --git a/vulkano/src/pipeline/mod.rs b/vulkano/src/pipeline/mod.rs index 194d94cd..71903c7f 100644 --- a/vulkano/src/pipeline/mod.rs +++ b/vulkano/src/pipeline/mod.rs @@ -344,24 +344,18 @@ impl PipelineShaderStageCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkPipelineShaderStageCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkPipelineShaderStageCreateInfo-flags-parameter"]) + })?; let entry_point_info = entry_point.info(); let stage_enum = ShaderStage::from(&entry_point_info.execution); - stage_enum - .validate_device(device) - .map_err(|err| ValidationError { - context: "entry_point.info().execution".into(), - vuids: &["VUID-VkPipelineShaderStageCreateInfo-stage-parameter"], - ..ValidationError::from_requirement(err) - })?; + stage_enum.validate_device(device).map_err(|err| { + err.add_context("entry_point.info().execution") + .set_vuids(&["VUID-VkPipelineShaderStageCreateInfo-stage-parameter"]) + })?; // VUID-VkPipelineShaderStageCreateInfo-pName-00707 // Guaranteed by definition of `EntryPoint`. diff --git a/vulkano/src/query.rs b/vulkano/src/query.rs index 27def8ba..9b7d8242 100644 --- a/vulkano/src/query.rs +++ b/vulkano/src/query.rs @@ -18,8 +18,8 @@ use crate::{ device::{Device, DeviceOwned}, instance::InstanceOwnedDebugWrapper, macros::{impl_id_counter, vulkan_bitflags}, - DeviceSize, RequirementNotMet, Requires, RequiresAllOf, RequiresOneOf, Validated, - ValidationError, VulkanError, VulkanObject, + DeviceSize, Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, VulkanError, + VulkanObject, }; use std::{ ffi::c_void, @@ -183,13 +183,10 @@ impl QueryPool { where T: QueryResultElement, { - flags - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-vkGetQueryPoolResults-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(&self.device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-vkGetQueryPoolResults-flags-parameter"]) + })?; if destination.is_empty() { return Err(Box::new(ValidationError { @@ -363,13 +360,10 @@ impl QueryPoolCreateInfo { _ne: _, } = self; - query_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "query_type".into(), - vuids: &["VUID-VkQueryPoolCreateInfo-queryType-parameter"], - ..ValidationError::from_requirement(err) - })?; + query_type.validate_device(device).map_err(|err| { + err.add_context("query_type") + .set_vuids(&["VUID-VkQueryPoolCreateInfo-queryType-parameter"]) + })?; match query_type { QueryType::PipelineStatistics(flags) => { @@ -384,13 +378,10 @@ impl QueryPoolCreateInfo { })); } - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "query_type.flags".into(), - vuids: &["VUID-VkQueryPoolCreateInfo-queryType-00792"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("query_type.flags") + .set_vuids(&["VUID-VkQueryPoolCreateInfo-queryType-00792"]) + })?; } QueryType::Occlusion | QueryType::Timestamp @@ -508,50 +499,55 @@ impl QueryType { } } - pub(crate) fn validate_device(&self, device: &Device) -> Result<(), RequirementNotMet> { + pub(crate) fn validate_device(&self, device: &Device) -> Result<(), Box> { match self { QueryType::Occlusion => (), QueryType::PipelineStatistics(_) => (), QueryType::Timestamp => (), QueryType::AccelerationStructureCompactedSize => { if !device.enabled_extensions().khr_acceleration_structure { - return Err(crate::RequirementNotMet { - required_for: "QueryType::AccelerationStructureCompactedSize", + return Err(Box::new(ValidationError { + problem: "is `QueryType::AccelerationStructureCompactedSize`".into(), requires_one_of: RequiresOneOf(&[RequiresAllOf(&[ Requires::DeviceExtension("khr_acceleration_structure"), ])]), - }); + ..Default::default() + })); } } QueryType::AccelerationStructureSerializationSize => { if !device.enabled_extensions().khr_acceleration_structure { - return Err(crate::RequirementNotMet { - required_for: "QueryType::AccelerationStructureSerializationSize", + return Err(Box::new(ValidationError { + problem: "is `QueryType::AccelerationStructureSerializationSize`".into(), requires_one_of: RequiresOneOf(&[RequiresAllOf(&[ Requires::DeviceExtension("khr_acceleration_structure"), ])]), - }); + ..Default::default() + })); } } QueryType::AccelerationStructureSerializationBottomLevelPointers => { if !device.enabled_extensions().khr_ray_tracing_maintenance1 { - return Err(crate::RequirementNotMet { - required_for: - "QueryType::AccelerationStructureSerializationBottomLevelPointers", + return Err(Box::new(ValidationError { + problem: + "is `QueryType::AccelerationStructureSerializationBottomLevelPointers`" + .into(), requires_one_of: RequiresOneOf(&[RequiresAllOf(&[ Requires::DeviceExtension("khr_ray_tracing_maintenance1"), ])]), - }); + ..Default::default() + })); } } QueryType::AccelerationStructureSize => { if !device.enabled_extensions().khr_ray_tracing_maintenance1 { - return Err(crate::RequirementNotMet { - required_for: "QueryType::AccelerationStructureSize", + return Err(Box::new(ValidationError { + problem: "is `QueryType::AccelerationStructureSize`".into(), requires_one_of: RequiresOneOf(&[RequiresAllOf(&[ Requires::DeviceExtension("khr_ray_tracing_maintenance1"), ])]), - }); + ..Default::default() + })); } } } diff --git a/vulkano/src/render_pass/framebuffer.rs b/vulkano/src/render_pass/framebuffer.rs index 2a338066..9364a0d8 100644 --- a/vulkano/src/render_pass/framebuffer.rs +++ b/vulkano/src/render_pass/framebuffer.rs @@ -523,13 +523,10 @@ impl FramebufferCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkFramebufferCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkFramebufferCreateInfo-flags-parameter"]) + })?; for (index, image_view) in attachments.iter().enumerate() { assert_eq!(device, image_view.device().as_ref()); diff --git a/vulkano/src/render_pass/mod.rs b/vulkano/src/render_pass/mod.rs index d54cbe3d..ce0c77c0 100644 --- a/vulkano/src/render_pass/mod.rs +++ b/vulkano/src/render_pass/mod.rs @@ -834,13 +834,10 @@ impl RenderPassCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkRenderPassCreateInfo2-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkRenderPassCreateInfo2-flags-parameter"]) + })?; let mut attachment_potential_format_features = vec![FormatFeatures::empty(); attachments.len()]; @@ -934,19 +931,18 @@ impl RenderPassCreateInfo { _ne: _, } = color_attachment; - let attachment_desc = - attachments - .get(attachment as usize) - .ok_or_else(|| ValidationError { - problem: format!( - "`subpasses[{0}].color_attachments[{1}].attachment` \ + let attachment_desc = attachments.get(attachment as usize).ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "`subpasses[{0}].color_attachments[{1}].attachment` \ is not less than the length of `attachments`", - subpass_index, ref_index - ) - .into(), - vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], - ..Default::default() - })?; + subpass_index, ref_index + ) + .into(), + vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], + ..Default::default() + }) + })?; let is_first_use = !replace(&mut attachment_is_used[attachment as usize], true); @@ -1023,15 +1019,17 @@ impl RenderPassCreateInfo { let resolve_attachment_desc = attachments .get(resolve_attachment as usize) - .ok_or_else(|| ValidationError { - problem: format!( + .ok_or_else(|| { + Box::new(ValidationError { + problem: format!( "`subpasses[{0}].color_resolve_attachments[{1}].attachment` is \ not less than the length of `attachments`", subpass_index, ref_index ) - .into(), - vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], - ..Default::default() + .into(), + vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], + ..Default::default() + }) })?; let is_first_use = @@ -1135,19 +1133,18 @@ impl RenderPassCreateInfo { _ne: _, } = depth_stencil_attachment; - let attachment_desc = - attachments - .get(attachment as usize) - .ok_or_else(|| ValidationError { - problem: format!( - "`subpasses[{}].depth_stencil_attachment.attachment` \ + let attachment_desc = attachments.get(attachment as usize).ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "`subpasses[{}].depth_stencil_attachment.attachment` \ is not less than the length of `attachments`", - subpass_index, - ) - .into(), - vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], - ..Default::default() - })?; + subpass_index, + ) + .into(), + vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], + ..Default::default() + }) + })?; let format = attachment_desc.format; @@ -1247,15 +1244,17 @@ impl RenderPassCreateInfo { let resolve_attachment_desc = attachments .get(resolve_attachment as usize) - .ok_or_else(|| ValidationError { - problem: format!( + .ok_or_else(|| { + Box::new(ValidationError { + problem: format!( "`subpasses[{}].depth_stencil_resolve_attachment.attachment` is \ not less than the length of `attachments`", subpass_index, ) - .into(), - vuids: &["VUID-VkRenderPassCreateInfo2-pSubpasses-06473"], - ..Default::default() + .into(), + vuids: &["VUID-VkRenderPassCreateInfo2-pSubpasses-06473"], + ..Default::default() + }) })?; let resolve_format = resolve_attachment_desc.format; @@ -1391,19 +1390,18 @@ impl RenderPassCreateInfo { _ne: _, } = input_attachment; - let attachment_desc = - attachments - .get(attachment as usize) - .ok_or_else(|| ValidationError { - problem: format!( - "`subpasses[{}].input_attachments[{}].attachment` \ + let attachment_desc = attachments.get(attachment as usize).ok_or_else(|| { + Box::new(ValidationError { + problem: format!( + "`subpasses[{}].input_attachments[{}].attachment` \ is not less than the length of `attachments`", - subpass_index, ref_index - ) - .into(), - vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], - ..Default::default() - })?; + subpass_index, ref_index + ) + .into(), + vuids: &["VUID-VkRenderPassCreateInfo2-attachment-03051"], + ..Default::default() + }) + })?; let format_aspects = attachment_desc.format.aspects(); let is_first_use = !replace(&mut attachment_is_used[attachment as usize], true); @@ -1614,12 +1612,12 @@ impl RenderPassCreateInfo { correlated_view_masks.iter().try_fold(0, |total, &mask| { if total & mask != 0 { - Err(ValidationError { + Err(Box::new(ValidationError { context: "correlated_view_masks".into(), problem: "the bit masks overlap with each other".into(), vuids: &["VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-03056"], ..Default::default() - }) + })) } else { Ok(total | mask) } @@ -1757,61 +1755,40 @@ impl AttachmentDescription { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkAttachmentDescription2-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkAttachmentDescription2-flags-parameter"]) + })?; - format - .validate_device(device) - .map_err(|err| ValidationError { - context: "format".into(), - vuids: &["VUID-VkAttachmentDescription2-format-parameter"], - ..ValidationError::from_requirement(err) - })?; + format.validate_device(device).map_err(|err| { + err.add_context("format") + .set_vuids(&["VUID-VkAttachmentDescription2-format-parameter"]) + })?; - samples - .validate_device(device) - .map_err(|err| ValidationError { - context: "samples".into(), - vuids: &["VUID-VkAttachmentDescription2-samples-parameter"], - ..ValidationError::from_requirement(err) - })?; + samples.validate_device(device).map_err(|err| { + err.add_context("samples") + .set_vuids(&["VUID-VkAttachmentDescription2-samples-parameter"]) + })?; - load_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "load_op".into(), - vuids: &["VUID-VkAttachmentDescription2-loadOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + load_op.validate_device(device).map_err(|err| { + err.add_context("load_op") + .set_vuids(&["VUID-VkAttachmentDescription2-loadOp-parameter"]) + })?; - store_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "store_op".into(), - vuids: &["VUID-VkAttachmentDescription2-storeOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + store_op.validate_device(device).map_err(|err| { + err.add_context("store_op") + .set_vuids(&["VUID-VkAttachmentDescription2-storeOp-parameter"]) + })?; - initial_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "initial_layout".into(), - vuids: &["VUID-VkAttachmentDescription2-initialLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + initial_layout.validate_device(device).map_err(|err| { + err.add_context("initial_layout") + .set_vuids(&["VUID-VkAttachmentDescription2-initialLayout-parameter"]) + })?; - final_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "final_layout".into(), - vuids: &["VUID-VkAttachmentDescription2-finalLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + final_layout.validate_device(device).map_err(|err| { + err.add_context("final_layout") + .set_vuids(&["VUID-VkAttachmentDescription2-finalLayout-parameter"]) + })?; if matches!( final_layout, @@ -1866,23 +1843,17 @@ impl AttachmentDescription { } if let Some(stencil_load_op) = stencil_load_op { - stencil_load_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_load_op".into(), - vuids: &["VUID-VkAttachmentDescription2-stencilLoadOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + stencil_load_op.validate_device(device).map_err(|err| { + err.add_context("stencil_load_op") + .set_vuids(&["VUID-VkAttachmentDescription2-stencilLoadOp-parameter"]) + })?; } if let Some(stencil_store_op) = stencil_store_op { - stencil_store_op - .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_store_op".into(), - vuids: &["VUID-VkAttachmentDescription2-stencilStoreOp-parameter"], - ..ValidationError::from_requirement(err) - })?; + stencil_store_op.validate_device(device).map_err(|err| { + err.add_context("stencil_store_op") + .set_vuids(&["VUID-VkAttachmentDescription2-stencilStoreOp-parameter"]) + })?; } if stencil_initial_layout.is_some() != stencil_final_layout.is_some() { @@ -1908,12 +1879,10 @@ impl AttachmentDescription { stencil_initial_layout .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_initial_layout".into(), - vuids: &[ + .map_err(|err| { + err.add_context("stencil_initial_layout").set_vuids(&[ "VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; if matches!( @@ -1951,12 +1920,10 @@ impl AttachmentDescription { stencil_final_layout .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_final_layout".into(), - vuids: &[ + .map_err(|err| { + err.add_context("stencil_final_layout").set_vuids(&[ "VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; if matches!( @@ -2375,13 +2342,10 @@ impl SubpassDescription { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkSubpassDescription2-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkSubpassDescription2-flags-parameter"]) + })?; if color_attachments.len() as u32 > properties.max_color_attachments { return Err(Box::new(ValidationError { @@ -2859,11 +2823,7 @@ impl SubpassDescription { depth_resolve_mode .validate_device(device) - .map_err(|err| ValidationError { - context: "depth_resolve_mode".into(), - // vuids? - ..ValidationError::from_requirement(err) - })?; + .map_err(|err| err.add_context("depth_resolve_mode"))?; if !properties .supported_depth_resolve_modes @@ -2892,11 +2852,7 @@ impl SubpassDescription { stencil_resolve_mode .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_resolve_mode".into(), - // vuids? - ..ValidationError::from_requirement(err) - })?; + .map_err(|err| err.add_context("stencil_resolve_mode"))?; if !properties .supported_stencil_resolve_modes @@ -3176,13 +3132,10 @@ impl AttachmentReference { _ne, } = self; - layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "layout".into(), - vuids: &["VUID-VkAttachmentReference2-layout-parameter"], - ..ValidationError::from_requirement(err) - })?; + layout.validate_device(device).map_err(|err| { + err.add_context("layout") + .set_vuids(&["VUID-VkAttachmentReference2-layout-parameter"]) + })?; if matches!( layout, @@ -3229,13 +3182,10 @@ impl AttachmentReference { })); } - stencil_layout - .validate_device(device) - .map_err(|err| ValidationError { - context: "stencil_layout".into(), - vuids: &["VUID-VkAttachmentReferenceStencilLayout-stencilLayout-parameter"], - ..ValidationError::from_requirement(err) - })?; + stencil_layout.validate_device(device).map_err(|err| { + err.add_context("stencil_layout") + .set_vuids(&["VUID-VkAttachmentReferenceStencilLayout-stencilLayout-parameter"]) + })?; if matches!( stencil_layout, @@ -3283,11 +3233,7 @@ impl AttachmentReference { aspects .validate_device(device) - .map_err(|err| ValidationError { - context: "aspects".into(), - // vuids? - ..ValidationError::from_requirement(err) - })?; + .map_err(|err| err.add_context("aspects"))?; Ok(()) } diff --git a/vulkano/src/swapchain/acquire_present.rs b/vulkano/src/swapchain/acquire_present.rs index c1458c21..57fea2b4 100644 --- a/vulkano/src/swapchain/acquire_present.rs +++ b/vulkano/src/swapchain/acquire_present.rs @@ -672,18 +672,13 @@ where ) { Ok(_) => (), Err(AccessCheckError::Unknown) => { - return Err(Box::new(ValidationError { - problem: AccessError::SwapchainImageNotAcquired.to_string().into(), - ..Default::default() - }) + return Err(Box::new(ValidationError::from_error( + AccessError::SwapchainImageNotAcquired, + )) .into()); } Err(AccessCheckError::Denied(err)) => { - return Err(Box::new(ValidationError { - problem: err.to_string().into(), - ..Default::default() - }) - .into()); + return Err(Box::new(ValidationError::from_error(err)).into()); } } diff --git a/vulkano/src/swapchain/display.rs b/vulkano/src/swapchain/display.rs index 09517bde..5e23fc8a 100644 --- a/vulkano/src/swapchain/display.rs +++ b/vulkano/src/swapchain/display.rs @@ -29,8 +29,7 @@ #![allow(unused_variables)] // TODO: this module isn't finished use crate::{ - device::physical::PhysicalDevice, swapchain::SurfaceTransforms, OomError, VulkanError, - VulkanObject, + device::physical::PhysicalDevice, swapchain::SurfaceTransforms, VulkanError, VulkanObject, }; use std::{ ffi::CStr, @@ -56,7 +55,7 @@ impl DisplayPlane { /// See the docs of enumerate(). pub fn enumerate_raw( physical_device: Arc, - ) -> Result, OomError> { + ) -> Result, VulkanError> { let fns = physical_device.instance().fns(); assert!(physical_device.instance().enabled_extensions().khr_display); // TODO: return error instead @@ -88,7 +87,7 @@ impl DisplayPlane { break properties; } ash::vk::Result::INCOMPLETE => (), - err => return Err(VulkanError::from(err).into()), + err => return Err(VulkanError::from(err)), } } }; @@ -189,7 +188,7 @@ impl Display { /// See the docs of enumerate(). pub fn enumerate_raw( physical_device: Arc, - ) -> Result, OomError> { + ) -> Result, VulkanError> { let fns = physical_device.instance().fns(); assert!(physical_device.instance().enabled_extensions().khr_display); // TODO: return error instead @@ -217,7 +216,7 @@ impl Display { break properties; } ash::vk::Result::INCOMPLETE => (), - err => return Err(VulkanError::from(err).into()), + err => return Err(VulkanError::from(err)), } } }; @@ -295,7 +294,7 @@ impl Display { } /// See the docs of display_modes(). - pub fn display_modes_raw(&self) -> Result, OomError> { + pub fn display_modes_raw(&self) -> Result, VulkanError> { let fns = self.physical_device.instance().fns(); let mode_properties = unsafe { @@ -324,7 +323,7 @@ impl Display { break properties; } ash::vk::Result::INCOMPLETE => (), - err => return Err(VulkanError::from(err).into()), + err => return Err(VulkanError::from(err)), } } }; @@ -371,7 +370,7 @@ pub struct DisplayMode { } impl DisplayMode { - /*pub fn new(display: &Display) -> Result, OomError> { + /*pub fn new(display: &Display) -> Result, VulkanError> { let fns = instance.fns(); assert!(device.instance().enabled_extensions().khr_display); // TODO: return error instead diff --git a/vulkano/src/swapchain/mod.rs b/vulkano/src/swapchain/mod.rs index 30d499b3..efd1e9b3 100644 --- a/vulkano/src/swapchain/mod.rs +++ b/vulkano/src/swapchain/mod.rs @@ -589,10 +589,13 @@ impl Swapchain { ..Default::default() }, ) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_capabilities".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_capabilities` \ + returned an error" + .into(), + ..Default::default() + }) })? }; let surface_formats = unsafe { @@ -608,20 +611,26 @@ impl Swapchain { ..Default::default() }, ) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_formats".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_formats` \ + returned an error" + .into(), + ..Default::default() + }) })? }; let surface_present_modes: SmallVec<[_; PresentMode::COUNT]> = unsafe { device .physical_device() .surface_present_modes_unchecked(surface) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_present_modes".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_present_modes` \ + returned an error" + .into(), + ..Default::default() + }) })? .collect() }; @@ -814,10 +823,13 @@ impl Swapchain { ..Default::default() }, ) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::surface_capabilities".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::surface_capabilities` \ + returned an error" + .into(), + ..Default::default() + }) })? }; @@ -1729,37 +1741,25 @@ impl SwapchainCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-flags-parameter"]) + })?; - image_format - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_format".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_format.validate_device(device).map_err(|err| { + err.add_context("image_format") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter"]) + })?; - image_color_space - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_color_space".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_color_space.validate_device(device).map_err(|err| { + err.add_context("image_color_space") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter"]) + })?; - image_usage - .validate_device(device) - .map_err(|err| ValidationError { - context: "image_usage".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter"], - ..ValidationError::from_requirement(err) - })?; + image_usage.validate_device(device).map_err(|err| { + err.add_context("image_usage") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter"]) + })?; if image_usage.is_empty() { return Err(Box::new(ValidationError { @@ -1770,29 +1770,20 @@ impl SwapchainCreateInfo { })); } - pre_transform - .validate_device(device) - .map_err(|err| ValidationError { - context: "pre_transform".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-preTransform-parameter"], - ..ValidationError::from_requirement(err) - })?; + pre_transform.validate_device(device).map_err(|err| { + err.add_context("pre_transform") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-preTransform-parameter"]) + })?; - composite_alpha - .validate_device(device) - .map_err(|err| ValidationError { - context: "composite_alpha".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter"], - ..ValidationError::from_requirement(err) - })?; + composite_alpha.validate_device(device).map_err(|err| { + err.add_context("composite_alpha") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter"]) + })?; - present_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: "present_mode".into(), - vuids: &["VUID-VkSwapchainCreateInfoKHR-presentMode-parameter"], - ..ValidationError::from_requirement(err) - })?; + present_mode.validate_device(device).map_err(|err| { + err.add_context("present_mode") + .set_vuids(&["VUID-VkSwapchainCreateInfoKHR-presentMode-parameter"]) + })?; if image_extent.contains(&0) { return Err(Box::new(ValidationError { @@ -1868,10 +1859,13 @@ impl SwapchainCreateInfo { usage: image_usage, ..Default::default() }) - .map_err(|_err| ValidationError { - context: "PhysicalDevice::image_format_properties".into(), - problem: "returned an error".into(), - ..Default::default() + .map_err(|_err| { + Box::new(ValidationError { + problem: "`PhysicalDevice::image_format_properties` \ + returned an error" + .into(), + ..Default::default() + }) })? }; @@ -1898,15 +1892,12 @@ impl SwapchainCreateInfo { } for (index, &present_mode) in present_modes.iter().enumerate() { - present_mode - .validate_device(device) - .map_err(|err| ValidationError { - context: format!("present_modes[{}]", index).into(), - vuids: &[ + present_mode.validate_device(device).map_err(|err| { + err.add_context(format!("present_modes[{}]", index)) + .set_vuids(&[ "VUID-VkSwapchainPresentModesCreateInfoEXT-pPresentModes-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + ]) + })?; } if !present_modes.contains(&present_mode) { @@ -1931,15 +1922,11 @@ impl SwapchainCreateInfo { })); } - scaling_behavior - .validate_device(device) - .map_err(|err| ValidationError { - context: "scaling_behavior".into(), - vuids: &[ - "VUID-VkSwapchainPresentScalingCreateInfoEXT-scalingBehavior-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + scaling_behavior.validate_device(device).map_err(|err| { + err.add_context("scaling_behavior").set_vuids(&[ + "VUID-VkSwapchainPresentScalingCreateInfoEXT-scalingBehavior-parameter", + ]) + })?; // VUID-VkSwapchainPresentScalingCreateInfoEXT-scalingBehavior-07767 // Ensured by the use of an enum. @@ -1958,16 +1945,13 @@ impl SwapchainCreateInfo { } for (axis_index, present_gravity) in present_gravity.into_iter().enumerate() { - present_gravity - .validate_device(device) - .map_err(|err| ValidationError { - context: format!("present_gravity[{}]", axis_index).into(), - vuids: &[ + present_gravity.validate_device(device).map_err(|err| { + err.add_context(format!("present_gravity[{}]", axis_index)) + .set_vuids(&[ "VUID-VkSwapchainPresentScalingCreateInfoEXT-presentGravityX-parameter", "VUID-VkSwapchainPresentScalingCreateInfoEXT-presentGravityY-parameter", - ], - ..ValidationError::from_requirement(err) - })?; + ]) + })?; } // VUID-VkSwapchainPresentScalingCreateInfoEXT-presentGravityX-07765 @@ -1993,12 +1977,10 @@ impl SwapchainCreateInfo { full_screen_exclusive .validate_device(device) - .map_err(|err| ValidationError { - context: "full_screen_exclusive".into(), - vuids: &[ + .map_err(|err| { + err.add_context("full_screen_exclusive").set_vuids(&[ "VUID-VkSurfaceFullScreenExclusiveInfoEXT-fullScreenExclusive-parameter", - ], - ..ValidationError::from_requirement(err) + ]) })?; } diff --git a/vulkano/src/swapchain/surface.rs b/vulkano/src/swapchain/surface.rs index 338b56e1..8425ef82 100644 --- a/vulkano/src/swapchain/surface.rs +++ b/vulkano/src/swapchain/surface.rs @@ -1882,10 +1882,9 @@ impl SurfaceInfo { present_mode .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "present_mode".into(), - vuids: &["VUID-VkSurfacePresentModeEXT-presentMode-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("present_mode") + .set_vuids(&["VUID-VkSurfacePresentModeEXT-presentMode-parameter"]) })?; } diff --git a/vulkano/src/sync/event.rs b/vulkano/src/sync/event.rs index 94be34b7..e7bb2d51 100644 --- a/vulkano/src/sync/event.rs +++ b/vulkano/src/sync/event.rs @@ -326,13 +326,10 @@ impl EventCreateInfo { pub(crate) fn validate(&self, device: &Device) -> Result<(), Box> { let &Self { flags, _ne: _ } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkEventCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkEventCreateInfo-flags-parameter"]) + })?; Ok(()) } diff --git a/vulkano/src/sync/fence.rs b/vulkano/src/sync/fence.rs index 1e94dcfb..b40f210c 100644 --- a/vulkano/src/sync/fence.rs +++ b/vulkano/src/sync/fence.rs @@ -574,13 +574,10 @@ impl Fence { })); } - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkFenceGetFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkFenceGetFdInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -728,13 +725,10 @@ impl Fence { })); } - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -1151,13 +1145,10 @@ impl FenceCreateInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkFenceCreateInfo-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkFenceCreateInfo-flags-parameter"]) + })?; if !export_handle_types.is_empty() { if !(device.api_version() >= Version::V1_1 @@ -1174,13 +1165,10 @@ impl FenceCreateInfo { })); } - export_handle_types - .validate_device(device) - .map_err(|err| ValidationError { - context: "export_handle_types".into(), - vuids: &["VUID-VkExportFenceCreateInfo-handleTypes-parameter"], - ..ValidationError::from_requirement(err) - })?; + export_handle_types.validate_device(device).map_err(|err| { + err.add_context("export_handle_types") + .set_vuids(&["VUID-VkExportFenceCreateInfo-handleTypes-parameter"]) + })?; for handle_type in export_handle_types.into_iter() { let external_fence_properties = unsafe { @@ -1344,21 +1332,15 @@ impl ImportFenceFdInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImportFenceFdInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImportFenceFdInfoKHR-flags-parameter"]) + })?; - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportFenceFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportFenceFdInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -1435,21 +1417,15 @@ impl ImportFenceWin32HandleInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter"]) + })?; - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457"]) + })?; if !matches!( handle_type, @@ -1513,10 +1489,9 @@ impl ExternalFenceInfo { handle_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter"]) })?; Ok(()) diff --git a/vulkano/src/sync/future/fence_signal.rs b/vulkano/src/sync/future/fence_signal.rs index 73e4d1b4..02c5b586 100644 --- a/vulkano/src/sync/future/fence_signal.rs +++ b/vulkano/src/sync/future/fence_signal.rs @@ -335,20 +335,13 @@ where ) { Ok(_) => (), Err(AccessCheckError::Unknown) => { - return Err(Box::new(ValidationError { - problem: AccessError::SwapchainImageNotAcquired - .to_string() - .into(), - ..Default::default() - }) + return Err(Box::new(ValidationError::from_error( + AccessError::SwapchainImageNotAcquired, + )) .into()); } Err(AccessCheckError::Denied(err)) => { - return Err(Box::new(ValidationError { - problem: err.to_string().into(), - ..Default::default() - }) - .into()); + return Err(Box::new(ValidationError::from_error(err)).into()); } } } diff --git a/vulkano/src/sync/future/semaphore_signal.rs b/vulkano/src/sync/future/semaphore_signal.rs index ea452328..2442edcd 100644 --- a/vulkano/src/sync/future/semaphore_signal.rs +++ b/vulkano/src/sync/future/semaphore_signal.rs @@ -163,20 +163,13 @@ where ) { Ok(_) => (), Err(AccessCheckError::Unknown) => { - return Err(Box::new(ValidationError { - problem: AccessError::SwapchainImageNotAcquired - .to_string() - .into(), - ..Default::default() - }) + return Err(Box::new(ValidationError::from_error( + AccessError::SwapchainImageNotAcquired, + )) .into()); } Err(AccessCheckError::Denied(err)) => { - return Err(Box::new(ValidationError { - problem: err.to_string().into(), - ..Default::default() - }) - .into()); + return Err(Box::new(ValidationError::from_error(err)).into()); } } } diff --git a/vulkano/src/sync/mod.rs b/vulkano/src/sync/mod.rs index 102a0f5a..57fb6494 100644 --- a/vulkano/src/sync/mod.rs +++ b/vulkano/src/sync/mod.rs @@ -104,7 +104,7 @@ pub(crate) enum CurrentAccess { pub enum HostAccessError { AccessConflict(AccessConflict), Invalidate(VulkanError), - ValidationError(ValidationError), + ValidationError(Box), } impl Error for HostAccessError { diff --git a/vulkano/src/sync/pipeline.rs b/vulkano/src/sync/pipeline.rs index 34be620e..e017774e 100644 --- a/vulkano/src/sync/pipeline.rs +++ b/vulkano/src/sync/pipeline.rs @@ -1774,13 +1774,10 @@ impl DependencyInfo { _ne: _, } = self; - dependency_flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "dependency_flags".into(), - vuids: &["VUID-VkDependencyInfo-dependencyFlags-parameter"], - ..ValidationError::from_requirement(err) - })?; + dependency_flags.validate_device(device).map_err(|err| { + err.add_context("dependency_flags") + .set_vuids(&["VUID-VkDependencyInfo-dependencyFlags-parameter"]) + })?; for (barrier_index, memory_barrier) in memory_barriers.iter().enumerate() { memory_barrier @@ -1911,37 +1908,25 @@ impl MemoryBarrier { _ne: _, } = self; - src_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_stages".into(), - vuids: &["VUID-VkMemoryBarrier2-srcStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_stages.validate_device(device).map_err(|err| { + err.add_context("src_stages") + .set_vuids(&["VUID-VkMemoryBarrier2-srcStageMask-parameter"]) + })?; - dst_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_stages".into(), - vuids: &["VUID-VkMemoryBarrier2-dstStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_stages.validate_device(device).map_err(|err| { + err.add_context("dst_stages") + .set_vuids(&["VUID-VkMemoryBarrier2-dstStageMask-parameter"]) + })?; - src_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_access".into(), - vuids: &["VUID-VkMemoryBarrier2-srcAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_access.validate_device(device).map_err(|err| { + err.add_context("src_access") + .set_vuids(&["VUID-VkMemoryBarrier2-srcAccessMask-parameter"]) + })?; - dst_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_access".into(), - vuids: &["VUID-VkMemoryBarrier2-dstAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_access.validate_device(device).map_err(|err| { + err.add_context("dst_access") + .set_vuids(&["VUID-VkMemoryBarrier2-dstAccessMask-parameter"]) + })?; if !device.enabled_features().synchronization2 { if src_stages.contains_flags2() { @@ -2439,37 +2424,25 @@ impl BufferMemoryBarrier { _ne, } = self; - src_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_stages".into(), - vuids: &["VUID-VkBufferMemoryBarrier2-srcStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_stages.validate_device(device).map_err(|err| { + err.add_context("src_stages") + .set_vuids(&["VUID-VkBufferMemoryBarrier2-srcStageMask-parameter"]) + })?; - dst_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_stages".into(), - vuids: &["VUID-VkBufferMemoryBarrier2-dstStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_stages.validate_device(device).map_err(|err| { + err.add_context("dst_stages") + .set_vuids(&["VUID-VkBufferMemoryBarrier2-dstStageMask-parameter"]) + })?; - src_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_access".into(), - vuids: &["VUID-VkBufferMemoryBarrier2-srcAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_access.validate_device(device).map_err(|err| { + err.add_context("src_access") + .set_vuids(&["VUID-VkBufferMemoryBarrier2-srcAccessMask-parameter"]) + })?; - dst_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_access".into(), - vuids: &["VUID-VkBufferMemoryBarrier2-dstAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_access.validate_device(device).map_err(|err| { + err.add_context("dst_access") + .set_vuids(&["VUID-VkBufferMemoryBarrier2-dstAccessMask-parameter"]) + })?; if !device.enabled_features().synchronization2 { if src_stages.contains_flags2() { @@ -3124,37 +3097,25 @@ impl ImageMemoryBarrier { _ne, } = self; - src_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_stages".into(), - vuids: &["VUID-VkImageMemoryBarrier2-srcStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_stages.validate_device(device).map_err(|err| { + err.add_context("src_stages") + .set_vuids(&["VUID-VkImageMemoryBarrier2-srcStageMask-parameter"]) + })?; - dst_stages - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_stages".into(), - vuids: &["VUID-VkImageMemoryBarrier2-dstStageMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_stages.validate_device(device).map_err(|err| { + err.add_context("dst_stages") + .set_vuids(&["VUID-VkImageMemoryBarrier2-dstStageMask-parameter"]) + })?; - src_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "src_access".into(), - vuids: &["VUID-VkImageMemoryBarrier2-srcAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + src_access.validate_device(device).map_err(|err| { + err.add_context("src_access") + .set_vuids(&["VUID-VkImageMemoryBarrier2-srcAccessMask-parameter"]) + })?; - dst_access - .validate_device(device) - .map_err(|err| ValidationError { - context: "dst_access".into(), - vuids: &["VUID-VkImageMemoryBarrier2-dstAccessMask-parameter"], - ..ValidationError::from_requirement(err) - })?; + dst_access.validate_device(device).map_err(|err| { + err.add_context("dst_access") + .set_vuids(&["VUID-VkImageMemoryBarrier2-dstAccessMask-parameter"]) + })?; if !device.enabled_features().synchronization2 { if src_stages.contains_flags2() { diff --git a/vulkano/src/sync/semaphore.rs b/vulkano/src/sync/semaphore.rs index 661d1bb2..d19c48b8 100644 --- a/vulkano/src/sync/semaphore.rs +++ b/vulkano/src/sync/semaphore.rs @@ -196,13 +196,10 @@ impl Semaphore { })); } - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -367,13 +364,10 @@ impl Semaphore { })); } - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -543,13 +537,10 @@ impl Semaphore { })); } - handle_type - .validate_device(&self.device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(&self.device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-parameter"]) + })?; if !matches!(handle_type, ExternalSemaphoreHandleType::ZirconEvent) { return Err(Box::new(ValidationError { @@ -1183,13 +1174,10 @@ impl SemaphoreCreateInfo { })); } - export_handle_types - .validate_device(device) - .map_err(|err| ValidationError { - context: "export_handle_types".into(), - vuids: &["VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter"], - ..ValidationError::from_requirement(err) - })?; + export_handle_types.validate_device(device).map_err(|err| { + err.add_context("export_handle_types") + .set_vuids(&["VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter"]) + })?; for handle_type in export_handle_types.into_iter() { let external_semaphore_properties = unsafe { @@ -1363,21 +1351,15 @@ impl ImportSemaphoreFdInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImportSemaphoreFdInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImportSemaphoreFdInfoKHR-flags-parameter"]) + })?; - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter"]) + })?; if !matches!( handle_type, @@ -1456,21 +1438,15 @@ impl ImportSemaphoreWin32HandleInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter"]) + })?; - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140"]) + })?; if !matches!( handle_type, @@ -1551,21 +1527,15 @@ impl ImportSemaphoreZirconHandleInfo { _ne: _, } = self; - flags - .validate_device(device) - .map_err(|err| ValidationError { - context: "flags".into(), - vuids: &["VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-flags-parameter"], - ..ValidationError::from_requirement(err) - })?; + flags.validate_device(device).map_err(|err| { + err.add_context("flags") + .set_vuids(&["VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-flags-parameter"]) + })?; - handle_type - .validate_device(device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-handleType-parameter"], - ..ValidationError::from_requirement(err) - })?; + handle_type.validate_device(device).map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-handleType-parameter"]) + })?; if !matches!(handle_type, ExternalSemaphoreHandleType::ZirconEvent) { return Err(Box::new(ValidationError { @@ -1626,10 +1596,9 @@ impl ExternalSemaphoreInfo { handle_type .validate_physical_device(physical_device) - .map_err(|err| ValidationError { - context: "handle_type".into(), - vuids: &["VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter"], - ..ValidationError::from_requirement(err) + .map_err(|err| { + err.add_context("handle_type") + .set_vuids(&["VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter"]) })?; Ok(())