From 85b2696a1f2a1fa459ac493e64e692746e0bafe8 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sun, 3 Jul 2022 21:54:17 +0200 Subject: [PATCH] Update Vulkan-Headers to 1.3.219 (#619) * Update Vulkan-Headers to 1.3.212 * Update Vulkan-Headers to 1.3.213 * Update Vulkan-Headers to 1.3.214 * Update Vulkan-Headers to 1.3.215 * Update Vulkan-Headers to 1.3.216 * Update Vulkan-Headers to 1.3.217 * Update Vulkan-Headers to 1.3.218 * Update Vulkan-Headers to 1.3.219 * Changelog: reorder entries chronologically based on PR ID --- Changelog.md | 6 +- ash/Cargo.toml | 2 +- ash/src/vk/aliases.rs | 3 + ash/src/vk/bitflags.rs | 105 +- ash/src/vk/const_debugs.rs | 286 +++- ash/src/vk/constants.rs | 1 + ash/src/vk/definitions.rs | 2890 ++++++++++++++++++++++++++++++++-- ash/src/vk/enums.rs | 53 +- ash/src/vk/extensions.rs | 794 ++++++++-- ash/src/vk/native.rs | 64 +- ash/src/vk/platform_types.rs | 18 +- generator/Vulkan-Headers | 2 +- generator/src/lib.rs | 16 +- 13 files changed, 3927 insertions(+), 313 deletions(-) diff --git a/Changelog.md b/Changelog.md index 1059337..2df843c 100644 --- a/Changelog.md +++ b/Changelog.md @@ -13,10 +13,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Added `VK_NV_coverage_reduction_mode` device extension (#617) -- Added `VK_EXT_sample_locations` device extension (#616) -- Update Vulkan-Headers to 1.3.211 (#605, #608) - Added `VK_EXT_image_drm_format_modifier` device extension (#603) +- Update Vulkan-Headers to 1.3.219 (#605, #608, #619) +- Added `VK_EXT_sample_locations` device extension (#616) +- Added `VK_NV_coverage_reduction_mode` device extension (#617) - Added new functions to `VK_KHR_swapchain`, available since Vulkan 1.1 (#629) - Added `VK_KHR_device_group_creation` instance extension (#630) - Added `VK_KHR_device_group` device extension (#631) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index def1784..9148186 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.211" +version = "0.37.0+1.3.219" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT" diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index ef6940b..75f24b8 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -166,6 +166,8 @@ pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomic pub type PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; +pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV = + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = @@ -188,6 +190,7 @@ pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; +pub type PipelineInfoEXT = PipelineInfoKHR; pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT = diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 6032cef..403b040 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -906,6 +906,7 @@ impl DeviceDiagnosticsConfigFlagsNV { pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); + pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(0b1000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1264,29 +1265,31 @@ impl VideoEncodeRateControlModeFlagsKHR { pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); impl VideoEncodeH264CapabilityFlagsEXT { - pub const DIRECT_8X8_INFERENCE: Self = Self(0b1); - pub const SEPARATE_COLOUR_PLANE: Self = Self(0b10); - pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b100); - pub const SCALING_LISTS: Self = Self(0b1000); - pub const HRD_COMPLIANCE: Self = Self(0b1_0000); - pub const CHROMA_QP_OFFSET: Self = Self(0b10_0000); - pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b100_0000); - pub const PIC_INIT_QP_MINUS26: Self = Self(0b1000_0000); - pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000); - pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b10_0000_0000); - pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b100_0000_0000); - pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1000_0000_0000); - pub const TRANSFORM_8X8: Self = Self(0b1_0000_0000_0000); - pub const CABAC: Self = Self(0b10_0000_0000_0000); - pub const CAVLC: Self = Self(0b100_0000_0000_0000); - pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1000_0000_0000_0000); - pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1_0000_0000_0000_0000); - pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b10_0000_0000_0000_0000); - pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b100_0000_0000_0000_0000); - pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1000_0000_0000_0000_0000); - pub const SLICE_MB_COUNT: Self = Self(0b1_0000_0000_0000_0000_0000); - pub const ROW_UNALIGNED_SLICE: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const DIFFERENT_SLICE_TYPE: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1); + pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10); + pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100); + pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000); + pub const SCALING_LISTS: Self = Self(0b1_0000); + pub const HRD_COMPLIANCE: Self = Self(0b10_0000); + pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000); + pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000); + pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000); + pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000); + pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000); + pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000); + pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000); + pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000); + pub const CABAC: Self = Self(0b100_0000_0000_0000); + pub const CAVLC: Self = Self(0b1000_0000_0000_0000); + pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000); + pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000); + pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1506,7 +1509,63 @@ impl VideoEncodeH265TransformBlockSizeFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExportMetalObjectTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ExportMetalObjectTypeFlagsEXT, Flags); +impl ExportMetalObjectTypeFlagsEXT { + pub const METAL_DEVICE: Self = Self(0b1); + pub const METAL_COMMAND_QUEUE: Self = Self(0b10); + pub const METAL_BUFFER: Self = Self(0b100); + pub const METAL_TEXTURE: Self = Self(0b1000); + pub const METAL_IOSURFACE: Self = Self(0b1_0000); + pub const METAL_SHARED_EVENT: Self = Self(0b10_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct InstanceCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(InstanceCreateFlags, Flags); impl InstanceCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFlagsEXT, Flags); +impl ImageCompressionFlagsEXT { + pub const DEFAULT: Self = Self(0); + pub const FIXED_RATE_DEFAULT: Self = Self(0b1); + pub const FIXED_RATE_EXPLICIT: Self = Self(0b10); + pub const DISABLED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFixedRateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFixedRateFlagsEXT, Flags); +impl ImageCompressionFixedRateFlagsEXT { + pub const NONE: Self = Self(0); + pub const TYPE_1BPC: Self = Self(0b1); + pub const TYPE_2BPC: Self = Self(0b10); + pub const TYPE_3BPC: Self = Self(0b100); + pub const TYPE_4BPC: Self = Self(0b1000); + pub const TYPE_5BPC: Self = Self(0b1_0000); + pub const TYPE_6BPC: Self = Self(0b10_0000); + pub const TYPE_7BPC: Self = Self(0b100_0000); + pub const TYPE_8BPC: Self = Self(0b1000_0000); + pub const TYPE_9BPC: Self = Self(0b1_0000_0000); + pub const TYPE_10BPC: Self = Self(0b10_0000_0000); + pub const TYPE_11BPC: Self = Self(0b100_0000_0000); + pub const TYPE_12BPC: Self = Self(0b1000_0000_0000); + pub const TYPE_13BPC: Self = Self(0b1_0000_0000_0000); + pub const TYPE_14BPC: Self = Self(0b10_0000_0000_0000); + pub const TYPE_15BPC: Self = Self(0b100_0000_0000_0000); + pub const TYPE_16BPC: Self = Self(0b1000_0000_0000_0000); + pub const TYPE_17BPC: Self = Self(0b1_0000_0000_0000_0000); + pub const TYPE_18BPC: Self = Self(0b10_0000_0000_0000_0000); + pub const TYPE_19BPC: Self = Self(0b100_0000_0000_0000_0000); + pub const TYPE_20BPC: Self = Self(0b1000_0000_0000_0000_0000); + pub const TYPE_21BPC: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const TYPE_22BPC: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000); +} diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 20d048f..9e895d1 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -304,7 +304,10 @@ impl fmt::Debug for AccessFlags2 { AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0, "INVOCATION_MASK_READ_HUAWEI", ), - (AccessFlags2::RESERVED_387_KHR.0, "RESERVED_387_KHR"), + ( + AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0, + "SHADER_BINDING_TABLE_READ_KHR", + ), (AccessFlags2::RESERVED_44_NV.0, "RESERVED_44_NV"), (AccessFlags2::RESERVED_45_NV.0, "RESERVED_45_NV"), (AccessFlags2::RESERVED_42_NV.0, "RESERVED_42_NV"), @@ -545,6 +548,7 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, "CONDITIONAL_RENDERING_EXT", ), + (BufferUsageFlags::RESERVED_25_AMD.0, "RESERVED_25_AMD"), ( BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0, "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR", @@ -1033,6 +1037,7 @@ impl fmt::Debug for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::RESERVED_3_EXT.0, "RESERVED_3_EXT"), (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; @@ -1180,6 +1185,10 @@ impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV { DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0, "ENABLE_AUTOMATIC_CHECKPOINTS", ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_ERROR_REPORTING.0, + "ENABLE_SHADER_ERROR_REPORTING", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -1342,6 +1351,7 @@ impl fmt::Debug for DriverId { Self::MESA_PANVK => Some("MESA_PANVK"), Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), Self::MESA_VENUS => Some("MESA_VENUS"), + Self::MESA_DOZEN => Some("MESA_DOZEN"), _ => None, }; if let Some(x) = name { @@ -1408,6 +1418,37 @@ impl fmt::Debug for EventCreateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ExportMetalObjectTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExportMetalObjectTypeFlagsEXT::METAL_DEVICE.0, + "METAL_DEVICE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_COMMAND_QUEUE.0, + "METAL_COMMAND_QUEUE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_BUFFER.0, + "METAL_BUFFER", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_TEXTURE.0, + "METAL_TEXTURE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_IOSURFACE.0, + "METAL_IOSURFACE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_SHARED_EVENT.0, + "METAL_SHARED_EVENT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -1576,10 +1617,6 @@ impl fmt::Debug for ExternalSemaphoreHandleTypeFlags { ExternalSemaphoreHandleTypeFlags::RESERVED_5_NV.0, "RESERVED_5_NV", ), - ( - ExternalSemaphoreHandleTypeFlags::RESERVED_6_NV.0, - "RESERVED_6_NV", - ), ]; debug_flags(f, KNOWN, self.0) } @@ -2138,6 +2175,100 @@ impl fmt::Debug for ImageAspectFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ImageCompressionFixedRateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFixedRateFlagsEXT::NONE.0, "NONE"), + (ImageCompressionFixedRateFlagsEXT::TYPE_1BPC.0, "TYPE_1BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_2BPC.0, "TYPE_2BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_3BPC.0, "TYPE_3BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_4BPC.0, "TYPE_4BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_5BPC.0, "TYPE_5BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_6BPC.0, "TYPE_6BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_7BPC.0, "TYPE_7BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_8BPC.0, "TYPE_8BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_9BPC.0, "TYPE_9BPC"), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_10BPC.0, + "TYPE_10BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_11BPC.0, + "TYPE_11BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_12BPC.0, + "TYPE_12BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_13BPC.0, + "TYPE_13BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_14BPC.0, + "TYPE_14BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_15BPC.0, + "TYPE_15BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_16BPC.0, + "TYPE_16BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_17BPC.0, + "TYPE_17BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_18BPC.0, + "TYPE_18BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_19BPC.0, + "TYPE_19BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_20BPC.0, + "TYPE_20BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_21BPC.0, + "TYPE_21BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_22BPC.0, + "TYPE_22BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_23BPC.0, + "TYPE_23BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_24BPC.0, + "TYPE_24BPC", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCompressionFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFlagsEXT::DEFAULT.0, "DEFAULT"), + ( + ImageCompressionFlagsEXT::FIXED_RATE_DEFAULT.0, + "FIXED_RATE_DEFAULT", + ), + ( + ImageCompressionFlagsEXT::FIXED_RATE_EXPLICIT.0, + "FIXED_RATE_EXPLICIT", + ), + (ImageCompressionFlagsEXT::DISABLED.0, "DISABLED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -2180,7 +2311,10 @@ impl fmt::Debug for ImageCreateFlags { ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), - (ImageCreateFlags::RESERVED_18_EXT.0, "RESERVED_18_EXT"), + ( + ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0, + "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT", + ), ( ImageCreateFlags::TYPE_2D_VIEW_COMPATIBLE_EXT.0, "TYPE_2D_VIEW_COMPATIBLE_EXT", @@ -2371,6 +2505,7 @@ impl fmt::Debug for ImageViewCreateFlags { ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", ), + (ImageViewCreateFlags::RESERVED_3_EXT.0, "RESERVED_3_EXT"), ]; debug_flags(f, KNOWN, self.0) } @@ -2908,7 +3043,10 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::RAY_TRACING_ALLOW_MOTION_NV.0, "RAY_TRACING_ALLOW_MOTION_NV", ), + (PipelineCreateFlags::RESERVED_25_EXT.0, "RESERVED_25_EXT"), + (PipelineCreateFlags::RESERVED_26_EXT.0, "RESERVED_26_EXT"), (PipelineCreateFlags::RESERVED_24_NV.0, "RESERVED_24_NV"), + (PipelineCreateFlags::RESERVED_27_EXT.0, "RESERVED_27_EXT"), ( PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, "VIEW_INDEX_FROM_DEVICE_INDEX", @@ -3209,7 +3347,10 @@ impl fmt::Debug for PipelineStageFlags2 { PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0, "INVOCATION_MASK_HUAWEI", ), - (PipelineStageFlags2::RESERVED_387_KHR.0, "RESERVED_387_KHR"), + ( + PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0, + "ACCELERATION_STRUCTURE_COPY_KHR", + ), (PipelineStageFlags2::RESERVED_30_NV.0, "RESERVED_30_NV"), (PipelineStageFlags2::RESERVED_29_NV.0, "RESERVED_29_NV"), ]; @@ -3457,6 +3598,10 @@ impl fmt::Debug for QueryType { Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") } Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"), + Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => { + Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR") + } + Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"), _ => None, }; if let Some(x) = name { @@ -3602,7 +3747,10 @@ impl fmt::Debug for SamplerCreateFlags { "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), (SamplerCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD"), - (SamplerCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"), + ( + SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0, + "NON_SEAMLESS_CUBE_MAP_EXT", + ), ( SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0, "IMAGE_PROCESSING_QCOM", @@ -3813,6 +3961,9 @@ impl fmt::Debug for ShaderStageFlags { ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0, "SUBPASS_SHADING_HUAWEI", ), + (ShaderStageFlags::EXT_483_RESERVE_15.0, "EXT_483_RESERVE_15"), + (ShaderStageFlags::EXT_483_RESERVE_16.0, "EXT_483_RESERVE_16"), + (ShaderStageFlags::EXT_483_RESERVE_17.0, "EXT_483_RESERVE_17"), ]; debug_flags(f, KNOWN, self.0) } @@ -4540,9 +4691,6 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => { Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV") } - Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV => { - Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV") - } Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => { Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV") } @@ -4789,6 +4937,22 @@ impl fmt::Debug for StructureType { Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV") } Self::RESERVED_QCOM => Some("RESERVED_QCOM"), + Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => { + Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT") + } + Self::EXPORT_METAL_OBJECTS_INFO_EXT => Some("EXPORT_METAL_OBJECTS_INFO_EXT"), + Self::EXPORT_METAL_DEVICE_INFO_EXT => Some("EXPORT_METAL_DEVICE_INFO_EXT"), + Self::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT => { + Some("EXPORT_METAL_COMMAND_QUEUE_INFO_EXT") + } + Self::EXPORT_METAL_BUFFER_INFO_EXT => Some("EXPORT_METAL_BUFFER_INFO_EXT"), + Self::IMPORT_METAL_BUFFER_INFO_EXT => Some("IMPORT_METAL_BUFFER_INFO_EXT"), + Self::EXPORT_METAL_TEXTURE_INFO_EXT => Some("EXPORT_METAL_TEXTURE_INFO_EXT"), + Self::IMPORT_METAL_TEXTURE_INFO_EXT => Some("IMPORT_METAL_TEXTURE_INFO_EXT"), + Self::EXPORT_METAL_IO_SURFACE_INFO_EXT => Some("EXPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::IMPORT_METAL_IO_SURFACE_INFO_EXT => Some("IMPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::EXPORT_METAL_SHARED_EVENT_INFO_EXT => Some("EXPORT_METAL_SHARED_EVENT_INFO_EXT"), + Self::IMPORT_METAL_SHARED_EVENT_INFO_EXT => Some("IMPORT_METAL_SHARED_EVENT_INFO_EXT"), Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => { Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") } @@ -4802,6 +4966,15 @@ impl fmt::Debug for StructureType { Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => { Some("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT") } + Self::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR") + } Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => { Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR") } @@ -4836,6 +5009,13 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => { Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR") } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT") + } + Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"), + Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"), + Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"), + Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"), Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") } @@ -4926,6 +5106,19 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => { Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV") } + Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => Some("PIPELINE_PROPERTIES_IDENTIFIER_EXT"), + Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT") + } + Self::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT => { + Some("SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT") + } + Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT => { + Some("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT") + } Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => { Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT") } @@ -4939,6 +5132,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR") + } Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => { Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT") } @@ -4970,6 +5166,9 @@ impl fmt::Debug for StructureType { Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => { Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE") } + Self::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM") } @@ -4982,6 +5181,29 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT") + } + Self::RENDER_PASS_CREATION_CONTROL_EXT => Some("RENDER_PASS_CREATION_CONTROL_EXT"), + Self::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT") + } + Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT") + } + Self::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT => { + Some("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT") + } + Self::SHADER_MODULE_IDENTIFIER_EXT => Some("SHADER_MODULE_IDENTIFIER_EXT"), Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -5400,6 +5622,36 @@ impl fmt::Debug for SubpassDescriptionFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for SubpassMergeStatusEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MERGED => Some("MERGED"), + Self::DISALLOWED => Some("DISALLOWED"), + Self::NOT_MERGED_SIDE_EFFECTS => Some("NOT_MERGED_SIDE_EFFECTS"), + Self::NOT_MERGED_SAMPLES_MISMATCH => Some("NOT_MERGED_SAMPLES_MISMATCH"), + Self::NOT_MERGED_VIEWS_MISMATCH => Some("NOT_MERGED_VIEWS_MISMATCH"), + Self::NOT_MERGED_ALIASING => Some("NOT_MERGED_ALIASING"), + Self::NOT_MERGED_DEPENDENCIES => Some("NOT_MERGED_DEPENDENCIES"), + Self::NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT => { + Some("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT") + } + Self::NOT_MERGED_TOO_MANY_ATTACHMENTS => Some("NOT_MERGED_TOO_MANY_ATTACHMENTS"), + Self::NOT_MERGED_INSUFFICIENT_STORAGE => Some("NOT_MERGED_INSUFFICIENT_STORAGE"), + Self::NOT_MERGED_DEPTH_STENCIL_COUNT => Some("NOT_MERGED_DEPTH_STENCIL_COUNT"), + Self::NOT_MERGED_RESOLVE_ATTACHMENT_REUSE => { + Some("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE") + } + Self::NOT_MERGED_SINGLE_SUBPASS => Some("NOT_MERGED_SINGLE_SUBPASS"), + Self::NOT_MERGED_UNSPECIFIED => Some("NOT_MERGED_UNSPECIFIED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; @@ -5784,8 +6036,12 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE.0, - "DIRECT_8X8_INFERENCE", + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0, + "DIRECT_8X8_INFERENCE_ENABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0, + "DIRECT_8X8_INFERENCE_DISABLED", ), ( VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, @@ -5869,6 +6125,10 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, "DIFFERENT_SLICE_TYPE", ), + ( + VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), ]; debug_flags(f, KNOWN, self.0) } diff --git a/ash/src/vk/constants.rs b/ash/src/vk/constants.rs index b10fad2..78da55e 100644 --- a/ash/src/vk/constants.rs +++ b/ash/src/vk/constants.rs @@ -23,4 +23,5 @@ pub const MAX_DRIVER_NAME_SIZE: usize = 256; pub const MAX_DRIVER_INFO_SIZE: usize = 256; pub const SHADER_UNUSED_KHR: u32 = !0; pub const MAX_GLOBAL_PRIORITY_SIZE_KHR: usize = 16; +pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32; pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 7bb56b0..57a5f7d 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -56,7 +56,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 211u32; +pub const HEADER_VERSION: u32 = 219u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -2918,6 +2918,7 @@ pub struct BufferViewCreateInfoBuilder<'a> { inner: BufferViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } +pub unsafe trait ExtendsBufferViewCreateInfo {} impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { type Target = BufferViewCreateInfo; fn deref(&self) -> &Self::Target { @@ -2955,6 +2956,20 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { self.inner.range = range; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -8199,6 +8214,7 @@ pub struct EventCreateInfoBuilder<'a> { inner: EventCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } +pub unsafe trait ExtendsEventCreateInfo {} impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { type Target = EventCreateInfo; fn deref(&self) -> &Self::Target { @@ -8216,6 +8232,20 @@ impl<'a> EventCreateInfoBuilder<'a> { self.inner.flags = flags; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21753,6 +21783,7 @@ pub struct SurfaceFormat2KHRBuilder<'a> { inner: SurfaceFormat2KHR, marker: ::std::marker::PhantomData<&'a ()>, } +pub unsafe trait ExtendsSurfaceFormat2KHR {} impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { type Target = SurfaceFormat2KHR; fn deref(&self) -> &Self::Target { @@ -21770,6 +21801,20 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { self.inner.surface_format = surface_format; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32635,72 +32680,6 @@ impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub fragment_shader_barycentric: Bool32, -} -impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - #[inline] - fn default() -> Self { - Self { - s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, - p_next: ::std::ptr::null_mut(), - fragment_shader_barycentric: Bool32::default(), - } - } -} -impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - #[inline] - pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { - self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - self.inner - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceShaderImageFootprintFeaturesNV { pub s_type: StructureType, @@ -35582,6 +35561,232 @@ impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> { } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct TraceRaysIndirectCommand2KHR { + pub raygen_shader_record_address: DeviceAddress, + pub raygen_shader_record_size: DeviceSize, + pub miss_shader_binding_table_address: DeviceAddress, + pub miss_shader_binding_table_size: DeviceSize, + pub miss_shader_binding_table_stride: DeviceSize, + pub hit_shader_binding_table_address: DeviceAddress, + pub hit_shader_binding_table_size: DeviceSize, + pub hit_shader_binding_table_stride: DeviceSize, + pub callable_shader_binding_table_address: DeviceAddress, + pub callable_shader_binding_table_size: DeviceSize, + pub callable_shader_binding_table_stride: DeviceSize, + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl TraceRaysIndirectCommand2KHR { + pub fn builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a> { + TraceRaysIndirectCommand2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TraceRaysIndirectCommand2KHRBuilder<'a> { + inner: TraceRaysIndirectCommand2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TraceRaysIndirectCommand2KHRBuilder<'a> { + type Target = TraceRaysIndirectCommand2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TraceRaysIndirectCommand2KHRBuilder<'a> { + #[inline] + pub fn raygen_shader_record_address( + mut self, + raygen_shader_record_address: DeviceAddress, + ) -> Self { + self.inner.raygen_shader_record_address = raygen_shader_record_address; + self + } + #[inline] + pub fn raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self { + self.inner.raygen_shader_record_size = raygen_shader_record_size; + self + } + #[inline] + pub fn miss_shader_binding_table_address( + mut self, + miss_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.miss_shader_binding_table_address = miss_shader_binding_table_address; + self + } + #[inline] + pub fn miss_shader_binding_table_size( + mut self, + miss_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_size = miss_shader_binding_table_size; + self + } + #[inline] + pub fn miss_shader_binding_table_stride( + mut self, + miss_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_stride = miss_shader_binding_table_stride; + self + } + #[inline] + pub fn hit_shader_binding_table_address( + mut self, + hit_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.hit_shader_binding_table_address = hit_shader_binding_table_address; + self + } + #[inline] + pub fn hit_shader_binding_table_size( + mut self, + hit_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_size = hit_shader_binding_table_size; + self + } + #[inline] + pub fn hit_shader_binding_table_stride( + mut self, + hit_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_stride = hit_shader_binding_table_stride; + self + } + #[inline] + pub fn callable_shader_binding_table_address( + mut self, + callable_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.callable_shader_binding_table_address = callable_shader_binding_table_address; + self + } + #[inline] + pub fn callable_shader_binding_table_size( + mut self, + callable_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_size = callable_shader_binding_table_size; + self + } + #[inline] + pub fn callable_shader_binding_table_stride( + mut self, + callable_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_stride = callable_shader_binding_table_stride; + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TraceRaysIndirectCommand2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_maintenance1: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + ray_tracing_maintenance1: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(), + } + } +} +impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self { + self.inner.ray_tracing_maintenance1 = ray_tracing_maintenance1.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_trace_rays_indirect2( + mut self, + ray_tracing_pipeline_trace_rays_indirect2: bool, + ) -> Self { + self.inner.ray_tracing_pipeline_trace_rays_indirect2 = + ray_tracing_pipeline_trace_rays_indirect2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] pub struct DrmFormatModifierPropertiesListEXT { @@ -51306,6 +51511,213 @@ impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multisampled_render_to_single_sampled: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: + StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + multisampled_render_to_single_sampled: Bool32::default(), + } + } +} +impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled( + mut self, + multisampled_render_to_single_sampled: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled = + multisampled_render_to_single_sampled.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassResolvePerformanceQueryEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optimal: Bool32, +} +impl ::std::default::Default for SubpassResolvePerformanceQueryEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, + p_next: ::std::ptr::null_mut(), + optimal: Bool32::default(), + } + } +} +impl SubpassResolvePerformanceQueryEXT { + pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> { + SubpassResolvePerformanceQueryEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> { + inner: SubpassResolvePerformanceQueryEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT {} +impl<'a> ::std::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> { + type Target = SubpassResolvePerformanceQueryEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> { + #[inline] + pub fn optimal(mut self, optimal: bool) -> Self { + self.inner.optimal = optimal.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassResolvePerformanceQueryEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultisampledRenderToSingleSampledInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub multisampled_render_to_single_sampled_enable: Bool32, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for MultisampledRenderToSingleSampledInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, + p_next: ::std::ptr::null(), + multisampled_render_to_single_sampled_enable: Bool32::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +impl MultisampledRenderToSingleSampledInfoEXT { + pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + MultisampledRenderToSingleSampledInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + inner: MultisampledRenderToSingleSampledInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT {} +impl<'a> ::std::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + type Target = MultisampledRenderToSingleSampledInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled_enable( + mut self, + multisampled_render_to_single_sampled_enable: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled_enable = + multisampled_render_to_single_sampled_enable.into(); + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultisampledRenderToSingleSampledInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoQueueFamilyProperties2KHR { pub s_type: StructureType, @@ -51371,7 +51783,7 @@ impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> { pub struct QueueFamilyQueryResultStatusProperties2KHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub supported: Bool32, + pub query_result_status_support: Bool32, } impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR { #[inline] @@ -51379,7 +51791,7 @@ impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR { Self { s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), - supported: Bool32::default(), + query_result_status_support: Bool32::default(), } } } @@ -51414,8 +51826,8 @@ impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuil } impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { #[inline] - pub fn supported(mut self, supported: bool) -> Self { - self.inner.supported = supported.into(); + pub fn query_result_status_support(mut self, query_result_status_support: bool) -> Self { + self.inner.query_result_status_support = query_result_status_support.into(); self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] @@ -51431,7 +51843,7 @@ impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { #[doc = ""] pub struct VideoProfilesKHR { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub profile_count: u32, pub p_profiles: *const VideoProfileKHR, } @@ -51440,7 +51852,7 @@ impl ::std::default::Default for VideoProfilesKHR { fn default() -> Self { Self { s_type: StructureType::VIDEO_PROFILES_KHR, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), profile_count: u32::default(), p_profiles: ::std::ptr::null(), } @@ -51459,12 +51871,12 @@ pub struct VideoProfilesKHRBuilder<'a> { inner: VideoProfilesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsFormatProperties2 for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfilesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfilesKHR {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfilesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfilesKHR {} unsafe impl ExtendsImageCreateInfo for VideoProfilesKHRBuilder<'_> {} unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR {} unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHRBuilder<'_> {} unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR {} impl<'a> ::std::ops::Deref for VideoProfilesKHRBuilder<'a> { @@ -51500,7 +51912,6 @@ pub struct PhysicalDeviceVideoFormatInfoKHR { pub s_type: StructureType, pub p_next: *mut c_void, pub image_usage: ImageUsageFlags, - pub p_video_profiles: *const VideoProfilesKHR, } impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR { #[inline] @@ -51509,7 +51920,6 @@ impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR { s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, p_next: ::std::ptr::null_mut(), image_usage: ImageUsageFlags::default(), - p_video_profiles: ::std::ptr::null(), } } } @@ -51526,6 +51936,7 @@ pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { inner: PhysicalDeviceVideoFormatInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } +pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { type Target = PhysicalDeviceVideoFormatInfoKHR; fn deref(&self) -> &Self::Target { @@ -51543,9 +51954,21 @@ impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { self.inner.image_usage = image_usage; self } - #[inline] - pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR) -> Self { - self.inner.p_video_profiles = video_profiles; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] @@ -51563,6 +51986,11 @@ pub struct VideoFormatPropertiesKHR { pub s_type: StructureType, pub p_next: *mut c_void, pub format: Format, + pub component_mapping: ComponentMapping, + pub image_create_flags: ImageCreateFlags, + pub image_type: ImageType, + pub image_tiling: ImageTiling, + pub image_usage_flags: ImageUsageFlags, } impl ::std::default::Default for VideoFormatPropertiesKHR { #[inline] @@ -51571,6 +51999,11 @@ impl ::std::default::Default for VideoFormatPropertiesKHR { s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), format: Format::default(), + component_mapping: ComponentMapping::default(), + image_create_flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + image_tiling: ImageTiling::default(), + image_usage_flags: ImageUsageFlags::default(), } } } @@ -51604,6 +52037,31 @@ impl<'a> VideoFormatPropertiesKHRBuilder<'a> { self.inner.format = format; self } + #[inline] + pub fn component_mapping(mut self, component_mapping: ComponentMapping) -> Self { + self.inner.component_mapping = component_mapping; + self + } + #[inline] + pub fn image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self { + self.inner.image_create_flags = image_create_flags; + self + } + #[inline] + pub fn image_type(mut self, image_type: ImageType) -> Self { + self.inner.image_type = image_type; + self + } + #[inline] + pub fn image_tiling(mut self, image_tiling: ImageTiling) -> Self { + self.inner.image_tiling = image_tiling; + self + } + #[inline] + pub fn image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self { + self.inner.image_usage_flags = image_usage_flags; + self + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -51617,7 +52075,7 @@ impl<'a> VideoFormatPropertiesKHRBuilder<'a> { #[doc = ""] pub struct VideoProfileKHR { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub video_codec_operation: VideoCodecOperationFlagsKHR, pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR, pub luma_bit_depth: VideoComponentBitDepthFlagsKHR, @@ -51628,7 +52086,7 @@ impl ::std::default::Default for VideoProfileKHR { fn default() -> Self { Self { s_type: StructureType::VIDEO_PROFILE_KHR, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), video_codec_operation: VideoCodecOperationFlagsKHR::default(), chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(), luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), @@ -51651,14 +52109,6 @@ pub struct VideoProfileKHRBuilder<'a> { } unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHRBuilder<'_> {} unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsFormatProperties2 for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoProfileKHR {} -unsafe impl ExtendsImageCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {} pub unsafe trait ExtendsVideoProfileKHR {} impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> { type Target = VideoProfileKHR; @@ -51705,7 +52155,7 @@ impl<'a> VideoProfileKHRBuilder<'a> { #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { - let next_ptr = <*mut T>::cast(next); + let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr; @@ -52383,14 +52833,6 @@ unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {} unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> { type Target = VideoDecodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -52881,14 +53323,6 @@ unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {} unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> { type Target = VideoDecodeH265ProfileEXT; fn deref(&self) -> &Self::Target { @@ -54872,14 +55306,6 @@ unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {} unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> { type Target = VideoEncodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -56308,14 +56734,6 @@ unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT {} unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileEXTBuilder<'a> { type Target = VideoEncodeH265ProfileEXT; fn deref(&self) -> &Self::Target { @@ -57686,6 +58104,141 @@ impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_barycentric: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + fragment_shader_barycentric: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + #[inline] + pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { + self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + #[inline] + pub fn tri_strip_vertex_order_independent_of_provoking_vertex( + mut self, + tri_strip_vertex_order_independent_of_provoking_vertex: bool, + ) -> Self { + self.inner + .tri_strip_vertex_order_independent_of_provoking_vertex = + tri_strip_vertex_order_independent_of_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV { pub s_type: StructureType, @@ -60802,3 +61355,2090 @@ impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { self.inner } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + shader_module_identifier: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self { + self.inner.shader_module_identifier = shader_module_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier_algorithm_uuid( + mut self, + shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], + ) -> Self { + self.inner.shader_module_identifier_algorithm_uuid = + shader_module_identifier_algorithm_uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub identifier_size: u32, + pub p_identifier: *const u8, +} +impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + identifier_size: u32::default(), + p_identifier: ::std::ptr::null(), + } + } +} +impl PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + inner: PipelineShaderStageModuleIdentifierCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + #[inline] + pub fn identifier(mut self, identifier: &'a [u8]) -> Self { + self.inner.identifier_size = identifier.len() as _; + self.inner.p_identifier = identifier.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub identifier_size: u32, + pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT], +} +impl ::std::default::Default for ShaderModuleIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::SHADER_MODULE_IDENTIFIER_EXT, + p_next: ::std::ptr::null_mut(), + identifier_size: u32::default(), + identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ShaderModuleIdentifierEXT { + pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> { + ShaderModuleIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleIdentifierEXTBuilder<'a> { + inner: ShaderModuleIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> { + type Target = ShaderModuleIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleIdentifierEXTBuilder<'a> { + #[inline] + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.inner.identifier_size = identifier_size; + self + } + #[inline] + pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self { + self.inner.identifier = identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCompressionFlagsEXT, + pub compression_control_plane_count: u32, + pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_COMPRESSION_CONTROL_EXT, + p_next: ::std::ptr::null(), + flags: ImageCompressionFlagsEXT::default(), + compression_control_plane_count: u32::default(), + p_fixed_rate_flags: ::std::ptr::null_mut(), + } + } +} +impl ImageCompressionControlEXT { + pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> { + ImageCompressionControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionControlEXTBuilder<'a> { + inner: ImageCompressionControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionControlEXTBuilder<'a> { + type Target = ImageCompressionControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionControlEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn fixed_rate_flags( + mut self, + fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], + ) -> Self { + self.inner.compression_control_plane_count = fixed_rate_flags.len() as _; + self.inner.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + image_compression_control: Bool32::default(), + } + } +} +impl PhysicalDeviceImageCompressionControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageCompressionControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { + self.inner.image_compression_control = image_compression_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_flags: ImageCompressionFlagsEXT, + pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + image_compression_flags: ImageCompressionFlagsEXT::default(), + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(), + } + } +} +impl ImageCompressionPropertiesEXT { + pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> { + ImageCompressionPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionPropertiesEXTBuilder<'a> { + inner: ImageCompressionPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> { + type Target = ImageCompressionPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionPropertiesEXTBuilder<'a> { + #[inline] + pub fn image_compression_flags( + mut self, + image_compression_flags: ImageCompressionFlagsEXT, + ) -> Self { + self.inner.image_compression_flags = image_compression_flags; + self + } + #[inline] + pub fn image_compression_fixed_rate_flags( + mut self, + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, + ) -> Self { + self.inner.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control_swapchain: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + image_compression_control_swapchain: Bool32::default(), + } + } +} +impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control_swapchain( + mut self, + image_compression_control_swapchain: bool, + ) -> Self { + self.inner.image_compression_control_swapchain = image_compression_control_swapchain.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSubresource2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_subresource: ImageSubresource, +} +impl ::std::default::Default for ImageSubresource2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_SUBRESOURCE_2_EXT, + p_next: ::std::ptr::null_mut(), + image_subresource: ImageSubresource::default(), + } + } +} +impl ImageSubresource2EXT { + pub fn builder<'a>() -> ImageSubresource2EXTBuilder<'a> { + ImageSubresource2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresource2EXTBuilder<'a> { + inner: ImageSubresource2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresource2EXTBuilder<'a> { + type Target = ImageSubresource2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresource2EXTBuilder<'a> { + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresource2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubresourceLayout2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subresource_layout: SubresourceLayout, +} +impl ::std::default::Default for SubresourceLayout2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::SUBRESOURCE_LAYOUT_2_EXT, + p_next: ::std::ptr::null_mut(), + subresource_layout: SubresourceLayout::default(), + } + } +} +impl SubresourceLayout2EXT { + pub fn builder<'a>() -> SubresourceLayout2EXTBuilder<'a> { + SubresourceLayout2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubresourceLayout2EXTBuilder<'a> { + inner: SubresourceLayout2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubresourceLayout2EXT {} +impl<'a> ::std::ops::Deref for SubresourceLayout2EXTBuilder<'a> { + type Target = SubresourceLayout2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubresourceLayout2EXTBuilder<'a> { + #[inline] + pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { + self.inner.subresource_layout = subresource_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubresourceLayout2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disallow_merging: Bool32, +} +impl ::std::default::Default for RenderPassCreationControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::RENDER_PASS_CREATION_CONTROL_EXT, + p_next: ::std::ptr::null(), + disallow_merging: Bool32::default(), + } + } +} +impl RenderPassCreationControlEXT { + pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> { + RenderPassCreationControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationControlEXTBuilder<'a> { + inner: RenderPassCreationControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationControlEXTBuilder<'a> { + type Target = RenderPassCreationControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationControlEXTBuilder<'a> { + #[inline] + pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { + self.inner.disallow_merging = disallow_merging.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RenderPassCreationFeedbackInfoEXT { + pub post_merge_subpass_count: u32, +} +impl RenderPassCreationFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + RenderPassCreationFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { + self.inner.post_merge_subpass_count = post_merge_subpass_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + p_render_pass_feedback: ::std::ptr::null_mut(), + } + } +} +impl RenderPassCreationFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + RenderPassCreationFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn render_pass_feedback( + mut self, + render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, + ) -> Self { + self.inner.p_render_pass_feedback = render_pass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackInfoEXT { + pub subpass_merge_status: SubpassMergeStatusEXT, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub post_merge_index: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT") + .field("subpass_merge_status", &self.subpass_merge_status) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("post_merge_index", &self.post_merge_index) + .finish() + } +} +impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT { + #[inline] + fn default() -> Self { + Self { + subpass_merge_status: SubpassMergeStatusEXT::default(), + description: unsafe { ::std::mem::zeroed() }, + post_merge_index: u32::default(), + } + } +} +impl RenderPassSubpassFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self { + self.inner.subpass_merge_status = subpass_merge_status; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { + self.inner.post_merge_index = post_merge_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + p_subpass_feedback: ::std::ptr::null_mut(), + } + } +} +impl RenderPassSubpassFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_feedback( + mut self, + subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, + ) -> Self { + self.inner.p_subpass_feedback = subpass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subpass_merge_feedback: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + subpass_merge_feedback: Bool32::default(), + } + } +} +impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { + self.inner.subpass_merge_feedback = subpass_merge_feedback.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelinePropertiesIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_identifier: [u8; UUID_SIZE], +} +impl ::std::default::Default for PipelinePropertiesIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT, + p_next: ::std::ptr::null_mut(), + pipeline_identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PipelinePropertiesIdentifierEXT { + pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> { + PipelinePropertiesIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelinePropertiesIdentifierEXTBuilder<'a> { + inner: PipelinePropertiesIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> { + type Target = PipelinePropertiesIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> { + #[inline] + pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_identifier = pipeline_identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelinePropertiesIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_properties_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + pipeline_properties_identifier: Bool32::default(), + } + } +} +impl PhysicalDevicePipelinePropertiesFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + PhysicalDevicePipelinePropertiesFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelinePropertiesFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelinePropertiesFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self { + self.inner.pipeline_properties_identifier = pipeline_properties_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_early_and_late_fragment_tests: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: + StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, + p_next: ::std::ptr::null_mut(), + shader_early_and_late_fragment_tests: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + #[inline] + pub fn shader_early_and_late_fragment_tests( + mut self, + shader_early_and_late_fragment_tests: bool, + ) -> Self { + self.inner.shader_early_and_late_fragment_tests = + shader_early_and_late_fragment_tests.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub export_object_type: ExportMetalObjectTypeFlagsEXT, +} +impl ::std::default::Default for ExportMetalObjectCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + export_object_type: ExportMetalObjectTypeFlagsEXT::default(), + } + } +} +impl ExportMetalObjectCreateInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> { + ExportMetalObjectCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> { + inner: ExportMetalObjectCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> { + type Target = ExportMetalObjectCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> { + #[inline] + pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self { + self.inner.export_object_type = export_object_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, +} +impl ::std::default::Default for ExportMetalObjectsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_OBJECTS_INFO_EXT, + p_next: ::std::ptr::null(), + } + } +} +impl ExportMetalObjectsInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> { + ExportMetalObjectsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectsInfoEXTBuilder<'a> { + inner: ExportMetalObjectsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsExportMetalObjectsInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> { + type Target = ExportMetalObjectsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalDeviceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_device: MTLDevice_id, +} +impl ::std::default::Default for ExportMetalDeviceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_DEVICE_INFO_EXT, + p_next: ::std::ptr::null(), + mtl_device: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalDeviceInfoEXT { + pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> { + ExportMetalDeviceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalDeviceInfoEXTBuilder<'a> { + inner: ExportMetalDeviceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> { + type Target = ExportMetalDeviceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self { + self.inner.mtl_device = mtl_device; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalDeviceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalCommandQueueInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue: Queue, + pub mtl_command_queue: MTLCommandQueue_id, +} +impl ::std::default::Default for ExportMetalCommandQueueInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT, + p_next: ::std::ptr::null(), + queue: Queue::default(), + mtl_command_queue: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalCommandQueueInfoEXT { + pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> { + ExportMetalCommandQueueInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> { + inner: ExportMetalCommandQueueInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> { + type Target = ExportMetalCommandQueueInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> { + #[inline] + pub fn queue(mut self, queue: Queue) -> Self { + self.inner.queue = queue; + self + } + #[inline] + pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self { + self.inner.mtl_command_queue = mtl_command_queue; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalCommandQueueInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ExportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_BUFFER_INFO_EXT, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalBufferInfoEXT { + pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> { + ExportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalBufferInfoEXTBuilder<'a> { + inner: ExportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> { + type Target = ExportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ImportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMPORT_METAL_BUFFER_INFO_EXT, + p_next: ::std::ptr::null(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImportMetalBufferInfoEXT { + pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> { + ImportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalBufferInfoEXTBuilder<'a> { + inner: ImportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> { + type Target = ImportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub image_view: ImageView, + pub buffer_view: BufferView, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ExportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_TEXTURE_INFO_EXT, + p_next: ::std::ptr::null(), + image: Image::default(), + image_view: ImageView::default(), + buffer_view: BufferView::default(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalTextureInfoEXT { + pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> { + ExportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalTextureInfoEXTBuilder<'a> { + inner: ExportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> { + type Target = ExportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn buffer_view(mut self, buffer_view: BufferView) -> Self { + self.inner.buffer_view = buffer_view; + self + } + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ImportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMPORT_METAL_TEXTURE_INFO_EXT, + p_next: ::std::ptr::null(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImportMetalTextureInfoEXT { + pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> { + ImportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalTextureInfoEXTBuilder<'a> { + inner: ImportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> { + type Target = ImportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT, + p_next: ::std::ptr::null(), + image: Image::default(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + ExportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ExportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ExportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT, + p_next: ::std::ptr::null(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + ImportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ImportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ImportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub event: Event, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ExportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + event: Event::default(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ExportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> { + ExportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalSharedEventInfoEXTBuilder<'a> { + inner: ExportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ExportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn event(mut self, event: Event) -> Self { + self.inner.event = event; + self + } + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ImportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT, + p_next: ::std::ptr::null(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> { + ImportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalSharedEventInfoEXTBuilder<'a> { + inner: ImportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ImportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub non_seamless_cube_map: Bool32, +} +impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + non_seamless_cube_map: Bool32::default(), + } + } +} +impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + #[inline] + pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { + self.inner.non_seamless_cube_map = non_seamless_cube_map.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 6878b6c..e4d80c4 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -896,7 +896,7 @@ impl Result { pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1); #[doc = "A device memory allocation has failed"] pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2); - #[doc = "Initialization of a object has failed"] + #[doc = "Initialization of an object has failed"] pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3); #[doc = "The logical device has been lost. See <>"] pub const ERROR_DEVICE_LOST: Self = Self(-4); @@ -931,7 +931,7 @@ impl fmt::Display for Result { Self::INCOMPLETE => Some("A return array was too small for the result"), Self::ERROR_OUT_OF_HOST_MEMORY => Some("A host memory allocation has failed"), Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("A device memory allocation has failed"), - Self::ERROR_INITIALIZATION_FAILED => Some("Initialization of a object has failed"), + Self::ERROR_INITIALIZATION_FAILED => Some("Initialization of an object has failed"), Self::ERROR_DEVICE_LOST => { Some("The logical device has been lost. See <>") } @@ -1665,6 +1665,8 @@ impl DriverId { pub const SAMSUNG_PROPRIETARY: Self = Self(21); #[doc = "Mesa open source project"] pub const MESA_VENUS: Self = Self(22); + #[doc = "Mesa open source project"] + pub const MESA_DOZEN: Self = Self(23); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -2200,6 +2202,34 @@ impl FragmentShadingRateTypeNV { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct SubpassMergeStatusEXT(pub(crate) i32); +impl SubpassMergeStatusEXT { + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SubpassMergeStatusEXT { + pub const MERGED: Self = Self(0); + pub const DISALLOWED: Self = Self(1); + pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2); + pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3); + pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4); + pub const NOT_MERGED_ALIASING: Self = Self(5); + pub const NOT_MERGED_DEPENDENCIES: Self = Self(6); + pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7); + pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8); + pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9); + pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10); + pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11); + pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12); + pub const NOT_MERGED_UNSPECIFIED: Self = Self(13); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct ProvokingVertexModeEXT(pub(crate) i32); impl ProvokingVertexModeEXT { @@ -2335,6 +2365,24 @@ impl fmt::Debug for Result { Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"), Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"), Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"), + Self::ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR => { + Some("ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR") + } Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => { Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT") } @@ -2346,6 +2394,7 @@ impl fmt::Debug for Result { Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"), Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"), Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"), + Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"), Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 7e91920..88bd1e6 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -1822,7 +1822,7 @@ impl KhrVideoQueueFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 4u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( @@ -2191,6 +2191,15 @@ impl QueryType { pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000); } #[doc = "Generated from 'VK_KHR_video_queue'"] +impl Result { + pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_000); + pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_001); + pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_002); + pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_003); + pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_004); + pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_005); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] impl StructureType { pub const VIDEO_PROFILE_KHR: Self = Self(1_000_023_000); pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001); @@ -3047,7 +3056,7 @@ impl ExtVideoEncodeH264Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") } } - pub const SPEC_VERSION: u32 = 6u32; + pub const SPEC_VERSION: u32 = 7u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn {} @@ -8041,6 +8050,10 @@ impl AmdExtension135Fn { Self {} } } +#[doc = "Generated from 'VK_AMD_extension_135'"] +impl BufferUsageFlags { + pub const RESERVED_25_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} impl AmdExtension136Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") } @@ -12024,7 +12037,8 @@ impl NvFragmentShaderBarycentricFn { } #[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"] impl StructureType { - pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1_000_203_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; } impl NvShaderImageFootprintFn { pub const fn name() -> &'static ::std::ffi::CStr { @@ -16379,7 +16393,7 @@ impl NvDeviceDiagnosticsConfigFn { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0") } } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] pub struct NvDeviceDiagnosticsConfigFn {} @@ -16588,24 +16602,64 @@ impl NvExtension311Fn { Self {} } } -impl ExtExtension312Fn { +impl ExtMetalObjectsFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_312\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_objects\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkExportMetalObjectsEXT = + unsafe extern "system" fn(device: Device, p_metal_objects_info: *mut ExportMetalObjectsInfoEXT); #[derive(Clone)] -pub struct ExtExtension312Fn {} -unsafe impl Send for ExtExtension312Fn {} -unsafe impl Sync for ExtExtension312Fn {} -impl ExtExtension312Fn { +pub struct ExtMetalObjectsFn { + pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT, +} +unsafe impl Send for ExtMetalObjectsFn {} +unsafe impl Sync for ExtMetalObjectsFn {} +impl ExtMetalObjectsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + export_metal_objects_ext: unsafe { + unsafe extern "system" fn export_metal_objects_ext( + _device: Device, + _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(export_metal_objects_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0"); + let val = _f(cname); + if val.is_null() { + export_metal_objects_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_metal_objects'"] +impl StructureType { + pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1_000_311_000); + pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1_000_311_001); + pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1_000_311_002); + pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1_000_311_003); + pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_004); + pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_005); + pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_006); + pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_007); + pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_008); + pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_009); + pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_010); + pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_011); +} impl ExtExtension313Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") } @@ -17103,17 +17157,21 @@ impl StructureType { pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1_000_320_001); pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1_000_320_002); } -impl AmdExtension322Fn { +impl AmdShaderEarlyAndLateFragmentTestsFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_322\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_shader_early_and_late_fragment_tests\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct AmdExtension322Fn {} -unsafe impl Send for AmdExtension322Fn {} -unsafe impl Sync for AmdExtension322Fn {} -impl AmdExtension322Fn { +pub struct AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Send for AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Sync for AmdShaderEarlyAndLateFragmentTestsFn {} +impl AmdShaderEarlyAndLateFragmentTestsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -17121,17 +17179,24 @@ impl AmdExtension322Fn { Self {} } } -impl AmdExtension323Fn { +#[doc = "Generated from 'VK_AMD_shader_early_and_late_fragment_tests'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self = + Self(1_000_321_000); +} +impl KhrFragmentShaderBarycentricFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_323\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shader_barycentric\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct AmdExtension323Fn {} -unsafe impl Send for AmdExtension323Fn {} -unsafe impl Sync for AmdExtension323Fn {} -impl AmdExtension323Fn { +pub struct KhrFragmentShaderBarycentricFn {} +unsafe impl Send for KhrFragmentShaderBarycentricFn {} +unsafe impl Sync for KhrFragmentShaderBarycentricFn {} +impl KhrFragmentShaderBarycentricFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -17139,6 +17204,12 @@ impl AmdExtension323Fn { Self {} } } +#[doc = "Generated from 'VK_KHR_fragment_shader_barycentric'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1_000_203_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self = + Self(1_000_322_000); +} impl KhrShaderSubgroupUniformControlFlowFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { @@ -17690,24 +17761,70 @@ impl StructureType { pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2; pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2; } -impl ArmExtension339Fn { +impl ExtImageCompressionControlFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_339\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_compression_control\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource2EXT, + p_layout: *mut SubresourceLayout2EXT, +); #[derive(Clone)] -pub struct ArmExtension339Fn {} -unsafe impl Send for ArmExtension339Fn {} -unsafe impl Sync for ArmExtension339Fn {} -impl ArmExtension339Fn { +pub struct ExtImageCompressionControlFn { + pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT, +} +unsafe impl Send for ExtImageCompressionControlFn {} +unsafe impl Sync for ExtImageCompressionControlFn {} +impl ExtImageCompressionControlFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_image_subresource_layout2_ext: unsafe { + unsafe extern "system" fn get_image_subresource_layout2_ext( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource2EXT, + _p_layout: *mut SubresourceLayout2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout2_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl Result { + pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1_000_338_000); +} +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000); + pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001); + pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002); + pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003); + pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004); +} impl ExtExtension340Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_340\0") } @@ -17727,9 +17844,18 @@ impl ExtExtension340Fn { } } #[doc = "Generated from 'VK_EXT_extension_340'"] +impl DependencyFlags { + pub const RESERVED_3_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_extension_340'"] impl ImageUsageFlags { pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000); } +#[doc = "Generated from 'VK_EXT_extension_340'"] +impl PipelineCreateFlags { + pub const RESERVED_25_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const RESERVED_26_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} impl Ext4444FormatsFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") } @@ -18983,24 +19109,60 @@ impl StructureType { pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000); pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001); } -impl NvExtension373Fn { +impl ExtPipelinePropertiesFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_373\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_properties\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoEXT, + p_pipeline_properties: *mut BaseOutStructure, +) -> Result; #[derive(Clone)] -pub struct NvExtension373Fn {} -unsafe impl Send for NvExtension373Fn {} -unsafe impl Sync for NvExtension373Fn {} -impl NvExtension373Fn { +pub struct ExtPipelinePropertiesFn { + pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT, +} +unsafe impl Send for ExtPipelinePropertiesFn {} +unsafe impl Sync for ExtPipelinePropertiesFn {} +impl ExtPipelinePropertiesFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_pipeline_properties_ext: unsafe { + unsafe extern "system" fn get_pipeline_properties_ext( + _device: Device, + _p_pipeline_info: *const PipelineInfoEXT, + _p_pipeline_properties: *mut BaseOutStructure, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelinePropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_pipeline_properties'"] +impl StructureType { + pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1_000_372_000); + pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001); + pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR; +} impl NvExtension374Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_374\0") } @@ -19027,7 +19189,6 @@ impl ExternalFenceHandleTypeFlags { #[doc = "Generated from 'VK_NV_extension_374'"] impl ExternalSemaphoreHandleTypeFlags { pub const RESERVED_5_NV: Self = Self(0b10_0000); - pub const RESERVED_6_NV: Self = Self(0b100_0000); } impl NvExtension375Fn { pub const fn name() -> &'static ::std::ffi::CStr { @@ -19069,17 +19230,21 @@ impl ExtExtension376Fn { Self {} } } -impl ExtExtension377Fn { +impl ExtMultisampledRenderToSingleSampledFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_377\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_multisampled_render_to_single_sampled\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension377Fn {} -unsafe impl Send for ExtExtension377Fn {} -unsafe impl Sync for ExtExtension377Fn {} -impl ExtExtension377Fn { +pub struct ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Send for ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Sync for ExtMultisampledRenderToSingleSampledFn {} +impl ExtMultisampledRenderToSingleSampledFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -19087,9 +19252,16 @@ impl ExtExtension377Fn { Self {} } } -#[doc = "Generated from 'VK_EXT_extension_377'"] +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] impl ImageCreateFlags { - pub const RESERVED_18_EXT: Self = Self(0b100_0000_0000_0000_0000); + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self = + Self(1_000_376_000); + pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_376_001); + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1_000_376_002); } impl ExtExtendedDynamicState2Fn { pub const fn name() -> &'static ::std::ffi::CStr { @@ -19501,31 +19673,72 @@ impl GoogleExtension386Fn { Self {} } } -impl KhrExtension387Fn { +impl KhrRayTracingMaintenance1Fn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_387\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_maintenance1\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_device_address: DeviceAddress, +); #[derive(Clone)] -pub struct KhrExtension387Fn {} -unsafe impl Send for KhrExtension387Fn {} -unsafe impl Sync for KhrExtension387Fn {} -impl KhrExtension387Fn { +pub struct KhrRayTracingMaintenance1Fn { + pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR, +} +unsafe impl Send for KhrRayTracingMaintenance1Fn {} +unsafe impl Sync for KhrRayTracingMaintenance1Fn {} +impl KhrRayTracingMaintenance1Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + cmd_trace_rays_indirect2_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_indirect2_khr( + _command_buffer: CommandBuffer, + _indirect_device_address: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_trace_rays_indirect2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdTraceRaysIndirect2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_indirect2_khr + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_KHR_extension_387'"] +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] impl AccessFlags2 { - pub const RESERVED_387_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_BINDING_TABLE_READ_KHR: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_KHR_extension_387'"] +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] impl PipelineStageFlags2 { - pub const RESERVED_387_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_COPY_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self = + Self(1_000_386_000); + pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1_000_386_001); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1_000_386_000); } impl ExtExtension388Fn { pub const fn name() -> &'static ::std::ffi::CStr { @@ -20383,6 +20596,10 @@ impl ExtExtension419Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_419'"] +impl ImageViewCreateFlags { + pub const RESERVED_3_EXT: Self = Self(0b1000); +} impl ExtExtension420Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") } @@ -20507,19 +20724,19 @@ impl ExtExtension422Fn { Self {} } } -impl ExtDisableCubeMapWrapFn { +impl ExtNonSeamlessCubeMapFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { - ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_disable_cube_map_wrap\0") + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_non_seamless_cube_map\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtDisableCubeMapWrapFn {} -unsafe impl Send for ExtDisableCubeMapWrapFn {} -unsafe impl Sync for ExtDisableCubeMapWrapFn {} -impl ExtDisableCubeMapWrapFn { +pub struct ExtNonSeamlessCubeMapFn {} +unsafe impl Send for ExtNonSeamlessCubeMapFn {} +unsafe impl Sync for ExtNonSeamlessCubeMapFn {} +impl ExtNonSeamlessCubeMapFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -20527,9 +20744,13 @@ impl ExtDisableCubeMapWrapFn { Self {} } } -#[doc = "Generated from 'VK_EXT_disable_cube_map_wrap'"] +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] impl SamplerCreateFlags { - pub const RESERVED_2_EXT: Self = Self(0b100); + pub const NON_SEAMLESS_CUBE_MAP_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] +impl StructureType { + pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1_000_422_000); } impl ArmExtension424Fn { pub const fn name() -> &'static ::std::ffi::CStr { @@ -20810,17 +21031,21 @@ impl ExtExtension437Fn { Self {} } } -impl ExtExtension438Fn { +impl ExtImageCompressionControlSwapchainFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_438\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_image_compression_control_swapchain\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension438Fn {} -unsafe impl Send for ExtExtension438Fn {} -unsafe impl Sync for ExtExtension438Fn {} -impl ExtExtension438Fn { +pub struct ExtImageCompressionControlSwapchainFn {} +unsafe impl Send for ExtImageCompressionControlSwapchainFn {} +unsafe impl Sync for ExtImageCompressionControlSwapchainFn {} +impl ExtImageCompressionControlSwapchainFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -20828,6 +21053,11 @@ impl ExtExtension438Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_image_compression_control_swapchain'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self = + Self(1_000_437_000); +} impl SecExtension439Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") } @@ -21216,17 +21446,19 @@ impl ExtExtension458Fn { Self {} } } -impl ArmExtension459Fn { +impl ExtSubpassMergeFeedbackFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_459\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subpass_merge_feedback\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] -pub struct ArmExtension459Fn {} -unsafe impl Send for ArmExtension459Fn {} -unsafe impl Sync for ArmExtension459Fn {} -impl ArmExtension459Fn { +pub struct ExtSubpassMergeFeedbackFn {} +unsafe impl Send for ExtSubpassMergeFeedbackFn {} +unsafe impl Sync for ExtSubpassMergeFeedbackFn {} +impl ExtSubpassMergeFeedbackFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -21234,6 +21466,13 @@ impl ArmExtension459Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_subpass_merge_feedback'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1_000_458_000); + pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1_000_458_001); + pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002); + pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003); +} impl ExtExtension460Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_460\0") } @@ -21292,24 +21531,91 @@ impl ExtExtension462Fn { Self {} } } -impl ExtExtension463Fn { +impl ExtShaderModuleIdentifierFn { pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_463\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_module_identifier\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_identifier: *mut ShaderModuleIdentifierEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_identifier: *mut ShaderModuleIdentifierEXT, +); #[derive(Clone)] -pub struct ExtExtension463Fn {} -unsafe impl Send for ExtExtension463Fn {} -unsafe impl Sync for ExtExtension463Fn {} -impl ExtExtension463Fn { +pub struct ExtShaderModuleIdentifierFn { + pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT, + pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT, +} +unsafe impl Send for ExtShaderModuleIdentifierFn {} +unsafe impl Sync for ExtShaderModuleIdentifierFn {} +impl ExtShaderModuleIdentifierFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_shader_module_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_identifier_ext( + _device: Device, + _shader_module: ShaderModule, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + get_shader_module_create_info_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_create_info_identifier_ext( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_create_info_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleCreateInfoIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_create_info_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_shader_module_identifier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1_000_462_000); + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1_000_462_001); + pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1_000_462_002); + pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1_000_462_003); +} impl ExtExtension464Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_464\0") } @@ -21410,6 +21716,10 @@ impl ExtExtension467Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_467'"] +impl PipelineCreateFlags { + pub const RESERVED_27_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} impl ExtExtension468Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_468\0") } @@ -21428,3 +21738,297 @@ impl ExtExtension468Fn { Self {} } } +impl AndroidExtension469Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_extension_469\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AndroidExtension469Fn {} +unsafe impl Send for AndroidExtension469Fn {} +unsafe impl Sync for AndroidExtension469Fn {} +impl AndroidExtension469Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension470Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_470\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension470Fn {} +unsafe impl Send for AmdExtension470Fn {} +unsafe impl Sync for AmdExtension470Fn {} +impl AmdExtension470Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension471Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_471\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension471Fn {} +unsafe impl Send for AmdExtension471Fn {} +unsafe impl Sync for AmdExtension471Fn {} +impl AmdExtension471Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension472Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_472\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension472Fn {} +unsafe impl Send for AmdExtension472Fn {} +unsafe impl Sync for AmdExtension472Fn {} +impl AmdExtension472Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension473Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_473\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension473Fn {} +unsafe impl Send for AmdExtension473Fn {} +unsafe impl Sync for AmdExtension473Fn {} +impl AmdExtension473Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension474Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_474\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension474Fn {} +unsafe impl Send for AmdExtension474Fn {} +unsafe impl Sync for AmdExtension474Fn {} +impl AmdExtension474Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension475Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_475\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension475Fn {} +unsafe impl Send for AmdExtension475Fn {} +unsafe impl Sync for AmdExtension475Fn {} +impl AmdExtension475Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension476Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_476\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension476Fn {} +unsafe impl Send for AmdExtension476Fn {} +unsafe impl Sync for AmdExtension476Fn {} +impl AmdExtension476Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension477Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_477\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension477Fn {} +unsafe impl Send for AmdExtension477Fn {} +unsafe impl Sync for AmdExtension477Fn {} +impl AmdExtension477Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension478Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_478\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension478Fn {} +unsafe impl Send for AmdExtension478Fn {} +unsafe impl Sync for AmdExtension478Fn {} +impl AmdExtension478Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension479Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_479\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension479Fn {} +unsafe impl Send for AmdExtension479Fn {} +unsafe impl Sync for AmdExtension479Fn {} +impl AmdExtension479Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension480Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_480\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension480Fn {} +unsafe impl Send for ExtExtension480Fn {} +unsafe impl Sync for ExtExtension480Fn {} +impl ExtExtension480Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension481Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_481\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension481Fn {} +unsafe impl Send for ExtExtension481Fn {} +unsafe impl Sync for ExtExtension481Fn {} +impl ExtExtension481Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension482Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_482\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension482Fn {} +unsafe impl Send for ExtExtension482Fn {} +unsafe impl Sync for ExtExtension482Fn {} +impl ExtExtension482Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension483Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_483\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension483Fn {} +unsafe impl Send for ExtExtension483Fn {} +unsafe impl Sync for ExtExtension483Fn {} +impl ExtExtension483Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_483'"] +impl ShaderStageFlags { + pub const EXT_483_RESERVE_15: Self = Self(0b1000_0000_0000_0000); + pub const EXT_483_RESERVE_16: Self = Self(0b1_0000_0000_0000_0000); + pub const EXT_483_RESERVE_17: Self = Self(0b10_0000_0000_0000_0000); +} +impl ExtExtension484Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_484\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension484Fn {} +unsafe impl Send for ExtExtension484Fn {} +unsafe impl Sync for ExtExtension484Fn {} +impl ExtExtension484Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index e5c52f4..2c57c07 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -4712,7 +4712,6 @@ pub struct StdVideoH265SequenceParameterSet { pub bit_depth_luma_minus8: u8, pub bit_depth_chroma_minus8: u8, pub log2_max_pic_order_cnt_lsb_minus4: u8, - pub sps_max_dec_pic_buffering_minus1: [u8; 8usize], pub log2_min_luma_coding_block_size_minus3: u8, pub log2_diff_max_min_luma_coding_block_size: u8, pub log2_min_luma_transform_block_size_minus2: u8, @@ -4742,7 +4741,7 @@ pub struct StdVideoH265SequenceParameterSet { fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { assert_eq!( ::std::mem::size_of::(), - 104usize, + 96usize, concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet)) ); assert_eq!( @@ -4908,25 +4907,12 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(log2_max_pic_order_cnt_lsb_minus4) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .sps_max_dec_pic_buffering_minus1 as *const _ as usize - }, - 27usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(sps_max_dec_pic_buffering_minus1) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())) .log2_min_luma_coding_block_size_minus3 as *const _ as usize }, - 35usize, + 27usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4939,7 +4925,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_luma_coding_block_size as *const _ as usize }, - 36usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4952,7 +4938,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_min_luma_transform_block_size_minus2 as *const _ as usize }, - 37usize, + 29usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4965,7 +4951,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_luma_transform_block_size as *const _ as usize }, - 38usize, + 30usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4978,7 +4964,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .max_transform_hierarchy_depth_inter as *const _ as usize }, - 39usize, + 31usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4991,7 +4977,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .max_transform_hierarchy_depth_intra as *const _ as usize }, - 40usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5004,7 +4990,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).num_short_term_ref_pic_sets as *const _ as usize }, - 41usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5017,7 +5003,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).num_long_term_ref_pics_sps as *const _ as usize }, - 42usize, + 34usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5030,7 +5016,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .pcm_sample_bit_depth_luma_minus1 as *const _ as usize }, - 43usize, + 35usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5043,7 +5029,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .pcm_sample_bit_depth_chroma_minus1 as *const _ as usize }, - 44usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5056,7 +5042,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_min_pcm_luma_coding_block_size_minus3 as *const _ as usize }, - 45usize, + 37usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5069,7 +5055,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_pcm_luma_coding_block_size as *const _ as usize }, - 46usize, + 38usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5082,7 +5068,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_left_offset as *const _ as usize }, - 48usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5095,7 +5081,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_right_offset as *const _ as usize }, - 52usize, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5108,7 +5094,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_top_offset as *const _ as usize }, - 56usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5121,7 +5107,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_bottom_offset as *const _ as usize }, - 60usize, + 52usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5134,7 +5120,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pDecPicBufMgr as *const _ as usize }, - 64usize, + 56usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5147,7 +5133,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pScalingLists as *const _ as usize }, - 72usize, + 64usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5160,7 +5146,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pSequenceParameterSetVui as *const _ as usize }, - 80usize, + 72usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5173,7 +5159,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).palette_max_size as *const _ as usize }, - 88usize, + 80usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5186,7 +5172,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .delta_palette_max_predictor_size as *const _ as usize }, - 89usize, + 81usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5199,7 +5185,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .motion_vector_resolution_control_idc as *const _ as usize }, - 90usize, + 82usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5212,7 +5198,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .sps_num_palette_predictor_initializer_minus1 as *const _ as usize }, - 91usize, + 83usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5225,7 +5211,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pPredictorPaletteEntries as *const _ as usize }, - 96usize, + 88usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), diff --git a/ash/src/vk/platform_types.rs b/ash/src/vk/platform_types.rs index da98594..4d6ffe0 100644 --- a/ash/src/vk/platform_types.rs +++ b/ash/src/vk/platform_types.rs @@ -1,33 +1,26 @@ +#![allow(non_camel_case_types)] + use std::os::raw::*; pub type RROutput = c_ulong; pub type VisualID = c_uint; pub type Display = *const c_void; pub type Window = c_ulong; -#[allow(non_camel_case_types)] pub type xcb_connection_t = c_void; -#[allow(non_camel_case_types)] pub type xcb_window_t = u32; -#[allow(non_camel_case_types)] pub type xcb_visualid_t = u32; pub type MirConnection = *const c_void; pub type MirSurface = *const c_void; pub type HINSTANCE = *const c_void; pub type HWND = *const c_void; -#[allow(non_camel_case_types)] pub type wl_display = c_void; -#[allow(non_camel_case_types)] pub type wl_surface = c_void; pub type HANDLE = *mut c_void; pub type HMONITOR = HANDLE; pub type DWORD = c_ulong; pub type LPCWSTR = *const u16; -#[allow(non_camel_case_types)] pub type zx_handle_t = u32; -#[allow(non_camel_case_types)] pub type _screen_context = c_void; -#[allow(non_camel_case_types)] pub type _screen_window = c_void; -#[allow(non_camel_case_types)] pub type SECURITY_ATTRIBUTES = c_void; // Opaque types pub type ANativeWindow = c_void; @@ -39,3 +32,10 @@ pub type GgpStreamDescriptor = u32; pub type GgpFrameToken = u64; pub type IDirectFB = c_void; pub type IDirectFBSurface = c_void; +pub type __IOSurface = c_void; +pub type IOSurfaceRef = *mut __IOSurface; +pub type MTLBuffer_id = *mut c_void; +pub type MTLCommandQueue_id = *mut c_void; +pub type MTLDevice_id = *mut c_void; +pub type MTLSharedEvent_id = *mut c_void; +pub type MTLTexture_id = *mut c_void; diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 23842a3..2c823b7 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 23842a31df9c9c2b3bc7c6c2bb56044bc5e51c05 +Subproject commit 2c823b7f27590ec0a489f7fbe14b154e13fa5cfb diff --git a/generator/src/lib.rs b/generator/src/lib.rs index edbf586..a05a4b7 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1399,9 +1399,21 @@ pub fn derive_default(struct_: &vkxml::Struct) -> Option { .filter_map(get_variant!(vkxml::StructElement::Member)); let is_structure_type = |field: &vkxml::Field| field.basetype == "VkStructureType"; - // This are also pointers, and therefor also don't implement Default. The spec + // These are also pointers, and therefor also don't implement Default. The spec // also doesn't mark them as pointers - let handles = ["LPCWSTR", "HANDLE", "HINSTANCE", "HWND", "HMONITOR"]; + let handles = [ + "LPCWSTR", + "HANDLE", + "HINSTANCE", + "HWND", + "HMONITOR", + "IOSurfaceRef", + "MTLBuffer_id", + "MTLCommandQueue_id", + "MTLDevice_id", + "MTLSharedEvent_id", + "MTLTexture_id", + ]; let contains_ptr = members.clone().any(|field| field.reference.is_some()); let contains_structure_type = members.clone().any(is_structure_type); let contains_static_array = members.clone().any(is_static_array);